2008-06-11 14:52:57 +04:00
|
|
|
// $Id$
|
|
|
|
|
2013-07-09 18:48:36 +04:00
|
|
|
#include <list>
|
2014-03-25 05:49:24 +04:00
|
|
|
#include <vector>
|
2008-06-11 14:52:57 +04:00
|
|
|
#include "TranslationOptionCollectionConfusionNet.h"
|
2013-06-21 04:17:17 +04:00
|
|
|
#include "ConfusionNet.h"
|
2013-10-03 14:05:53 +04:00
|
|
|
#include "DecodeGraph.h"
|
2013-06-28 18:43:56 +04:00
|
|
|
#include "DecodeStepTranslation.h"
|
2013-08-07 15:11:39 +04:00
|
|
|
#include "DecodeStepGeneration.h"
|
2008-06-11 14:52:57 +04:00
|
|
|
#include "FactorCollection.h"
|
2013-07-09 18:48:36 +04:00
|
|
|
#include "FF/InputFeature.h"
|
2013-07-11 15:37:20 +04:00
|
|
|
#include "TranslationModel/PhraseDictionaryTreeAdaptor.h"
|
2013-11-20 15:59:36 +04:00
|
|
|
#include "util/exception.hh"
|
2014-03-25 05:49:24 +04:00
|
|
|
#include <boost/foreach.hpp>
|
2013-06-28 18:43:56 +04:00
|
|
|
|
|
|
|
using namespace std;
|
2008-06-11 14:52:57 +04:00
|
|
|
|
2008-10-09 03:51:26 +04:00
|
|
|
namespace Moses
|
|
|
|
{
|
2011-02-24 16:14:42 +03:00
|
|
|
|
2008-06-11 14:52:57 +04:00
|
|
|
/** constructor; just initialize the base class */
|
2014-03-25 05:49:24 +04:00
|
|
|
TranslationOptionCollectionConfusionNet::
|
2015-04-30 08:05:11 +03:00
|
|
|
TranslationOptionCollectionConfusionNet(ttasksptr const& ttask,
|
2015-05-02 13:45:24 +03:00
|
|
|
const ConfusionNet &input,
|
2014-05-19 17:34:27 +04:00
|
|
|
size_t maxNoTransOptPerCoverage,
|
|
|
|
float translationOptionThreshold)
|
2015-03-30 03:20:17 +03:00
|
|
|
: TranslationOptionCollection(ttask,input, maxNoTransOptPerCoverage,
|
2014-05-19 17:34:27 +04:00
|
|
|
translationOptionThreshold)
|
2013-07-09 18:48:36 +04:00
|
|
|
{
|
2014-03-25 05:49:24 +04:00
|
|
|
// Prefix checkers are phrase dictionaries that provide a prefix check
|
|
|
|
// to indicate that a phrase table entry with a given prefix exists.
|
|
|
|
// If no entry with the given prefix exists, there is no point in
|
|
|
|
// expanding it further.
|
|
|
|
vector<PhraseDictionary*> prefixCheckers;
|
|
|
|
BOOST_FOREACH(PhraseDictionary* pd, PhraseDictionary::GetColl())
|
2014-05-19 17:34:27 +04:00
|
|
|
if (pd->ProvidesPrefixCheck()) prefixCheckers.push_back(pd);
|
|
|
|
|
2015-10-16 15:01:32 +03:00
|
|
|
const InputFeature *inputFeature = InputFeature::InstancePtr();
|
|
|
|
UTIL_THROW_IF2(inputFeature == NULL, "Input feature must be specified");
|
2013-07-09 18:48:36 +04:00
|
|
|
|
2013-10-07 19:44:26 +04:00
|
|
|
size_t inputSize = input.GetSize();
|
|
|
|
m_inputPathMatrix.resize(inputSize);
|
|
|
|
|
|
|
|
size_t maxSizePhrase = StaticData::Instance().GetMaxPhraseLength();
|
|
|
|
maxSizePhrase = std::min(inputSize, maxSizePhrase);
|
2013-07-09 18:48:36 +04:00
|
|
|
|
|
|
|
// 1-word phrases
|
2013-10-07 19:44:26 +04:00
|
|
|
for (size_t startPos = 0; startPos < inputSize; ++startPos) {
|
2013-08-02 21:24:36 +04:00
|
|
|
vector<InputPathList> &vec = m_inputPathMatrix[startPos];
|
2013-07-09 19:56:49 +04:00
|
|
|
vec.push_back(InputPathList());
|
|
|
|
InputPathList &list = vec.back();
|
2013-07-09 18:48:36 +04:00
|
|
|
|
2013-07-09 19:56:49 +04:00
|
|
|
WordsRange range(startPos, startPos);
|
2013-08-02 18:54:49 +04:00
|
|
|
const NonTerminalSet &labels = input.GetLabelSet(startPos, startPos);
|
2013-07-09 18:48:36 +04:00
|
|
|
|
2013-07-09 19:56:49 +04:00
|
|
|
const ConfusionNet::Column &col = input.GetColumn(startPos);
|
|
|
|
for (size_t i = 0; i < col.size(); ++i) {
|
|
|
|
const Word &word = col[i].first;
|
|
|
|
Phrase subphrase;
|
|
|
|
subphrase.AddWord(word);
|
2013-07-09 18:48:36 +04:00
|
|
|
|
2013-09-08 21:22:55 +04:00
|
|
|
const ScorePair &scores = col[i].second;
|
|
|
|
ScorePair *inputScore = new ScorePair(scores);
|
2013-07-09 18:48:36 +04:00
|
|
|
|
2013-10-02 19:51:16 +04:00
|
|
|
InputPath *path = new InputPath(subphrase, labels, range, NULL, inputScore);
|
|
|
|
list.push_back(path);
|
2013-07-09 18:48:36 +04:00
|
|
|
|
2013-10-03 21:58:45 +04:00
|
|
|
m_inputPathQueue.push_back(path);
|
2013-07-09 19:56:49 +04:00
|
|
|
}
|
2013-07-09 18:48:36 +04:00
|
|
|
}
|
|
|
|
|
2013-07-09 19:56:49 +04:00
|
|
|
// subphrases of 2+ words
|
2013-10-07 19:44:26 +04:00
|
|
|
for (size_t phraseSize = 2; phraseSize <= maxSizePhrase; ++phraseSize) {
|
|
|
|
for (size_t startPos = 0; startPos < inputSize - phraseSize + 1; ++startPos) {
|
|
|
|
size_t endPos = startPos + phraseSize -1;
|
2013-08-02 18:54:49 +04:00
|
|
|
|
2013-07-09 19:56:49 +04:00
|
|
|
WordsRange range(startPos, endPos);
|
2013-08-02 18:54:49 +04:00
|
|
|
const NonTerminalSet &labels = input.GetLabelSet(startPos, endPos);
|
2013-07-09 19:56:49 +04:00
|
|
|
|
2013-08-02 21:24:36 +04:00
|
|
|
vector<InputPathList> &vec = m_inputPathMatrix[startPos];
|
2013-07-10 21:02:38 +04:00
|
|
|
vec.push_back(InputPathList());
|
2013-07-09 19:56:49 +04:00
|
|
|
InputPathList &list = vec.back();
|
|
|
|
|
|
|
|
// loop thru every previous path
|
2013-10-02 19:51:16 +04:00
|
|
|
const InputPathList &prevPaths = GetInputPathList(startPos, endPos - 1);
|
2013-07-10 21:02:38 +04:00
|
|
|
|
|
|
|
int prevNodesInd = 0;
|
|
|
|
InputPathList::const_iterator iterPath;
|
2013-10-02 19:51:16 +04:00
|
|
|
for (iterPath = prevPaths.begin(); iterPath != prevPaths.end(); ++iterPath) {
|
|
|
|
//for (size_t pathInd = 0; pathInd < prevPaths.size(); ++pathInd) {
|
|
|
|
const InputPath &prevPath = **iterPath;
|
|
|
|
//const InputPath &prevPath = *prevPaths[pathInd];
|
2013-07-10 21:02:38 +04:00
|
|
|
|
2013-10-02 19:51:16 +04:00
|
|
|
const Phrase &prevPhrase = prevPath.GetPhrase();
|
|
|
|
const ScorePair *prevInputScore = prevPath.GetInputScore();
|
2013-11-23 00:27:46 +04:00
|
|
|
UTIL_THROW_IF2(prevInputScore == NULL,
|
2014-01-15 19:42:02 +04:00
|
|
|
"No input score for path: " << prevPath);
|
2013-07-09 19:56:49 +04:00
|
|
|
|
|
|
|
// loop thru every word at this position
|
2013-07-10 21:02:38 +04:00
|
|
|
const ConfusionNet::Column &col = input.GetColumn(endPos);
|
|
|
|
|
2013-07-09 19:56:49 +04:00
|
|
|
for (size_t i = 0; i < col.size(); ++i) {
|
|
|
|
const Word &word = col[i].first;
|
|
|
|
Phrase subphrase(prevPhrase);
|
|
|
|
subphrase.AddWord(word);
|
|
|
|
|
2014-05-19 17:34:27 +04:00
|
|
|
bool OK = prefixCheckers.size() == 0;
|
|
|
|
for (size_t k = 0; !OK && k < prefixCheckers.size(); ++k)
|
2015-03-30 03:20:17 +03:00
|
|
|
OK = prefixCheckers[k]->PrefixExists(m_ttask.lock(), subphrase);
|
2014-05-19 17:34:27 +04:00
|
|
|
if (!OK) continue;
|
2014-03-25 05:49:24 +04:00
|
|
|
|
2013-09-08 21:22:55 +04:00
|
|
|
const ScorePair &scores = col[i].second;
|
2013-09-08 17:57:31 +04:00
|
|
|
ScorePair *inputScore = new ScorePair(*prevInputScore);
|
|
|
|
inputScore->PlusEquals(scores);
|
2013-07-09 19:56:49 +04:00
|
|
|
|
2013-10-02 19:51:16 +04:00
|
|
|
InputPath *path = new InputPath(subphrase, labels, range, &prevPath, inputScore);
|
|
|
|
list.push_back(path);
|
2013-07-09 19:56:49 +04:00
|
|
|
|
2013-10-03 21:58:45 +04:00
|
|
|
m_inputPathQueue.push_back(path);
|
2013-07-10 21:02:38 +04:00
|
|
|
} // for (size_t i = 0; i < col.size(); ++i) {
|
2013-07-09 19:56:49 +04:00
|
|
|
|
2013-07-10 21:02:38 +04:00
|
|
|
++prevNodesInd;
|
2013-10-02 19:51:16 +04:00
|
|
|
} // for (iterPath = prevPaths.begin(); iterPath != prevPaths.end(); ++iterPath) {
|
2013-07-09 19:56:49 +04:00
|
|
|
}
|
2013-07-09 18:48:36 +04:00
|
|
|
}
|
2014-05-19 17:34:27 +04:00
|
|
|
// cerr << "HAVE " << m_inputPathQueue.size()
|
|
|
|
// << " input paths of max. length "
|
2014-03-25 05:49:24 +04:00
|
|
|
// << maxSizePhrase << "." << endl;
|
2013-07-09 19:56:49 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
InputPathList &TranslationOptionCollectionConfusionNet::GetInputPathList(size_t startPos, size_t endPos)
|
|
|
|
{
|
|
|
|
size_t offset = endPos - startPos;
|
2013-11-23 00:27:46 +04:00
|
|
|
UTIL_THROW_IF2(offset >= m_inputPathMatrix[startPos].size(),
|
|
|
|
"Out of bound access: " << offset);
|
2013-11-20 15:59:36 +04:00
|
|
|
|
2013-08-02 21:24:36 +04:00
|
|
|
return m_inputPathMatrix[startPos][offset];
|
2013-07-09 18:48:36 +04:00
|
|
|
}
|
2008-06-11 14:52:57 +04:00
|
|
|
|
|
|
|
/* forcibly create translation option for a particular source word.
|
2011-02-24 16:14:42 +03:00
|
|
|
* call the base class' ProcessOneUnknownWord() for each possible word in the confusion network
|
2008-06-11 14:52:57 +04:00
|
|
|
* at a particular source position
|
|
|
|
*/
|
2011-02-24 16:14:42 +03:00
|
|
|
void TranslationOptionCollectionConfusionNet::ProcessUnknownWord(size_t sourcePos)
|
2008-06-11 14:52:57 +04:00
|
|
|
{
|
2011-02-24 16:14:42 +03:00
|
|
|
ConfusionNet const& source=dynamic_cast<ConfusionNet const&>(m_source);
|
|
|
|
|
|
|
|
ConfusionNet::Column const& coll=source.GetColumn(sourcePos);
|
2013-08-13 22:44:52 +04:00
|
|
|
const InputPathList &inputPathList = GetInputPathList(sourcePos, sourcePos);
|
|
|
|
|
|
|
|
ConfusionNet::Column::const_iterator iterCol;
|
|
|
|
InputPathList::const_iterator iterInputPath;
|
2011-02-24 16:14:42 +03:00
|
|
|
size_t j=0;
|
2013-08-13 22:44:52 +04:00
|
|
|
for(iterCol = coll.begin(), iterInputPath = inputPathList.begin();
|
2013-08-16 00:14:04 +04:00
|
|
|
iterCol != coll.end();
|
|
|
|
++iterCol , ++iterInputPath) {
|
|
|
|
const InputPath &inputPath = **iterInputPath;
|
|
|
|
size_t length = source.GetColumnIncrement(sourcePos, j++);
|
2013-09-08 21:22:55 +04:00
|
|
|
const ScorePair &inputScores = iterCol->second;
|
2013-08-13 22:44:52 +04:00
|
|
|
ProcessOneUnknownWord(inputPath ,sourcePos, length, &inputScores);
|
2011-02-24 16:14:42 +03:00
|
|
|
}
|
|
|
|
|
2008-06-11 14:52:57 +04:00
|
|
|
}
|
2015-04-30 08:05:11 +03:00
|
|
|
|
|
|
|
void
|
2015-03-30 03:20:17 +03:00
|
|
|
TranslationOptionCollectionConfusionNet
|
|
|
|
::CreateTranslationOptions()
|
2013-07-11 19:19:38 +04:00
|
|
|
{
|
2013-10-02 23:02:05 +04:00
|
|
|
if (!StaticData::Instance().GetUseLegacyPT()) {
|
2013-07-11 23:18:06 +04:00
|
|
|
GetTargetPhraseCollectionBatch();
|
2013-07-11 19:19:38 +04:00
|
|
|
}
|
|
|
|
TranslationOptionCollection::CreateTranslationOptions();
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2013-06-28 18:43:56 +04:00
|
|
|
/** create translation options that exactly cover a specific input span.
|
|
|
|
* Called by CreateTranslationOptions() and ProcessUnknownWord()
|
|
|
|
* \param decodeGraph list of decoding steps
|
|
|
|
* \param factorCollection input sentence with all factors
|
|
|
|
* \param startPos first position in input sentence
|
|
|
|
* \param lastPos last position in input sentence
|
|
|
|
* \param adhereTableLimit whether phrase & generation table limits are adhered to
|
2015-02-19 15:27:23 +03:00
|
|
|
* \return true if there is at least one path for the range has matches
|
2015-02-06 02:31:39 +03:00
|
|
|
* in the source side of the parallel data, i.e., the phrase prefix exists
|
|
|
|
* (abortion condition for trie-based lookup if false)
|
2013-06-28 18:43:56 +04:00
|
|
|
*/
|
2015-02-06 02:31:39 +03:00
|
|
|
bool
|
|
|
|
TranslationOptionCollectionConfusionNet::
|
|
|
|
CreateTranslationOptionsForRange(const DecodeGraph &decodeGraph,
|
2015-02-19 15:27:23 +03:00
|
|
|
size_t startPos, size_t endPos,
|
|
|
|
bool adhereTableLimit, size_t graphInd)
|
2013-07-11 15:46:04 +04:00
|
|
|
{
|
2013-10-02 23:02:05 +04:00
|
|
|
if (StaticData::Instance().GetUseLegacyPT()) {
|
2015-02-19 15:27:23 +03:00
|
|
|
return CreateTranslationOptionsForRangeLEGACY(decodeGraph, startPos, endPos,
|
|
|
|
adhereTableLimit, graphInd);
|
2013-07-11 19:20:15 +04:00
|
|
|
} else {
|
2015-02-19 15:27:23 +03:00
|
|
|
return CreateTranslationOptionsForRangeNew(decodeGraph, startPos, endPos,
|
|
|
|
adhereTableLimit, graphInd);
|
2013-07-11 15:46:04 +04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-02-06 02:31:39 +03:00
|
|
|
bool
|
|
|
|
TranslationOptionCollectionConfusionNet::
|
2015-03-30 03:20:17 +03:00
|
|
|
CreateTranslationOptionsForRangeNew
|
2015-04-30 08:05:11 +03:00
|
|
|
( const DecodeGraph &decodeGraph, size_t startPos, size_t endPos,
|
2015-03-30 03:20:17 +03:00
|
|
|
bool adhereTableLimit, size_t graphInd)
|
2013-07-11 15:46:04 +04:00
|
|
|
{
|
|
|
|
InputPathList &inputPathList = GetInputPathList(startPos, endPos);
|
2015-02-06 02:31:39 +03:00
|
|
|
if (inputPathList.size() == 0) return false; // no input path matches!
|
2013-07-11 15:46:04 +04:00
|
|
|
InputPathList::iterator iter;
|
|
|
|
for (iter = inputPathList.begin(); iter != inputPathList.end(); ++iter) {
|
2013-07-11 19:20:15 +04:00
|
|
|
InputPath &inputPath = **iter;
|
2015-02-06 02:31:39 +03:00
|
|
|
TranslationOptionCollection::CreateTranslationOptionsForRange
|
2015-02-19 15:27:23 +03:00
|
|
|
(decodeGraph, startPos, endPos, adhereTableLimit, graphInd, inputPath);
|
2013-07-11 15:46:04 +04:00
|
|
|
}
|
2015-02-06 02:31:39 +03:00
|
|
|
return true;
|
2013-07-11 15:46:04 +04:00
|
|
|
}
|
|
|
|
|
2015-02-06 02:31:39 +03:00
|
|
|
bool
|
|
|
|
TranslationOptionCollectionConfusionNet::
|
|
|
|
CreateTranslationOptionsForRangeLEGACY(const DecodeGraph &decodeGraph, size_t startPos,
|
2015-02-19 15:27:23 +03:00
|
|
|
size_t endPos, bool adhereTableLimit, size_t graphInd)
|
2013-06-28 18:43:56 +04:00
|
|
|
{
|
2015-02-06 02:31:39 +03:00
|
|
|
bool retval = true;
|
|
|
|
XmlInputType intype = StaticData::Instance().GetXmlInputType();
|
|
|
|
if ((intype != XmlExclusive) || !HasXmlOptionsOverlappingRange(startPos,endPos)) {
|
2013-08-07 17:18:12 +04:00
|
|
|
InputPathList &inputPathList = GetInputPathList(startPos, endPos);
|
2015-02-19 15:27:23 +03:00
|
|
|
|
2013-07-11 19:20:15 +04:00
|
|
|
// partial trans opt stored in here
|
|
|
|
PartialTranslOptColl* oldPtoc = new PartialTranslOptColl;
|
|
|
|
size_t totalEarlyPruned = 0;
|
2013-06-28 18:43:56 +04:00
|
|
|
|
2013-07-11 19:20:15 +04:00
|
|
|
// initial translation step
|
|
|
|
list <const DecodeStep* >::const_iterator iterStep = decodeGraph.begin();
|
|
|
|
const DecodeStep &decodeStep = **iterStep;
|
|
|
|
|
2013-08-24 00:34:10 +04:00
|
|
|
static_cast<const DecodeStepTranslation&>(decodeStep).ProcessInitialTranslationLEGACY
|
2015-02-06 02:31:39 +03:00
|
|
|
(m_source, *oldPtoc, startPos, endPos, adhereTableLimit, inputPathList);
|
2013-06-28 18:43:56 +04:00
|
|
|
|
2013-07-11 19:20:15 +04:00
|
|
|
// do rest of decode steps
|
|
|
|
int indexStep = 0;
|
|
|
|
|
|
|
|
for (++iterStep ; iterStep != decodeGraph.end() ; ++iterStep) {
|
|
|
|
|
2013-08-07 15:11:39 +04:00
|
|
|
const DecodeStep *decodeStep = *iterStep;
|
|
|
|
const DecodeStepTranslation *transStep =dynamic_cast<const DecodeStepTranslation*>(decodeStep);
|
|
|
|
const DecodeStepGeneration *genStep =dynamic_cast<const DecodeStepGeneration*>(decodeStep);
|
|
|
|
|
2013-07-11 19:20:15 +04:00
|
|
|
PartialTranslOptColl* newPtoc = new PartialTranslOptColl;
|
|
|
|
|
|
|
|
// go thru each intermediate trans opt just created
|
|
|
|
const vector<TranslationOption*>& partTransOptList = oldPtoc->GetList();
|
|
|
|
vector<TranslationOption*>::const_iterator iterPartialTranslOpt;
|
2014-05-19 17:34:27 +04:00
|
|
|
for (iterPartialTranslOpt = partTransOptList.begin();
|
|
|
|
iterPartialTranslOpt != partTransOptList.end();
|
|
|
|
++iterPartialTranslOpt) {
|
2013-07-11 19:20:15 +04:00
|
|
|
TranslationOption &inputPartialTranslOpt = **iterPartialTranslOpt;
|
|
|
|
|
2013-08-07 15:11:39 +04:00
|
|
|
if (transStep) {
|
2013-08-24 00:34:10 +04:00
|
|
|
transStep->ProcessLEGACY(inputPartialTranslOpt
|
2013-08-07 17:18:12 +04:00
|
|
|
, *decodeStep
|
|
|
|
, *newPtoc
|
|
|
|
, this
|
2013-08-08 20:10:56 +04:00
|
|
|
, adhereTableLimit);
|
2013-08-07 17:18:12 +04:00
|
|
|
} else {
|
2013-11-20 15:59:36 +04:00
|
|
|
assert(genStep);
|
2013-08-07 17:18:12 +04:00
|
|
|
genStep->Process(inputPartialTranslOpt
|
2013-08-07 15:11:39 +04:00
|
|
|
, *decodeStep
|
2013-07-11 19:20:15 +04:00
|
|
|
, *newPtoc
|
|
|
|
, this
|
2013-08-08 20:10:56 +04:00
|
|
|
, adhereTableLimit);
|
2013-08-07 15:11:39 +04:00
|
|
|
}
|
2013-06-28 18:43:56 +04:00
|
|
|
}
|
|
|
|
|
2013-07-11 19:20:15 +04:00
|
|
|
// last but 1 partial trans not required anymore
|
|
|
|
totalEarlyPruned += newPtoc->GetPrunedCount();
|
2013-06-28 18:43:56 +04:00
|
|
|
delete oldPtoc;
|
2013-07-11 19:20:15 +04:00
|
|
|
oldPtoc = newPtoc;
|
|
|
|
|
|
|
|
indexStep++;
|
|
|
|
} // for (++iterStep
|
|
|
|
|
|
|
|
// add to fully formed translation option list
|
|
|
|
PartialTranslOptColl &lastPartialTranslOptColl = *oldPtoc;
|
|
|
|
const vector<TranslationOption*>& partTransOptList = lastPartialTranslOptColl.GetList();
|
|
|
|
vector<TranslationOption*>::const_iterator iterColl;
|
|
|
|
for (iterColl = partTransOptList.begin() ; iterColl != partTransOptList.end() ; ++iterColl) {
|
|
|
|
TranslationOption *transOpt = *iterColl;
|
|
|
|
Add(transOpt);
|
|
|
|
}
|
|
|
|
|
|
|
|
lastPartialTranslOptColl.DetachAll();
|
|
|
|
totalEarlyPruned += oldPtoc->GetPrunedCount();
|
|
|
|
delete oldPtoc;
|
|
|
|
// TRACE_ERR( "Early translation options pruned: " << totalEarlyPruned << endl);
|
2013-06-28 18:43:56 +04:00
|
|
|
|
2015-02-06 02:31:39 +03:00
|
|
|
} // if ((intype != XmlExclusive) || !HasXmlOptionsOverlappingRange(startPos,endPos))
|
2015-02-19 15:27:23 +03:00
|
|
|
|
|
|
|
|
|
|
|
if (graphInd == 0 && intype != XmlPassThrough &&
|
2015-02-06 02:31:39 +03:00
|
|
|
HasXmlOptionsOverlappingRange(startPos,endPos)) {
|
2013-06-28 18:43:56 +04:00
|
|
|
CreateXmlOptionsForRange(startPos, endPos);
|
|
|
|
}
|
2015-02-06 02:31:39 +03:00
|
|
|
return retval;
|
2013-06-28 18:43:56 +04:00
|
|
|
}
|
|
|
|
|
2013-07-11 15:37:20 +04:00
|
|
|
|
2008-10-09 03:51:26 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
|