/*
* ---------------------------------------------------------------------------
* Recognizer.java
*
* Copyright 2007 Nuance Communciations, Inc.
*
* Licensed under the Apache License, Version 2.0 (the 'License'); you may not
* use this file except in compliance with the License.
*
* You may obtain a copy of the License at
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an 'AS IS' BASIS, WITHOUT
* WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
* License for the specific language governing permissions and limitations under
* the License.
*
* ---------------------------------------------------------------------------
*/
package android.speech.srec;
import android.util.Config;
import android.util.Log;
import java.io.File;
import java.io.InputStream;
import java.io.IOException;
import java.util.Locale;
/**
* Simple, synchronous speech recognizer, using the Nuance SREC package.
* Usages proceeds as follows:
*
* <ul>
* <li>Create a <code>Recognizer</code>.
* <li>Create a <code>Recognizer.Grammar</code>.
* <li>Setup the <code>Recognizer.Grammar</code>.
* <li>Reset the <code>Recognizer.Grammar</code> slots, if needed.
* <li>Fill the <code>Recognizer.Grammar</code> slots, if needed.
* <li>Compile the <code>Recognizer.Grammar</code>, if needed.
* <li>Save the filled <code>Recognizer.Grammar</code>, if needed.
* <li>Start the <code>Recognizer</code>.
* <li>Loop over <code>advance</code> and <code>putAudio</code> until recognition complete.
* <li>Fetch and process results, or notify of failure.
* <li>Stop the <code>Recognizer</code>.
* <li>Destroy the <code>Recognizer</code>.
* </ul>
*
* <p>Below is example code</p>
*
* <pre class="prettyprint">
*
* // create and start audio input
* InputStream audio = new MicrophoneInputStream(11025, 11025*5);
* // create a Recognizer
* String cdir = Recognizer.getConfigDir(null);
* Recognizer recognizer = new Recognizer(cdir + "/baseline11k.par");
* // create and load a Grammar
* Recognizer.Grammar grammar = recognizer.new Grammar(cdir + "/grammars/VoiceDialer.g2g");
* // setup the Grammar to work with the Recognizer
* grammar.setupRecognizer();
* // fill the Grammar slots with names and save, if required
* grammar.resetAllSlots();
* for (String name : names) grammar.addWordToSlot("@Names", name, null, 1, "V=1");
* grammar.compile();
* grammar.save(".../foo.g2g");
* // start the Recognizer
* recognizer.start();
* // loop over Recognizer events
* while (true) {
* switch (recognizer.advance()) {
* case Recognizer.EVENT_INCOMPLETE:
* case Recognizer.EVENT_STARTED:
* case Recognizer.EVENT_START_OF_VOICING:
* case Recognizer.EVENT_END_OF_VOICING:
* // let the Recognizer continue to run
* continue;
* case Recognizer.EVENT_RECOGNITION_RESULT:
* // success, so fetch results here!
* for (int i = 0; i < recognizer.getResultCount(); i++) {
* String result = recognizer.getResult(i, Recognizer.KEY_LITERAL);
* }
* break;
* case Recognizer.EVENT_NEED_MORE_AUDIO:
* // put more audio in the Recognizer
* recognizer.putAudio(audio);
* continue;
* default:
* notifyFailure();
* break;
* }
* break;
* }
* // stop the Recognizer
* recognizer.stop();
* // destroy the Recognizer
* recognizer.destroy();
* // stop the audio device
* audio.close();
*
* </pre>
*/
public final class Recognizer {
static {
System.loadLibrary("srec_jni");
}
private static String TAG = "Recognizer";
/**
* Result key corresponding to confidence score.
*/
public static final String KEY_CONFIDENCE = "conf";
/**
* Result key corresponding to literal text.
*/
public static final String KEY_LITERAL = "literal";
/**
* Result key corresponding to semantic meaning text.
*/
public static final String KEY_MEANING = "meaning";
// handle to SR_Vocabulary object
private int mVocabulary = 0;
// handle to SR_Recognizer object
private int mRecognizer = 0;
// Grammar currently associated with Recognizer via SR_GrammarSetupRecognizer
private Grammar mActiveGrammar = null;
/**
* Get the pathname of the SREC configuration directory corresponding to the
* language indicated by the Locale.
* This directory contains dictionaries, speech models,
* configuration files, and other data needed by the Recognizer.
* @param locale <code>Locale</code> corresponding to the desired language,
* or null for default, currently <code>Locale.US</code>.
* @return Pathname of the configuration directory.
*/
public static String getConfigDir(Locale locale) {
if (locale == null) locale = Locale.US;
String dir = "/system/usr/srec/config/" +
locale.toString().replace('_', '.').toLowerCase();
if ((new File(dir)).isDirectory()) return dir;
return null;
}
/**
* Create an instance of a SREC speech recognizer.
*
* @param configFile pathname of the baseline*.par configuration file,
* which in turn contains references to dictionaries, speech models,
* and other data needed to configure and operate the recognizer.
* A separate config file is needed for each audio sample rate.
* Two files, baseline11k.par and baseline8k.par, which correspond to
* 11025 and 8000 hz, are present in the directory indicated by
* {@link #getConfigDir}.
* @throws IOException
*/
public Recognizer(String configFile) throws IOException {
PMemInit();
SR_SessionCreate(configFile);
mRecognizer = SR_RecognizerCreate();
SR_RecognizerSetup(mRecognizer);
mVocabulary = SR_VocabularyLoad();
}
/**
* Represents a grammar loaded into the Recognizer.
*/
public class Grammar {
private int mGrammar = 0;
/**
* Create a <code>Grammar</code> instance.
* @param g2gFileName pathname of g2g file.
*/
public Grammar(String g2gFileName) throws IOException {
mGrammar = SR_GrammarLoad(g2gFileName);
SR_GrammarSetupVocabulary(mGrammar, mVocabulary);
}
/**
* Reset all slots.
*/
public void resetAllSlots() {
SR_GrammarResetAllSlots(mGrammar);
}
/**
* Add a word to a slot.
*
* @param slot slot name.
* @param word word to insert.
* @param pron pronunciation, or null to derive from word.
* @param weight weight to give the word. One is normal, 50 is low.
* @param tag semantic meaning tag string.
*/
public void addWordToSlot(String slot, String word, String pron, int weight, String tag) {
SR_GrammarAddWordToSlot(mGrammar, slot, word, pron, weight, tag);
}
/**
* Compile all slots.
*/
public void compile() {
SR_GrammarCompile(mGrammar);
}
/**
* Setup <code>Grammar</code> with <code>Recognizer</code>.
*/
public void setupRecognizer() {
SR_GrammarSetupRecognizer(mGrammar, mRecognizer);
mActiveGrammar = this;
}
/**
* Save <code>Grammar</code> to g2g file.
*
* @param g2gFileName
* @throws IOException
*/
public void save(String g2gFileName) throws IOException {
SR_GrammarSave(mGrammar, g2gFileName);
}
/**
* Release resources associated with this <code>Grammar</code>.
*/
public void destroy() {
// TODO: need to do cleanup and disassociation with Recognizer
if (mGrammar != 0) {
SR_GrammarDestroy(mGrammar);
mGrammar = 0;
}
}
/**
* Clean up resources.
*/
protected void finalize() {
if (mGrammar != 0) {
destroy();
throw new IllegalStateException("someone forgot to destroy Grammar");
}
}
}
/**
* Start recognition
*/
public void start() {
// TODO: shouldn't be here?
SR_RecognizerActivateRule(mRecognizer, mActiveGrammar.mGrammar, "trash", 1);
SR_RecognizerStart(mRecognizer);
}
/**
* Process some audio and return the current status.
* @return recognition event, one of:
* <ul>
* <li><code>EVENT_INVALID</code>
* <li><code>EVENT_NO_MATCH</code>
* <li><code>EVENT_INCOMPLETE</code>
* <li><code>EVENT_STARTED</code>
* <li><code>EVENT_STOPPED</code>
* <li><code>EVENT_START_OF_VOICING</code>
* <li><code>EVENT_END_OF_VOICING</code>
* <li><code>EVENT_SPOKE_TOO_SOON</code>
* <li><code>EVENT_RECOGNITION_RESULT</code>
* <li><code>EVENT_START_OF_UTTERANCE_TIMEOUT</code>
* <li><code>EVENT_RECOGNITION_TIMEOUT</code>
* <li><code>EVENT_NEED_MORE_AUDIO</code>
* <li><code>EVENT_MAX_SPEECH</code>
* </ul>
*/
public int advance() {
return SR_RecognizerAdvance(mRecognizer);
}
/**
* Put audio samples into the <code>Recognizer</code>.
* @param buf holds the audio samples.
* @param offset offset of the first sample.
* @param length number of bytes containing samples.
* @param isLast indicates no more audio data, normally false.
* @return number of bytes accepted.
*/
public int putAudio(byte[] buf, int offset, int length, boolean isLast) {
return SR_RecognizerPutAudio(mRecognizer, buf, offset, length, isLast);
}
/**
* Read audio samples from an <code>InputStream</code> and put them in the
* <code>Recognizer</code>.
* @param audio <code>InputStream</code> containing PCM audio samples.
*/
public void putAudio(InputStream audio) throws IOException {
// make sure the audio buffer is allocated
if (mPutAudioBuffer == null) mPutAudioBuffer = new byte[512];
// read some data
int nbytes = audio.read(mPutAudioBuffer);
// eof, so signal Recognizer
if (nbytes == -1) {
SR_RecognizerPutAudio(mRecognizer, mPutAudioBuffer, 0, 0, true);
}
// put it into the Recognizer
else if (nbytes != SR_RecognizerPutAudio(mRecognizer, mPutAudioBuffer, 0, nbytes, false)) {
throw new IOException("SR_RecognizerPutAudio failed nbytes=" + nbytes);
}
}
// audio buffer for putAudio(InputStream)
private byte[] mPutAudioBuffer = null;
/**
* Get the number of recognition results. Must be called after
* <code>EVENT_RECOGNITION_RESULT</code> is returned by
* <code>advance</code>, but before <code>stop</code>.
*
* @return number of results in nbest list.
*/
public int getResultCount() {
return SR_RecognizerResultGetSize(mRecognizer);
}
/**
* Get a set of keys for the result. Must be called after
* <code>EVENT_RECOGNITION_RESULT</code> is returned by
* <code>advance</code>, but before <code>stop</code>.
*
* @param index index of result.
* @return array of keys.
*/
public String[] getResultKeys(int index) {
return SR_RecognizerResultGetKeyList(mRecognizer, index);
}
/**
* Get a result value. Must be called after
* <code>EVENT_RECOGNITION_RESULT</code> is returned by
* <code>advance</code>, but before <code>stop</code>.
*
* @param index index of the result.
* @param key key of the result. This is typically one of
* <code>KEY_CONFIDENCE</code>, <code>KEY_LITERAL</code>, or
* <code>KEY_MEANING</code>, but the user can also define their own keys
* in a grxml file, or in the <code>tag</code> slot of
* <code>Grammar.addWordToSlot</code>.
* @return the result.
*/
public String getResult(int index, String key) {
return SR_RecognizerResultGetValue(mRecognizer, index, key);
}
/**
* Stop the <code>Recognizer</code>.
*/
public void stop() {
SR_RecognizerStop(mRecognizer);
SR_RecognizerDeactivateRule(mRecognizer, mActiveGrammar.mGrammar, "trash");
}
/**
* Reset the acoustic state vectorto it's default value.
*
* @hide
*/
public void resetAcousticState() {
SR_AcousticStateReset(mRecognizer);
}
/**
* Set the acoustic state vector.
* @param state String containing the acoustic state vector.
*
* @hide
*/
public void setAcousticState(String state) {
SR_AcousticStateSet(mRecognizer, state);
}
/**
* Get the acoustic state vector.
* @return String containing the acoustic state vector.
*
* @hide
*/
public String getAcousticState() {
return SR_AcousticStateGet(mRecognizer);
}
/**
* Clean up resources.
*/
public void destroy() {
try {
if (mVocabulary != 0) SR_VocabularyDestroy(mVocabulary);
} finally {
mVocabulary = 0;
try {
if (mRecognizer != 0) SR_RecognizerUnsetup(mRecognizer);
} finally {
try {
if (mRecognizer != 0) SR_RecognizerDestroy(mRecognizer);
} finally {
mRecognizer = 0;
try {
SR_SessionDestroy();
} finally {
PMemShutdown();
}
}
}
}
}
/**
* Clean up resources.
*/
protected void finalize() throws Throwable {
if (mVocabulary != 0 || mRecognizer != 0) {
destroy();
throw new IllegalStateException("someone forgot to destroy Recognizer");
}
}
/* an example session captured, for reference
void doall() {
if (PMemInit ( )
|| lhs_audioinOpen ( WAVE_MAPPER, SREC_TEST_DEFAULT_AUDIO_FREQUENCY, &audio_in_handle )
|| srec_test_init_application_data ( &applicationData, argc, argv )
|| SR_SessionCreate ( "/system/usr/srec/config/en.us/baseline11k.par" )
|| SR_RecognizerCreate ( &applicationData.recognizer )
|| SR_RecognizerSetup ( applicationData.recognizer)
|| ESR_SessionGetLCHAR ( L("cmdline.vocabulary"), filename, &flen )
|| SR_VocabularyLoad ( filename, &applicationData.vocabulary )
|| SR_VocabularyGetLanguage ( applicationData.vocabulary, &applicationData.locale )
|| (applicationData.nametag = NULL)
|| SR_NametagsCreate ( &applicationData.nametags )
|| (LSTRCPY ( applicationData.grammars [0].grammar_path, "/system/usr/srec/config/en.us/grammars/VoiceDialer.g2g" ), 0)
|| (LSTRCPY ( applicationData.grammars [0].grammarID, "BothTags" ), 0)
|| (LSTRCPY ( applicationData.grammars [0].ruleName, "trash" ), 0)
|| (applicationData.grammars [0].is_ve_grammar = ESR_FALSE, 0)
|| SR_GrammarLoad (applicationData.grammars [0].grammar_path, &applicationData.grammars [applicationData.grammarCount].grammar )
|| SR_GrammarSetupVocabulary ( applicationData.grammars [0].grammar, applicationData.vocabulary )
|| SR_GrammarSetupRecognizer( applicationData.grammars [0].grammar, applicationData.recognizer )
|| SR_GrammarSetDispatchFunction ( applicationData.grammars [0].grammar, L("myDSMCallback"), NULL, myDSMCallback )
|| (applicationData.grammarCount++, 0)
|| SR_RecognizerActivateRule ( applicationData.recognizer, applicationData.grammars [0].grammar,
applicationData.grammars [0].ruleName, 1 )
|| (applicationData.active_grammar_num = 0, 0)
|| lhs_audioinStart ( audio_in_handle )
|| SR_RecognizerStart ( applicationData.recognizer )
|| strl ( applicationData.grammars [0].grammar, &applicationData, audio_in_handle, &recognition_count )
|| SR_RecognizerStop ( applicationData.recognizer )
|| lhs_audioinStop ( audio_in_handle )
|| SR_RecognizerDeactivateRule ( applicationData.recognizer, applicationData.grammars [0].grammar, applicationData.grammars [0].ruleName )
|| (applicationData.active_grammar_num = -1, 0)
|| SR_GrammarDestroy ( applicationData.grammars [0].grammar )
|| (applicationData.grammarCount--, 0)
|| SR_NametagsDestroy ( applicationData.nametags )
|| (applicationData.nametags = NULL, 0)
|| SR_VocabularyDestroy ( applicationData.vocabulary )
|| (applicationData.vocabulary = NULL)
|| SR_RecognizerUnsetup ( applicationData.recognizer) // releases acoustic models
|| SR_RecognizerDestroy ( applicationData.recognizer )
|| (applicationData.recognizer = NULL)
|| SR_SessionDestroy ( )
|| srec_test_shutdown_application_data ( &applicationData )
|| lhs_audioinClose ( &audio_in_handle )
|| PMemShutdown ( )
}
*/
//
// PMem native methods
//
private static native void PMemInit();
private static native void PMemShutdown();
//
// SR_Session native methods
//
private static native void SR_SessionCreate(String filename);
private static native void SR_SessionDestroy();
//
// SR_Recognizer native methods
//
/**
* Reserved value.
*/
public final static int EVENT_INVALID = 0;
/**
* <code>Recognizer</code> could not find a match for the utterance.
*/
public final static int EVENT_NO_MATCH = 1;
/**
* <code>Recognizer</code> processed one frame of audio.
*/
public final static int EVENT_INCOMPLETE = 2;
/**
* <code>Recognizer</code> has just been started.
*/
public final static int EVENT_STARTED = 3;
/**
* <code>Recognizer</code> is stopped.
*/
public final static int EVENT_STOPPED = 4;
/**
* Beginning of speech detected.
*/
public final static int EVENT_START_OF_VOICING = 5;
/**
* End of speech detected.
*/
public final static int EVENT_END_OF_VOICING = 6;
/**
* Beginning of utterance occured too soon.
*/
public final static int EVENT_SPOKE_TOO_SOON = 7;
/**
* Recognition match detected.
*/
public final static int EVENT_RECOGNITION_RESULT = 8;
/**
* Timeout occured before beginning of utterance.
*/
public final static int EVENT_START_OF_UTTERANCE_TIMEOUT = 9;
/**
* Timeout occured before speech recognition could complete.
*/
public final static int EVENT_RECOGNITION_TIMEOUT = 10;
/**
* Not enough samples to process one frame.
*/
public final static int EVENT_NEED_MORE_AUDIO = 11;
/**
* More audio encountered than is allowed by 'swirec_max_speech_duration'.
*/
public final static int EVENT_MAX_SPEECH = 12;
/**
* Produce a displayable string from an <code>advance</code> event.
* @param event
* @return String representing the event.
*/
public static String eventToString(int event) {
switch (event) {
case EVENT_INVALID:
return "EVENT_INVALID";
case EVENT_NO_MATCH:
return "EVENT_NO_MATCH";
case EVENT_INCOMPLETE:
return "EVENT_INCOMPLETE";
case EVENT_STARTED:
return "EVENT_STARTED";
case EVENT_STOPPED:
return "EVENT_STOPPED";
case EVENT_START_OF_VOICING:
return "EVENT_START_OF_VOICING";
case EVENT_END_OF_VOICING:
return "EVENT_END_OF_VOICING";
case EVENT_SPOKE_TOO_SOON:
return "EVENT_SPOKE_TOO_SOON";
case EVENT_RECOGNITION_RESULT:
return "EVENT_RECOGNITION_RESULT";
case EVENT_START_OF_UTTERANCE_TIMEOUT:
return "EVENT_START_OF_UTTERANCE_TIMEOUT";
case EVENT_RECOGNITION_TIMEOUT:
return "EVENT_RECOGNITION_TIMEOUT";
case EVENT_NEED_MORE_AUDIO:
return "EVENT_NEED_MORE_AUDIO";
case EVENT_MAX_SPEECH:
return "EVENT_MAX_SPEECH";
}
return "EVENT_" + event;
}
//
// SR_Recognizer methods
//
private static native void SR_RecognizerStart(int recognizer);
private static native void SR_RecognizerStop(int recognizer);
private static native int SR_RecognizerCreate();
private static native void SR_RecognizerDestroy(int recognizer);
private static native void SR_RecognizerSetup(int recognizer);
private static native void SR_RecognizerUnsetup(int recognizer);
private static native boolean SR_RecognizerIsSetup(int recognizer);
private static native String SR_RecognizerGetParameter(int recognizer, String key);
private static native int SR_RecognizerGetSize_tParameter(int recognizer, String key);
private static native boolean SR_RecognizerGetBoolParameter(int recognizer, String key);
private static native void SR_RecognizerSetParameter(int recognizer, String key, String value);
private static native void SR_RecognizerSetSize_tParameter(int recognizer,
String key, int value);
private static native void SR_RecognizerSetBoolParameter(int recognizer, String key,
boolean value);
private static native void SR_RecognizerSetupRule(int recognizer, int grammar,
String ruleName);
private static native boolean SR_RecognizerHasSetupRules(int recognizer);
private static native void SR_RecognizerActivateRule(int recognizer, int grammar,
String ruleName, int weight);
private static native void SR_RecognizerDeactivateRule(int recognizer, int grammar,
String ruleName);
private static native void SR_RecognizerDeactivateAllRules(int recognizer);
private static native boolean SR_RecognizerIsActiveRule(int recognizer, int grammar,
String ruleName);
private static native boolean SR_RecognizerCheckGrammarConsistency(int recognizer,
int grammar);
private static native int SR_RecognizerPutAudio(int recognizer, byte[] buffer, int offset,
int length, boolean isLast);
private static native int SR_RecognizerAdvance(int recognizer);
// private static native void SR_RecognizerLoadUtterance(int recognizer,
// const LCHAR* filename);
// private static native void SR_RecognizerLoadWaveFile(int recognizer,
// const LCHAR* filename);
// private static native void SR_RecognizerSetLockFunction(int recognizer,
// SR_RecognizerLockFunction function, void* data);
private static native boolean SR_RecognizerIsSignalClipping(int recognizer);
private static native boolean SR_RecognizerIsSignalDCOffset(int recognizer);
private static native boolean SR_RecognizerIsSignalNoisy(int recognizer);
private static native boolean SR_RecognizerIsSignalTooQuiet(int recognizer);
private static native boolean SR_RecognizerIsSignalTooFewSamples(int recognizer);
private static native boolean SR_RecognizerIsSignalTooManySamples(int recognizer);
// private static native void SR_Recognizer_Change_Sample_Rate (size_t new_sample_rate);
//
// SR_AcousticState native methods
//
private static native void SR_AcousticStateReset(int recognizer);
private static native void SR_AcousticStateSet(int recognizer, String state);
private static native String SR_AcousticStateGet(int recognizer);
//
// SR_Grammar native methods
//
private static native void SR_GrammarCompile(int grammar);
private static native void SR_GrammarAddWordToSlot(int grammar, String slot,
String word, String pronunciation, int weight, String tag);
private static native void SR_GrammarResetAllSlots(int grammar);
// private static native void SR_GrammarAddNametagToSlot(int grammar, String slot,
// const struct SR_Nametag_t* nametag, int weight, String tag);
private static native void SR_GrammarSetupVocabulary(int grammar, int vocabulary);
// private static native void SR_GrammarSetupModels(int grammar, SR_AcousticModels* models);
private static native void SR_GrammarSetupRecognizer(int grammar, int recognizer);
private static native void SR_GrammarUnsetupRecognizer(int grammar);
// private static native void SR_GrammarGetModels(int grammar,SR_AcousticModels** models);
private static native int SR_GrammarCreate();
private static native void SR_GrammarDestroy(int grammar);
private static native int SR_GrammarLoad(String filename);
private static native void SR_GrammarSave(int grammar, String filename);
// private static native void SR_GrammarSetDispatchFunction(int grammar,
// const LCHAR* name, void* userData, SR_GrammarDispatchFunction function);
// private static native void SR_GrammarSetParameter(int grammar, const
// LCHAR* key, void* value);
// private static native void SR_GrammarSetSize_tParameter(int grammar,
// const LCHAR* key, size_t value);
// private static native void SR_GrammarGetParameter(int grammar, const
// LCHAR* key, void** value);
// private static native void SR_GrammarGetSize_tParameter(int grammar,
// const LCHAR* key, size_t* value);
// private static native void SR_GrammarCheckParse(int grammar, const LCHAR*
// transcription, SR_SemanticResult** result, size_t* resultCount);
private static native void SR_GrammarAllowOnly(int grammar, String transcription);
private static native void SR_GrammarAllowAll(int grammar);
//
// SR_Vocabulary native methods
//
// private static native int SR_VocabularyCreate();
private static native int SR_VocabularyLoad();
// private static native void SR_VocabularySave(SR_Vocabulary* self,
// const LCHAR* filename);
// private static native void SR_VocabularyAddWord(SR_Vocabulary* self,
// const LCHAR* word);
// private static native void SR_VocabularyGetLanguage(SR_Vocabulary* self,
// ESR_Locale* locale);
private static native void SR_VocabularyDestroy(int vocabulary);
private static native String SR_VocabularyGetPronunciation(int vocabulary, String word);
//
// SR_RecognizerResult native methods
//
private static native byte[] SR_RecognizerResultGetWaveform(int recognizer);
private static native int SR_RecognizerResultGetSize(int recognizer);
private static native int SR_RecognizerResultGetKeyCount(int recognizer, int nbest);
private static native String[] SR_RecognizerResultGetKeyList(int recognizer, int nbest);
private static native String SR_RecognizerResultGetValue(int recognizer,
int nbest, String key);
// private static native void SR_RecognizerResultGetLocale(int recognizer, ESR_Locale* locale);
}
|
