// September 2015
// Levee Patroller / Dijk Patrouille
// This source file is (c) by Deltares. This source file is open source but only available to select users. Do not redistribute without written permission of Stichting Deltares, Delft, The Netherlands.
// This header has been automatically generated.



//=============================================================================
// Object that contains signal string data
//
// ------------------------------------------------------------
//  Created by Rui Guimaraes
//  © 2006, Geodelft
//
// Date       Id   Modification
// 2006-07-26 Zmr  Added GetNrAllQuestions, GetAllQuestionStrings,ConcatStringArray,
//                 ConcatAnswerArray and GetAllAnswers
// 2006-08-11 The  Replaced HeightDifference with HeightDifference (from
//                 SignalReportSettlement)
// 2006-10-27 Zmr  Added Strings from Settlement and...
// 2007-02-20 Bze  Fixed "uitspoeiling" typo
// 2007-06-01 wsl  Commented away all log statements
// 2007-06-01 wsl  for howserious of RipRap, checked for both elementsLoose and elementsMissingOrMoved
// 2007-06-29 wsl  fixed two bugs in howserious of RipRap, regarding not giving reasons & size relevancy
// 2007-07-02 wsl  fixed bug in howserious of HorizontalMovement, regarding size relevancy
//=============================================================================
class SignalStringDataDroogte extends SignalStringData
dependsOn(Signal);

/*
struct AnswerStruct
{
        var string Answers[8];                          // max of 8 strings of answers to signal questions: not all elements used!!!
};

struct HowSeriousStruct
{
        var GeoEnums.GeoStates states;              // the seriousness of the failure, according to the observations done
        var array<string> ReasonNot_NotSerious;         // summation of reasons why the failure is worse than reportable/not serious
        var array<string> ReasonNot_Serious;            // summation of reasons why the failure is not relevant/serious
        var array<string> ReasonNot_VerySerious;        // summation of reasons why the failure is less serious than critical/very serious
                                                        // every string in these arrays is for one signal; one string can
                                                        // contain multiple reasons for a signal
};

//  WATCH OUT! DUPLICATE DEFINITION!
//  When changing this enum in Signal, be sure to make the same changes here and in MenuConversation!
//  DependsOn(Signal) does not work here for some reason (it did for other classes).
//
//  When you want to call an signal or call function which depends on GeoSignalTypes. Just
//  TypeCast it to an int and in the function it is then typecasted back to an GeoSignalTypesTwo.

var() enum GeoSignalTypesTwo
{
       SIG_RipRapPitching,
       SIG_GrassRevetment,
       SIG_Crack,
       SIG_Settlement,
       SIG_HorizontalMovement,
       SIG_Uprise,
       SIG_Liquefaction,
       SIG_WaterOutflow,
       SIG_OverToppingWash,
       SIG_FloatingWasteOther,
       SIG_HumanActivity,
       SIG_BioActivity,

       SIG_NONE


} TempSignalType;
*/

var array<string>       EN_TelWoorden,
                        NL_TelWoorden;

var array<string>       EmptyStringArray;
var array<AnswerStruct> EmptyAnswerStructArray;


var array<string>       EN_CrossCut_QuestionStrings,
                        NL_CrossCut_QuestionStrings,
                        EN_CrossCut_Question_Short, //The question in one or two words
                        NL_CrossCut_Question_Short, //The question in one or two words
                        EN_CrossCut_Missing,
                        NL_CrossCut_Missing;

var array<AnswerStruct> EN_CrossCut_AnswerString,
                        NL_CrossCut_AnswerString;



var int                 RipPitching_NrQuestions;             // number of questions in menu
var array<string>       EN_RipPitching_QuestionStrings,      // one string per question: not all elements used!!!
                        EN_RipPitching_Question_Short,       //The question in one or two words
                        NL_RipPitching_QuestionStrings,
                        NL_RipPitching_Question_Short,       //The question in one or two words
                        EN_RipPitching_Missing,
                        NL_RipPitching_Missing;


var array<AnswerStruct> EN_RipPitching_AnswerStrings;        // one set of answer strings per question
var array<AnswerStruct> NL_RipPitching_AnswerStrings;

var int                 Grass_NrQuestions;
var array<string>       EN_Grass_QuestionStrings,
                        NL_Grass_QuestionStrings,
                        EN_Grass_Question_Short,            //The question in one or two words
                        NL_Grass_Question_Short,            //The question in one or two words
                        EN_Grass_Missing,
                        NL_Grass_Missing;



var array<AnswerStruct> EN_Grass_AnswerStrings;
var array<AnswerStruct> NL_Grass_AnswerStrings;

var int                 Crack_NrQuestions;
var array<string>       EN_Crack_QuestionStrings,
                        NL_Crack_QuestionStrings,
                        EN_Crack_Question_Short,            //The question in one or two words
                        NL_Crack_Question_Short,            //The question in one or two words
                        EN_Crack_Missing,
                        NL_Crack_Missing;


var array<AnswerStruct> EN_Crack_AnswerStrings;
var array<AnswerStruct> NL_Crack_AnswerStrings;

var int                 Settlement_NrQuestions;
var array<string>       EN_Settlement_QuestionStrings,
                        NL_Settlement_QuestionStrings,
                        EN_Settlement_Question_Short,       //The question in one or two words
                        NL_Settlement_Question_Short,       //The question in one or two words
                        EN_Settlement_Missing,
                        NL_Settlement_Missing;


var array<AnswerStruct> EN_Settlement_AnswerStrings;
var array<AnswerStruct> NL_Settlement_AnswerStrings;

var int                 HorizontalMovement_NrQuestions;
var array<string>       EN_HorizontalMovement_QuestionStrings,
                        NL_HorizontalMovement_QuestionStrings,
                        EN_HorizontalMovement_Question_Short,//The question in one or two words
                        NL_HorizontalMovement_Question_Short,//The question in one or two words
                        EN_HorizontalMovement_Missing,
                        NL_HorizontalMovement_Missing;


var array<AnswerStruct> EN_HorizontalMovement_AnswerStrings;
var array<AnswerStruct> NL_HorizontalMovement_AnswerStrings;

var int                 Uprise_NrQuestions;
var array<string>       EN_Uprise_QuestionStrings,
                        NL_Uprise_QuestionStrings,
                        EN_Uprise_Question_Short,//The question in one or two words
                        NL_Uprise_Question_Short,//The question in one or two words
                        EN_Uprise_Missing,
                        NL_Uprise_Missing;


var array<AnswerStruct> EN_Uprise_AnswerStrings;
var array<AnswerStruct> NL_Uprise_AnswerStrings;

var int                 Liquefaction_NrQuestions;
var array<string>       EN_Liquefaction_QuestionStrings,
                        NL_Liquefaction_QuestionStrings,
                        EN_Liquefaction_Question_Short,//The question in one or two words
                        NL_Liquefaction_Question_Short,//The question in one or two words
                        EN_Liquefaction_Missing,
                        NL_Liquefaction_Missing;


var array<AnswerStruct> EN_Liquefaction_AnswerStrings;
var array<AnswerStruct> NL_Liquefaction_AnswerStrings;

var int                 WaterOutflow_NrQuestions;
var array<string>       EN_WaterOutflow_QuestionStrings,
                        NL_WaterOutflow_QuestionStrings,
                        EN_WaterOutflow_Question_Short,//The question in one or two words
                        NL_WaterOutflow_Question_Short,//The question in one or two words
                        EN_WaterOutflow_Missing,
                        NL_WaterOutflow_Missing;


var array<AnswerStruct> EN_WaterOutflow_AnswerStrings;
var array<AnswerStruct> NL_WaterOutflow_AnswerStrings;

var int                 OverToppingWash_NrQuestions;
var array<string>       EN_OverToppingWash_QuestionStrings,
                        NL_OverToppingWash_QuestionStrings,
                        EN_OverToppingWash_Question_Short,//The question in one or two words
                        NL_OverToppingWash_Question_Short,//The question in one or two words
                        EN_OverToppingWash_Missing,
                        NL_OverToppingWash_Missing;

var array<AnswerStruct> EN_OverToppingWash_AnswerStrings;
var array<AnswerStruct> NL_OverToppingWash_AnswerStrings;

var int                 FloatingWaste_NrQuestions;
var array<string>       EN_FloatingWaste_QuestionStrings,
                        NL_FloatingWaste_QuestionStrings,
                        EN_FloatingWaste_Question_Short,//The question in one or two words
                        NL_FloatingWaste_Question_Short,//The question in one or two words
                        EN_FloatingWaste_Missing,
                        NL_FloatingWaste_Missing;

var array<AnswerStruct> EN_FloatingWaste_AnswerStrings;
var array<AnswerStruct> NL_FloatingWaste_AnswerStrings;

var int                 HumanActivity_NrQuestions;
var array<string>       EN_HumanActivity_QuestionStrings,
                        NL_HumanActivity_QuestionStrings,
                        EN_HumanActivity_Question_Short,//The question in one or two words
                        NL_HumanActivity_Question_Short,//The question in one or two words
                        EN_HumanActivity_Missing,
                        NL_HumanActivity_Missing;


var array<AnswerStruct> EN_HumanActivity_AnswerStrings;
var array<AnswerStruct> NL_HumanActivity_AnswerStrings;

var int                 BioActivity_NrQuestions;
var array<string>       EN_BioActivity_QuestionStrings,
                        NL_BioActivity_QuestionStrings,
                        EN_BioActivity_Question_Short,//The question in one or two words
                        NL_BioActivity_Question_Short,//The question in one or two words
                        EN_BioActivity_Missing,
                        NL_BioActivity_Missing;

var array<AnswerStruct> EN_BioActivity_AnswerStrings;
var array<AnswerStruct> NL_BioActivity_AnswerStrings;

var string        EN_About;
var string        NL_About;


var string        EN_SignalLocation;
var string        NL_SignalLocation;

var string        EN_De;
var string        NL_De;

var string        EN_Het;
var string        NL_Het;

var string        EN_ALittle;
var string        NL_ALittle;

var string        EN_Quite;
var string        NL_Quite;

var string        EN_Length;
var string        NL_Length;

var string        EN_Width;
var string        NL_Width;

var string        EN_Dept;
var string        NL_Dept;

var string        EN_Dept1;
var string        NL_Dept1;

var string        EN_Flushing;
var string        NL_Flushing;

var string        EN_M;
var string        NL_M;

var string        EN_CM;
var string        NL_CM;

var string        EN_NoMissingElements;
var string        NL_NoMissingElements;

var string        EN_MissingElements;
var string        NL_MissingElements;

var string        EN_Occurs;
var string        NL_Occurs;

var string        EN_NotOccurs;
var string        NL_NotOccurs;

var string        EN_Little;
var string        NL_Little;

var string        EN_Heavily;
var string        NL_Heavily;

var string        EN_Huge;
var string        NL_Huge;

var string        EN_NOLooseElements;
var string        NL_NOLooseElements;

var string        EN_LooseElements;
var string        NL_LooseElements;

var string        EN_Located;
var string        NL_Located;

var string        EN_IsA;
var string        NL_IsA;

var string        EN_Perp;
var string        NL_Perp;

var string        EN_Par;
var string        NL_Par;

var string        EN_Grass;
var string        NL_Grass;

var string        EN_Asphalt;
var string        NL_Asphalt;

var string        EN_MultipleCracks;
var string        NL_MultipleCracks;

var string        EN_NoMultipleCracks;
var string        NL_NoMultipleCracks;

var string        EN_Directed;
var string        NL_Directed;

var string        EN_Hinter;
var string        NL_Hinter;

var string        EN_Fore;
var string        NL_Fore;

var string        EN_EntireL;
var string        NL_EntireL;

var string        EN_Velocity;
var string        NL_Velocity;

var string        EN_AmountOut;
var string        NL_AmountOut;

var string        EN_Outflow;
var string        NL_Outflow;

var string        EN_Multiple;
var string        NL_Multiple;

var string        EN_Slow;
var string        NL_Slow;

var string        EN_Fast;
var string        NL_Fast;

var string        EN_Levee;
var string        NL_Levee;

var string        EN_Acc;
var string        NL_Acc;

var string        EN_Infi;
var string        NL_Infi;

var string        EN_AmountOver;
var string        NL_AmountOver;

var string        EN_Waves;
var string        NL_Waves;

var string        EN_OverT;
var string        NL_OverT;

var string        EN_OverW;
var string        NL_OverW;

var string        EN_Not;
var string        NL_Not;

var string        EN_Surface,
        NL_Surface,

        NL_Surface2,

        EN_Surface3,
        NL_Surface3,

        EN_NotOccur,
        NL_NotOccur,

        EN_Damage,
        NL_Damage,

        EN_Small,
        NL_Small,

        EN_Large,
        NL_Large,
        NL_Large2,

        EN_Very,
        NL_Very,

        EN_Of,
        NL_Of,

        EN_At,
        NL_At,

        EN_On,
        NL_On,

        EN_Is,
        NL_Is,

        EN_Deep,
        NL_Deep,

        EN_WhatA,
        NL_WhatA,

        EN_Width2,
        NL_Width2,


        EN_Wide,
        NL_Wide,

        EN_Length2,
        NL_Length2,

        EN_And,
        NL_And,
        
        EN_Or,
        NL_Or,

        EN_But,
        NL_But,

        EN_A,
        NL_A,

        EN_Signal,
        NL_Signal,
        
        EN_Observation,
        NL_Observation,

        EN_AC,
        NL_AC;



// get the number of questions specific to the signal type (so excl. signal location)
function int GetNrQuestions(int SignalType)
{

        local GeoSignalTypesTwo type;

        type = GeoSignalTypesTwo(SignalType);
        switch (type)
        {
                case SIG_RipRapPitching:

                        return RipPitching_NrQuestions;

                case SIG_GrassRevetment:

                        return Grass_NrQuestions;

                case SIG_Crack:

                        return Crack_NrQuestions;

                case SIG_Settlement:

                        return Settlement_NrQuestions;

                case SIG_HorizontalMovement:

                        return HorizontalMovement_NrQuestions;

                case SIG_Uprise:

                        return Uprise_NrQuestions;

                case SIG_Liquefaction:

                        return Liquefaction_NrQuestions;

                case SIG_WaterOutflow:

                        return WaterOutflow_NrQuestions;

                case SIG_OverToppingWash:

                        return OverToppingWash_NrQuestions;

                case SIG_FloatingWasteOther:

                        return FloatingWaste_NrQuestions;

                case SIG_HumanActivity:

                        return HumanActivity_NrQuestions;

                case SIG_BioActivity:

                        return BioActivity_NrQuestions;

                default:
                        return -1;
        }

}


//This function returns the nr of all the questions (including the signal location).
function int GetNrAllQuestions(int SignalType)
{
        return GetNrQuestions(SignalType)+1;
}

function array<string> GetQuestionStrings(int SignalType, bool dutch)
{
        local array<string> returner;

        local GeoSignalTypesTwo type;

        type = GeoSignalTypesTwo(SignalType);
        switch (type)
        {
                case SIG_RipRapPitching:

                        if(dutch)
                                returner = NL_RipPitching_QuestionStrings;
                        else
                                returner = EN_RipPitching_QuestionStrings;
                        break;

                case SIG_GrassRevetment:

                        if(dutch)
                                returner = NL_Grass_QuestionStrings;
                        else
                                returner = EN_Grass_QuestionStrings;
                        break;
                case SIG_Crack:

                        if(dutch)
                                returner = NL_Crack_QuestionStrings;
                        else
                                returner = EN_Crack_QuestionStrings;
                        break;
                case SIG_Settlement:

                        if(dutch)
                                returner = NL_Settlement_QuestionStrings;
                        else
                                returner = EN_Settlement_QuestionStrings;
                        break;
                case SIG_HorizontalMovement:

                        if(dutch)
                                returner = NL_HorizontalMovement_QuestionStrings;
                        else
                                returner = EN_HorizontalMovement_QuestionStrings;
                        break;
                case SIG_Uprise:

                        if(dutch)
                                returner = NL_Uprise_QuestionStrings;
                        else
                                returner = EN_Uprise_QuestionStrings;
                        break;
                case SIG_Liquefaction:

                        if(dutch)
                                returner = NL_Liquefaction_QuestionStrings;
                        else
                                returner = EN_Liquefaction_QuestionStrings;
                        break;
                case SIG_WaterOutflow:

                        if(dutch)
                                returner = NL_WaterOutflow_QuestionStrings;
                        else
                                returner = EN_WaterOutflow_QuestionStrings;
                        break;
                case SIG_OverToppingWash:

                        if(dutch)
                                returner = NL_OverToppingWash_QuestionStrings;
                        else
                                returner = EN_OverToppingWash_QuestionStrings;
                        break;
                case SIG_FloatingWasteOther:

                        if(dutch)
                                returner = NL_FloatingWaste_QuestionStrings;
                        else
                                returner = EN_FloatingWaste_QuestionStrings;
                        break;
                case SIG_HumanActivity:

                        if(dutch)
                                returner = NL_HumanActivity_QuestionStrings;
                        else
                                returner = EN_HumanActivity_QuestionStrings;
                        break;
                case SIG_BioActivity:

                        if(dutch)
                                returner = NL_BioActivity_QuestionStrings;
                        else
                                returner = EN_BioActivity_QuestionStrings;
                        break;
                default:
                        returner = EmptyStringArray;
        }
        return returner;

}

//This function returns all the questionstrings (including the signal location).In the right order.(See the switch)
function array<string> GetAllQuestionStrings(int SignalType, bool dutch)
{
        local array<string> returner;
        local GeoSignalTypesTwo type;
        local string            temp;

        returner = GetQuestionStrings(SignalType, dutch);

        type = GeoSignalTypesTwo(SignalType);
        switch (type)
        {
                case SIG_RipRapPitching:
                        temp = returner[6];
                        returner[6] = returner[5];
                        returner[5] = returner[4];
                        returner[4] = returner[3];
                        returner[3] = returner[2];
                        returner[2] = returner[1];
                        returner[1] = temp;
                        break;
                case SIG_OverToppingWash:
                        temp = returner[6];
                        returner[6] = returner[5];
                        returner[5] = returner[4];
                        returner[4] = returner[3];
                        returner[3] = returner[2];
                        returner[2] = returner[1];
                        returner[1] = temp;
                        break;
                default:

        }
        if(dutch)
                return ConcatStringArray(NL_CrossCut_QuestionStrings,returner);
        else
                return ConcatStringArray(EN_CrossCut_QuestionStrings,returner);
}


function array<string> GetQuestionShortStrings(int SignalType, bool dutch)
{
        local array<string> returner;
        local GeoSignalTypesTwo type;
        type = GeoSignalTypesTwo(SignalType);

        switch (type)
        {
                case SIG_RipRapPitching:
                        if(dutch)
                                returner = NL_RipPitching_Question_Short;
                        else
                                returner = EN_RipPitching_Question_Short;
                        break;

                case SIG_GrassRevetment:
                        if(dutch)
                                returner = NL_Grass_Question_Short;
                        else
                                returner = EN_Grass_Question_Short;
                        break;
                case SIG_Crack:
                        if(dutch)
                                returner = NL_Crack_Question_Short;
                        else
                                returner = EN_Crack_Question_Short;
                        break;
                case SIG_Settlement:

                        if(dutch)
                                returner = NL_Settlement_Question_Short;
                        else
                                returner = EN_Settlement_Question_Short;
                        break;
                case SIG_HorizontalMovement:

                        if(dutch)
                                returner = NL_HorizontalMovement_Question_Short;
                        else
                                returner = EN_HorizontalMovement_Question_Short;
                        break;
                case SIG_Uprise:

                        if(dutch)
                                returner = NL_Uprise_Question_Short;
                        else
                                returner = EN_Uprise_Question_Short;
                        break;
                case SIG_Liquefaction:

                        if(dutch)
                                returner = NL_Liquefaction_Question_Short;
                        else
                                returner = EN_Liquefaction_Question_Short;
                        break;
                case SIG_WaterOutflow:

                        if(dutch)
                                returner = NL_WaterOutflow_Question_Short;
                        else
                                returner = EN_WaterOutflow_Question_Short;
                        break;
                case SIG_OverToppingWash:

                        if(dutch)
                                returner = NL_OverToppingWash_Question_Short;
                        else
                                returner = EN_OverToppingWash_Question_Short;
                        break;
                case SIG_FloatingWasteOther:

                        if(dutch)
                                returner = NL_FloatingWaste_Question_Short;
                        else
                                returner = EN_FloatingWaste_Question_Short;
                        break;
                case SIG_HumanActivity:

                        if(dutch)
                                returner = NL_HumanActivity_Question_Short;
                        else
                                returner = EN_HumanActivity_Question_Short;
                        break;
                case SIG_BioActivity:

                        if(dutch)
                                returner = NL_BioActivity_Question_Short;
                        else
                                returner = EN_BioActivity_Question_Short;
                        break;
                default:
                        returner = EmptyStringArray;
        }

        return returner;
}
// return al the missing strings
function array<string> GetQuestionMissingStrings(int SignalType, bool dutch)
{
        local array<string> returner;
        local GeoSignalTypesTwo type;
        type = GeoSignalTypesTwo(SignalType);

        switch (type)
        {
                case SIG_RipRapPitching:
                        if(dutch)
                                returner = NL_RipPitching_Missing;
                        else
                                returner = EN_RipPitching_Missing;
                        break;

                case SIG_GrassRevetment:
                        if(dutch)
                                returner = NL_Grass_Missing;
                        else
                                returner = EN_Grass_Missing;
                        break;
                case SIG_Crack:
                        if(dutch)
                                returner = NL_Crack_Missing;
                        else
                                returner = EN_Crack_Missing;
                        break;
                case SIG_Settlement:

                        if(dutch)
                                returner = NL_Settlement_Missing;
                        else
                                returner = EN_Settlement_Missing;
                        break;
                case SIG_HorizontalMovement:

                        if(dutch)
                                returner = NL_HorizontalMovement_Missing;
                        else
                                returner = EN_HorizontalMovement_Missing;
                        break;
                case SIG_Uprise:

                        if(dutch)
                                returner = NL_Uprise_Missing;
                        else
                                returner = EN_Uprise_Missing;
                        break;
                case SIG_Liquefaction:

                        if(dutch)
                                returner = NL_Liquefaction_Missing;
                        else
                                returner = EN_Liquefaction_Missing;
                        break;
                case SIG_WaterOutflow:

                        if(dutch)
                                returner = NL_WaterOutflow_Missing;
                        else
                                returner = EN_WaterOutflow_Missing;
                        break;
                case SIG_OverToppingWash:

                        if(dutch)
                                returner = NL_OverToppingWash_Missing;
                        else
                                returner = EN_OverToppingWash_Missing;
                        break;
                case SIG_FloatingWasteOther:

                        if(dutch)
                                returner = NL_FloatingWaste_Missing;
                        else
                                returner = EN_FloatingWaste_Missing;
                        break;
                case SIG_HumanActivity:

                        if(dutch)
                                returner = NL_HumanActivity_Missing;
                        else
                                returner = EN_HumanActivity_Missing;
                        break;
                case SIG_BioActivity:

                        if(dutch)
                                returner = NL_BioActivity_Missing;
                        else
                                returner = EN_BioActivity_Missing;
                        break;
                default:
                        returner = EmptyStringArray;
        }

        return returner;
}

//This function returns all the missing question strings (including the signal location).In the right order.(See the switch)
function array<string> GetAllQuestionMissingStrings(int SignalType, bool dutch)
{
        local array<string>     returner;
        local GeoSignalTypesTwo type;
        local string            temp;

        returner = GetQuestionMissingStrings(SignalType, dutch);

        type = GeoSignalTypesTwo(SignalType);
        switch (type)
        {

                case SIG_RipRapPitching:
                        temp = returner[6];
                        returner[6] = returner[5];
                        returner[5] = returner[4];
                        returner[4] = returner[3];
                        returner[3] = returner[2];
                        returner[2] = returner[1];
                        returner[1] = temp;
                        break;

                case SIG_OverToppingWash:
                        temp = returner[5];
                        returner[6] = returner[5];
                        returner[5] = returner[4];
                        returner[4] = returner[3];
                        returner[3] = returner[2];
                        returner[2] = returner[1];
                        returner[1] = temp;
                        break;

                default:



        }
        if(dutch)
                return ConcatStringArray(NL_CrossCut_Missing, returner);
        else
                return ConcatStringArray(EN_CrossCut_Missing, returner);
}

//This function returns all the questionshorts (including the signal location).In the right order.(See the switch)
function array<string> GetAllQuestionShortStrings(int SignalType, bool dutch)
{
        local array<string>     returner;
        local GeoSignalTypesTwo type;
        local string            temp;

        returner = GetQuestionShortStrings(SignalType, dutch);

        type = GeoSignalTypesTwo(SignalType);
        switch (type)
        {

                case SIG_RipRapPitching:
                        temp = returner[6];
                        returner[6] = returner[5];
                        returner[5] = returner[4];
                        returner[4] = returner[3];
                        returner[3] = returner[2];
                        returner[2] = returner[1];
                        returner[1] = temp;
                        break;

                case SIG_OverToppingWash:
                        temp = returner[6];
                        returner[6] = returner[5];
                        returner[5] = returner[4];
                        returner[4] = returner[3];
                        returner[3] = returner[2];
                        returner[2] = returner[1];
                        returner[1] = temp;
                        break;

                default:



        }
        if(dutch)
                return ConcatStringArray(NL_CrossCut_Question_Short, returner);
        else
                return ConcatStringArray(EN_CrossCut_Question_Short, returner);
}


function array<AnswerStruct> GetAnswerStrings(int SignalType, bool dutch)
{
        local GeoSignalTypesTwo type;

        type = GeoSignalTypesTwo(SignalType);
        switch (type)
        {
                case SIG_RipRapPitching:

                        if(dutch)
                                return NL_RipPitching_AnswerStrings;
                        else
                                return EN_RipPitching_AnswerStrings;
                        break;
                case SIG_GrassRevetment:

                        if(dutch)
                                return NL_Grass_AnswerStrings;
                        else
                                return EN_Grass_AnswerStrings;
                        break;
                case SIG_Crack:

                        if(dutch)
                                return NL_Crack_AnswerStrings;
                        else
                                return EN_Crack_AnswerStrings;
                        break;
                case SIG_Settlement:

                        if(dutch)
                                return NL_Settlement_AnswerStrings;
                        else
                                return EN_Settlement_AnswerStrings;
                        break;
                case SIG_HorizontalMovement:

                        if(dutch)
                                return NL_HorizontalMovement_AnswerStrings;
                        else
                                return EN_HorizontalMovement_AnswerStrings;
                        break;
                case SIG_Uprise:

                        if(dutch)
                                return NL_Uprise_AnswerStrings;
                        else
                                return EN_Uprise_AnswerStrings;
                        break;
                case SIG_Liquefaction:

                        if(dutch)
                                return NL_Liquefaction_AnswerStrings;
                        else
                                return EN_Liquefaction_AnswerStrings;
                        break;
                case SIG_WaterOutflow:

                        if(dutch)
                                return NL_WaterOutflow_AnswerStrings;
                        else
                                return EN_WaterOutflow_AnswerStrings;
                        break;
                case SIG_OverToppingWash:

                        if(dutch)
                                return NL_OverToppingWash_AnswerStrings;
                        else
                                return EN_OverToppingWash_AnswerStrings;
                        break;
                case SIG_FloatingWasteOther:

                        if(dutch)
                                return NL_FloatingWaste_AnswerStrings;
                        else
                                return EN_FloatingWaste_AnswerStrings;
                        break;
                case SIG_HumanActivity:

                        if(dutch)
                                return NL_HumanActivity_AnswerStrings;
                        else
                                return EN_HumanActivity_AnswerStrings;
                        break;
                case SIG_BioActivity:

                        if(dutch)
                                return NL_BioActivity_AnswerStrings;
                        else
                                return EN_BioActivity_AnswerStrings;
                        break;
                default:
                        return EmptyAnswerStructArray;

        }
}



//This function returns all the answerstructs (including the signal location).In the right order.(See the switch)
function array<AnswerStruct> GetAllAnswerStrings(int SignalType, bool dutch)
{
        local array<AnswerStruct> returner;
        local AnswerStruct temp;
        local GeoSignalTypesTwo type;

        returner = GetAnswerStrings(SignalType, dutch);

        type = GeoSignalTypesTwo(SignalType);
        switch (type)
        {

                case SIG_RipRapPitching:
                        temp = returner[6];
                        returner[6] = returner[5];
                        returner[5] = returner[4];
                        returner[4] = returner[3];
                        returner[3] = returner[2];
                        returner[2] = returner[1];
                        returner[1] = temp;
                        break;

                case SIG_OverToppingWash:
                        temp = returner[6];
                        returner[6] = returner[5];
                        returner[5] = returner[4];
                        returner[4] = returner[3];
                        returner[3] = returner[2];
                        returner[2] = returner[1];
                        returner[1] = temp;
                        break;

                default:
        }

        if(dutch)
                return ConcatAnswerArray(NL_CrossCut_AnswerString,returner);
        else
                return ConcatAnswerArray(EN_CrossCut_AnswerString,returner);

}

// This function returns an array<int>.
// When the value is -1 the question is not answered yet;
// When the value is -2 the question did not have to be answered (was not applicable).
function array<int> GetAllAnswers(signal Sig, int ReportIndex)
{
        local array<int> Returner;
        local int       i;

        local SignalRipPitching SigRip;
        local SignalReportRipPitching SigReportRip;

        local SignalGrass SigGrass;
        local SignalReportGrass SigReportGrass;

        local SignalCrack SigCrack;
        local SignalReportCrack SigReportCrack;

        local SignalSettlement SigSett;
        local SignalReportSettlement SigReportSett;

        local SignalHorizontalMovement SigHor;
        local SignalReportHorizontalMovement SigReportHor;

        local SignalUprise SigUp;
        local SignalReportUprise SigReportUp;

        local SignalLiquefaction SigLiq;
        local SignalReportLiquefaction SigReportLiq;

        local SignalWaterOutflow SigFlow;
        local SignalReportWaterOutflow SigReportFlow;

        local SignalOverToppingWash SigWas;
        local SignalReportOverToppingWash SigReportWas;

        local SignalFloatingWaste SigFlo;

        local SignalHumanActivity SigHum;

        local SignalBioActivity SigBio;


        i = 0;

        //question 1 is for every signal the same

        Returner.Insert(i,1);
        if(Sig.CrossCutLocation==Cut_NONE)
                returner[i]=-1;
        else
                returner[i]=Sig.CrossCutLocation;
        i++;

        switch(Sig.SignalType)
        {
                case SIG_RipRapPitching:
                        Returner.Insert(i,RipPitching_NrQuestions);
                        SigRip = SignalRipPitching(Sig);
                        SigReportRip = SignalReportRipPitching(SigRip.SignalReports[ReportIndex]);

                        //question 2
                        Returner[i] = SigRip.RevetmentType-2;       // WATCH OUT! substract 2 because of the value this has in the enum
                        //There is no answer filled in yet.
                        if(Returner[i]== 2)
                                Returner[i] =-1;
                        i++;

                        //question8(2A)
                        if(SigRip.RevetmentType == REV_PitchingStone)// pitching stone
                        {
                                Returner[i] = SigReportRip.ElementsLoose;
                                if(Returner[i]== 2)
                                        Returner[i]=-1;
                        }
                        else
                        {
                                Returner[i] = -2;
                        }
                        i++;

                        //question3
                        Returner[i] = SigReportRip.LengthOfDamage;
                         //There is no answer filled in yet.
                        if(Returner[i]== 6)
                                Returner[i]=-1;
                        i++;

                        //question4
                        Returner[i] = SigReportRip.WidthOfDamage;
                         //There is no answer filled in yet.
                        if(Returner[i]== 6)
                                Returner[i]=-1;
                        i++;

                        //question5
                        Returner[i] = SigReportRip.ElementsMissingOrMoved;
                        if(Returner[i]== 2)
                                Returner[i]=-1;
                        i++;

                        //question6
                        Returner[i] = SigReportRip.FlushingSoil;
                        if(Returner[i]== 2)
                                Returner[i]=-1;
                        i++;

                        //question7(6A)
                        if(SigReportRip.FlushingSoil == GEO_Yes)
                        {
                                Returner[i] = SigReportRip.FlushingSoilQuantity;
                                if(Returner[i]== 2)
                                        Returner[i]=-1;
                        }
                        else
                        {
                                Returner[i] = -2;
                        }
                        i++;

                        break;


                case SIG_GrassRevetment:
                        Returner.Insert(i,Grass_NrQuestions);
                        SigGrass= SignalGrass(Sig);
                        SigReportGrass = SignalReportGrass(SigGrass.SignalReports[ReportIndex]);

                        //question 2
                        Returner[i] = SigReportGrass.LengthOfDamage;
                         //There is no answer filled in yet.
                        if(Returner[i]== 6)
                                Returner[i]=-1;
                        i++;

                        //question 3
                        Returner[i] = SigReportGrass.WidthOfDamage;
                         //There is no answer filled in yet.
                        if(Returner[i]== 6)
                                Returner[i]=-1;
                        i++;

                        /*//question 4  Variable is not used anymore
                        Returner[i] = SigReportGrass.DepthOfDamage;
                         //There is no answer filled in yet.
                        if(Returner[i]== 6)
                                Returner[i]=-2;
                        i++;*/
                        break;

                case SIG_Crack:
                        Returner.Insert(i,Crack_NrQuestions);
                        SigCrack = SignalCrack(Sig);
                        SigReportCrack = SignalReportCrack(SigCrack.SignalReports[ReportIndex]);

                        //question 2
                        Returner[i] = SigCrack.RevetmentType;
                         //There is no answer filled in yet.
                        if(Returner[i]> 1)
                                Returner[i]=-1;
                        i++;

                        //question 3
                        Returner[i] = SigCrack.CrackType;
                         //There is no answer filled in yet.
                        if(Returner[i] == 2)
                                Returner[i]=-1;
                        i++;

                        //question 4
                        Returner[i] = SigReportCrack.LengthOfDamage;
                         //There is no answer filled in yet.
                        if(Returner[i] == 6)
                                Returner[i]=-1;
                        i++;

                        //question 5
                        Returner[i] = SigReportCrack.WidthOfDamage;
                         //There is no answer filled in yet.
                        if(Returner[i] == 6)
                                Returner[i]=-1;
                        i++;

                        //question 6
                        Returner[i] = SigReportCrack.MultipleCracks;
                         //There is no answer filled in yet.
                        if(Returner[i] == 2)
                                Returner[i]=-1;
                        i++;

                        //question 7
                        Returner[i] = SigReportCrack.FlushingSoil;
                         //There is no answer filled in yet.
                        if(Returner[i] == 2)
                                Returner[i]=-1;
                        i++;

                        //question 8(7A)
                        if(SigReportCrack.FlushingSoil == GEO_Yes)
                        {
                                Returner[i] = SigReportCrack.FlushingSoilQuantity;
                                //There is no answer filled in yet.
                                if(Returner[i] == 2)
                                        Returner[i]=-1;
                        }
                        else
                        {
                                Returner[i] = -2;
                        }
                        i++;

                        break;

                case SIG_Settlement:
                        Returner.Insert(i,Settlement_NrQuestions);
                        SigSett = SignalSettlement(Sig);
                        SigReportSett = SignalReportSettlement(SigSett.SignalReports[ReportIndex]);

                        //question 2
                        Returner[i] = SigSett.RevetmentType;
                         //There is no answer filled in yet.
                        if(Returner[i]> 1)
                                Returner[i]=-1;
                        i++;

                
                        //question 3
                        Returner[i] = SigSett.SettlementPosition;
                         //There is no answer filled in yet.
                        if(Returner[i] == 3)
                                Returner[i]=-1;
                        if(SigSett.SettlementPosition == SET_Entire)
                                Returner[i] = -2;
                        i++;
                 //begin hinter/outerland
                        //question 4
                        Returner[i] = SigReportSett.LengthOfDamage;
                         //There is no answer filled in yet.
                        if(Returner[i] == 6)
                                Returner[i]=-1;
                        if(SigSett.SettlementPosition == SET_Entire)
                                Returner[i] = -2;
                        i++;

                        //question 5
                        Returner[i] = SigReportSett.WidthOfDamage;
                         //There is no answer filled in yet.
                        if(Returner[i] == 6)
                                Returner[i]=-1;
                        if(SigSett.SettlementPosition == SET_Entire)
                                Returner[i] = -2;
                        i++;

                        //question 6
                        Returner[i] = SigReportSett.HeightDifference;
                         //There is no answer filled in yet.
                        if(Returner[i] == 6)
                                Returner[i]=-1;
                        if(SigSett.SettlementPosition == SET_Entire)
                                Returner[i] = -2;
                        i++;
                //eind hinter/outerland
                //begin entire levee
                        //question 7
                        Returner[i] = SigReportSett.LengthOfDamage;
                         //There is no answer filled in yet.
                        if(Returner[i] == 6)
                                Returner[i]=-1;
                        if(SigSett.SettlementPosition != SET_Entire)
                                Returner[i] = -2;
                        i++;
                        //question 8
                        Returner[i] = SigReportSett.HeightDifference;
                         //There is no answer filled in yet.
                        if(Returner[i] == 6)
                                Returner[i]=-1;
                        if(SigSett.SettlementPosition != SET_Entire)
                                Returner[i] = -2;

                        break;
                //begin entire levee
                case SIG_HorizontalMovement:
                        Returner.Insert(i,HorizontalMovement_NrQuestions);
                        SigHor = SignalHorizontalMovement(Sig);
                        SigReportHor = SignalReportHorizontalMovement(SigHor.SignalReports[ReportIndex]);


                        //question 2
                        Returner[i] = SigHor.RevetmentType;
                        //There is no answer filled in yet.
                        if(Returner[i]> 1)
                                Returner[i]=-1;
                        i++;

                        //question 3
                        Returner[i] = SigReportHor.LengthOfDamage;
                        //There is no answer filled in yet.
                        if(Returner[i] == 6)
                                Returner[i]=-1;
                        i++;

                        //question 4
                        Returner[i] = SigReportHor.WidthOfDamage;
                        //There is no answer filled in yet.
                        if(Returner[i] == 6)
                                Returner[i]=-1;
                        i++;

                        break;

                case SIG_Uprise:
                        Returner.Insert(i,Uprise_NrQuestions);
                        SigUp = SignalUprise(Sig);
                        SigReportUp = SignalReportUprise(Sigup.SignalReports[ReportIndex]);

                        //question 2
                        Returner[i] = SigReportup.LengthOfDamage;
                        //There is no answer filled in yet.
                        if(Returner[i] == 6)
                                Returner[i]=-1;
                        i++;

                        //question 3
                        Returner[i] = SigReportup.WidthOfDamage;
                        //There is no answer filled in yet.
                        if(Returner[i] == 6)
                                Returner[i]=-1;
                        i++;
                        break;

                case SIG_Liquefaction:
                        Returner.Insert(i,Liquefaction_NrQuestions);
                        SigLiq = SignalLiquefaction(Sig);
                        SigReportLiq = SignalReportLiquefaction(SigLiq.SignalReports[ReportIndex]);

                        //question 2
                        Returner[i] = SigReportLiq.LengthOfDamage;
                        //There is no answer filled in yet.
                        if(Returner[i] == 6)
                                Returner[i]=-1;
                        i++;

                        //question 3
                        Returner[i] = SigReportLiq.WidthOfDamage;
                        //There is no answer filled in yet.
                        if(Returner[i] == 6)
                                Returner[i]=-1;
                        i++;

                        //question4
                        Returner[i] = SigReportLiq.FlushingSoil;
                        if(Returner[i]== 2)
                                Returner[i]=-1;
                        i++;

                        //question5(4A)
                        if(SigReportLiq.FlushingSoil == GEO_Yes)
                        {
                                Returner[i] = SigReportLiq.FlushingSoilQuantity;
                                if(Returner[i]== 2)
                                        Returner[i]=-1;
                        }
                        else
                        {
                                Returner[i] = -2;
                        }
                        i++;


                        break;

                case SIG_WaterOutflow:
                        Returner.Insert(i,WaterOutFlow_NrQuestions);
                        SigFlow = SignalWaterOutflow(Sig);
                        SigReportFlow = SignalReportWaterOutflow(SigFlow.SignalReports[ReportIndex]);

                        //question 2
                        Returner[i] = SigReportFlow.LengthOfDamage;
                        //There is no answer filled in yet.
                        if(Returner[i] == 6)
                                Returner[i]=-1;
                        i++;

                        //question 3
                        Returner[i] = SigReportFlow.WidthOfDamage;
                        //There is no answer filled in yet.
                        if(Returner[i] == 6)
                                Returner[i]=-1;
                        i++;

                        //question 4
                        Returner[i] = SigReportFlow.CurrentSpeed;
                        //There is no answer filled in yet.
                        if(Returner[i] == 2)
                                Returner[i]=-1;
                        i++;

                        //question 5
                        Returner[i] = SigReportFlow.WaterFlowOut;
                        //There is no answer filled in yet.
                        if(Returner[i] == 2)
                                Returner[i]=-1;
                        i++;

                        //question 6
                        Returner[i] = SigReportFlow.MultipleLocations;
                        //There is no answer filled in yet.
                        if(Returner[i] == 2)
                                Returner[i]=-1;
                        i++;


                        //question 7
                        Returner[i] = SigReportFlow.FlushingSoil;
                        //There is no answer filled in yet.
                        if(Returner[i] == 2)
                                Returner[i]=-1;
                        i++;


                        //question 8(7A)
                        if(SigReportFlow.FlushingSoil == GEO_Yes)
                        {
                                Returner[i] = SigReportFlow.FlushingSoilQuantity;
                                //There is no answer filled in yet.
                                if(Returner[i] == 2)
                                        Returner[i]=-1;
                        }
                        else
                        {
                                Returner[i] = -2;
                        }
                        i++;

                        break;

                case SIG_OverToppingWash:
                        Returner.Insert(i,OverToppingWash_NrQuestions);
                        SigWas = SignalOverToppingWash(Sig);
                        SigReportWas = SignalReportOverToppingWash(SigWas.SignalReports[ReportIndex]);

                        //question 2
                        Returner[i] = SigWas.TypeOcurring;
                        //There is no answer filled in yet.
                        if(Returner[i] == 2)
                                Returner[i]=-1;
                        i++;

                        //question 7(2A)
                        if(SigWas.TypeOcurring == OVER_Wash)
                        {
                                Returner[i] = SigReportWas.WavesDescription;
                                //There is no answer filled in yet.
                                if(Returner[i] == 2)
                                        Returner[i]=-1;
                        }
                        else
                        {
                                Returner[i] = -2;
                        }
                        i++;

                        //question 3
                         Returner[i] = SigReportWas.IsAccessible;
                        //There is no answer filled in yet.
                        if(Returner[i] == 2)
                                Returner[i]=-1;
                        i++;

                        //question 4
                        Returner[i] = SigReportWas.InfiltrateTopInner;
                        //There is no answer filled in yet.
                        if(Returner[i] == 2)
                                Returner[i]=-1;
                        i++;

                        //question 5
                        Returner[i] = SigReportWas.WaterFlowQuantity;
                        //There is no answer filled in yet.
                        if(Returner[i] == 2)
                                Returner[i]=-1;
                        i++;

                        //question6
                        Returner[i] = SigReportWas.FlushingSoil;
                        if(Returner[i]== 2)
                                Returner[i]=-1;
                        i++;

                        //question7(6A)
                        if(SigReportWas.FlushingSoil == GEO_Yes)
                        {
                                Returner[i] = SigReportWas.FlushingSoilQuantity;
                                if(Returner[i]== 2)
                                        Returner[i]=-1;
                        }
                        else
                        {
                                Returner[i] = -2;
                        }
                        i++;


                        break;

                case SIG_FloatingWasteOther:
                        Returner.Insert(i,FloatingWaste_NrQuestions);
                        SigFlo = SignalFloatingWaste(Sig);

                        //question 2 var(Signal) RiskFactor          RiskCause;
                        Returner[i] = SigFlo.RiskCause;
                        //There is no answer filled in yet.
                        if(Returner[i] > 3)
                                Returner[i]=-1;
                        i++;
                        break;

                case SIG_HumanActivity:
                        Returner.Insert(i,HumanActivity_NrQuestions);
                        SigHum = SignalHumanActivity(Sig);

                        //question 2
                        Returner[i] = SigHum.RiskCause-3;       // WATCH OUT! substract 3 because of the value this has in the enum
                        //There is no answer filled in yet.
                        if(Returner[i] > 4 || Returner[i]< -1)
                                Returner[i]=-1;
                        i++;
                        break;

                case SIG_BioActivity:
                        Returner.Insert(i,BioActivity_NrQuestions);
                        SigBio = SignalBioActivity(Sig);

                        //question 2
                        Returner[i] = SigBio.RiskCause-8;       // WATCH OUT! substract 8 because of the value this has in the enum
                        //There is no answer filled in yet.
                        if(Returner[i] > 7 || Returner[i]<-1)
                                Returner[i]=-1;
                        i++;
                        break;
         }

        return Returner;
}


//=============================================================================
// Date       Id   Modification
// 2006-11-07 Bas  Created header
//=============================================================================
function String GetAllAnswersSentences(signal Sig, int ReportIndex,GeoPlayerController GeoPC,int NumberOfSignal, bool onlySignal)
{


        local string Returner;
        //local int       i;

        local SignalRipPitching SigRip;
        local SignalReportRipPitching SigReportRip;

        local SignalGrass SigGrass;
        local SignalReportGrass SigReportGrass;

        local SignalCrack SigCrack;
        local SignalReportCrack SigReportCrack;

        local SignalSettlement SigSett;
        local SignalReportSettlement SigReportSett;

        local SignalHorizontalMovement SigHor;
        local SignalReportHorizontalMovement SigReportHor;

        local SignalUprise SigUp;
        local SignalReportUprise SigReportUp;

        local SignalLiquefaction SigLiq;
        local SignalReportLiquefaction SigReportLiq;

        local SignalWaterOutflow SigFlow;
        local SignalReportWaterOutflow SigReportFlow;

        local SignalOverToppingWash SigWas;
        local SignalReportOverToppingWash SigReportWas;

        local SignalFloatingWaste SigFlo;

        local SignalHumanActivity SigHum;
        
        local bool entirelevee;

        local SignalBioActivity SigBio;
        //log("GetAllAnswersSentences0");
        if(GeoPC.Dutch)
        {
                if(!onlySignal)
                {
                        if(NumberOfSignal == -1){
                                // betreffende de observatie van X:
                                returner="|"$NL_About@NL_De@NL_Observation@NL_Of@Lower(Sig.NL_DamageName)$":";
                        }else{
                                // betreffende de eerste observatie van X:
                                returner="|"$NL_About@NL_De@NL_TelWoorden[NumberOfSignal]@NL_Observation@NL_Of@Lower(Sig.NL_DamageName)$":";
                        }
                }

                //first tell the name and location of the signal
                //log("GetAllAnswersSentences1");
                if(Sig.CrossCutLocation!=Cut_NONE)
                {
                        returner=returner$"|  - "@NL_SignalLocation;
                        if(Sig.CrossCutLocation == 0)
                        {
                                returner=returner@NL_De;
                        }else
                        {
                                returner=returner@NL_Het;
                        }
                        returner=returner@Lower(NL_CrossCut_AnswerString[0].Answers[Sig.CrossCutLocation])$".";
                }
                //log("GetAllAnswersSentences2");
                switch(Sig.SignalType)
                {
                        case SIG_RipRapPitching:
                                SigRip = SignalRipPitching(Sig);
                                SigReportRip = SignalReportRipPitching(SigRip.SignalReports[ReportIndex]);

                                //log("GetAllAnswersSentences3");
                                //question3
                                if(SigReportRip.LengthOfDamage!=6)
                                {
                                        returner = returner$"|  - "@NL_Length@Lower(NL_RipPitching_AnswerStrings[1].Answers[SigReportRip.LengthOfDamage])@NL_CM$".";
                                }
                                //log("GetAllAnswersSentences4");
                                //question4
                                if(SigReportRip.WidthOfDamage!=6)
                                {
                                        returner = returner$"|  - "@NL_Width@Lower(NL_RipPitching_AnswerStrings[2].Answers[SigReportRip.WidthOfDamage])@NL_CM$".";
                                }
                                //log("GetAllAnswersSentences5");
                                //question8(2A)
                                if(SigRip.RevetmentType == REV_PitchingStone)// pitching stone
                                {
                                        if(SigReportRip.ElementsLoose!=2)
                                        {
                                                returner = returner$"|  - ";
                                                if(SigReportRip.ElementsLoose == 0)
                                                {
                                                        returner = returner@NL_LooseElements;
                                                }else
                                                {
                                                        returner = returner@NL_NOLooseElements;

                                                }

                                        }
                                }
                                //log("GetAllAnswersSentences6");
                                //question5
                                if(SigReportRip.ElementsMissingOrMoved!=2)
                                {
                                        returner = returner$"|  - ";
                                        if(SigReportRip.ElementsMissingOrMoved == Geo_Yes)
                                        {
                                                returner = returner@NL_MissingElements;

                                        }else
                                        {
                                                returner = returner@NL_NoMissingElements;
                                        }

                                }
                                //log("GetAllAnswersSentences7");
                                if(SigReportRip.FlushingSoil !=GEO_NONE)
                                {       //log("GetAllAnswersSentences7");
                                        returner = returner$"|  - "@NL_Flushing;
                                        if(SigReportRip.FlushingSoil == GEO_Yes)
                                        {       //log("GetAllAnswersSentences7");
                                                returner = returner@NL_Occurs;
                                                if(SigReportRip.FlushingSoilQuantity == QUA_Little)
                                                {       //log("GetAllAnswersSentences7");
                                                        returner = returner@NL_ALittle;
                                                }else if(SigReportRip.FlushingSoilQuantity == QUA_Much)
                                                {    //log("GetAllAnswersSentences7");
                                                     returner = returner@NL_Heavily;
                                                }
                                                returner = returner$".";

                                        }else
                                        {       //log("GetAllAnswersSentences7");
                                                returner = returner@NL_NotOccurs$".";
                                        }
                                }
                                break;
                        case SIG_GrassRevetment:
                                SigGrass= SignalGrass(Sig);
                                SigReportGrass = SignalReportGrass(SigGrass.SignalReports[ReportIndex]);

                                //question 2
                                if(SigReportGrass.LengthOfDamage!=6)
                                {
                                        returner = returner$"|  - "@NL_Length@Lower(NL_Grass_AnswerStrings[0].Answers[SigReportGrass.LengthOfDamage])@NL_CM$".";
                                }


                                //question 3
                                if(SigReportGrass.WidthOfDamage!=6)
                                {
                                        returner = returner$"|  - "@NL_Width@Lower(NL_Grass_AnswerStrings[1].Answers[SigReportGrass.WidthOfDamage])@NL_CM$".";
                                }

                                /* Variable is not used anymore
                                //question 4
                                if(SigReportGrass.DepthOfDamage!=6)
                                {
                                        returner = returner$"|  - "@NL_Dept@Lower(NL_Grass_AnswerStrings[2].Answers[SigReportGrass.DepthOfDamage])@NL_CM$".";
                                } */
                                break;


                        case SIG_Crack:
                                SigCrack = SignalCrack(Sig);
                                SigReportCrack = SignalReportCrack(SigCrack.SignalReports[ReportIndex]);

                                //question 2
                                if(SigCrack.RevetmentType!=REV_None && SigCrack.RevetmentType!=REV_RipRap&& SigCrack.RevetmentType!=REV_PitchingStone)
                                {
                                        returner = returner$"|  - "@NL_Located;
                                        if(SigCrack.RevetmentType == REV_Grass)
                                        {
                                                returner = returner@NL_Grass$".";
                                        }else if(SigCrack.RevetmentType ==REV_Asphalt)
                                        {
                                                returner = returner@NL_Asphalt$".";
                                        }

                                }

                                //question 3
                                if(SigCrack.CrackType != CRK_NONE)
                                {
                                        returner = returner$"|  - "@NL_IsA;

                                        if(SigCrack.CrackType ==CRK_Perpendicular)
                                        {
                                                returner = returner@NL_Perp;
                                        }else if(SigCrack.CrackType == CRK_Parallel)
                                        {
                                                returner = returner@NL_Par;
                                        }
                                }
                                //question 4
                                if(SigReportCrack.LengthOfDamage!=SIZE_NONE)
                                {
                                        returner = returner$"|  - "@NL_Length@Lower(NL_Crack_AnswerStrings[2].Answers[SigReportCrack.LengthOfDamage])@NL_CM$".";
                                }
                                //question 5
                                if(SigReportCrack.WidthOfDamage!=SIZE_NONE)
                                {
                                        returner = returner$"|  - "@NL_Width@Lower(NL_Crack_AnswerStrings[3].Answers[SigReportCrack.WidthOfDamage])@NL_CM$".";
                                }

                                //question 6
                                if(SigReportCrack.MultipleCracks!=GEO_NONE)
                                {
                                        if(SigReportCrack.MultipleCracks==GEO_Yes)
                                        {
                                                returner = returner$"|  - "@NL_MultipleCracks;
                                        }else if(SigReportCrack.MultipleCracks==GEO_No)
                                        {
                                                returner = returner$"|  - "@NL_NoMultipleCracks;
                                        }

                                }


                                //question 7
                                if(SigReportCrack.FlushingSoil !=GEO_NONE)
                                {
                                        returner = returner$"|  - "@NL_Flushing;
                                        if(SigReportCrack.FlushingSoil == GEO_Yes)
                                        {
                                                returner = returner@NL_Occurs;
                                                if(SigReportCrack.FlushingSoilQuantity == QUA_Little)
                                                {
                                                        returner = returner@NL_Little;
                                                }else if(SigReportCrack.FlushingSoilQuantity == QUA_Much)
                                                {
                                                     returner = returner@NL_Heavily;
                                                }
                                                returner = returner$".";

                                        }else
                                        {
                                                returner = returner@NL_NotOccurs$".";
                                        }
                                }
                                break;


                        case SIG_Settlement:
                                SigSett = SignalSettlement(Sig);
                                SigReportSett = SignalReportSettlement(SigSett.SignalReports[ReportIndex]);

                                //question 2
                                if(SigSett.RevetmentType!=REV_None && SigSett.RevetmentType!=REV_RipRap&& SigSett.RevetmentType!=REV_PitchingStone)
                                {
                                        returner = returner$"|  - "@NL_Located;
                                        if(SigSett.RevetmentType == REV_Grass)
                                        {
                                                returner = returner@NL_Grass$".";
                                        }else if(SigSett.RevetmentType ==REV_Asphalt)
                                        {
                                                returner = returner@NL_Asphalt$".";
                                        }

                                }

                                //question 3
                                entirelevee = false;
                                if(SigSett.SettlementPosition !=SET_None)
                                {
                                        returner = returner$"|  - "@NL_Directed;
                                        if(SigSett.SettlementPosition == SET_Inwards)
                                        {
                                                returner = returner@NL_Hinter$".";

                                        }else if(SigSett.SettlementPosition == SET_Outwards)
                                        {
                                                returner = returner@NL_Fore$".";
                                        }else if(SigSett.SettlementPosition == SET_Entire)
                                        {
                                                returner = returner@NL_EntireL$".";
                                                entirelevee = true;
                                        }

                                }

                                if(!entirelevee)
                                {
                                        //question 4
                                        if(SigReportSett.LengthOfDamage!=SIZE_NONE)
                                        {
                                                returner = returner$"|  - "@NL_Length@Lower(NL_Settlement_AnswerStrings[2].Answers[SigReportSett.LengthOfDamage])@NL_CM$".";
                                        }
        
        
                                        //question 5
                                        if(SigReportSett.WidthOfDamage!=SIZE_NONE)
                                        {
                                                returner = returner$"|  - "@NL_Width@Lower(NL_Settlement_AnswerStrings[3].Answers[SigReportSett.WidthOfDamage])@NL_CM$".";
                                        }
        
        
                                        //question 6
                                        if(SigReportSett.HeightDifference!=SIZE_NONE)
                                        {
                                                returner = returner$"|  - "@NL_Dept@Lower(NL_Settlement_AnswerStrings[4].Answers[SigReportSett.HeightDifference])@NL_CM$".";
                                        }
                                }else
                                {
                                        //question 4
                                        if(SigReportSett.LengthOfDamage!=SIZE_NONE)
                                        {
                                                returner = returner$"|  - "@NL_Length@Lower(NL_Settlement_AnswerStrings[5].Answers[SigReportSett.LengthOfDamage])@NL_CM$".";
                                        }


                                        //question 5
                                        if(SigReportSett.HeightDifference!=SIZE_NONE)
                                        {
                                                returner = returner$"|  - "@NL_Dept@Lower(NL_Settlement_AnswerStrings[6].Answers[SigReportSett.HeightDifference])@NL_CM$".";
                                        }
                                }

                                break;


                        case SIG_HorizontalMovement:
                                SigHor = SignalHorizontalMovement(Sig);
                                SigReportHor = SignalReportHorizontalMovement(SigHor.SignalReports[ReportIndex]);


                                //question 2
                                if(SigHor.RevetmentType!=REV_None && SigHor.RevetmentType!=REV_RipRap&& SigHor.RevetmentType!=REV_PitchingStone)
                                {
                                        returner = returner$"|  - "@NL_Located;
                                        if(SigHor.RevetmentType == REV_Grass)
                                        {
                                                returner = returner@NL_Grass$".";
                                        }else if(SigHor.RevetmentType ==REV_Asphalt)
                                        {
                                                returner = returner@NL_Asphalt$".";
                                        }

                                }

                                //question 3
                                if(SigReportHor.LengthOfDamage!=SIZE_NONE)
                                {
                                        returner = returner$"|  - "@NL_Length@Lower(NL_HorizontalMovement_AnswerStrings[1].Answers[SigReportHor.LengthOfDamage])@NL_CM$".";
                                }


                                //question 4
                                if(SigReportHor.WidthOfDamage!=SIZE_NONE)
                                {
                                        returner = returner$"|  - "@NL_Width@Lower(NL_HorizontalMovement_AnswerStrings[2].Answers[SigReportHor.WidthOfDamage])@NL_CM$".";
                                }

                                break;


                        case SIG_Uprise:
                                SigUp = SignalUprise(Sig);
                                SigReportUp = SignalReportUprise(Sigup.SignalReports[ReportIndex]);

                                //question 2
                                if(SigReportUp.LengthOfDamage!=SIZE_NONE)
                                {
                                        returner = returner$"|  - "@NL_Length@Lower(NL_Uprise_AnswerStrings[0].Answers[SigReportUp.LengthOfDamage])@NL_CM$".";
                                }

                                //question 3
                                if(SigReportUp.WidthOfDamage!=SIZE_NONE)
                                {
                                        returner = returner$"|  - "@NL_Width@Lower(NL_Uprise_AnswerStrings[1].Answers[SigReportUp.WidthOfDamage])@NL_CM$".";
                                }
                                break;


                        case SIG_Liquefaction:
                                SigLiq = SignalLiquefaction(Sig);
                                SigReportLiq = SignalReportLiquefaction(SigLiq.SignalReports[ReportIndex]);

                                //question 2
                                if(SigReportLiq.LengthOfDamage!=SIZE_NONE)
                                {
                                        returner = returner$"|  - "@NL_Length@Lower(NL_Uprise_AnswerStrings[0].Answers[SigReportLiq.LengthOfDamage])@NL_CM$".";
                                }


                                //question 3
                                if(SigReportLiq.WidthOfDamage!=SIZE_NONE)
                                {
                                        returner = returner$"|  - "@NL_Width@Lower(NL_Uprise_AnswerStrings[1].Answers[SigReportLiq.WidthOfDamage])@NL_CM$".";
                                }

                                //question 4
                                if(SigReportLiq.FlushingSoil !=GEO_NONE)
                                {
                                        returner = returner$"|  - "@NL_Flushing;
                                        if(SigReportLiq.FlushingSoil == GEO_Yes)
                                        {
                                                returner = returner@NL_Occurs;
                                                //to do when question four has been made.
                                                if(SigReportLiq.FlushingSoilQuantity == QUA_Little)
                                                {
                                                        returner = returner@NL_Little;
                                                }else if(SigReportLiq.FlushingSoilQuantity == QUA_Much)
                                                {
                                                     returner = returner@NL_Heavily;
                                                }
                                                returner = returner$".";

                                        }else
                                        {
                                                returner = returner@NL_NotOccurs$".";
                                        }
                                }
                                //log("************ liquefaction"@returner);
                                break;


                        case SIG_WaterOutflow:

                                SigFlow = SignalWaterOutflow(Sig);
                                SigReportFlow = SignalReportWaterOutflow(SigFlow.SignalReports[ReportIndex]);

                                //question 2
                                if(SigReportFlow.LengthOfDamage!=SIZE_NONE)
                                {
                                        returner = returner$"|  - "@NL_Length@Lower(NL_WaterOutflow_AnswerStrings[0].Answers[SigReportFlow.LengthOfDamage])@NL_CM$".";
                                }

                                //question 3
                                if(SigReportFlow.WidthOfDamage!=SIZE_NONE)
                                {
                                        returner = returner$"|  - "@NL_Width@Lower(NL_WaterOutflow_AnswerStrings[1].Answers[SigReportFlow.WidthOfDamage])@NL_CM$".";
                                }

                                //question 4
                                if(SigReportFlow.CurrentSpeed != SPE_None)
                                {
                                        returner = returner$"|  - "@NL_Velocity;
                                        if(SigReportFlow.CurrentSpeed == SPE_Slow)
                                        {
                                                returner = returner@NL_Slow$".";
                                        }else if(SigReportFlow.CurrentSpeed == SPE_Fast)
                                        {
                                                returner = returner@NL_Fast$".";
                                        }

                                }

                                //question 5
                                if(SigReportFlow.WaterFlowOut != QUA_None)
                                {

                                        returner = returner$"|  - "@NL_AmountOut;
                                        if(SigReportFlow.WaterFlowOut == QUA_Little)
                                        {
                                                returner = returner@NL_Little$".";

                                        }else if(SigReportFlow.WaterFlowOut == QUA_Much)
                                        {
                                                returner = returner@NL_Huge$".";
                                        }
                                }

                                //question 6
                                if(SigReportFlow.MultipleLocations != GEO_NONE)
                                {
                                        returner = returner$"|  - "@NL_Outflow;
                                        if(SigReportFlow.MultipleLocations == GEO_Yes)
                                        {
                                                returner = returner@NL_Occurs@NL_Multiple$".";
                                        }else if(SigReportFlow.MultipleLocations == GEO_No)
                                        {
                                                returner = returner@NL_NotOccurs@NL_Multiple$".";
                                        }


                                }


                                //question 7

                                if(SigReportFlow.FlushingSoil !=GEO_NONE)
                                {
                                        returner = returner$"|  - "@NL_Flushing;
                                        if(SigReportFlow.FlushingSoil == GEO_Yes)
                                        {
                                                returner = returner@NL_Occurs;
                                                if(SigReportFlow.FlushingSoilQuantity == QUA_Little)
                                                {
                                                        returner = returner@NL_Little;
                                                }else if(SigReportFlow.FlushingSoilQuantity == QUA_Much)
                                                {
                                                     returner = returner@NL_Heavily;
                                                }
                                                returner = returner$".";

                                        }else
                                        {
                                                returner = returner@NL_NotOccurs$".";
                                        }
                                }
                                break;


                        case SIG_OverToppingWash:

                                SigWas = SignalOverToppingWash(Sig);
                                SigReportWas = SignalReportOverToppingWash(SigWas.SignalReports[ReportIndex]);



                                //question 3
                                if(SigReportWas.IsAccessible!=GEO_None)
                                {
                                        returner = returner$"|  - "@NL_Levee;
                                        if(SigReportWas.IsAccessible == GEO_No)
                                        {
                                                returner = returner@NL_Not;
                                        }
                                        returner = returner@NL_Acc$".";

                                }

                                //question 4
                                if(SigReportWas.InfiltrateTopInner != GEO_None)
                                {
                                        returner = returner$"|  - "@NL_Infi;
                                        if(SigReportWas.InfiltrateTopInner == GEO_Yes)
                                        {
                                                returner = returner@NL_Occurs$".";
                                        }else if(SigReportWas.InfiltrateTopInner == GEO_No)
                                        {
                                                returner = returner@NL_NotOccurs$".";
                                        }
                                }


                                //question 5
                                if(SigReportWas.WaterFlowQuantity != QUA_None)
                                {

                                        returner = returner$"|  - "@NL_AmountOver;

                                        if(SigReportWas.WaterFlowQuantity == QUA_Little)
                                        {
                                                returner = returner@NL_Little$".";
                                        }else if(SigReportWas.WaterFlowQuantity == QUA_Much)
                                        {
                                                returner = returner@NL_Huge$".";
                                        }


                                }


                                //question 6

                                if(SigReportWas.FlushingSoil != GEO_None)
                                {
                                        returner = returner$"|  - "@NL_Flushing;
                                        if(SigReportWas.FlushingSoil == GEO_Yes)
                                        {
                                                returner = returner@NL_Occurs;
                                                if(SigReportWas.FlushingSoilQuantity == QUA_Little)
                                                {
                                                        returner = returner@NL_Little;
                                                }else if(SigReportWas.FlushingSoilQuantity == QUA_Much)
                                                {
                                                     returner = returner@NL_Heavily;
                                                }
                                                returner = returner$".";

                                        }else if(SigReportWas.FlushingSoil == GEO_No)
                                        {
                                                returner = returner@NL_NotOccurs$".";
                                        }
                                }

                                if(SigWas.TypeOcurring == OVER_Wash)
                                {
                                        if(SigReportWas.WavesDescription != WAVE_None)
                                        {
                                                returner = returner$"|  - "@NL_Waves;
                                                if(SigReportWas.WavesDescription == WAVE_Medium)
                                                {
                                                        returner = returner@lower(NL_OverToppingWash_AnswerStrings[5].Answers[0])$".";
                                                }else if(SigReportWas.WavesDescription == WAVE_Fierce)
                                                {
                                                        returner = returner@lower(NL_OverToppingWash_AnswerStrings[5].Answers[1])$".";
                                                }
                                        }

                                }


                                break;

                        case SIG_FloatingWasteOther:

                                SigFlo = SignalFloatingWaste(Sig);

                                break;
                        case SIG_HumanActivity:
                                SigHum = SignalHumanActivity(Sig);


                                break;

                        case SIG_BioActivity:
                                SigBio = SignalBioActivity(Sig);

                                break;



                }





        }else
        {

                if(!onlySignal)
                {
                        if(NumberOfSignal == -1){
                                // about the observation of X:
                                returner="|"$EN_About@EN_De@EN_Observation@EN_Of@Lower(Sig.EN_DamageName)$":";
                        }else{
                                // about the first observation of X:
                                returner="|"$EN_About@EN_De@EN_TelWoorden[NumberOfSignal]@EN_Observation@EN_Of@Lower(Sig.EN_DamageName)$":";
                        }
                }

                //first tell the name and location of the signal
                if(Sig.CrossCutLocation!=Cut_NONE)
                {
                        returner=returner$"|  - "@EN_SignalLocation;
                        if(Sig.CrossCutLocation == 0)
                        {
                                returner=returner@EN_De;
                        }else
                        {
                                returner=returner@EN_Het;
                        }
                        returner=returner@lower(EN_CrossCut_AnswerString[0].Answers[Sig.CrossCutLocation])$".";
                }
                switch(Sig.SignalType)
                {

                        case SIG_RipRapPitching:

                                SigRip = SignalRipPitching(Sig);
                                SigReportRip = SignalReportRipPitching(SigRip.SignalReports[ReportIndex]);


                                //question3
                                if(SigReportRip.LengthOfDamage!=6)
                                {
                                        returner = returner$"|  - "@EN_Length@Lower(EN_RipPitching_AnswerStrings[1].Answers[SigReportRip.LengthOfDamage])@EN_CM$".";
                                }

                                //question4
                                if(SigReportRip.WidthOfDamage!=6)
                                {
                                        returner = returner$"|  - "@EN_Width@Lower(EN_RipPitching_AnswerStrings[2].Answers[SigReportRip.WidthOfDamage])@EN_CM$".";
                                }

                                //question8(2A)
                                if(SigRip.RevetmentType == REV_PitchingStone)// pitching stone
                                {
                                        if(SigReportRip.ElementsLoose!=2)
                                        {
                                                returner = returner$"|  - ";
                                                if(SigReportRip.ElementsLoose == 0)
                                                {
                                                        returner = returner@EN_LooseElements;
                                                }else
                                                {
                                                        returner = returner@EN_NOLooseElements;

                                                }

                                        }
                                }

                                //question5
                                if(SigReportRip.ElementsMissingOrMoved!=2)
                                {
                                        returner = returner$"|  - ";
                                        if(SigReportRip.ElementsMissingOrMoved == Geo_Yes)
                                        {
                                                returner = returner@EN_MissingElements;

                                        }else
                                        {
                                                returner = returner@EN_NoMissingElements;
                                        }

                                }

                                if(SigReportRip.FlushingSoil !=GEO_NONE)
                                {
                                        returner = returner$"|  - "@EN_Flushing;
                                        if(SigReportRip.FlushingSoil == GEO_Yes)
                                        {
                                                returner = returner@EN_Occurs;
                                                if(SigReportRip.FlushingSoilQuantity == QUA_Little)
                                                {
                                                        returner = returner@EN_ALittle;
                                                }else if(SigReportRip.FlushingSoilQuantity == QUA_Much)
                                                {
                                                     returner = returner@EN_Heavily;
                                                }
                                                returner = returner$".";

                                        }else
                                        {
                                                returner = returner@EN_NotOccurs$".";
                                        }
                                }
                                break;

                        case SIG_GrassRevetment:
                                SigGrass= SignalGrass(Sig);
                                SigReportGrass = SignalReportGrass(SigGrass.SignalReports[ReportIndex]);

                                //question 2
                                if(SigReportGrass.LengthOfDamage!=6)
                                {
                                        returner = returner$"|  - "@EN_Length@Lower(EN_Grass_AnswerStrings[0].Answers[SigReportGrass.LengthOfDamage])@EN_CM$".";
                                }


                                //question 3
                                if(SigReportGrass.WidthOfDamage!=6)
                                {
                                        returner = returner$"|  - "@EN_Width@Lower(EN_Grass_AnswerStrings[1].Answers[SigReportGrass.WidthOfDamage])@EN_CM$".";
                                }

                                /*question 4 Variable is not used anymore
                                if(SigReportGrass.DepthOfDamage!=6)
                                {
                                        returner = returner$"|  - "@EN_Dept@Lower(EN_Grass_AnswerStrings[2].Answers[SigReportGrass.DepthOfDamage])@EN_CM$".";
                                } */
                                break;


                        case SIG_Crack:
                                SigCrack = SignalCrack(Sig);
                                SigReportCrack = SignalReportCrack(SigCrack.SignalReports[ReportIndex]);

                                //question 2
                                if(SigCrack.RevetmentType!=REV_None && SigCrack.RevetmentType!=REV_RipRap&& SigCrack.RevetmentType!=REV_PitchingStone)
                                {
                                        returner = returner$"|  - "@EN_Located;
                                        if(SigCrack.RevetmentType == REV_Grass)
                                        {
                                                returner = returner@EN_Grass$".";
                                        }else if(SigCrack.RevetmentType ==REV_Asphalt)
                                        {
                                                returner = returner@EN_Asphalt$".";
                                        }

                                }

                                //question 3
                                if(SigCrack.CrackType != CRK_NONE)
                                {
                                        returner = returner$"|  - "@EN_IsA;

                                        if(SigCrack.CrackType ==CRK_Perpendicular)
                                        {
                                                returner = returner@EN_Perp;
                                        }else if(SigCrack.CrackType == CRK_Parallel)
                                        {
                                                returner = returner@EN_Par;
                                        }
                                }
                                //question 4
                                if(SigReportCrack.LengthOfDamage!=SIZE_NONE)
                                {
                                        returner = returner$"|  - "@EN_Length@Lower(EN_Crack_AnswerStrings[2].Answers[SigReportCrack.LengthOfDamage])@EN_CM$".";
                                }
                                //question 5
                                if(SigReportCrack.WidthOfDamage!=SIZE_NONE)
                                {
                                        returner = returner$"|  - "@EN_Width@Lower(EN_Crack_AnswerStrings[3].Answers[SigReportCrack.WidthOfDamage])@EN_CM$".";
                                }

                                //question 6
                                if(SigReportCrack.MultipleCracks!=GEO_NONE)
                                {
                                        if(SigReportCrack.MultipleCracks==GEO_Yes)
                                        {
                                                returner = returner$"|  - "@EN_MultipleCracks;
                                        }else if(SigReportCrack.MultipleCracks==GEO_No)
                                        {
                                                returner = returner$"|  - "@EN_NoMultipleCracks;
                                        }

                                }


                                //question 7
                                if(SigReportCrack.FlushingSoil !=GEO_NONE)
                                {
                                        returner = returner$"|  - "@EN_Flushing;
                                        if(SigReportCrack.FlushingSoil == GEO_Yes)
                                        {
                                                returner = returner@EN_Occurs;
                                                if(SigReportCrack.FlushingSoilQuantity == QUA_Little)
                                                {
                                                        returner = returner@EN_Little;
                                                }else if(SigReportCrack.FlushingSoilQuantity == QUA_Much)
                                                {
                                                     returner = returner@EN_Heavily;
                                                }
                                                returner = returner$".";

                                        }else
                                        {
                                                returner = returner@EN_NotOccurs$".";
                                        }
                                }
                                break;


                        case SIG_Settlement:
                                SigSett = SignalSettlement(Sig);
                                SigReportSett = SignalReportSettlement(SigSett.SignalReports[ReportIndex]);

                                //question 2
                                if(SigSett.RevetmentType!=REV_None && SigSett.RevetmentType!=REV_RipRap&& SigSett.RevetmentType!=REV_PitchingStone)
                                {
                                        returner = returner$"|  - "@EN_Located;
                                        if(SigSett.RevetmentType == REV_Grass)
                                        {
                                                returner = returner@EN_Grass$".";
                                        }else if(SigSett.RevetmentType ==REV_Asphalt)
                                        {
                                                returner = returner@EN_Asphalt$".";
                                        }

                                }

                                //question 3
                                entirelevee = false;
                                if(SigSett.SettlementPosition !=SET_None)
                                {
                                        returner = returner$"|  - "@EN_Directed;
                                        if(SigSett.SettlementPosition == SET_Inwards)
                                        {
                                                returner = returner@EN_Hinter$".";

                                        }else if(SigSett.SettlementPosition == SET_Outwards)
                                        {
                                                returner = returner@EN_Fore$".";
                                        }else if(SigSett.SettlementPosition == SET_Entire)
                                        {
                                                returner = returner@EN_EntireL$".";
                                                entirelevee = true;
                                        }

                                }

                                 if(!entirelevee)
                                 {
                                        //question 4
                                        if(SigReportSett.LengthOfDamage!=SIZE_NONE)
                                        {
                                                returner = returner$"|  - "@EN_Length@Lower(EN_Settlement_AnswerStrings[2].Answers[SigReportSett.LengthOfDamage])@EN_CM$".";
                                        }
        
        
                                        //question 5
                                        if(SigReportSett.WidthOfDamage!=SIZE_NONE)
                                        {
                                                returner = returner$"|  - "@EN_Width@Lower(EN_Settlement_AnswerStrings[3].Answers[SigReportSett.WidthOfDamage])@EN_CM$".";
                                        }
        
        
                                        //question 6
                                        if(SigReportSett.HeightDifference!=SIZE_NONE)
                                        {
                                                returner = returner$"|  - "@EN_Dept@Lower(EN_Settlement_AnswerStrings[4].Answers[SigReportSett.HeightDifference])@EN_CM$".";
                                        }
                                }else
                                {
                                        //question 4
                                        if(SigReportSett.LengthOfDamage!=SIZE_NONE)
                                        {
                                                returner = returner$"|  - "@EN_Length@Lower(EN_Settlement_AnswerStrings[5].Answers[SigReportSett.LengthOfDamage])@EN_CM$".";
                                        }


                                        //question 5
                                        if(SigReportSett.HeightDifference!=SIZE_NONE)
                                        {
                                                returner = returner$"|  - "@EN_Dept@Lower(EN_Settlement_AnswerStrings[6].Answers[SigReportSett.HeightDifference])@EN_CM$".";
                                        }
                                }

                                break;


                        case SIG_HorizontalMovement:
                                SigHor = SignalHorizontalMovement(Sig);
                                SigReportHor = SignalReportHorizontalMovement(SigHor.SignalReports[ReportIndex]);


                                //question 2
                                if(SigHor.RevetmentType!=REV_None && SigHor.RevetmentType!=REV_RipRap&& SigHor.RevetmentType!=REV_PitchingStone)
                                {
                                        returner = returner$"|  - "@EN_Located;
                                        if(SigHor.RevetmentType == REV_Grass)
                                        {
                                                returner = returner@EN_Grass$".";
                                        }else if(SigHor.RevetmentType ==REV_Asphalt)
                                        {
                                                returner = returner@EN_Asphalt$".";
                                        }

                                }

                                //question 3
                                if(SigReportHor.LengthOfDamage!=SIZE_NONE)
                                {
                                        returner = returner$"|  - "@EN_Length@Lower(NL_HorizontalMovement_AnswerStrings[1].Answers[SigReportHor.LengthOfDamage])@EN_CM$".";
                                }


                                //question 4
                                if(SigReportHor.WidthOfDamage!=SIZE_NONE)
                                {
                                        returner = returner$"|  - "@EN_Width@Lower(NL_HorizontalMovement_AnswerStrings[2].Answers[SigReportHor.WidthOfDamage])@EN_CM$".";
                                }

                                break;


                        case SIG_Uprise:
                                SigUp = SignalUprise(Sig);
                                SigReportUp = SignalReportUprise(Sigup.SignalReports[ReportIndex]);

                                //question 2
                                if(SigReportUp.LengthOfDamage!=SIZE_NONE)
                                {
                                        returner = returner$"|  - "@EN_Length@Lower(NL_Uprise_AnswerStrings[0].Answers[SigReportUp.LengthOfDamage])@EN_CM$".";
                                }

                                //question 3
                                if(SigReportUp.WidthOfDamage!=SIZE_NONE)
                                {
                                        returner = returner$"|  - "@EN_Width@Lower(NL_Uprise_AnswerStrings[1].Answers[SigReportUp.WidthOfDamage])@EN_CM$".";
                                }
                                break;


                        case SIG_Liquefaction:
                                SigLiq = SignalLiquefaction(Sig);
                                SigReportLiq = SignalReportLiquefaction(SigLiq.SignalReports[ReportIndex]);

                                //question 2
                                if(SigReportLiq.LengthOfDamage!=SIZE_NONE)
                                {
                                        returner = returner$"|  - "@EN_Length@Lower(NL_Uprise_AnswerStrings[0].Answers[SigReportLiq.LengthOfDamage])@EN_CM$".";
                                }


                                //question 3
                                if(SigReportLiq.WidthOfDamage!=SIZE_NONE)
                                {
                                        returner = returner$"|  - "@EN_Width@Lower(NL_Uprise_AnswerStrings[1].Answers[SigReportLiq.WidthOfDamage])@EN_CM$".";
                                }

                                //question 4
                                if(SigReportLiq.FlushingSoil !=GEO_NONE)
                                {
                                        returner = returner$"|  - "@EN_Flushing;
                                        if(SigReportLiq.FlushingSoil == GEO_Yes)
                                        {
                                                returner = returner@EN_Occurs;
                                                //to do when question four has been made.
                                                if(SigReportLiq.FlushingSoilQuantity == QUA_Little)
                                                {
                                                        returner = returner@EN_Little;
                                                }else if(SigReportLiq.FlushingSoilQuantity == QUA_Much)
                                                {
                                                     returner = returner@EN_Heavily;
                                                }
                                                returner = returner$".";

                                        }else
                                        {
                                                returner = returner@EN_NotOccurs$".";
                                        }
                                }
                                break;


                        case SIG_WaterOutflow:

                                SigFlow = SignalWaterOutflow(Sig);
                                SigReportFlow = SignalReportWaterOutflow(SigFlow.SignalReports[ReportIndex]);

                                //question 2
                                if(SigReportFlow.LengthOfDamage!=SIZE_NONE)
                                {
                                        returner = returner$"|  - "@EN_Length@Lower(EN_WaterOutflow_AnswerStrings[0].Answers[SigReportFlow.LengthOfDamage])@EN_CM$".";
                                }

                                //question 3
                                if(SigReportFlow.WidthOfDamage!=SIZE_NONE)
                                {
                                        returner = returner$"|  - "@EN_Width@Lower(EN_WaterOutflow_AnswerStrings[1].Answers[SigReportFlow.WidthOfDamage])@EN_CM$".";
                                }

                                //question 4
                                if(SigReportFlow.CurrentSpeed != SPE_None)
                                {
                                        returner = returner$"|  - "@EN_Velocity;
                                        if(SigReportFlow.CurrentSpeed == SPE_Slow)
                                        {
                                                returner = returner@EN_Slow$".";
                                        }else if(SigReportFlow.CurrentSpeed == SPE_Fast)
                                        {
                                                returner = returner@EN_Fast$".";
                                        }

                                }

                                //question 5
                                if(SigReportFlow.WaterFlowOut != QUA_None)
                                {

                                        returner = returner$"|  - "@EN_AmountOut;
                                        if(SigReportFlow.WaterFlowOut == QUA_Little)
                                        {
                                                returner = returner@EN_Little$".";

                                        }else if(SigReportFlow.WaterFlowOut == QUA_Much)
                                        {
                                                returner = returner@EN_Huge$".";
                                        }
                                }

                                //question 6
                                if(SigReportFlow.MultipleLocations != GEO_NONE)
                                {
                                        returner = returner$"|  - "@EN_Outflow;
                                        if(SigReportFlow.MultipleLocations == GEO_Yes)
                                        {
                                                returner = returner@EN_Occurs@EN_Multiple$".";
                                        }else if(SigReportFlow.MultipleLocations == GEO_No)
                                        {
                                                returner = returner@EN_NotOccurs@EN_Multiple$".";
                                        }


                                }


                                //question 7

                                if(SigReportFlow.FlushingSoil !=GEO_NONE)
                                {
                                        returner = returner$"|  - "@EN_Flushing;
                                        if(SigReportFlow.FlushingSoil == GEO_Yes)
                                        {
                                                returner = returner@EN_Occurs;
                                                if(SigReportFlow.FlushingSoilQuantity == QUA_Little)
                                                {
                                                        returner = returner@EN_Little;
                                                }else if(SigReportFlow.FlushingSoilQuantity == QUA_Much)
                                                {
                                                     returner = returner@EN_Heavily;
                                                }
                                                returner = returner$".";

                                        }else
                                        {
                                                returner = returner@EN_NotOccurs$".";
                                        }
                                }
                                break;


                        case SIG_OverToppingWash:

                                SigWas = SignalOverToppingWash(Sig);
                                SigReportWas = SignalReportOverToppingWash(SigWas.SignalReports[ReportIndex]);



                                //question 3
                                if(SigReportWas.IsAccessible!=GEO_None)
                                {
                                        returner = returner$"|  - "@EN_Levee;
                                        if(SigReportWas.IsAccessible == GEO_No)
                                        {
                                                returner = returner@EN_Not;
                                        }
                                        returner = returner@EN_Acc$".";

                                }

                                //question 4
                                if(SigReportWas.InfiltrateTopInner != GEO_None)
                                {
                                        returner = returner$"|  - "@EN_Infi;
                                        if(SigReportWas.InfiltrateTopInner == GEO_Yes)
                                        {
                                                returner = returner@EN_Occurs$".";
                                        }else if(SigReportWas.InfiltrateTopInner == GEO_No)
                                        {
                                                returner = returner@EN_NotOccurs$".";
                                        }
                                }


                                //question 5
                                if(SigReportWas.WaterFlowQuantity != QUA_None)
                                {

                                        returner = returner$"|  - "@EN_AmountOver;

                                        if(SigReportWas.WaterFlowQuantity == QUA_Little)
                                        {
                                                returner = returner@EN_Little$".";
                                        }else if(SigReportWas.WaterFlowQuantity == QUA_Much)
                                        {
                                                returner = returner@EN_Huge$".";
                                        }


                                }


                                //question 6

                                if(SigReportWas.FlushingSoil != GEO_None)
                                {
                                        returner = returner$"|  - "@EN_Flushing;
                                        if(SigReportWas.FlushingSoil == GEO_Yes)
                                        {
                                                returner = returner@EN_Occurs;
                                                //to do when menu's change
                                                if(SigReportWas.FlushingSoilQuantity == QUA_Little)
                                                {
                                                        returner = returner@EN_Little;
                                                }else if(SigReportWas.FlushingSoilQuantity == QUA_Much)
                                                {
                                                     returner = returner@EN_Heavily;
                                                }
                                                returner = returner$".";

                                        }else if(SigReportWas.FlushingSoil == GEO_No)
                                        {
                                                returner = returner@EN_NotOccurs$".";
                                        }
                                }

                                if(SigWas.TypeOcurring == OVER_Wash)
                                {
                                        if(SigReportWas.WavesDescription != WAVE_None)
                                        {
                                                returner = returner$"|  - "@EN_Waves;
                                                if(SigReportWas.WavesDescription == WAVE_Medium)
                                                {
                                                        returner = returner@lower(EN_OverToppingWash_AnswerStrings[5].Answers[0])$".";
                                                }else if(SigReportWas.WavesDescription == WAVE_Fierce)
                                                {
                                                        returner = returner@lower(EN_OverToppingWash_AnswerStrings[5].Answers[1])$".";
                                                }
                                        }

                                }


                                break;

                        case SIG_FloatingWasteOther:

                                SigFlo = SignalFloatingWaste(Sig);

                                break;
                        case SIG_HumanActivity:
                                SigHum = SignalHumanActivity(Sig);


                                break;

                        case SIG_BioActivity:
                                SigBio = SignalBioActivity(Sig);

                                break;



                }



        }
        //log("GetAllAnswersSentences72");
        return Returner;
}

function array<String> ConcatStringArray(array<String> Ar1,array<String> Ar2)
{
        local array<String> Returner;
        local int i;
        local int Length;
        Length = Ar1.Length+Ar2.Length;
        Returner.Insert(0,Length);
        for(i=0;i<Length;i++)
        {
                if(i<Ar1.Length)
                {
                        Returner[i] = Ar1[i];
                }
                else
                {
                        Returner[i] = Ar2[i-Ar1.Length];
                }
        }
        return Returner;

}


//this function return all the signals which are changed (has just been created) or the player changed the values of them.
function array<Signal> GetChangedSignals(array<Signal> Signals)
{
        local array<Signal> returner;
        local int i,changedCount;
        changedCount = 0;
        for(i = 0; i < Signals.Length;i++)
        {
                if(!Signals[i].bReported)
                {
                        returner.Insert(changedCount,1);
                        returner[changedCount] = Signals[i];
                        changedCount++;
                }

        }
        return returner;

}

//function to concatenate 2 arrays
//if empty in empty out
function array<AnswerStruct> ConcatAnswerArray(array<AnswerStruct> Ar1,array<AnswerStruct> Ar2)
{
        local array<AnswerStruct> Returner;
        local int i;
        local int Length;
        Length = Ar1.Length+Ar2.Length;
        Returner.Insert(0,Length);
        for(i = 0; i < Length; i++)
        {
                if(i < Ar1.Length)
                {
                        Returner[i] = Ar1[i];
                }
                else
                {
                        Returner[i] = Ar2[i-Ar1.Length];
                }
        }
        return Returner;
}
// Determine how relevant the Signals together are and store the reason.
function HowSeriousStruct HowSerious(array<Signal> Signals, GeoPlayerController GeoPC)
{
        local HowSeriousStruct returner;

        local array<HowSeriousStruct> HowSeriousStructs;        // to contain results of function howSeriousSignal for each signal
                                                                // in parameter Signals, so how serious it is given the observations
        local array <int> TotalOfType;                          // counts the total number of signals for every signal type
        local array <int> TempOfType;                           // counts off the current number of signals for each signal type while calling HowSerious

        local int i;

        // fill arrays to start
        TotalOfType.Insert(0,11); //11=enumcount GeoSignalTypes
        TempOfType.Insert(0,11); //11=enumcount GeoSignalTypes
        //set all indices of TempOfType on -1 (zero-based interpreted by SignalStringData) and
        // all values of TotalOfType to 0 (simply counts the total number)
        for(i = 0; i < 11; i++)
        {
                TotalOfType[i] = 0;
                TempOfType[i] = -1;
        }
        
        // count the total number of signals for every signal type
        //(except for the ones that aren't there anyway)
        for(i = 0; i< Signals.Length;i++)
        {
                TotalOfType[Signals[i].SignalType]++;
        }

        //Get all the HowSeriousStructs from signals
        for(i = 0; i< Signals.Length;i++)
        {
                HowSeriousStructs.Insert(i,1);
                TempOfType[Signals[i].SignalType]++;
                HowSeriousStructs[i] = HowSeriousSignal(Signals[i], GeoPC, TempOfType[Signals[i].SignalType], TotalOfType[Signals[i].SignalType]);
        }

        // how serious are the signals all together; take the most serious state in any of the Signals
        // and set returner.states to this state
        returner.states = STA_Reportable;
        for(i = 0;i< Signals.Length;i++)
        {
                if(HowSeriousStructs[i].states > returner.states && HowSeriousStructs[i].states!=STA_NONE)
                        returner.states = HowSeriousStructs[i].states;
        }
        // for all signals that are of this most serious state, add their explanatory strings to
        // the string-array of returner (which is also a HSeriousStruct).
        for(i = 0;i< Signals.Length;i++)
        {
                if(HowSeriousStructs[i].states == returner.states )
                {
                        if(HowSeriousStructs[i].states == STA_Reportable)
                        {
                                // to ReasonNot_Serious, add strings made for this Signal
                                returner.ReasonNot_Serious.Insert(returner.ReasonNot_Serious.Length,1);
                                returner.ReasonNot_Serious[returner.ReasonNot_Serious.Length-1] = HowSeriousStructs[i].ReasonNot_Serious[0];
                                // same for ReasonNot_VerySerious
                                returner.ReasonNot_VerySerious.Insert(returner.ReasonNot_VerySerious.Length,1);
                                returner.ReasonNot_VerySerious[returner.ReasonNot_VerySerious.Length-1] = HowSeriousStructs[i].ReasonNot_VerySerious[0];
                        }
                        else if(HowSeriousStructs[i].states == STA_Relevant)
                        {
                                // to ReasonNot_NotSerious, add strings made for this Signal
                                returner.ReasonNot_NotSerious.Insert(returner.ReasonNot_NotSerious.Length,1);
                                returner.ReasonNot_NotSerious[returner.ReasonNot_NotSerious.Length-1] = HowSeriousStructs[i].ReasonNot_NotSerious[0];
                                // same for ReasonNot_VerySerious
                                returner.ReasonNot_VerySerious.Insert(returner.ReasonNot_VerySerious.Length,1);
                                returner.ReasonNot_VerySerious[returner.ReasonNot_VerySerious.Length-1] = HowSeriousStructs[i].ReasonNot_VerySerious[0];
                        }
                        else if(HowSeriousStructs[i].states == STA_Critical)
                        {
                                // to ReasonNot_NotSerious, add strings made for this Signal
                                returner.ReasonNot_NotSerious.Insert(returner.ReasonNot_NotSerious.Length,1);
                                returner.ReasonNot_NotSerious[returner.ReasonNot_NotSerious.Length-1] = HowSeriousStructs[i].ReasonNot_NotSerious[0];
                                // same for ReasonNot_Serious
                                returner.ReasonNot_Serious.Insert(returner.ReasonNot_Serious.Length,1);
                                returner.ReasonNot_Serious[returner.ReasonNot_Serious.Length-1] = HowSeriousStructs[i].ReasonNot_Serious[0];
                        }
                }
        }

        return returner;
}

// Determine how relevant an Signal is and store the reason for being that relevant.
function HowSeriousStruct HowSeriousSignal(Signal Sig, GeoPlayerController GeoPC, int NumberOfSignal, int TotalNumberOfType)
{
        local HowSeriousStruct returner;

        local SignalRipPitching SigRip;
        local SignalReportRipPitching SigReportRip;

        local SignalGrass SigGrass;
        local SignalReportGrass SigReportGrass;

        local SignalCrack SigCrack;
        local SignalReportCrack SigReportCrack;

        local SignalSettlement SigSett;
        local SignalReportSettlement SigReportSett;

        local SignalHorizontalMovement SigHor;
        local SignalReportHorizontalMovement SigReportHor;

        local SignalUprise SigUp;
        local SignalReportUprise SigReportUp;

        local SignalLiquefaction SigLiq;
        local SignalReportLiquefaction SigReportLiq;

        local SignalWaterOutflow SigFlow;
        local SignalReportWaterOutflow SigReportFlow;

        local SignalOverToppingWash SigWas;
        local SignalReportOverToppingWash SigReportWas;

        local SignalFloatingWaste SigFlo;

        local SignalHumanActivity SigHum;

        local SignalBioActivity SigBio;

        local bool done;
        
        //local int i;

        local GeoEnums.GeoStates TempState;

        local String TempString;
        
        done = false;

        returner.states = STA_Reportable;

        returner.ReasonNot_NotSerious.Insert(0,1);
        returner.ReasonNot_Serious.Insert(0,1);
        returner.ReasonNot_VerySerious.Insert(0,1);

        switch(Sig.SignalType)
        {
                case SIG_RipRapPitching:
                        SigRip = SignalRipPitching(Sig);
                        SigReportRip = SignalReportRipPitching(SigRip.SignalReports[SigRip.SignalReports.Length-1]);
                        //log("####################### RIPRAP #######################");
                        while(!done)
                        {
                                returner.ReasonNot_NotSerious.Remove(0,returner.ReasonNot_NotSerious.Length);
                                returner.ReasonNot_Serious.Remove(0,returner.ReasonNot_Serious.Length);
                                returner.ReasonNot_VerySerious.Remove(0,returner.ReasonNot_VerySerious.Length);

                                returner.ReasonNot_NotSerious.Insert(0,1);
                                returner.ReasonNot_Serious.Insert(0,1);
                                returner.ReasonNot_VerySerious.Insert(0,1);

                                if(GeoPC.Dutch){
                                        if(TotalNumberOfType == 1){
                                                // wat betreft de zetsteen-schade:
                                                TempString = NL_WhatA@NL_De@Lower(SigRip.NL_DamageName)$"-"$NL_Damage$":";
                                        }else{
                                                // wat betreft de eerste observatie van zetsteen-schade:
                                                TempString = NL_WhatA@NL_De@NL_TelWoorden[NumberOfSignal]@NL_Observation@NL_Of@Lower(SigRip.NL_DamageName)$"-"$NL_Damage$":";
                                        }
                                }else{
                                        if(TotalNumberOfType == 1){
                                                // wat betreft de zetsteen-schade:
                                                TempString = EN_WhatA@EN_De@Lower(SigRip.EN_DamageName)@EN_Damage$":";
                                        }else{
                                                // wat betreft de eerste observatie van zetsteen-schade:
                                                TempString = EN_WhatA@EN_De@EN_TelWoorden[NumberOfSignal]@EN_Observation@EN_Of@Lower(SigRip.EN_DamageName)@EN_Damage$":";
                                        }
                                }
                                returner.ReasonNot_NotSerious[0] = Tempstring;
                                returner.ReasonNot_Serious[0] = Tempstring;
                                returner.ReasonNot_VerySerious[0] = Tempstring;

                                TempState = STA_NONE;
                                
                                // ##### determine size of damage (and draw relevancy conclusions from it) #### //

                                /*else if(SigReportRip.LengthOfDamage == SIZE_NONE||SigReportRip.WidthOfDamage == SIZE_NONE )
                                {
                                        log("RR1.0");
                                        TempState = STA_Reportable;
                                }*/
                                if(SigReportRip.LengthOfDamage >= SIZE_Medium && SigReportRip.WidthOfDamage >= SIZE_Medium)
                                {
                                        //log("RR1.2");
                                        // if both length and width are medium or larger, it's critical
                                        TempState = STA_Critical;
                                }
                                else if(SigReportRip.LengthOfDamage >= SIZE_MediumLarge || SigReportRip.WidthOfDamage >= SIZE_MediumLarge)
                                {
                                        //log("RR1.3");
                                        // if either length or width is 'mediumLarge' or larger, it's critical
                                        TempState = STA_Critical;
                                }
                                else
                                {
                                        //log("RR1.1");
                                        // in all other cases, it's relevant (any damage to the stones will make it serious)
                                        TempState = STA_Relevant;
                                }

                                //Adding text for the size of the damage
                                /*
                                commented this away, because in the current situation, it's always minimally relevant
                                if (TempState == STA_Reportable)
                                {
                                        log("RR2.1");
                                        // not serious, so set texts for serious and very serious
                                        if(returner.States == STA_Reportable|| returner.States == STA_NONE)
                                        {
                                                log("RR2.2");
                                                returner.States = STA_Reportable;
                                                //Add Reportable ReasonNot_Serious and ReasonNot_VerySerious
                                                if(GeoPC.Dutch){
                                                        TempString = "|  - "@NL_Surface@Lower(SigRip.NL_DamageName)@NL_Damage@NL_Is@NL_Small$".";
                                                }else{
                                                        TempString = "|  - "@EN_Surface@Lower(SigRip.EN_DamageName)@EN_Damage@EN_Is@EN_Small$".";
                                                }
                                                returner.ReasonNot_Serious[0] = returner.ReasonNot_Serious[0]$TempString;
                                                returner.ReasonNot_VerySerious[0] = returner.ReasonNot_VerySerious[0]$TempString;
                                        }//else an other signal is more relevant so do nothing
                                }*/
                                if(TempState == STA_Relevant)
                                {
                                        //log("RR2.3");
                                        // serious, so
                                        if(returner.States == STA_Reportable || returner.States == STA_NONE )
                                        {
                                                //it is more serious than thought before so change the level of serioussness and start again
                                                //log("RR2.4 - continue");
                                                returner.States = STA_Relevant;
                                                continue;
                                        }
                                        else if(returner.States == STA_Critical)
                                        {
                                                // an other signal is more critical so do nothing
                                                //log("RR2.4");
                                        }
                                        else
                                        {
                                                //Add Reportable ReasonNot_NotSerious and ReasonNot_VerySerious
                                                //log("RR2.5");
                                                If(GeoPC.Dutch)
                                                {
                                                        // in Dutch
                                                        returner.ReasonNot_NotSerious[0] = returner.ReasonNot_NotSerious[0]$"|  - "@NL_Surface@NL_Damage@NL_Is@NL_Large$".";
                                                        returner.ReasonNot_VerySerious[0] = returner.ReasonNot_VerySerious[0]$"|  - "@NL_Surface@NL_Damage@NL_Is@NL_Not@NL_Very@NL_Large$".";


                                                }else
                                                {
                                                        // in English
                                                        returner.ReasonNot_NotSerious[0] = returner.ReasonNot_NotSerious[0]$"|  - "@EN_Surface@EN_Damage@EN_Is@EN_Large$".";
                                                        returner.ReasonNot_VerySerious[0] =  returner.ReasonNot_VerySerious[0]$"|  - "@EN_Surface@EN_Damage@EN_Is@NL_Not@EN_Very@EN_Large$".";
                                                }

                                        }
                                }
                                else if(TempState == STA_Critical)
                                {
                                        //very serious
                                        //log("RR2.6");

                                        if(returner.States != STA_Critical)
                                        {
                                                //log("RR2.7 - continue");
                                                returner.States = STA_Critical;
                                                continue;
                                        }
                                        else
                                        {
                                                //Add critical ReasonNot_Serious and ReasonNot_NotSerious
                                                //log("RR2.8");
                                                If(GeoPC.Dutch)
                                                {
                                                        tempstring = "|  - "@NL_Surface@NL_Damage@NL_Is@NL_Very@NL_Large$".";// in Dutch

                                                }else
                                                {
                                                        // in English
                                                        tempstring = "|  - "@EN_Surface@EN_Damage@EN_Is@EN_Very@EN_Large$".";
                                                }
                                                returner.ReasonNot_NotSerious[0] = returner.ReasonNot_NotSerious[0]$tempstring;
                                                returner.ReasonNot_Serious[0] = returner.ReasonNot_Serious[0]$tempstring;
                                        }
                                }


                                TempState = STA_NONE;
                                
                                // ##### determine presence of flushing soil (and draw relevancy conclusions from it) #### //

                                if(SigReportRip.FlushingSoil == GEO_Yes)
                                {
                                        //log("RR3.1");
                                        if(SigReportRip.FlushingSoilQuantity == QUA_Much)
                                        {
                                                //very serious
                                                //log("RR3.2");
                                                if(returner.States != STA_Critical)
                                                {
                                                        //log("RR3.3 - set to critical and continue");
                                                        returner.States = STA_Critical;
                                                        continue;
                                                }
                                                else
                                                {
                                                        //Add critical ReasonNot_NotSerious and ReasonNot_Serious
                                                        //log("RR3.4");
                                                        if(GeoPC.Dutch)
                                                        {
                                                                TempString = "|  - "@NL_Flushing@NL_Occurs@NL_Heavily$".";
                                                        }else
                                                        {
                                                                tempstring = "|  - "@EN_Flushing@EN_Occurs@EN_Heavily$".";
                                                        }
                                                        returner.ReasonNot_NotSerious[0] = returner.ReasonNot_NotSerious[0]$TempString;
                                                        returner.ReasonNot_Serious[0] = returner.ReasonNot_Serious[0]$TempString;
                                                }
                                        }
                                        else
                                        {
                                                //serious
                                                //log("RR3.5");
                                                if(returner.States == STA_Reportable || returner.States == STA_NONE )
                                                {
                                                        //it is more serious than thought before so change the level of serioussness and start again
                                                        //log("RR3.6 - continue");
                                                        returner.States = STA_Relevant;
                                                        continue;
                                                }
                                                else if(returner.States == STA_Critical)
                                                {
                                                        // an other signal is more critical so do nothing
                                                        //log("RR3.7");
                                                }
                                                else
                                                {
                                                        //log("RR3.8");
                                                        //Add Reportable ReasonNot_NotSerious and ReasonNot_VerySerious
                                                        if(GeoPC.Dutch)
                                                        {
                                                                 returner.ReasonNot_NotSerious[0] = returner.ReasonNot_NotSerious[0]$"|  - "@NL_Flushing@NL_Occurs$".";
                                                                 returner.ReasonNot_VerySerious[0] = returner.ReasonNot_VerySerious[0]$"|  - "@NL_Flushing@NL_Occurs@NL_ALittle$","@NL_Not@NL_Heavily$".";
                                                        }
                                                        else
                                                        {
                                                                returner.ReasonNot_NotSerious[0] = returner.ReasonNot_NotSerious[0]$"|  - "@EN_Flushing@EN_Occurs$".";
                                                                returner.ReasonNot_VerySerious[0] = returner.ReasonNot_VerySerious[0]$"|  - "@EN_Flushing@EN_Occurs@EN_ALittle$","@EN_Not@EN_Heavily$".";
                                                        }

                                                }
                                        }
                                }
                                else
                                {
                                        //not serious
                                        //log("RR3.9");
                                        if(returner.States == STA_Reportable|| returner.States == STA_NONE)
                                        {
                                                //log("RR3.10");
                                                returner.States = STA_Reportable;
                                                //Add Reportable ReasonNot_Serious and ReasonNot_VerySerious
                                                if(GeoPC.Dutch)
                                                {
                                                        TempString = "|  - "@NL_Flushing@NL_NotOccurs$".";
                                                }else
                                                {
                                                        TempString = "|  - "@EN_Flushing@EN_NotOccurs$".";
                                                }
                                                returner.ReasonNot_Serious[0] = returner.ReasonNot_Serious[0]$TempString;
                                                returner.ReasonNot_VerySerious[0] = returner.ReasonNot_VerySerious[0]$TempString;
                                        }//else an other signal is more relevant
                                        else if(returner.States == STA_Relevant)
                                        {
                                                //log("RR3.11");
                                                //Add Reportable ReasonNot_VerySerious
                                                if(GeoPC.Dutch)
                                                {
                                                        returner.ReasonNot_VerySerious[0] = returner.ReasonNot_VerySerious[0]$"|  - "@NL_Flushing@NL_NotOccurs$".";
                                                }else
                                                {
                                                        returner.ReasonNot_VerySerious[0] = returner.ReasonNot_VerySerious[0]$"|  - "@EN_Flushing@EN_NotOccurs$".";
                                                }
                                        }
                                }

                                TempState = STA_NONE;
                                
                                // ##### determine if there are elements loose (and draw relevancy conclusions from it) #### //

                                if(SigReportRip.ElementsLoose == GEO_Yes || SigReportRip.ElementsMissingOrMoved == GEO_Yes)
                                {
                                        // elements are loose, so it's serious or very serious
                                        //log("RR4.1");
                                        if(returner.States == STA_Reportable || returner.States == STA_NONE )
                                        {
                                                //it is more serious than thought before so change the level of serioussness and start again
                                                //log("RR4.2 - continue");
                                                returner.States = STA_Relevant;
                                                continue;
                                        }
                                        else if(returner.States == STA_Critical || returner.States == STA_Relevant)
                                        {
                                                //Add Reportable ReasonNot_NotSerious
                                                //log("RR4.3 - done");
                                                if(GeoPC.Dutch)
                                                {
                                                        if(SigReportRip.ElementsLoose == GEO_Yes && SigReportRip.ElementsMissingOrMoved == GEO_Yes)
                                                        {
                                                                returner.ReasonNot_NotSerious[0] = returner.ReasonNot_NotSerious[0]$"|  - "@NL_MissingElements $ "|  - "@NL_LooseElements;
                                                        }
                                                        else if(SigReportRip.ElementsLoose == GEO_Yes)
                                                        {
                                                                returner.ReasonNot_NotSerious[0] = returner.ReasonNot_NotSerious[0]$"|  - "@NL_LooseElements;
                                                        }
                                                        else
                                                        {
                                                                returner.ReasonNot_NotSerious[0] = returner.ReasonNot_NotSerious[0]$"|  - "@NL_MissingElements;
                                                        }
                                                }
                                                else
                                                {
                                                        if(SigReportRip.ElementsLoose == GEO_Yes && SigReportRip.ElementsMissingOrMoved == GEO_Yes)
                                                        {
                                                                returner.ReasonNot_NotSerious[0] = returner.ReasonNot_NotSerious[0]$"|  - "@EN_MissingElements $ "|  - "@EN_LooseElements;
                                                        }
                                                        else if(SigReportRip.ElementsLoose == GEO_Yes)
                                                        {
                                                                returner.ReasonNot_NotSerious[0] = returner.ReasonNot_NotSerious[0]$"|  - "@EN_LooseElements;
                                                        }
                                                        else
                                                        {
                                                                returner.ReasonNot_NotSerious[0] = returner.ReasonNot_NotSerious[0]$"|  - "@EN_MissingElements;
                                                        }
                                                }
                                                done = true;
                                        }
                                }
                                else
                                {
                                        // no elements loose AND no elements missing or moved, so not serious
                                        //log("RR4.4");
                                        if(returner.States == STA_Reportable|| returner.States == STA_NONE)
                                        {
                                                //log("RR4.5 - done");
                                                returner.States = STA_Reportable;
                                                //Add Reportable ReasonNot_Serious and ReasonNot_VerySerious
                                                If(GeoPC.Dutch)
                                                {
                                                        TempString="|  - "@NL_NoMissingElements $ "|  - "@NL_NoLooseElements;
                                                }else
                                                {
                                                        TempString="|  - "@EN_NoMissingElements $ "|  - "@EN_NoLooseElements;
                                                }// all the reasons have been filled in so
                                                returner.ReasonNot_Serious[0] = returner.ReasonNot_Serious[0]$TempString;
                                                returner.ReasonNot_VerySerious[0] = returner.ReasonNot_VerySerious[0]$TempString;
                                                done = true;
                                        }
                                        else
                                        {
                                                //an other signal is more relevant so again all the reasons have been filled in so:
                                                //log("RR4.6 - done");
                                                done = true;
                                        }
                                }
                        }


                        /*
                        log("returner.states set to: "$returner.states);
                        log("returner.ReasonNot_NotSerious set to: ");
                        for(i = 0; i < returner.ReasonNot_NotSerious.length; i++)
                        {
                                log("["$i$"] = "$returner.ReasonNot_NotSerious[i]);
                        }
                        log("returner.ReasonNot_Serious set to: ");
                        for(i = 0; i < returner.ReasonNot_Serious.length; i++)
                        {
                                log("["$i$"] = "$returner.ReasonNot_Serious[i]);
                        }
                        log("returner.ReasonNot_VerySerious set to: ");
                        for(i = 0; i < returner.ReasonNot_VerySerious.length; i++)
                        {
                                log("["$i$"] = "$returner.ReasonNot_VerySerious[i]);
                        }
                        log("####################### EOF RIPRAP #######################");
                        */
                        break;

                case SIG_GrassRevetment:
                        SigGrass= SignalGrass(Sig);
                        SigReportGrass = SignalReportGrass(SigGrass.SignalReports[SigGrass.SignalReports.Length-1]);
                        //log("####################### GRASS REVETMENT #######################");

                        returner.ReasonNot_NotSerious.Remove(0,returner.ReasonNot_NotSerious.Length);
                        returner.ReasonNot_Serious.Remove(0,returner.ReasonNot_Serious.Length);
                        returner.ReasonNot_VerySerious.Remove(0,returner.ReasonNot_VerySerious.Length);

                        returner.ReasonNot_NotSerious.Insert(0,1);
                        returner.ReasonNot_Serious.Insert(0,1);
                        returner.ReasonNot_VerySerious.Insert(0,1);

                        if(GeoPC.Dutch){
                                if(TotalNumberOfType == 1){
                                        // wat betreft de schade aan de grasbekleding:
                                        TempString = NL_WhatA@NL_De@"schade aan de"@Lower(SigGrass.NL_DamageName)$":";
                                }else{
                                        // wat betreft de eerste grasbekleding-observatie:
                                        TempString = NL_WhatA@NL_De@NL_TelWoorden[NumberOfSignal]@Lower(SigGrass.NL_DamageName)$"-"$NL_Observation$":";
                                }
                        }else{
                                if(TotalNumberOfType == 1){
                                        // wat betreft de schade aan de grasbekleding:
                                        TempString = EN_WhatA@EN_De@"schade aan de"@Lower(SigGrass.EN_DamageName)$":";
                                }else{
                                        // wat betreft de eerste grasbekleding-observatie:
                                        TempString = EN_WhatA@EN_De@EN_TelWoorden[NumberOfSignal]@Lower(SigGrass.EN_DamageName)$"-"$EN_Observation$":";
                                }
                        }
                        returner.ReasonNot_NotSerious[0] = Tempstring;
                        returner.ReasonNot_Serious[0] = Tempstring;
                        returner.ReasonNot_VerySerious[0] = Tempstring;

                        returner.States = STA_Reportable;
                        
                        if(GeoPC.dutch)
                        {
                                Tempstring = "Schade aan de grasbekleding kan er nooit alleen voor zorgen dat de schade aan een dijk serieus of heel serieus is.";
                        }else
                        {
                                Tempstring = "Grassrevetment damage alone will never make a situation serious or very serious.";
                        }

                        returner.ReasonNot_Serious[0] = returner.ReasonNot_Serious[0]$"|  - "@ Tempstring;
                        returner.ReasonNot_VerySerious[0] = returner.ReasonNot_VerySerious[0] $"|  - "@Tempstring;


                        /*while(!done){
                                returner.ReasonNot_NotSerious.Remove(0,returner.ReasonNot_NotSerious.Length);
                                returner.ReasonNot_Serious.Remove(0,returner.ReasonNot_Serious.Length);
                                returner.ReasonNot_VerySerious.Remove(0,returner.ReasonNot_VerySerious.Length);

                                returner.ReasonNot_NotSerious.Insert(0,1);
                                returner.ReasonNot_Serious.Insert(0,1);
                                returner.ReasonNot_VerySerious.Insert(0,1);

                                if(GeoPC.Dutch){
                                        TempString = NL_WhatA@NL_Het@NL_TelWoorden[NumberOfSignal]@NL_Damage@NL_Signal$": "$Lower(SigGrass.NL_DamageName)$".";
                                }else{
                                        TempString = EN_WhatA@EN_Het@EN_TelWoorden[NumberOfSignal]@EN_Damage@EN_Signal$": "$Lower(SigGrass.EN_DamageName)$".";
                                }
                                returner.ReasonNot_NotSerious[0] = Tempstring;
                                returner.ReasonNot_Serious[0] = Tempstring;
                                returner.ReasonNot_VerySerious[0] = Tempstring;

                                TempState = STA_NONE;
                                // depending on size how critical it is
                                if(SigReportGrass.LengthOfDamage == SIZE_VerySmall && SigReportGrass.WidthOfDamage < SIZE_Medium){
                                        //small surface, not serious for both primary levee and regional levee
                                        log("gr1.1");
                                        TempState = STA_Reportable;
                                }else if(Failure(GeoPC.NearByMarker.Volume).LeveeType == LT_PrimaryLevee
                                      && SigReportGrass.LengthOfDamage < SIZE_VeryLarge && SigReportGrass.WidthOfDamage < SIZE_VeryLarge){
                                        //Primary levee serious: large damage size
                                        log("gr1.2");
                                        TempState = STA_Relevant;
                                }else if(Failure(GeoPC.NearByMarker.Volume).LeveeType == LT_RegionalLevee
                                      && (SigReportGrass.LengthOfDamage < SIZE_Medium && SigReportGrass.WidthOfDamage < SIZE_Medium)){
                                        //Regional levee serious: medium damage size
                                        log("gr1.3");
                                        TempState = STA_Relevant;
                                }else{
                                        //very serious: (very) large damage size
                                        log("gr1.4");
                                        TempState = STA_Critical;
                                }

                                // add text for damage sizes
                                if(TempState == STA_Reportable){
                                      // not serious: small damage size
                                      log("gr2.1");
                                      if(returner.States == STA_Reportable || returner.States == STA_NONE){

                                              log("gr2.2");
                                              returner.States = STA_Reportable;
                                              if(GeoPC.Dutch){
                                                      returner.ReasonNot_Serious[0] = returner.ReasonNot_Serious[0]$"|  - "@NL_Surface@Lower(SigGrass.NL_DamageName)@NL_Damage@NL_Is@NL_Small$".";
                                                      returner.ReasonNot_VerySerious[0] = returner.ReasonNot_VerySerious[0]$"|  - "@NL_Surface@Lower(SigGrass.NL_DamageName)@NL_Damage@NL_Is@NL_Small$".";
                                              }else{
                                                      returner.ReasonNot_Serious[0] = returner.ReasonNot_Serious[0]$"|  - "@EN_Surface@Lower(SigGrass.EN_DamageName)@EN_Damage@EN_Is@EN_Small$".";
                                                      returner.ReasonNot_VerySerious[0] = returner.ReasonNot_VerySerious[0]$"|  - "@EN_Surface@Lower(SigGrass.EN_DamageName)@EN_Damage@EN_Is@EN_Small$".";
                                              }
                                      }
                                }else if(TempState == STA_Relevant){
                                      // serious: damage size large
                                      log("gr2.3");
                                      if(returner.States == STA_Reportable || returner.States == STA_NONE){
                                              //it is more serious than thought before so change the level of serioussness and start again
                                              log("gr2.4");
                                              returner.States = STA_Relevant;
                                              continue;
                                      }else if(returner.States == STA_Critical){
                                              // an other signal is more critical so do nothing
                                              log("gr2.5");
                                      }else{
                                              log("gr2.6");
                                              If(GeoPC.Dutch){
                                                      returner.ReasonNot_NotSerious[0] = returner.ReasonNot_NotSerious[0]$"|  - "@NL_Surface@Lower(SigGrass.NL_DamageName)@NL_Damage@NL_Is@NL_Large$".";
                                                      returner.ReasonNot_VerySerious[0] = returner.ReasonNot_VerySerious[0]$"|  - "@NL_Surface@Lower(SigGrass.NL_DamageName)@NL_Damage@NL_Is@NL_Not@NL_Very@NL_Large$".";
                                              }else{
                                                      returner.ReasonNot_NotSerious[0] = returner.ReasonNot_NotSerious[0]$"|  - "@EN_Surface@Lower(SigGrass.EN_DamageName)@EN_Damage@EN_Is@EN_Large$".";
                                                      returner.ReasonNot_VerySerious[0] = returner.ReasonNot_VerySerious[0]$"|  - "@EN_Surface@Lower(SigGrass.EN_DamageName)@EN_Damage@EN_Is@NL_Not@EN_Very@EN_Large$".";
                                              }
                                      }
                                }else if(TempState == STA_Critical){
                                      //very serious: large damage size

                                      if(returner.States != STA_Critical){
                                              //it is more serious than thought before so change the level of serioussness and start again
                                              log("gr2.7");
                                              returner.States = STA_Critical;
                                              continue;
                                      }else{
                                      
//      remove done when uncommenting...
                                              done = true;
                                              log("gr2.8");
                                              If(GeoPC.Dutch){
                                                      returner.ReasonNot_NotSerious[0] = returner.ReasonNot_NotSerious[0]$"|  - "@NL_Surface@Lower(SigGrass.NL_DamageName)@NL_Damage@NL_Very@NL_Large$".";
                                                      returner.ReasonNot_Serious[0] = returner.ReasonNot_Serious[0]$"|  - "@NL_Surface@Lower(SigGrass.NL_DamageName)@NL_Damage@NL_Very@NL_Large$".";
                                              }else{
                                                      returner.ReasonNot_NotSerious[0] = returner.ReasonNot_NotSerious[0]$"|  - "@EN_Surface@Lower(SigGrass.EN_DamageName)@EN_Damage@EN_Very@EN_Large$".";
                                                      returner.ReasonNot_Serious[0] = returner.ReasonNot_Serious[0]$"|  - "@EN_Surface@Lower(SigGrass.EN_DamageName)@EN_Damage@EN_Very@EN_Large$".";

                                              }
                                      }
                                }// eof add text for damage sizes


                                // depending on depth how critical it is
                                //TempState = STA_NONE;
                                if(SigReportGrass.DepthOfDamage == SIZE_VeryLarge){
                                      //very serious: depth is (very) large (depth > 10cm)

                                      log("gr3.1");
                                      if(returner.States != STA_Critical){
                                              log("gr3.2");
                                              returner.States = STA_Critical;
                                              continue;
                                      }else{
                                              log("gr3.3");
                                              if(GeoPC.Dutch){
                                                    returner.ReasonNot_NotSerious[0] = returner.ReasonNot_NotSerious[0]$"|  - "@NL_Dept1@Lower(SigGrass.NL_DamageName)@NL_Damage@NL_Is@NL_Very@NL_Large$".";
                                                    returner.ReasonNot_Serious[0] = returner.ReasonNot_Serious[0]$"|  - "@NL_Dept1@Lower(SigGrass.NL_DamageName)@NL_Damage@NL_Is@NL_Very@NL_Large$".";
                                              }else{
                                                    // The depth of the grass revetment is very large.
                                                    returner.ReasonNot_NotSerious[0] = returner.ReasonNot_NotSerious[0]$"|  - "@EN_Dept1@Lower(SigGrass.EN_DamageName)@EN_Damage@EN_Is@EN_Very@EN_Large$".";
                                                    returner.ReasonNot_Serious[0] = returner.ReasonNot_Serious[0]$"|  - "@EN_Dept1@Lower(SigGrass.EN_DamageName)@EN_Damage@EN_Is@EN_Very@EN_Large$".";
                                              }
                                              done = true;
                                      }
                                }else if(SigReportGrass.DepthOfDamage == SIZE_MediumLarge || SigReportGrass.DepthOfDamage == SIZE_Large){
                                      //serious: depth 5 - 10 cm (medium - large) on top/slope of Levee

                                      log("gr3.4");
                                      if(returner.States == STA_Reportable || returner.States == STA_None){
                                              // do nothing, because damage size is to small for STA_Relevant
                                              log("gr3.5 - done");
                                              done = true;

                                      }else if(returner.States == STA_Critical){
                                              // something else is more critical, do nothing
                                              log("gr3.6 - done");
                                              done = true;
                                      }else if(returner.States == STA_Relevant){
                                              // damage size and depth are ok for STA_Relevant, now check for location
                                              log("gr3.7");
                                              if(GeoPC.NewSignal.CrossCutLocation > 2){
                                                      // location is not on top/slope of the levee, so not serious
                                                      log("gr3.8 - done");
                                                      returner.States = STA_Reportable;
                                                      done = true;
                                                      if(GeoPC.Dutch){
                                                              returner.ReasonNot_Serious[0] = returner.ReasonNot_Serious[0]$"|  - "@SigGrass.NL_DamageName@NL_Damage@NL_Is@NL_Not@NL_On@NL_De@Lower(NL_CrossCut_AnswerString[0].Answers[0])@"/"@Lower(NL_CrossCut_AnswerString[0].Answers[1])@"/"@Lower(NL_CrossCut_AnswerString[0].Answers[2])$".";
                                                              returner.ReasonNot_VerySerious[0] = returner.ReasonNot_VerySerious[0]$"|  - "@SigGrass.NL_DamageName@NL_Damage@NL_Is@NL_Not@NL_On@NL_De@Lower(NL_CrossCut_AnswerString[0].Answers[0])@"/"@Lower(NL_CrossCut_AnswerString[0].Answers[1])@"/"@Lower(NL_CrossCut_AnswerString[0].Answers[2])$".";
                                                      }else{
                                                              returner.ReasonNot_Serious[0] = returner.ReasonNot_Serious[0]$"|  - "@SigGrass.EN_DamageName@EN_Damage@EN_Is@EN_Not@EN_On@EN_De@Lower(EN_CrossCut_AnswerString[0].Answers[0])@"/"@Lower(EN_CrossCut_AnswerString[0].Answers[1])@"/"@Lower(EN_CrossCut_AnswerString[0].Answers[2])$".";
                                                              returner.ReasonNot_VerySerious[0] = returner.ReasonNot_VerySerious[0]$"|  - "@SigGrass.EN_DamageName@EN_Damage@EN_Is@EN_Not@EN_On@EN_De@Lower(EN_CrossCut_AnswerString[0].Answers[0])@"/"@Lower(EN_CrossCut_AnswerString[0].Answers[1])@"/"@Lower(EN_CrossCut_AnswerString[0].Answers[2])$".";
                                                      }
                                              }else{
                                                      // serious: location is on top/slope with large damage size and depth between 5 and 10 cm
                                                      log("gr3.9 - done");
                                                      if(GeoPC.Dutch){
                                                              if(GeoPC.NewSignal.CrossCutLocation == CUT_Top){
                                                                      TempString = "|  - "@NL_SignalLocation@NL_On@NL_De@Lower(NL_CrossCut_AnswerString[0].Answers[GeoPC.NewSignal.CrossCutLocation])$".";
                                                              }else{
                                                                      TempString = "|  - "@NL_SignalLocation@NL_On@NL_Het@Lower(NL_CrossCut_AnswerString[0].Answers[GeoPC.NewSignal.CrossCutLocation])$".";
                                                              }
                                                      }else{
                                                              TempString = "|  - "@EN_SignalLocation@EN_Het@Lower(EN_CrossCut_AnswerString[0].Answers[GeoPC.NewSignal.CrossCutLocation])$".";
                                                      }
                                                      returner.ReasonNot_NotSerious[0] = returner.ReasonNot_NotSerious[0]$TempString;
                                                      returner.ReasonNot_VerySerious[0] = returner.ReasonNot_VerySerious[0]$TempString;
                                                      done = true;
                                              }
                                      }
                                }else{
                                      //not serious: damage not deep enough
                                      log("gr4.1 - done");
                                      if(GeoPC.Dutch){
                                              returner.ReasonNot_Serious[0] = returner.ReasonNot_Serious[0]$"|  - "@NL_Dept1@Lower(SigGrass.NL_DamageName)@NL_Damage@NL_Is@NL_Small$".";
                                              returner.ReasonNot_VerySerious[0] = returner.ReasonNot_VerySerious[0]$"|  - "@NL_Dept1@Lower(SigGrass.NL_DamageName)@NL_Damage@NL_Is@NL_Small$".";
                                      }else{
                                              returner.ReasonNot_Serious[0] = returner.ReasonNot_Serious[0]$"|  - "@EN_Dept1@Lower(SigGrass.EN_DamageName)@EN_Damage@EN_Is@EN_Small$".";
                                              returner.ReasonNot_VerySerious[0] = returner.ReasonNot_VerySerious[0]$"|  - "@EN_Dept1@Lower(SigGrass.EN_DamageName)@EN_Damage@EN_Is@EN_Small$".";
                                      }
                                      done = true;
                                }
                        }// eof while*/

                        //log("####################### EOF GRASS REVETMENT #######################");
                        break;

                case SIG_Crack:
                        SigCrack = SignalCrack(Sig);
                        SigReportCrack = SignalReportCrack(SigCrack.SignalReports[SigCrack.SignalReports.Length-1]);
                        //log("####################### CRACK #######################");

                        while(!done)
                        {
                                returner.ReasonNot_NotSerious.Remove(0,returner.ReasonNot_NotSerious.Length);
                                returner.ReasonNot_Serious.Remove(0,returner.ReasonNot_Serious.Length);
                                returner.ReasonNot_VerySerious.Remove(0,returner.ReasonNot_VerySerious.Length);

                                returner.ReasonNot_NotSerious.Insert(0,1);
                                returner.ReasonNot_Serious.Insert(0,1);
                                returner.ReasonNot_VerySerious.Insert(0,1);

                                if(GeoPC.Dutch){
                                        if(TotalNumberOfType == 1){
                                                // wat betreft de scheur:
                                                TempString = NL_WhatA@NL_De@Lower(SigCrack.NL_DamageName)$":";
                                        }
                                        else{
                                                // wat betreft de eerste scheur:
                                                TempString = NL_WhatA@NL_De@NL_TelWoorden[NumberOfSignal]@Lower(SigCrack.NL_DamageName)$":";
                                        }
                                }else{
                                        if(TotalNumberOfType == 1){
                                                // wat betreft de scheur:
                                                TempString = EN_WhatA@EN_De@Lower(SigCrack.EN_DamageName)$":";
                                        }
                                        else{
                                                // wat betreft de eerste scheur:
                                                TempString = EN_WhatA@EN_De@EN_TelWoorden[NumberOfSignal]@Lower(SigCrack.EN_DamageName)$":";
                                        }
                                }

                                returner.ReasonNot_NotSerious[0] = Tempstring;
                                returner.ReasonNot_Serious[0] = Tempstring;
                                returner.ReasonNot_VerySerious[0] = Tempstring;


                                // perpendicular or parallel crack with size
                                if(SigCrack.CrackType == CRK_Parallel)
                                {
                                       // depending on size how critical it is.
                                       //log("CR1.1");
                                       if(((GeoPC.NearByMarker.LTile).LeveeType == LT_PrimaryLevee && SigReportCrack.LengthOfDamage <=SIZE_MediumLarge )||( ((GeoPC.NearByMarker.LTile).LeveeType == LT_RegionalLevee || (GeoPC.NearByMarker.LTile).LeveeType == LT_RegionalLeveeWithoutRoad) && SigReportCrack.LengthOfDamage <=SIZE_Medium))
                                       {
                                                //small parallel so not serious
                                                //log("CR1.2");
                                                if(SigReportCrack.WidthOfDamage <= SIZE_MediumLarge)
                                                {
                                                        //log("CR1.3");
                                                        if(returner.States == STA_Reportable|| returner.States == STA_NONE)
                                                        {
                                                                //log("CR1.4");
                                                                returner.States = STA_Reportable;
                                                                //Add Reportable ReasonNot_Serious and ReasonNot_VerySerious
                                                                if(GeoPC.Dutch)
                                                                {
                                                                        TempString = "|  - "@NL_IsA@NL_Small$"e"@"(in"@NL_Width2@NL_And@NL_Length2$")"@Lower(NL_Crack_AnswerStrings[1].Answers[SigCrack.CrackType])$".";

                                                                }else
                                                                {
                                                                       TempString = "|  - "@EN_IsA@EN_Small@"(in"@EN_Width2@EN_And@EN_Length2$")"@Lower(EN_Crack_AnswerStrings[1].Answers[SigCrack.CrackType])$".";
                                                                }
                                                                returner.ReasonNot_Serious[0]= returner.ReasonNot_Serious[0]$TempString;
                                                                returner.ReasonNot_VerySerious[0]=returner.ReasonNot_VerySerious[0]$TempString;
                                                        }
                                                }

                                       }
                                       else if(((GeoPC.NearByMarker.LTile).LeveeType == LT_PrimaryLevee && SigReportCrack.LengthOfDamage <=SIZE_Large )|| (GeoPC.NearByMarker.LTile.LeveeType == LT_RegionalLevee || GeoPC.NearByMarker.LTile.LeveeType == LT_RegionalLeveeWithoutRoad) )
                                       {
                                                //large parallel so serious
                                                //log("CR1.5");
                                                if(returner.States == STA_Reportable || returner.States == STA_NONE )
                                                {
                                                        //it is more serious than thought before so change the level of serioussness and start again
                                                        //log("CR1.6 - continue");
                                                        returner.States = STA_Relevant;
                                                        continue;
                                                }
                                                else if(returner.States == STA_Critical)
                                                {
                                                        // an other signal is more critical so do nothing
                                                        //log("CR1.7");
                                                }
                                                else
                                                {
                                                        // add text large parallel (length)
                                                        //log("CR1.8");
                                                        if(GeoPC.dutch)
                                                        {
                                                                Tempstring = "|  - "@NL_IsA@NL_Large2@Lower(NL_Crack_AnswerStrings[1].Answers[SigCrack.CrackType])$".";
                                                                returner.ReasonNot_NotSerious[0] = returner.ReasonNot_NotSerious[0]$Tempstring;
                                                                if((GeoPC.NearByMarker.LTile).LeveeType != LT_RegionalLevee && (GeoPC.NearByMarker.LTile).LeveeType != LT_RegionalLeveeWithoutRoad )
                                                                {
                                                                        Tempstring = "|  - "@NL_IsA@NL_Large2$","@NL_But@NL_Not@NL_A@NL_Very@NL_Large2@Lower(NL_Crack_AnswerStrings[1].Answers[SigCrack.CrackType])$".";
                                                                        returner.ReasonNot_VerySerious[0] = returner.ReasonNot_VerySerious[0]$Tempstring;
                                                                }
                                                        }else
                                                        {
                                                                Tempstring = "|  - "@EN_IsA@EN_Large@Lower(EN_Crack_AnswerStrings[1].Answers[SigCrack.CrackType])$".";
                                                                returner.ReasonNot_NotSerious[0] = returner.ReasonNot_NotSerious[0]$Tempstring;
																if((GeoPC.NearByMarker.LTile).LeveeType != LT_RegionalLevee && (GeoPC.NearByMarker.LTile).LeveeType != LT_RegionalLeveeWithoutRoad )
                                                                {
                                                                        Tempstring = "|  - "@EN_IsA@EN_Large$","@EN_But@EN_Not@EN_A@EN_Very@EN_Large@Lower(EN_Crack_AnswerStrings[1].Answers[SigCrack.CrackType])$".";
                                                                        returner.ReasonNot_VerySerious[0] = returner.ReasonNot_VerySerious[0]$Tempstring;
                                                                }
                                                        }
                                                }
                                       }
                                       else
                                       {
                                                //very large parallel crack on a primary levee so very serious
                                                //log("CR1.9");
                                                if(returner.States != STA_Critical)
                                                {
                                                        //log("CR1.10 - continue");
                                                        returner.States = STA_Critical;
                                                        continue;
                                                }else
                                                {
                                                        //add text large parallel crack(length) very serious
                                                        //log("CR1.11");
                                                        if(GeoPC.Dutch)
                                                        {
                                                                TempString = "|  - "@NL_IsA@NL_Very@NL_Large2@Lower(NL_Crack_AnswerStrings[1].Answers[SigCrack.CrackType])$".";
                                                        }else
                                                        {
                                                                TempString = "|  - "@EN_IsA@EN_Very@EN_Large@Lower(EN_Crack_AnswerStrings[1].Answers[SigCrack.CrackType])$".";
                                                        }
                                                        returner.ReasonNot_Serious[0] = returner.ReasonNot_Serious[0]$TempString;
                                                        returner.ReasonNot_NotSerious[0] = returner.ReasonNot_NotSerious[0]$TempString;
                                                }
                                       }
                                       // width of the crack



									   Log ("type: " $ GeoPC.NearByMarker.LTile.myFailure.IsA('LeveeFailureDroogteWigCrack'));

									   if(SigReportCrack.WidthOfDamage < SIZE_Medium && ( GeoPC.NearByMarker.LTile.myFailure.IsA('LeveeFailureDroogteWigCrack') || GeoPC.NearByMarker.LTile.myFailure.IsA('LeveeFailureDroogteMultipleCracks') ) )
                                       {
											if(returner.States == STA_Reportable || returner.States == STA_NONE )
											{
													//it is more serious than thought before so change the level of serioussness and start again
												   //log("CR3.2 - continue");
													returner.States = STA_Reportable;

													Log("WigCrack/Multiple - small - A");
													done = true;
													continue;

											}else if(returner.States == STA_Critical)
											{
													// an other signal is more critical so do nothing
													//log("CR3.3");

													Log("WigCrack/Multiple - small - B");

											}else
											{
													// add text large perpendicular (width)
													//log("CR3.4");

													Log("WigCrack/Multiple - small - C");

													if(GeoPC.Dutch)
													{
															Tempstring = "|  - "@NL_IsA@Lower(NL_Crack_AnswerStrings[1].Answers[SigCrack.CrackType])$","@NL_But@NL_Not@NL_A@NL_Wide@Lower(NL_Crack_AnswerStrings[1].Answers[SigCrack.CrackType])$".";

													}else
													{
															Tempstring = "|  - "@EN_IsA@Lower(EN_Crack_AnswerStrings[1].Answers[SigCrack.CrackType])$","@EN_But@EN_Not@EN_A@EN_Wide@Lower(EN_Crack_AnswerStrings[1].Answers[SigCrack.CrackType])$".";
													}

													returner.ReasonNot_VerySerious[0] = returner.ReasonNot_VerySerious[0]$Tempstring;
													returner.ReasonNot_Serious[0] = returner.ReasonNot_Serious[0];
											}
												
									   }




									   if(SigReportCrack.WidthOfDamage >= SIZE_Medium && ( GeoPC.NearByMarker.LTile.myFailure.IsA('LeveeFailureDroogteWigCrack')) )
                                       {

												Log("New signalstringdata code");
                                                //medium perpendicular crack so serious
                                                //log("CR3.1");
                                                if(returner.States == STA_Reportable || returner.States == STA_NONE )
                                                {
                                                        //it is more serious than thought before so change the level of serioussness and start again
                                                       //log("CR3.2 - continue");
                                                         returner.States = STA_Relevant;
                                                        continue;

                                                }else if(returner.States == STA_Critical)
                                                {
                                                        // an other signal is more critical so do nothing
                                                        //log("CR3.3");
                                                }else
                                                {
                                                        // add text large perpendicular (width)
                                                        //log("CR3.4");
                                                        if(GeoPC.Dutch)
                                                        {
                                                                Tempstring = "|  - "@NL_IsA@Lower(NL_Crack_AnswerStrings[1].Answers[SigCrack.CrackType])$","@NL_But@NL_Not@NL_A@NL_Wide@Lower(NL_Crack_AnswerStrings[1].Answers[SigCrack.CrackType])$".";

                                                        }else
                                                        {
                                                                Tempstring = "|  - "@EN_IsA@Lower(EN_Crack_AnswerStrings[1].Answers[SigCrack.CrackType])$","@EN_But@EN_Not@EN_A@EN_Wide@Lower(EN_Crack_AnswerStrings[1].Answers[SigCrack.CrackType])$".";
                                                        }


                                                        returner.ReasonNot_VerySerious[0] = returner.ReasonNot_VerySerious[0]$Tempstring;

														if(GeoPC.Dutch)
														{
																Tempstring = "|  - "@NL_IsA@NL_Large2@Lower(NL_Crack_AnswerStrings[1].Answers[SigCrack.CrackType])$".";

														}else
														{
																Tempstring = "|  - "@EN_IsA@EN_Large@Lower(EN_Crack_AnswerStrings[1].Answers[SigCrack.CrackType])$".";
														}

//"[XX]" $ 
														returner.ReasonNot_NotSerious[0] = returner.ReasonNot_NotSerious[0]$Tempstring;

                                                }


                                                //not so wide crack so not serious, but only if length is also small. Text already added.
                                                //log("CR2.1");
                                       }else if(SigReportCrack.WidthOfDamage >= SIZE_Medium && ( GeoPC.NearByMarker.LTile.myFailure.IsA('LeveeFailureDroogteMultipleCracks')) )
									   {
                                      
												Log("New Multiple cracks code");
                                                //medium perpendicular crack so serious
                                                //log("CR3.1");
                                                if(returner.States == STA_Reportable || returner.States == STA_NONE )
                                                {
                                                        //it is more serious than thought before so change the level of serioussness and start again
                                                       //log("CR3.2 - continue");
                                                         returner.States = STA_Relevant;
                                                        continue;

                                                }else if(returner.States == STA_Critical)
                                                {
                                                        // an other signal is more critical so do nothing
                                                        //log("CR3.3");
                                                }else
                                                {
                                                        // add text large perpendicular (width)
                                                        //log("CR3.4");
                                                        if(GeoPC.Dutch)
                                                        {
                                                                Tempstring = "|  - "@NL_IsA@Lower(NL_Crack_AnswerStrings[1].Answers[SigCrack.CrackType])$","@NL_But@NL_Not@NL_A@NL_Wide@Lower(NL_Crack_AnswerStrings[1].Answers[SigCrack.CrackType])$".";

                                                        }else
                                                        {
                                                                Tempstring = "|  - "@EN_IsA@Lower(EN_Crack_AnswerStrings[1].Answers[SigCrack.CrackType])$","@EN_But@EN_Not@EN_A@EN_Wide@Lower(EN_Crack_AnswerStrings[1].Answers[SigCrack.CrackType])$".";
                                                        }
                                                        returner.ReasonNot_VerySerious[0] = returner.ReasonNot_VerySerious[0]$Tempstring;

                                                }


                                                //not so wide crack so not serious, but only if length is also small. Text already added.
                                                //log("CR2.1");
                                       }
	
                                       else if(SigReportCrack.WidthOfDamage > SIZE_MediumLarge && ( GeoPC.NearByMarker.LTile.LeveeType == LT_RegionalLevee || GeoPC.NearByMarker.LTile.LeveeType == LT_RegionalLeveeWithoutRoad ))
                                       {
                                                //wide crack so serious and it cannot become more serious because of the width for a regional levee
                                                //log("CR2.2");
                                                if(returner.States == STA_Reportable || returner.States == STA_NONE )
                                                {
                                                        //log("CR2.3 - continue");
                                                        //it is more serious than thought before so change the level of serioussness and start again
                                                        returner.States = STA_Relevant;
                                                        continue;
                                                }
                                                else if(returner.States == STA_Critical)
                                                {
                                                        // an other signal is more critical so do nothing
                                                        //log("CR2.4");
                                                }
                                                else
                                                {
                                                        // add text large parallel (width)
                                                        //log("CR2.5");
                                                        if(GeoPC.Dutch)
                                                        {
                                                                Tempstring = "|  - "@NL_IsA@NL_Wide@Lower(NL_Crack_AnswerStrings[1].Answers[SigCrack.CrackType])$".";
                                                                returner.ReasonNot_NotSerious[0] = returner.ReasonNot_NotSerious[0]$Tempstring;
                                                                //Tempstring = "|  - "@NL_IsA@NL_Wide$","@NL_But@NL_Not@NL_A@NL_Very@NL_Wide@Lower(NL_Crack_AnswerStrings[1].Answers[SigCrack.CrackType])$".";
                                                                //returner.ReasonNot_VerySerious[0] = returner.ReasonNot_VerySerious[0]$Tempstring;
                                                        }
                                                        else
                                                        {
                                                                Tempstring = "|  - "@EN_IsA@EN_Wide@Lower(EN_Crack_AnswerStrings[1].Answers[SigCrack.CrackType])$".";
                                                                returner.ReasonNot_NotSerious[0] = returner.ReasonNot_NotSerious[0]$Tempstring;
                                                                //Tempstring = "|  - "@EN_IsA@EN_Wide$","@EN_But@EN_Not@EN_A@EN_Very@EN_Wide@Lower(EN_Crack_AnswerStrings[1].Answers[SigCrack.CrackType])$".";
                                                                //returner.ReasonNot_VerySerious[0] = returner.ReasonNot_VerySerious[0]$Tempstring;
                                                        }
                                                }
                                       }
                                       else
                                       {
                                                //very wide crack so very serious for primary levee
                                                //log("CR2.6");
                                                if(returner.States !=STA_Critical)
                                                {
                                                        returner.States = STA_Critical;
                                                        //log("CR2.7 - continue");
                                                        continue;
                                                }
                                                else
                                                {
                                                        //add text large parallel crack(wide) very serious
                                                        //log("CR2.8");
                                                        if(GeoPC.Dutch)
                                                        {
                                                                Tempstring = "|  - "@NL_IsA@NL_Very@NL_Wide@Lower(NL_Crack_AnswerStrings[1].Answers[SigCrack.CrackType])$".";
                                                        }else
                                                        {
                                                                Tempstring = "|  - "@EN_IsA@EN_Very@EN_Wide@Lower(EN_Crack_AnswerStrings[1].Answers[SigCrack.CrackType])$".";
                                                        }
                                                        returner.ReasonNot_NotSerious[0] = returner.ReasonNot_NotSerious[0]$Tempstring;
                                                        returner.ReasonNot_Serious[0] = returner.ReasonNot_Serious[0]$Tempstring;
                                                }
                                       }
                                }
                                else if(SigCrack.CrackType == CRK_Perpendicular)
                                {
                                        // serious, but perhaps very serious (depending on size)
                                        // currently, same for primary and regional levee
                                        //log("CR2.9");
                                        if(SigReportCrack.LengthOfDamage <= SIZE_Small)
                                        {
                                                //large perpendicular
                                                //log("CR2.10");
                                                if(returner.States == STA_Reportable || returner.States == STA_NONE)
                                                {
                                                        //it is more serious than thought before so change the level of serioussness and start again
                                                        //log("CR2.11 - continue");
                                                        returner.States = STA_Relevant;
                                                        continue;
                                                }
                                                else if(returner.States == STA_Critical)
                                                {
                                                        // an other signal is more critical so do nothing
                                                        //log("CR2.12");
                                                }
                                                else
                                                {
                                                        // add text perpendicular (length)
                                                        //log("CR2.13");
                                                        if(GeoPC.dutch)
                                                        {
                                                                Tempstring = "|  - "@NL_IsA@Lower(NL_Crack_AnswerStrings[1].Answers[SigCrack.CrackType])$".";
                                                                returner.ReasonNot_NotSerious[0] = returner.ReasonNot_NotSerious[0]$Tempstring;
                                                                Tempstring = "|  - "@NL_IsA@Lower(NL_Crack_AnswerStrings[1].Answers[SigCrack.CrackType])$","@NL_But@NL_Not@NL_A@NL_Large2@Lower(NL_Crack_AnswerStrings[1].Answers[SigCrack.CrackType])$".";
                                                                returner.ReasonNot_VerySerious[0] = returner.ReasonNot_VerySerious[0]$Tempstring;
                                                        }
                                                        else
                                                        {
                                                                Tempstring = "|  - "@EN_IsA@Lower(EN_Crack_AnswerStrings[1].Answers[SigCrack.CrackType])$".";
                                                                returner.ReasonNot_NotSerious[0] = returner.ReasonNot_NotSerious[0]$Tempstring;
                                                                Tempstring = "|  - "@EN_IsA@Lower(EN_Crack_AnswerStrings[1].Answers[SigCrack.CrackType])$","@EN_But@EN_Not@EN_A@EN_Large@Lower(EN_Crack_AnswerStrings[1].Answers[SigCrack.CrackType])$".";
                                                                returner.ReasonNot_VerySerious[0] = returner.ReasonNot_VerySerious[0]$Tempstring;
                                                        }
                                                }
                                        }
                                        else
                                        {
                                                //very large perpendicular
                                                //log("CR2.14");
                                                if(returner.States !=STA_Critical)
                                                {
                                                        returner.States = STA_Critical;
                                                        //log("CR2.15 - continue");
                                                        continue;
                                                }
                                                else
                                                {
                                                        //add text large perpendicular crack(length) very serious
                                                        //log("CR2.16");
                                                        if(GeoPC.Dutch)
                                                        {
                                                                Tempstring = "|  - "@NL_IsA@NL_Large2@Lower(NL_Crack_AnswerStrings[1].Answers[SigCrack.CrackType])$".";
                                                        }else
                                                        {
                                                                Tempstring = "|  - "@EN_IsA@EN_Large@Lower(EN_Crack_AnswerStrings[1].Answers[SigCrack.CrackType])$".";
                                                        }
                                                        returner.ReasonNot_NotSerious[0] = returner.ReasonNot_NotSerious[0]$Tempstring;
                                                        returner.ReasonNot_Serious[0] = returner.ReasonNot_Serious[0]$Tempstring;
                                                }
                                        }
                                        
                                        // width of the crack
                                        if(SigReportCrack.WidthOfDamage <= SIZE_MediumLarge)
                                        {
                                                //medium perpendicular crack so serious
                                                //log("CR3.1");
                                                if(returner.States == STA_Reportable || returner.States == STA_NONE )
                                                {
                                                        //it is more serious than thought before so change the level of serioussness and start again
                                                        //log("CR3.2 - continue");
                                                        returner.States = STA_Relevant;
                                                        continue;
                                                }else if(returner.States == STA_Critical)
                                                {
                                                        // an other signal is more critical so do nothing
                                                        //log("CR3.3");
                                                }else
                                                {
                                                        // add text large perpendicular (width)
                                                        //log("CR3.4");
                                                        if(GeoPC.Dutch)
                                                        {
                                                                Tempstring = "|  - "@NL_IsA@Lower(NL_Crack_AnswerStrings[1].Answers[SigCrack.CrackType])$","@NL_But@NL_Not@NL_A@NL_Wide@Lower(NL_Crack_AnswerStrings[1].Answers[SigCrack.CrackType])$".";

                                                        }else
                                                        {
                                                                Tempstring = "|  - "@EN_IsA@Lower(EN_Crack_AnswerStrings[1].Answers[SigCrack.CrackType])$","@EN_But@EN_Not@EN_A@EN_Wide@Lower(EN_Crack_AnswerStrings[1].Answers[SigCrack.CrackType])$".";
                                                        }
                                                        returner.ReasonNot_VerySerious[0] = returner.ReasonNot_VerySerious[0]$Tempstring;
                                                }
                                        }
                                        else
                                        {
                                                //large perpendicular crack so very serious
                                                //log("CR3.5");
                                                if(returner.States !=STA_Critical)
                                                {
                                                        //log("CR3.6");
                                                        returner.States = STA_Critical;
                                                        continue;
                                                }else
                                                {
                                                        //add text large perpendicular crack(width) very serious
                                                        //log("CR3.7");
                                                        if(GeoPC.Dutch)
                                                        {
                                                                Tempstring = "|  - "@NL_IsA@NL_Wide@Lower(NL_Crack_AnswerStrings[1].Answers[SigCrack.CrackType])$".";
                                                        }else
                                                        {
                                                                Tempstring = "|  - "@EN_IsA@EN_Wide@Lower(EN_Crack_AnswerStrings[1].Answers[SigCrack.CrackType])$".";
                                                        }
                                                        returner.ReasonNot_NotSerious[0] = returner.ReasonNot_NotSerious[0]$Tempstring;
                                                        returner.ReasonNot_Serious[0] = returner.ReasonNot_Serious[0]$Tempstring;
                                                }
                                        }
                                }

                                //flushing of soil?
                                if(SigReportCrack.FlushingSoil == Geo_Yes)
                                {
                                        //log("CR4.1");
                                        if(SigReportCrack.FlushingSoilQuantity == QUA_Much)
                                        {
                                                // a lot of soil flushing so very serious
                                                //log("CR4.2");
                                                if(returner.States !=STA_Critical)
                                                {
                                                        //log("CR4.3 - continue");
                                                        returner.States = STA_Critical;
                                                        continue;
                                                }
                                                else
                                                {
                                                        //add text flushing very serious
                                                        //log("CR4.4 - done");
                                                        if(GeoPC.Dutch)
                                                        {
                                                                Tempstring = "|  - "@NL_Flushing@NL_Occurs@NL_Heavily@NL_At@NL_De@Lower(NL_Crack_AnswerStrings[1].Answers[SigCrack.CrackType])$".";
                                                        }else
                                                        {
                                                                Tempstring = "|  - "@EN_Flushing@EN_Occurs@EN_Heavily@EN_At@EN_De@Lower(EN_Crack_AnswerStrings[1].Answers[SigCrack.CrackType])$".";
                                                        }
                                                        returner.ReasonNot_NotSerious[0] = returner.ReasonNot_NotSerious[0]$Tempstring;
                                                        returner.ReasonNot_Serious[0] = returner.ReasonNot_Serious[0]$Tempstring;
                                                        done = true;
                                                }
                                        }
                                        else
                                        {
                                                // soil is only flushing with small quantities so serious
                                                //log("CR4.5");
                                                if(returner.States == STA_Reportable || returner.States == STA_NONE )
                                                {
                                                        //it is more serious than thought before so change the level of serioussness and start again
                                                        //log("CR4.6 - continue");
                                                        returner.States = STA_Relevant;
                                                        continue;
                                                }
                                                else if(returner.States == STA_Critical)
                                                {
                                                        // an other signal is more critical so do nothing
                                                        //log("CR4.7");
                                                }
                                                else
                                                {
                                                        // add text flushing of soil serious
                                                        //log("CR4.8 - done");
                                                        if(GeoPC.Dutch)
                                                        {
                                                                Tempstring = "|  - "@NL_Flushing@NL_Occurs@NL_At@NL_De@Lower(NL_Crack_AnswerStrings[1].Answers[SigCrack.CrackType])$".";
                                                                returner.ReasonNot_NotSerious[0] = returner.ReasonNot_NotSerious[0]$Tempstring;
                                                                Tempstring = "|  - "@NL_Flushing@NL_Occurs@NL_At@NL_De@Lower(NL_Crack_AnswerStrings[1].Answers[SigCrack.CrackType])$","@NL_But@NL_Not@NL_Heavily$".";
                                                                returner.ReasonNot_VerySerious[0] = returner.ReasonNot_VerySerious[0]$Tempstring;
                                                        }
                                                        else
                                                        {
                                                                Tempstring = "|  - "@EN_Flushing@EN_Occurs@EN_At@EN_De@Lower(EN_Crack_AnswerStrings[1].Answers[SigCrack.CrackType])$".";
                                                                returner.ReasonNot_NotSerious[0] = returner.ReasonNot_NotSerious[0]$Tempstring;
                                                                Tempstring = "|  - "@EN_Flushing@EN_Occurs@EN_At@EN_De@Lower(NL_Crack_AnswerStrings[1].Answers[SigCrack.CrackType])$","@EN_But@EN_Not@EN_Heavily$".";
                                                                returner.ReasonNot_VerySerious[0] = returner.ReasonNot_VerySerious[0]$Tempstring;
                                                        }
                                                        done = true;
                                                }
                                        }
                                }
                                else
                                {
                                        //no soil is flushing
                                        //log("CR4.9");
                                        if(returner.States == STA_Reportable|| returner.States == STA_NONE)
                                        {
                                                //log("CR4.10 - done");
                                                returner.States = STA_Reportable;
                                                //Add Reportable ReasonNot_Serious and ReasonNot_VerySerious
                                                if(GeoPC.Dutch)
                                                {
                                                        Tempstring = "|  - "@NL_Flushing@NL_NotOccurs@NL_At@NL_De@Lower(NL_Crack_AnswerStrings[1].Answers[SigCrack.CrackType])$".";
                                                }else
                                                {
                                                        Tempstring = "|  - "@EN_Flushing@EN_NotOccurs@EN_At@EN_De@Lower(EN_Crack_AnswerStrings[1].Answers[SigCrack.CrackType])$".";
                                                }
                                                returner.ReasonNot_Serious[0]= returner.ReasonNot_Serious[0]$Tempstring;
                                                returner.ReasonNot_VerySerious[0]=returner.ReasonNot_VerySerious[0]$Tempstring;
                                        }
                                        done = true;
                                }
                        }

                        //log("####################### EOF CRACK #######################");
                        break;

                case SIG_Settlement:
                        SigSett = SignalSettlement(Sig);
                        SigReportSett = SignalReportSettlement(SigSett.SignalReports[SigSett.SignalReports.Length-1]);
                        //log("####################### SETTLEMENT #######################");

                        while(!done)
                        {
                                returner.ReasonNot_NotSerious.Remove(0,returner.ReasonNot_NotSerious.Length);
                                returner.ReasonNot_Serious.Remove(0,returner.ReasonNot_Serious.Length);
                                returner.ReasonNot_VerySerious.Remove(0,returner.ReasonNot_VerySerious.Length);

                                returner.ReasonNot_NotSerious.Insert(0,1);
                                returner.ReasonNot_Serious.Insert(0,1);
                                returner.ReasonNot_VerySerious.Insert(0,1);

                                if(GeoPC.Dutch){
                                        if(TotalNumberOfType == 1){
                                                // wat betreft de verzakking:
                                                TempString = NL_WhatA@NL_De@Lower(SigSett.NL_DamageName)$":";
                                        }
                                        else{
                                                // wat betreft de eerste verzakking:
                                                TempString = NL_WhatA@NL_De@NL_TelWoorden[NumberOfSignal]@Lower(SigSett.NL_DamageName)$":";
                                        }
                                }else{
                                        if(TotalNumberOfType == 1){
                                                // wat betreft de verzakking:
                                                TempString = EN_WhatA@EN_De@Lower(SigSett.EN_DamageName)$":";
                                        }
                                        else{
                                                // wat betreft de eerste verzakking:
                                                TempString = EN_WhatA@EN_De@EN_TelWoorden[NumberOfSignal]@Lower(SigSett.EN_DamageName)$":";
                                        }
                                }

                                returner.ReasonNot_NotSerious[0] = TempString;
                                returner.ReasonNot_Serious[0] = TempString;
                                returner.ReasonNot_VerySerious[0] = TempString;


                                // depending on size how critical it is
                                TempState = STA_NONE;
                                if(SigSett.SettlementPosition == SET_Entire)
                                {
                                        /*
                                         * ENTIRE LEVEE, doesn't matter if Regional or Primary levee
                                         */

                                        //log("ST1.1");
                                        if(SigReportSett.LengthOfDamage <= SIZE_Medium)
                                        {
                                                  //not serious: small damage size
                                                  //log("ST1.2");
                                                  TempState = STA_Reportable;
                                        }
                                        else if(SigReportSett.LengthOfDamage <= SIZE_Large)
                                        {
                                                  //serious: medium damage size
                                                  //log("ST1.3");
                                                  TempState = STA_Relevant;
                                        }
                                        else
                                        {
                                                  //very serious: large damage size
                                                  //log("ST1.4");
                                                  TempState = STA_Critical;
                                        }
                                }
                                else
                                {
                                        /*
                                         * Hinterland/Foreland, settlement at least relevant
                                         */

                                        //log("ST1.5");
                                        if((GeoPC.NearByMarker.LTile).LeveeType == LT_PrimaryLevee)
                                        {
                                                //Primary levee

                                                if(SigReportSett.LengthOfDamage <= SIZE_Large
                                                        && SigReportSett.WidthOfDamage <= SIZE_Small)
                                                {
                                                        //serious: medium/large damage size
                                                        //log("ST1.6");
                                                        TempState = STA_Relevant;
                                                }
                                                else
                                                {
                                                        //very serious: very large damage size
                                                        //log("ST1.7");
                                                        TempState = STA_Critical;
                                                }
                                        }
                                        else
                                        {
                                                //Regional levee

                                                if(SigReportSett.LengthOfDamage > SIZE_Small
                                                        || SigReportSett.WidthOfDamage > SIZE_Small)
                                                {
                                                        //very serious: large damage size
                                                        //log("ST1.8");
                                                        TempState = STA_Critical;
                                                }
                                                else
                                                {
                                                        //log("ST1.9");
                                                        TempState = STA_Relevant;
                                                }

                                        }
                                }// eof damage size check

                                // add text for damage sizes
                                if(TempState == STA_Reportable)
                                {
                                      // not serious: small damage size
                                      //log("ST1.10");

                                      if(returner.States == STA_Reportable || returner.States == STA_NONE)
                                      {
                                              //log("ST1.11");
                                              returner.States = STA_Reportable;
                                              if(GeoPC.Dutch){
                                                      returner.ReasonNot_Serious[0] = returner.ReasonNot_Serious[0]$"|  - "@NL_Surface@Lower(SigSett.NL_DamageName)@NL_Is@NL_Small$".";
                                                      returner.ReasonNot_VerySerious[0] = returner.ReasonNot_VerySerious[0]$"|  - "@NL_Surface@Lower(SigSett.NL_DamageName)@NL_Is@NL_Small$".";
                                              }else{
                                                      returner.ReasonNot_Serious[0] = returner.ReasonNot_Serious[0]$"|  - "@EN_Surface@Lower(SigSett.EN_DamageName)@EN_Is@EN_Small$".";
                                                      returner.ReasonNot_VerySerious[0] = returner.ReasonNot_VerySerious[0]$"|  - "@EN_Surface@Lower(SigSett.EN_DamageName)@EN_Is@EN_Small$".";
                                              }
                                              done = true;
                                      }
                                }
                                else if(TempState == STA_Relevant)
                                {
                                      // serious: damage size large
                                      //log("ST1.12");

                                      if(returner.States == STA_Reportable || returner.States == STA_NONE)
                                      {
                                              //it is more serious than thought before so change the level of serioussness and start again
                                              //log("ST1.13");
                                              returner.States = STA_Relevant;
                                              continue;
                                      }
                                      else if(returner.States == STA_Critical)
                                      {
                                              // an other signal is more critical so do nothing
                                              //log("ST1.14");
                                      }
                                      else
                                      {
                                              //log("ST1.15");
                                              if(GeoPC.Dutch){
                                                      returner.ReasonNot_NotSerious[0] = returner.ReasonNot_NotSerious[0]$"|  - "@NL_Surface@Lower(SigSett.NL_DamageName)@NL_Is@NL_Large$".";
                                                      returner.ReasonNot_VerySerious[0] = returner.ReasonNot_VerySerious[0]$"|  - "@NL_Surface@Lower(SigSett.NL_DamageName)@NL_Is@NL_Not@NL_Very@NL_Large$".";
                                              }else{
                                                      returner.ReasonNot_NotSerious[0] = returner.ReasonNot_NotSerious[0]$"|  - "@EN_Surface@Lower(SigSett.EN_DamageName)@EN_Is@EN_Large$".";
                                                      returner.ReasonNot_VerySerious[0] = returner.ReasonNot_VerySerious[0]$"|  - "@EN_Surface@Lower(SigSett.EN_DamageName)@EN_Is@EN_Not@EN_Very@EN_Large$".";
                                              }
                                              done = true;
                                      }
                                      done = true;
                                }
                                else if(TempState == STA_Critical)
                                {
                                      //very serious: large damage size
                                      //log("ST1.16");

                                      if(returner.States != STA_Critical)
                                      {
                                              //it is more serious than thought before so change the level of serioussness and start again
                                              //log("ST1.17");
                                              returner.States = STA_Critical;
                                              continue;
                                      }
                                      else
                                      {
                                              //log("ST1.18");
                                              if(GeoPC.Dutch){
                                                      returner.ReasonNot_NotSerious[0] = returner.ReasonNot_NotSerious[0]$"|  - "@NL_Surface@Lower(SigSett.NL_DamageName)@NL_Is@NL_Very@NL_Large$".";
                                                      returner.ReasonNot_Serious[0] = returner.ReasonNot_Serious[0]$"|  - "@NL_Surface@Lower(SigSett.NL_DamageName)@NL_Is@NL_Very@NL_Large$".";
                                              }else{
                                                      returner.ReasonNot_NotSerious[0] = returner.ReasonNot_NotSerious[0]$"|  - "@EN_Surface@Lower(SigSett.EN_DamageName)@EN_Is@EN_Very@EN_Large$".";
                                                      returner.ReasonNot_Serious[0] = returner.ReasonNot_Serious[0]$"|  - "@EN_Surface@Lower(SigSett.EN_DamageName)@EN_Is@EN_Very@EN_Large$".";
                                              }
                                              done = true;
                                      }
                                }// eof add text for damage sizes

                                //check for damage depth
                                if(SigSett.SettlementPosition == SET_Entire)
                                {
                                        // ENTIRE LEVEE, doesn't matter if Regional or Primary levee
                                        done = false;
                                        //log("ST2.1");
                                        if(SigReportSett.HeightDifference == SIZE_MediumLarge
                                                && returner.States != STA_Critical)
                                        {
                                                //serious: heightdifference is quite large

                                                //log("ST2.2");
                                                if(returner.States != STA_Relevant)
                                                {
                                                        //log("ST2.3 - continue");
                                                        returner.States = STA_Relevant;
                                                        continue;
                                                }
                                                else
                                                {
                                                        //log("ST2.4 - done");
                                                        if(GeoPC.Dutch){
                                                            returner.ReasonNot_NotSerious[0] = returner.ReasonNot_NotSerious[0]$"|  - "@NL_Dept1@Lower(SigSett.NL_DamageName)@NL_Is@NL_Quite@NL_Large$".";
                                                            returner.ReasonNot_VerySerious[0] = returner.ReasonNot_VerySerious[0]$"|  - "@NL_Dept1@Lower(SigSett.NL_DamageName)@NL_Is@NL_Not@NL_Very@NL_Large$".";
                                                        }else{
                                                            returner.ReasonNot_NotSerious[0] = returner.ReasonNot_NotSerious[0]$"|  - "@EN_Dept1@Lower(SigSett.EN_DamageName)@EN_Is@EN_Quite@EN_Large$".";
                                                            returner.ReasonNot_VerySerious[0] = returner.ReasonNot_VerySerious[0]$"|  - "@EN_Dept1@Lower(SigSett.EN_DamageName)@EN_Is@EN_Not@EN_Very@EN_Large$".";
                                                        }
                                                        done = true;
                                                }
                                        }
                                        else if(SigReportSett.HeightDifference > SIZE_MediumLarge)
                                        {
                                                //very serious: heightdifference is very large

                                                //log("ST2.5");
                                                if(returner.States != STA_Critical)
                                                {
                                                        //log("ST2.6 - continue");
                                                        returner.States = STA_Critical;
                                                        continue;
                                                }
                                                else
                                                {
                                                        //log("ST2.7 - done");
                                                        if(GeoPC.Dutch){
                                                            returner.ReasonNot_NotSerious[0] = returner.ReasonNot_NotSerious[0]$"|  - "@NL_Dept1@Lower(SigSett.NL_DamageName)@NL_Is@NL_Very@NL_Large$".";
                                                            returner.ReasonNot_Serious[0] = returner.ReasonNot_Serious[0]$"|  - "@NL_Dept1@Lower(SigSett.NL_DamageName)@NL_Is@NL_Very@NL_Large$".";
                                                        }else{
                                                            returner.ReasonNot_NotSerious[0] = returner.ReasonNot_NotSerious[0]$"|  - "@EN_Dept1@Lower(SigSett.EN_DamageName)@EN_Is@EN_Very@EN_Large$".";
                                                            returner.ReasonNot_Serious[0] = returner.ReasonNot_Serious[0]$"|  - "@EN_Dept1@Lower(SigSett.EN_DamageName)@EN_Is@EN_Very@EN_Large$".";
                                                        }
                                                        done = true;
                                                }
                                        }
                                        else
                                        {
                                                //not serious
                                                //log("ST2.8");
                                                if(returner.States == STA_Reportable || returner.States == STA_NONE ){
                                                        //log("ST2.9 - continue");
                                                        returner.States = STA_Reportable;
                                                        //log("ST2.10 - done");
                                                        if(GeoPC.Dutch){
                                                            returner.ReasonNot_Serious[0] = returner.ReasonNot_Serious[0]$"|  - "@NL_Dept1@Lower(SigSett.NL_DamageName)@NL_Is@NL_Not@NL_Large$".";
                                                            returner.ReasonNot_VerySerious[0] = returner.ReasonNot_VerySerious[0]$"|  - "@NL_Dept1@Lower(SigSett.NL_DamageName)@NL_Is@NL_Not@NL_Very@NL_Large$".";
                                                        }else{
                                                            returner.ReasonNot_Serious[0] = returner.ReasonNot_Serious[0]$"|  - "@EN_Dept1@Lower(SigSett.EN_DamageName)@EN_Is@EN_Not@EN_Very@EN_Large$".";
                                                            returner.ReasonNot_VerySerious[0] = returner.ReasonNot_VerySerious[0]$"|  - "@EN_Dept1@Lower(SigSett.EN_DamageName)@EN_Is@EN_Not@EN_Very@EN_Large$".";
                                                        }
                                                        done = true;
                                                }
                                                //log("ST2.11");
                                                done = true;
                                        }
                                }//else{
                                        /*
                                         * Hinterland/Foreland, settlement at least relevant

                                        log("ST3.1");
                                        if(GeoPC.NewSignal.CrossCutLocation == CUT_Top
                                                && returner.States != STA_Critical){
                                                //on top of levee AND toward the hinterland or foreland
                                                log("ST3.2");

                                                if(returner.States != STA_Relevant){
                                                        log("ST3.3 - continue");
                                                        returner.States = STA_Relevant;
                                                        continue;
                                                }else{
                                                        log("ST3.4 - done");
                                                        if(GeoPC.Dutch){
                                                                if(SigSett.SettlementPosition == SET_Inwards){
                                                                        TempString = "|  - "@NL_SignalLocation@NL_On@NL_De@Lower(NL_CrossCut_AnswerString[0].Answers[GeoPC.NewSignal.CrossCutLocation])@NL_And@Lower(NL_Directed)@NL_Hinter$".";
                                                                }else{
                                                                        TempString = "|  - "@NL_SignalLocation@NL_On@NL_De@Lower(NL_CrossCut_AnswerString[0].Answers[GeoPC.NewSignal.CrossCutLocation])@NL_And@Lower(NL_Directed)@NL_Fore$".";
                                                                }
                                                        }else{
                                                                if(SigSett.SettlementPosition == SET_Inwards){
                                                                        TempString = "|  - "@EN_SignalLocation@EN_De@Lower(EN_CrossCut_AnswerString[0].Answers[GeoPC.NewSignal.CrossCutLocation])@EN_And@Lower(EN_Directed)@EN_Hinter$".";
                                                                }else{
                                                                        TempString = "|  - "@EN_SignalLocation@EN_De@Lower(EN_CrossCut_AnswerString[0].Answers[GeoPC.NewSignal.CrossCutLocation])@EN_And@Lower(EN_Directed)@EN_Fore$".";
                                                                }
                                                        }
                                                        returner.ReasonNot_NotSerious[0] = returner.ReasonNot_NotSerious[0]$TempString;
                                                        //not relevant for STA_Critical returner.ReasonNot_VerySerious[0] = returner.ReasonNot_VerySerious[0]$TempString;

                                                        done = true;
                                                }
                                        }else if(SigReportSett.HeightDifference > SIZE_VerySmall){
                                                //2cm heightdifference, so very serious
                                                log("ST3.5");

                                                if(returner.States != STA_Critical){
                                                        log("ST3.6 - continue");
                                                        returner.States = STA_Critical;
                                                        continue;
                                                }else{
                                                        log("ST3.7 - done");
                                                        if(GeoPC.Dutch){
                                                            returner.ReasonNot_NotSerious[0] = returner.ReasonNot_NotSerious[0]$"|  - "@NL_Dept1@Lower(SigSett.NL_DamageName)@NL_Is@NL_Very@NL_Large$".";
                                                            returner.ReasonNot_Serious[0] = returner.ReasonNot_Serious[0]$"|  - "@NL_Dept1@Lower(SigSett.NL_DamageName)@NL_Is@NL_Very@NL_Large$".";
                                                        }else{
                                                            returner.ReasonNot_NotSerious[0] = returner.ReasonNot_NotSerious[0]$"|  - "@EN_Dept1@Lower(SigSett.EN_DamageName)@EN_Is@EN_Very@EN_Large$".";
                                                            returner.ReasonNot_Serious[0] = returner.ReasonNot_Serious[0]$"|  - "@EN_Dept1@Lower(SigSett.EN_DamageName)@EN_Is@EN_Very@EN_Large$".";
                                                        }
                                                        done = true;
                                                }
                                        }else{
                                                log("ST3.8 - done");
                                                done = true;
                                        }
                                }*/
                        }// eof while

                        //log("####################### EOF SETTLEMENT #######################");
                        break;

                case SIG_HorizontalMovement:
                        SigHor = SignalHorizontalMovement(Sig);
                        SigReportHor = SignalReportHorizontalMovement(SigHor.SignalReports[SigHor.SignalReports.Length-1]);
                        //log("####################### HORIZONTAL MOVEMENT #######################");

                        returner.ReasonNot_NotSerious.Remove(0,returner.ReasonNot_NotSerious.Length);
                        returner.ReasonNot_Serious.Remove(0,returner.ReasonNot_Serious.Length);
                        returner.ReasonNot_VerySerious.Remove(0,returner.ReasonNot_VerySerious.Length);

                        returner.ReasonNot_NotSerious.Insert(0,1);
                        returner.ReasonNot_Serious.Insert(0,1);
                        returner.ReasonNot_VerySerious.Insert(0,1);

                        if(GeoPC.Dutch){
                                if(TotalNumberOfType == 1){
                                        // wat betreft de horizontale verplaatsing:
                                        TempString = NL_WhatA@NL_De@Lower(SigHor.NL_DamageName)$":";
                                }
                                else{
                                        // wat betreft de eerste observatie van horizontale verplaatsing:
                                        TempString = NL_WhatA@NL_De@NL_TelWoorden[NumberOfSignal]@NL_Observation@NL_Of@Lower(SigHor.NL_DamageName)$":";
                                }
                        }else{
                                if(TotalNumberOfType == 1){
                                        // wat betreft de horizontale verplaatsing:
                                        TempString = EN_WhatA@EN_De@Lower(SigHor.EN_DamageName)$":";
                                }
                                else{
                                        // wat betreft de eerste observatie van horizontale verplaatsing:
                                        TempString = EN_WhatA@EN_De@EN_TelWoorden[NumberOfSignal]@EN_Observation@EN_Of@Lower(SigHor.EN_DamageName)$":";
                                }
                        }

                        returner.ReasonNot_NotSerious[0]=TempString;
                        returner.ReasonNot_Serious[0]=TempString;
                        returner.ReasonNot_VerySerious[0]=TempString;

                        if(GeoPC.Dutch){
                                returner.ReasonNot_NotSerious[0] = returner.ReasonNot_NotSerious[0]$"|  -  Als een "$Lower(SigHor.NL_DamageName)$" opgemerkt is, wordt de observatie onmiddellijk als 'ernstig' beschouwd.";
                        }else{
                                returner.ReasonNot_NotSerious[0] = returner.ReasonNot_NotSerious[0]$"|  -  If noticed, a "$Lower(SigHor.NL_DamageName)$" always becomes 'serious' immediately.";
                        }

                        // depending on size how critical it is
                        TempState = STA_NONE;
                        // size of damage - not different any more for primary and regional levees
                        //log("HM1.1");
                        if(SigReportHor.LengthOfDamage <= SIZE_MediumLarge && SigReportHor.WidthOfDamage <= SIZE_Medium)
                        {
                                //serious: medium damage size
                                //log("HM1.2");
                                TempState = STA_Relevant;
                        }else{
                                //very serious: large damage size
                                //log("HM1.3");
                                TempState = STA_Critical;
                        }

						/// jln - 17-03-2010 
					   Log ("type: " $ GeoPC.NearByMarker.LTile.myFailure.IsA('LeveeFailureDroogteWilnis'));
                       if(SigReportHor.LengthOfDamage <= SIZE_Medium && ( GeoPC.NearByMarker.LTile.myFailure.IsA('LeveeFailureDroogteWilnis')) )
					   {
							TempState = STA_Reportable;
					   }


                        if(TempState == STA_Relevant)
                        {
                                //log("HM1.4");
                                returner.States = STA_Relevant;
                                //log("HM1.5");
                                if(GeoPC.Dutch){
                                       // returner.ReasonNot_NotSerious[0] = returner.ReasonNot_NotSerious[0]$"|  - "@NL_Surface@Lower(SigHor.NL_DamageName)@NL_Is@NL_Large$".";
                                        returner.ReasonNot_VerySerious[0] = returner.ReasonNot_VerySerious[0]$"|  - "@NL_Surface3@NL_Is@NL_Not@NL_Very@NL_Large$".";
                                }else{
                                       // returner.ReasonNot_NotSerious[0] = returner.ReasonNot_NotSerious[0]$"|  - "@EN_Surface@Lower(SigHor.EN_DamageName)@EN_Is@EN_Large$".";
                                        returner.ReasonNot_VerySerious[0] = returner.ReasonNot_VerySerious[0]$"|  - "@EN_Surface3@EN_Is@EN_Not@EN_Very@EN_Large$".";
                                }
                        } /// jln - 17-03-2010 
						
						else if (TempState == STA_Reportable)
						{
							Log ("Horizontalmovement new code: " $ GeoPC.NearByMarker.LTile.myFailure.IsA('LeveeFailureDroogteWilnis'));

							returner.States = STA_Reportable;

							returner.ReasonNot_VerySerious[0] = returner.ReasonNot_VerySerious[0]$"|  - "@NL_Surface3@NL_Is@NL_Not@NL_Very@NL_Large$".";
							returner.ReasonNot_Serious[0] = returner.ReasonNot_VerySerious[0]$"|  - "@NL_Surface3@NL_Is@NL_Not@NL_Very@NL_Large$".";

                        }else
                        {
                                //log("HM1.8");
                                returner.States = STA_Critical;
                                if(SigReportHor.LengthOfDamage > SIZE_Medium && SigReportHor.WidthOfDamage > SIZE_MediumLarge){
                                        if(GeoPC.Dutch){
                                                returner.ReasonNot_Serious[0] = returner.ReasonNot_Serious[0]$"|  - "@NL_Surface3@NL_Is@NL_Very@NL_Large$".";
                                        }else{
                                                returner.ReasonNot_Serious[0] = returner.ReasonNot_Serious[0]$"|  - "@EN_Surface3@EN_Is@EN_Very@EN_Large$".";
                                        }
                                }else if(SigReportHor.LengthOfDamage > SIZE_Medium){
                                        //log("HM1.6");
                                        if(GeoPC.Dutch){
                                                returner.ReasonNot_Serious[0] = returner.ReasonNot_Serious[0]$"|  -  De"@NL_Length2@NL_Is@NL_Very@NL_Large$".";
                                        }else{
                                                returner.ReasonNot_Serious[0] = returner.ReasonNot_Serious[0]$"|  -  The"@EN_Length2@EN_Is@EN_Very@EN_Large$".";
                                        }
                                }else{
                                        //log("HM1.7");
                                        if(GeoPC.Dutch){
                                                returner.ReasonNot_Serious[0] = returner.ReasonNot_Serious[0]$"|  -  De"@NL_Width2@NL_Is@NL_Very@NL_Large$".";
                                        }else{
                                                returner.ReasonNot_Serious[0] = returner.ReasonNot_Serious[0]$"|  -  The"@EN_Width2@EN_Is@EN_Very@EN_Large$".";
                                        }
                                }



                        }
                        /*}else{
                                // not primary levee, so regional levee
                                log("HM2.1");
                                if(SigReportHor.LengthOfDamage <= SIZE_Medium || SigReportHor.WidthOfDamage <= SIZE_MediumLarge){
                                        //serious: medium damage size
                                        log("HM2.2");
                                        TempState = STA_Relevant;
                                }else{
                                        //very serious: large damage size
                                        log("HM2.3");
                                        TempState = STA_Critical;
                                }

                                if(TempState == STA_Relevant){
                                        log("HM2.4");

                                        returner.States = STA_Relevant;
                                        if(SigReportHor.LengthOfDamage < SIZE_MediumLarge && SigReportHor.WidthOfDamage < SIZE_Small){
                                                log("HM2.5");
                                                if(GeoPC.Dutch){
                                                        returner.ReasonNot_NotSerious[0] = returner.ReasonNot_NotSerious[0]$"|  - "@NL_Surface@Lower(SigHor.NL_DamageName)@NL_Is@NL_Large$".";
                                                        returner.ReasonNot_VerySerious[0] = returner.ReasonNot_VerySerious[0]$"|  - "@NL_Surface@Lower(SigHor.NL_DamageName)@NL_Is@NL_Not@NL_Very@NL_Large$".";
                                                }else{
                                                        returner.ReasonNot_NotSerious[0] = returner.ReasonNot_NotSerious[0]$"|  - "@EN_Surface@Lower(SigHor.EN_DamageName)@EN_Is@EN_Large$".";
                                                        returner.ReasonNot_VerySerious[0] = returner.ReasonNot_VerySerious[0]$"|  - "@EN_Surface@Lower(SigHor.EN_DamageName)@EN_Is@EN_Not@EN_Very@EN_Large$".";
                                                }
                                        }else if(SigReportHor.LengthOfDamage < SIZE_MediumLarge){
                                                log("HM2.6");
                                                if(GeoPC.Dutch){
                                                        returner.ReasonNot_NotSerious[0] = returner.ReasonNot_NotSerious[0]$"|  - "@NL_De@NL_Length2@NL_Of@NL_De@Lower(SigHor.NL_DamageName)@NL_Is@NL_Quite@NL_Large$".";
                                                        returner.ReasonNot_VerySerious[0] = returner.ReasonNot_VerySerious[0]$"|  - "@NL_De@NL_Length2@NL_Of@NL_De@Lower(SigHor.NL_DamageName)@NL_Is@NL_Not@NL_Very@NL_Large$".";
                                                }else{
                                                        returner.ReasonNot_NotSerious[0] = returner.ReasonNot_NotSerious[0]$"|  - "@EN_De@EN_Length2@EN_Of@EN_De@Lower(SigHor.EN_DamageName)@EN_Is@EN_Quite@EN_Large$".";
                                                        returner.ReasonNot_VerySerious[0] = returner.ReasonNot_VerySerious[0]$"|  - "@EN_De@EN_Length2@EN_Of@EN_De@Lower(SigHor.EN_DamageName)@EN_Is@EN_Not@EN_Very@EN_Large$".";
                                                }
                                        }else{
                                                log("HM2.7");
                                                if(GeoPC.Dutch){
                                                        returner.ReasonNot_NotSerious[0] = returner.ReasonNot_NotSerious[0]$"|  - "@NL_De@NL_Width2@NL_Of@NL_De@Lower(SigHor.NL_DamageName)@NL_Is@NL_Quite@NL_Large$".";
                                                        returner.ReasonNot_VerySerious[0] = returner.ReasonNot_VerySerious[0]$"|  - "@NL_De@NL_Width2@NL_Of@NL_De@Lower(SigHor.NL_DamageName)@NL_Is@NL_Not@NL_Very@NL_Large$".";
                                                }else{
                                                        returner.ReasonNot_NotSerious[0] = returner.ReasonNot_NotSerious[0]$"|  - "@EN_De@EN_Width2@EN_Of@EN_De@Lower(SigHor.EN_DamageName)@EN_Is@EN_Quite@EN_Large$".";
                                                        returner.ReasonNot_VerySerious[0] = returner.ReasonNot_VerySerious[0]$"|  - "@EN_De@EN_Width2@EN_Of@EN_De@Lower(SigHor.EN_DamageName)@EN_Is@EN_Not@EN_Very@EN_Large$".";
                                                }
                                        }
                                }else{
                                        log("HM2.8");
                                        returner.States = STA_Critical;
                                        if(GeoPC.Dutch){
                                                returner.ReasonNot_NotSerious[0] = returner.ReasonNot_NotSerious[0]$"|  - "@NL_Surface@Lower(SigHor.NL_DamageName)@NL_Very@NL_Large$".";
                                                returner.ReasonNot_Serious[0] = returner.ReasonNot_Serious[0]$"|  - "@NL_Surface@Lower(SigHor.NL_DamageName)@NL_Very@NL_Large$".";
                                        }else{
                                                returner.ReasonNot_NotSerious[0] = returner.ReasonNot_NotSerious[0]$"|  - "@EN_Surface@Lower(SigHor.EN_DamageName)@EN_Very@EN_Large$".";
                                                returner.ReasonNot_Serious[0] = returner.ReasonNot_Serious[0]$"|  - "@EN_Surface@Lower(SigHor.EN_DamageName)@EN_Very@EN_Large$".";
                                        }
                                }
                        }*/

                        //log("####################### EOF HORIZONTAL MOVEMENT #######################");
                        break;

                case SIG_Uprise:
                        SigUp = SignalUprise(Sig);
                        SigReportUp = SignalReportUprise(Sigup.SignalReports[Sigup.SignalReports.Length-1]);
                        //log("####################### UPRISE #######################");

                        returner.ReasonNot_NotSerious.Remove(0,returner.ReasonNot_NotSerious.Length);
                        returner.ReasonNot_Serious.Remove(0,returner.ReasonNot_Serious.Length);
                        returner.ReasonNot_VerySerious.Remove(0,returner.ReasonNot_VerySerious.Length);

                        returner.ReasonNot_NotSerious.Insert(0,1);
                        returner.ReasonNot_Serious.Insert(0,1);
                        returner.ReasonNot_VerySerious.Insert(0,1);

                        if(GeoPC.Dutch){
                                if(TotalNumberOfType == 1){
                                        // wat betreft de opbolling:
                                        TempString = NL_WhatA@NL_De@Lower(SigUp.NL_DamageName)$":";
                                }
                                else{
                                        // wat betreft de eerste observatie van opbolling:
                                        TempString = NL_WhatA@NL_De@NL_TelWoorden[NumberOfSignal]@NL_Observation@NL_Of@Lower(SigUp.NL_DamageName)$":";
                                }
                        }else{
                                if(TotalNumberOfType == 1){
                                        // wat betreft de opbolling:
                                        TempString = EN_WhatA@EN_De@Lower(SigUp.EN_DamageName)$":";
                                }
                                else{
                                        // wat betreft de eerste observatie van opbolling:
                                        TempString = EN_WhatA@EN_De@EN_TelWoorden[NumberOfSignal]@EN_Observation@EN_Of@Lower(SigUp.EN_DamageName)$":";
                                }
                        }
                        returner.ReasonNot_NotSerious[0] = TempString;
                        returner.ReasonNot_Serious[0] = TempString;
                        returner.ReasonNot_VerySerious[0] = TempString;

                        if(GeoPC.Dutch){
                                returner.ReasonNot_Serious[0] = returner.ReasonNot_Serious[0]$"|  - Een opbolling is altijd 'niet ernstig'.";
                                returner.ReasonNot_VerySerious[0] = returner.ReasonNot_VerySerious[0]$"|  - Een opbolling is altijd 'niet ernstig'.";
                        }else{
                                returner.ReasonNot_Serious[0] = returner.ReasonNot_Serious[0]$"|  - An uprise always is 'not serious'.";
                                returner.ReasonNot_VerySerious[0] = returner.ReasonNot_VerySerious[0]$"|  - An uprise always is 'not serious'.";
                        }

                        //log("####################### EOF UPRISE #######################");
                        break;

                case SIG_Liquefaction:
                        SigLiq = SignalLiquefaction(Sig);
                        SigReportLiq = SignalReportLiquefaction(SigLiq.SignalReports[SigLiq.SignalReports.Length-1]);
                        //log("####################### LIQUEFACTION #######################");
                        
                        while(!done)
                        {
                                returner.ReasonNot_NotSerious.Remove(0,returner.ReasonNot_NotSerious.Length);
                                returner.ReasonNot_Serious.Remove(0,returner.ReasonNot_Serious.Length);
                                returner.ReasonNot_VerySerious.Remove(0,returner.ReasonNot_VerySerious.Length);
        
                                returner.ReasonNot_NotSerious.Insert(0,1);
                                returner.ReasonNot_Serious.Insert(0,1);
                                returner.ReasonNot_VerySerious.Insert(0,1);
        
                                if(GeoPC.Dutch){
                                        if(TotalNumberOfType == 1){
                                                // wat betreft de verweking:
                                                TempString = NL_WhatA@NL_De@Lower(SigLiq.NL_DamageName)$":";
                                        }
                                        else{
                                                // wat betreft de eerste observatie van verweking:
                                                TempString = NL_WhatA@NL_De@NL_TelWoorden[NumberOfSignal]@NL_Observation@NL_Of@Lower(SigLiq.NL_DamageName)$":";
                                        }
                                }else{
                                        if(TotalNumberOfType == 1){
                                                // wat betreft de verweking:
                                                TempString = EN_WhatA@EN_De@Lower(SigLiq.EN_DamageName)$":";
                                        }
                                        else{
                                                // wat betreft de eerste observatie van verweking:
                                                TempString = EN_WhatA@EN_De@EN_TelWoorden[NumberOfSignal]@EN_Observation@EN_Of@Lower(SigLiq.EN_DamageName)$":";
                                        }
                                }
        
                                returner.ReasonNot_NotSerious[0] = TempString;
                                returner.ReasonNot_Serious[0] = TempString;
                                returner.ReasonNot_VerySerious[0] = TempString;


                                if(SigReportLiq.FlushingSoil == GEO_Yes)
                                {
                                        //log("WO4.1");
                                        if(SigReportLiq.FlushingSoilQuantity == QUA_Little)
                                        {
                                                //serious: flushing of soil occurs
                                                //log("WO4.2");

                                                if(returner.States == STA_Reportable || returner.States == STA_NONE){
                                                        //log("WO4.3");
                                                        returner.States = STA_Relevant;
                                                        continue;
                                                }else if(returner.States == STA_Critical){
                                                        //do nothing, something else is more important
                                                        //log("WO4.4");
                                                }else{
                                                        //log("WO4.5 done");
                                                        if(GeoPC.Dutch){
                                                                returner.ReasonNot_NotSerious[0] = returner.ReasonNot_NotSerious[0]$"|  - "@NL_Flushing@NL_Occurs$".";
                                                                returner.ReasonNot_VerySerious[0] = returner.ReasonNot_VerySerious[0]$"|  - "@NL_Flushing@NL_NotOccurs@NL_Heavily$".";
                                                        }else{
                                                                returner.ReasonNot_NotSerious[0] = returner.ReasonNot_NotSerious[0]$"|  - "@EN_Flushing@EN_Occurs$".";
                                                                returner.ReasonNot_VerySerious[0] = returner.ReasonNot_VerySerious[0]$"|  - "@EN_Flushing@EN_NotOccurs@EN_Heavily$".";
                                                        }
                                                        done = true;
                                                }
                                        }
                                        else if(SigReportLiq.FlushingSoilQuantity == QUA_Much)
                                        {
                                                //very serious: flushing of soil occurs heavily
                                                //log("WO4.6");

                                                if(returner.States != STA_Critical){
                                                        //log("WO4.7");
                                                        returner.States = STA_Critical;
                                                        continue;
                                                }else{
                                                        //log("WO4.8 = done");
                                                        if(GeoPC.Dutch){
                                                                returner.ReasonNot_NotSerious[0] = returner.ReasonNot_NotSerious[0]$"|  - "@NL_Flushing@NL_Occurs@NL_Heavily$".";
                                                                returner.ReasonNot_Serious[0] = returner.ReasonNot_Serious[0]$"|  - "@NL_Flushing@NL_Occurs@NL_Heavily$".";
                                                        }else{
                                                                returner.ReasonNot_NotSerious[0] = returner.ReasonNot_NotSerious[0]$"|  - "@EN_Flushing@EN_Occurs@EN_Heavily$".";
                                                                returner.ReasonNot_Serious[0] = returner.ReasonNot_Serious[0]$"|  - "@EN_Flushing@EN_Occurs@EN_Heavily$".";
                                                        }
                                                        done = true;
                                                }

                                        }
                                }
                                else if(SigReportLiq.FlushingSoil == GEO_No)
                                {
                                       if(returner.States == STA_Reportable || returner.States == STA_NONE)
                                       {
                                                //log("WO4.9 - done");
                                                returner.States = STA_Reportable;
                                                if(GeoPC.Dutch){
                                                        returner.ReasonNot_Serious[0] = returner.ReasonNot_Serious[0]$"|  - "@NL_Flushing@NL_NotOccurs$".";
                                                        returner.ReasonNot_VerySerious[0] = returner.ReasonNot_VerySerious[0]$"|  - "@NL_Flushing@NL_NotOccurs$".";
                                                }else{
                                                        returner.ReasonNot_Serious[0] = returner.ReasonNot_Serious[0]$"|  - "@EN_Flushing@EN_NotOccurs$".";
                                                        returner.ReasonNot_VerySerious[0] = returner.ReasonNot_VerySerious[0]$"|  - "@EN_Flushing@EN_NotOccurs$".";
                                                }
                                                done = true;
                                        }
                                }
                        }

                        //log("####################### EOF LIQUEFACTION #######################");
                        break;

                case SIG_WaterOutflow:
                        SigFlow = SignalWaterOutflow(Sig);
                        SigReportFlow = SignalReportWaterOutflow(SigFlow.SignalReports[SigFlow.SignalReports.Length-1]);
                        //log("####################### WATEROUTFLOW #######################");

                        while(!done){
                                returner.ReasonNot_NotSerious.Remove(0,returner.ReasonNot_NotSerious.Length);
                                returner.ReasonNot_Serious.Remove(0,returner.ReasonNot_Serious.Length);
                                returner.ReasonNot_VerySerious.Remove(0,returner.ReasonNot_VerySerious.Length);

                                returner.ReasonNot_NotSerious.Insert(0,1);
                                returner.ReasonNot_Serious.Insert(0,1);
                                returner.ReasonNot_VerySerious.Insert(0,1);

                                if(GeoPC.Dutch){
                                        if(TotalNumberOfType == 1){
                                                // wat betreft het uitstromend water:
                                                TempString = NL_WhatA@NL_Het@Lower(SigFlow.NL_DamageName)$":";
                                        }
                                        else{
                                                // wat betreft de eerste observatie van uitstromend water:
                                                TempString = NL_WhatA@NL_De@NL_TelWoorden[NumberOfSignal]@NL_Observation@NL_Of@Lower(SigFlow.NL_DamageName)$":";
                                        }
                                }else{
                                        if(TotalNumberOfType == 1){
                                                // wat betreft het uitstromend water:
                                                TempString = EN_WhatA@EN_Het@Lower(SigFlow.EN_DamageName)$":";
                                        }
                                        else{
                                                // wat betreft de eerste observatie van uitstromend water:
                                                TempString = EN_WhatA@EN_De@EN_TelWoorden[NumberOfSignal]@EN_Observation@EN_Of@Lower(SigFlow.EN_DamageName)$":";
                                        }
                                }

                                returner.ReasonNot_NotSerious[0] = TempString;
                                returner.ReasonNot_Serious[0] = TempString;
                                returner.ReasonNot_VerySerious[0] = TempString;
                                /*
                                 //depending on size how critical situation is
                                TempState = STA_NONE;
                                if(Failure(GeoPC.NearByMarker.Volume).LeveeType == LT_PrimaryLevee){
                                        //Primary levee

                                        //log("WO1.1");
                                        if(SigReportFlow.LengthOfDamage == SIZE_None || SigReportFlow.WidthOfDamage == SIZE_None){
                                                //not serious
                                                log("WO1.2");
                                                TempState = STA_Reportable;
                                        }else if(SigReportFlow.LengthOfDamage < SIZE_Medium && SigReportFlow.WidthOfDamage == SIZE_VerySmall){
                                                //not serious: small damage size
                                                log("WO1.3");
                                                TempState = STA_Reportable;
                                        }else{
                                                //serious: medium damage size
                                                log("WO1.4");
                                                TempState = STA_Relevant;
                                        }
                                }else{
                                        //Regional levee

                                        log("WO1.5");
                                        if(SigReportFlow.LengthOfDamage == SIZE_None || SigReportFlow.WidthOfDamage == SIZE_None){
                                                //not serious
                                                log("WO1.6");
                                                TempState = STA_Reportable;
                                        }else if(SigReportFlow.LengthOfDamage == SIZE_VerySmall && SigReportFlow.WidthOfDamage == SIZE_VerySmall){
                                                //not serious small damage size
                                                log("WO1.7");
                                                TempState = STA_Reportable;
                                        }else{
                                                //serious: medium damage size
                                                log("WO1.8");
                                                TempState = STA_Relevant;
                                        }
                                }

                                // add text for damage sizes
                                if(TempState == STA_Reportable){
                                        // not serious: small damage size
                                        log("WO2.1");
                                        if(returner.States == STA_Reportable || returner.States == STA_NONE){
                                                log("WO2.2");
                                                returner.States = STA_Reportable;
                                                if(GeoPC.Dutch){
                                                        returner.ReasonNot_Serious[0] = returner.ReasonNot_Serious[0]$"|  - "@NL_Surface2@Lower(SigFlow.NL_DamageName)@NL_Is@NL_Small$".";
                                                        returner.ReasonNot_VerySerious[0] = returner.ReasonNot_VerySerious[0]$"|  - "@NL_Surface2@Lower(SigFlow.NL_DamageName)@NL_Is@NL_Small$".";
                                                }else{
                                                        returner.ReasonNot_Serious[0] = returner.ReasonNot_Serious[0]$"|  - "@EN_Surface@Lower(SigFlow.EN_DamageName)@EN_Is@EN_Small$".";
                                                        returner.ReasonNot_VerySerious[0] = returner.ReasonNot_VerySerious[0]$"|  - "@EN_Surface@Lower(SigFlow.EN_DamageName)@EN_Is@EN_Small$".";
                                                }
                                        }
                                }else{
                                        log("WO2.3");
                                        if(returner.States == STA_Reportable || returner.States == STA_NONE){
                                                //it is more serious than thought before so change the level of serioussness and start again
                                                log("WO2.4");
                                                returner.States = STA_Relevant;
                                                continue;
                                        }else if(returner.States == STA_Critical){
                                                //do nothing, something else is more important
                                                log("WO2.5");
                                        }else{
                                                log("WO2.6");
                                                if(GeoPC.Dutch){
                                                        returner.ReasonNot_NotSerious[0] = returner.ReasonNot_NotSerious[0]$"|  - "@NL_Surface2@Lower(SigFlow.NL_DamageName)@NL_Is@NL_Large$".";
                                                        returner.ReasonNot_VerySerious[0] = returner.ReasonNot_VerySerious[0]$"|  - "@NL_Surface2@Lower(SigFlow.NL_DamageName)@NL_Is@NL_Not@NL_Very@NL_Large$".";
                                                }else{
                                                        returner.ReasonNot_NotSerious[0] = returner.ReasonNot_NotSerious[0]$"|  - "@EN_Surface@Lower(SigFlow.EN_DamageName)@EN_Is@EN_Large$".";
                                                        returner.ReasonNot_VerySerious[0] = returner.ReasonNot_VerySerious[0]$"|  - "@EN_Surface@Lower(SigFlow.EN_DamageName)@EN_Is@EN_Not@EN_Very@EN_Large$".";
                                                }
                                        }
                                }//eof add text for damage sizes
                                */
                                if(SigReportFlow.FlushingSoil == GEO_Yes)
                                {
                                        //log("WO4.1");
                                        if(SigReportFlow.FlushingSoilQuantity == QUA_Little)
                                        {
                                                //serious: flushing of soil occurs
                                                //log("WO4.2");

                                                if(returner.States == STA_Reportable || returner.States == STA_NONE)
                                                {
                                                        //log("WO4.3");
                                                        returner.States = STA_Relevant;
                                                        continue;
                                                }
                                                else if(returner.States == STA_Critical)
                                                {
                                                        //do nothing, something else is more important
                                                        //log("WO4.4");
                                                }
                                                else
                                                {
                                                        //log("WO4.5 done");
                                                        if(GeoPC.Dutch){
                                                                returner.ReasonNot_NotSerious[0] = returner.ReasonNot_NotSerious[0]$"|  - "@NL_Flushing@NL_Occurs$".";
                                                                returner.ReasonNot_VerySerious[0] = returner.ReasonNot_VerySerious[0]$"|  - "@NL_Flushing@NL_NotOccurs@NL_Heavily$".";
                                                        }else{
                                                                returner.ReasonNot_NotSerious[0] = returner.ReasonNot_NotSerious[0]$"|  - "@EN_Flushing@EN_Occurs$".";
                                                                returner.ReasonNot_VerySerious[0] = returner.ReasonNot_VerySerious[0]$"|  - "@EN_Flushing@EN_NotOccurs@EN_Heavily$".";
                                                        }
                                                        done = true;
                                                }
                                        }
                                        else if(SigReportFlow.FlushingSoilQuantity == QUA_Much)
                                        {
                                                //very serious: flushing of soil occurs heavily
                                                //log("WO4.6");

                                                if(returner.States != STA_Critical){
                                                        //log("WO4.7");
                                                        returner.States = STA_Critical;
                                                        continue;
                                                }else{
                                                        //log("WO4.8 = done");
                                                        if(GeoPC.Dutch){
                                                                returner.ReasonNot_NotSerious[0] = returner.ReasonNot_NotSerious[0]$"|  - "@NL_Flushing@NL_Occurs@NL_Heavily$".";
                                                                returner.ReasonNot_Serious[0] = returner.ReasonNot_Serious[0]$"|  - "@NL_Flushing@NL_Occurs@NL_Heavily$".";
                                                        }else{
                                                                returner.ReasonNot_NotSerious[0] = returner.ReasonNot_NotSerious[0]$"|  - "@EN_Flushing@EN_Occurs@EN_Heavily$".";
                                                                returner.ReasonNot_Serious[0] = returner.ReasonNot_Serious[0]$"|  - "@EN_Flushing@EN_Occurs@EN_Heavily$".";
                                                        }
                                                        done = true;
                                                }

                                        }
                                }
                                else if(SigReportFlow.FlushingSoil == GEO_No)
                                {
                                       if(returner.States == STA_Reportable || returner.States == STA_NONE)
                                       {
                                                //log("WO4.9 - done");
                                                returner.States = STA_Reportable;
                                                if(GeoPC.Dutch){
                                                        returner.ReasonNot_Serious[0] = returner.ReasonNot_Serious[0]$"|  - "@NL_Flushing@NL_NotOccurs$".";
                                                        returner.ReasonNot_VerySerious[0] = returner.ReasonNot_VerySerious[0]$"|  - "@NL_Flushing@NL_NotOccurs$".";
                                                }else{
                                                        returner.ReasonNot_Serious[0] = returner.ReasonNot_Serious[0]$"|  - "@EN_Flushing@EN_NotOccurs$".";
                                                        returner.ReasonNot_VerySerious[0] = returner.ReasonNot_VerySerious[0]$"|  - "@EN_Flushing@EN_NotOccurs$".";
                                                }
                                                done = true;
                                        }
                                }
                                /*
                                if(SigReportFlow.WaterFlowOut == QUA_Much){
                                        //very serious: water outflow occurs heavily
                                        log("WO5.1");

                                        if(returner.States != STA_Critical){
                                                log("WO5.2");
                                                returner.States = STA_Critical;
                                                continue;
                                        }else{
                                                log("WO5.3");
                                                if(GeoPC.Dutch){
                                                        returner.ReasonNot_NotSerious[0] = returner.ReasonNot_NotSerious[0]$"|  - "@NL_Outflow@NL_Occurs@NL_Heavily$".";
                                                        returner.ReasonNot_Serious[0] = returner.ReasonNot_Serious[0]$"|  - "@NL_Outflow@NL_Occurs@NL_Heavily$".";
                                                }else{
                                                        returner.ReasonNot_NotSerious[0] = returner.ReasonNot_NotSerious[0]$"|  - "@EN_Outflow@EN_Occurs@EN_Heavily$".";
                                                        returner.ReasonNot_Serious[0] = returner.ReasonNot_Serious[0]$"|  - "@EN_Outflow@EN_Occurs@EN_Heavily$".";
                                                }
                                        }
                                }

                                if(SigReportFlow.MultipleLocations == GEO_Yes){
                                        //very serious: outflow occurs at multiple locations
                                        log("WO6.1");
                                        if(returner.States != STA_Critical){
                                                log("WO6.2");
                                                returner.States = STA_Critical;
                                                continue;
                                        }else{
                                                log("WO6.3");
                                                if(GeoPC.Dutch){
                                                        returner.ReasonNot_NotSerious[0] = returner.ReasonNot_NotSerious[0]$"|  - "@NL_Outflow@NL_Occurs@NL_Multiple$".";
                                                        returner.ReasonNot_Serious[0] = returner.ReasonNot_Serious[0]$"|  - "@NL_Outflow@NL_Occurs@NL_Multiple$".";
                                                }else{
                                                        returner.ReasonNot_NotSerious[0] = returner.ReasonNot_NotSerious[0]$"|  - "@EN_Outflow@EN_Occurs@EN_Multiple$".";
                                                        returner.ReasonNot_Serious[0] = returner.ReasonNot_Serious[0]$"|  - "@EN_Outflow@EN_Occurs@EN_Multiple$".";
                                                }
                                        }
                                }

                                if(SigReportFlow.CurrentSpeed == SPE_Fast && returner.States != STA_Critical){
                                        //serious: speed of outflow is fast
                                        log("WO7.1");
                                        if(returner.States == STA_Reportable || returner.States == STA_NONE){
                                                log("WO7.2 - continue");
                                                returner.States = STA_Relevant;
                                                continue;
                                        }else{
                                                log("WO7.3 - done");
                                                if(GeoPC.Dutch){
                                                        returner.ReasonNot_NotSerious[0] = returner.ReasonNot_NotSerious[0]$"|  - "@NL_Velocity@NL_Fast$".";
                                                        returner.ReasonNot_VerySerious[0] = returner.ReasonNot_VerySerious[0]$"|  - "@NL_Velocity@NL_Fast@NL_But@NL_NotOccurs@NL_Multiple@NL_And@NL_De@Lower(NL_Outflow)@NL_NotOccurs@NL_Heavily$".";
                                                }else{
                                                        returner.ReasonNot_NotSerious[0] = returner.ReasonNot_NotSerious[0]$"|  - "@EN_Velocity@EN_Fast$".";
                                                        returner.ReasonNot_VerySerious[0] = returner.ReasonNot_VerySerious[0]$"|  - "@EN_Velocity@EN_Fast@EN_But@EN_NotOccurs@EN_Multiple@EN_And@EN_De@Lower(EN_Outflow)@EN_NotOccurs@EN_Heavily$".";
                                                }
                                                done = true;
                                        }
                                }else{
                                        log("WO7.4 - done");
                                        done = true;
                                } */
                        }//eof while

                        //log("####################### EOF WATEROUTFLOW #######################");
                        break;

                case SIG_OverToppingWash:
                        SigWas = SignalOverToppingWash(Sig);
                        SigReportWas = SignalReportOverToppingWash(SigWas.SignalReports[SigWas.SignalReports.Length-1]);
                        //log("####################### OVERTOPPING #######################");

                        while(!done){
                                returner.ReasonNot_NotSerious.Remove(0,returner.ReasonNot_NotSerious.Length);
                                returner.ReasonNot_Serious.Remove(0,returner.ReasonNot_Serious.Length);
                                returner.ReasonNot_VerySerious.Remove(0,returner.ReasonNot_VerySerious.Length);

                                returner.ReasonNot_NotSerious.Insert(0,1);
                                returner.ReasonNot_Serious.Insert(0,1);
                                returner.ReasonNot_VerySerious.Insert(0,1);

                                if(GeoPC.Dutch){
                                        if(TotalNumberOfType == 1){
                                                // wat betreft de overloop / overslag:
                                                TempString = NL_WhatA@NL_De@Lower(SigWas.NL_DamageName)$":";
                                        }
                                        else{
                                                // wat betreft de eerste observatie van overloop / overslag:
                                                TempString = NL_WhatA@NL_De@NL_TelWoorden[NumberOfSignal]@NL_Observation@NL_Of@Lower(SigWas.NL_DamageName)$":";
                                        }
                                }else{
                                        if(TotalNumberOfType == 1){
                                                // wat betreft de overloop / overslag:
                                                TempString = EN_WhatA@EN_De@Lower(SigWas.EN_DamageName)$":";
                                        }
                                        else{
                                                // wat betreft de eerste observatie van overloop / overslag:
                                                TempString = EN_WhatA@EN_De@EN_TelWoorden[NumberOfSignal]@EN_Observation@EN_Of@Lower(SigWas.EN_DamageName)$":";
                                        }
                                }

                                returner.ReasonNot_NotSerious[0] = TempString;
                                returner.ReasonNot_Serious[0] = TempString;
                                returner.ReasonNot_VerySerious[0] = TempString;

                                // waves description
                                if(SigWas.TypeOcurring == OVER_Wash)
                                {
                                        if(SigReportWas.WavesDescription == WAVE_Medium)
                                        {
                                                if(returner.States == STA_Reportable || returner.States == STA_NONE)
                                                {
                                                        //log("Wa1.3");
                                                        returner.States = STA_Relevant;
                                                        continue;
                                                }
                                                else if(returner.States == STA_Critical)
                                                {
                                                        //do nothing, something else is more important
                                                        //log("WA1.4");
                                                }
                                                else
                                                {
                                                        if(GeoPC.Dutch){
                                                                returner.ReasonNot_VerySerious[0] = returner.ReasonNot_VerySerious[0]$"|  - "@"De golven kunnen niet als zijnde heftig getypeerd worden.";
                                                        }else{
                                                                returner.ReasonNot_VerySerious[0] = returner.ReasonNot_VerySerious[0]$"|  - "@"The waves cannot be descriped as fierce.";
                                                        }
                                                }
                                        }
                                        else if(SigReportWas.WavesDescription == WAVE_Fierce)
                                        {
                                                //log("WA1.1");
                                                returner.States = STA_Critical;
                                                if(GeoPC.Dutch){
                                                        returner.ReasonNot_NotSerious[0] = returner.ReasonNot_NotSerious[0]$"|  - "@"De golven kunnen getypeerd worden als heftig.";
                                                        returner.ReasonNot_Serious[0] = returner.ReasonNot_Serious[0]$"|  - "@"De golven kunnen getypeerd worden als heftig.";
                                                }else{
                                                        returner.ReasonNot_NotSerious[0] = returner.ReasonNot_NotSerious[0]$"|  - "@"The waves can be descriped as fierce.";
                                                        returner.ReasonNot_Serious[0] = returner.ReasonNot_Serious[0]$"|  - "@"The waves can be descriped as fierce.";
                                                }

                                        }
                                }
                                
                                // amount of water flowing out
                                if(SigReportWas.WaterFlowQuantity == QUA_Much)
                                {
                                        //very serious: water flow is enormous

                                        //log("WA1.1");
                                        returner.States = STA_Critical;
                                        if(GeoPC.Dutch){
                                                returner.ReasonNot_NotSerious[0] = returner.ReasonNot_NotSerious[0]$"|  - "@NL_Outflow@NL_Occurs@NL_Heavily$".";
                                                returner.ReasonNot_Serious[0] = returner.ReasonNot_Serious[0]$"|  - "@NL_Outflow@NL_Occurs@NL_Heavily$".";
                                        }else{
                                                returner.ReasonNot_NotSerious[0] = returner.ReasonNot_NotSerious[0]$"|  - "@EN_Outflow@EN_Occurs@EN_Heavily$".";
                                                returner.ReasonNot_Serious[0] = returner.ReasonNot_Serious[0]$"|  - "@EN_Outflow@EN_Occurs@EN_Heavily$".";
                                        }
                                }
                                else
                                {
                                        //serious:
                                        //log("WA1.2");
                                        if(returner.States == STA_Reportable || returner.States == STA_NONE)
                                        {
                                                //log("Wa1.3");
                                                returner.States = STA_Relevant;
                                                continue;
                                        }
                                        else if(returner.States == STA_Critical)
                                        {
                                                //do nothing, something else is more important
                                                //log("WA1.4");
                                        }
                                        else
                                        {
                                                if(GeoPC.Dutch){
                                                        returner.ReasonNot_NotSerious[0] = returner.ReasonNot_Serious[0]$"|  - "@NL_Outflow@NL_Occurs$".";
                                                        returner.ReasonNot_VerySerious[0] = returner.ReasonNot_VerySerious[0]$"|  - "@NL_Outflow@NL_NotOccurs@NL_Heavily$".";
                                                }else{
                                                        returner.ReasonNot_NotSerious[0] = returner.ReasonNot_Serious[0]$"|  - "@EN_Outflow@EN_Occurs$".";
                                                        returner.ReasonNot_VerySerious[0] = returner.ReasonNot_VerySerious[0]$"|  - "@EN_Outflow@EN_NotOccurs@EN_Heavily$".";
                                                }
                                        }
                                }
                                /*
                                if(SigReportWas.SoilPartsMoving == GEO_Yes){
                                        //very serious: flushing of soil occurs

                                        log("WA2.1");
                                        if(returner.States != STA_Critical){
                                                log("WA2.2");
                                                returner.States = STA_Critical;
                                                continue;
                                        }else{
                                                log("WA2.3 - done");
                                                if(GeoPC.Dutch){
                                                        returner.ReasonNot_NotSerious[0] = returner.ReasonNot_NotSerious[0]$"|  - "@NL_Flushing@NL_Occurs$".";
                                                        returner.ReasonNot_Serious[0] = returner.ReasonNot_Serious[0]$"|  - "@NL_Flushing@NL_Occurs$".";
                                                }else{
                                                        returner.ReasonNot_NotSerious[0] = returner.ReasonNot_NotSerious[0]$"|  - "@EN_Flushing@EN_Occurs$".";
                                                        returner.ReasonNot_Serious[0] = returner.ReasonNot_Serious[0]$"|  - "@EN_Flushing@EN_Occurs$".";
                                                }
                                                done = true;
                                        }

                                }else{
                                        log("WA2.4 - done");
                                        if(returner.States != STA_Critical){
                                                returner.States = STA_Relevant;
                                                if(GeoPC.Dutch){
                                                        returner.ReasonNot_NotSerious[0] = returner.ReasonNot_NotSerious[0]$"|  - "@"Als"@Lower(SigWas.NL_DamageName)@"opgemerkt is, wordt de observatie onmiddelijk als 'ernstig' beschouwd.";
                                                        returner.ReasonNot_VerySerious[0] = returner.ReasonNot_VerySerious[0]$"|  - "@NL_Flushing@NL_And@Lower(NL_Outflow)@NL_NotOccur$".";
                                                }else{
                                                        returner.ReasonNot_NotSerious[0] = returner.ReasonNot_NotSerious[0]$"|  - "@"If noticed,"@Lower(SigWas.NL_DamageName)@"always becomes 'serious' immediately.";
                                                        returner.ReasonNot_VerySerious[0] = returner.ReasonNot_VerySerious[0]$"|  - "@EN_Flushing@EN_And@Lower(EN_Outflow)@EN_NotOccur$".";
                                                }
                                        }
                                        done = true;
                                }*/
                                
                                // flushing of soil
                                if(SigReportWas.FlushingSoil == GEO_Yes)
                                {
                                        //log("Wa3.1");
                                        if(SigReportWas.FlushingSoilQuantity == QUA_Little)
                                        {
                                                //serious: flushing of soil occurs
                                                //log("WA3.2");

                                                if(returner.States == STA_Reportable || returner.States == STA_NONE)
                                                {
                                                        //log("Wa3.3");
                                                        returner.States = STA_Relevant;
                                                        continue;
                                                }
                                                else if(returner.States == STA_Critical)
                                                {
                                                        //do nothing, something else is more important
                                                        //log("WA3.4 done");
                                                        done = true;
                                                }
                                                else
                                                {
                                                        //log("WA3.5 done");
                                                        if(GeoPC.Dutch){
                                                                returner.ReasonNot_NotSerious[0] = returner.ReasonNot_NotSerious[0]$"|  - "@NL_Flushing@NL_Occurs$".";
                                                                returner.ReasonNot_VerySerious[0] = returner.ReasonNot_VerySerious[0]$"|  - "@NL_Flushing@NL_NotOccurs@NL_Heavily$".";
                                                        }else{
                                                                returner.ReasonNot_NotSerious[0] = returner.ReasonNot_NotSerious[0]$"|  - "@EN_Flushing@EN_Occurs$".";
                                                                returner.ReasonNot_VerySerious[0] = returner.ReasonNot_VerySerious[0]$"|  - "@EN_Flushing@EN_NotOccurs@EN_Heavily$".";
                                                        }
                                                        done = true;
                                                }
                                        }
                                        else if(SigReportWas.FlushingSoilQuantity == QUA_Much)
                                        {
                                                //very serious: flushing of soil occurs heavily
                                                //log("WA3.6");

                                                if(returner.States != STA_Critical)
                                                {
                                                        //log("WA3.7");
                                                        returner.States = STA_Critical;
                                                        continue;
                                                }
                                                else
                                                {
                                                        //log("WA3.8 = done");
                                                        if(GeoPC.Dutch){
                                                                returner.ReasonNot_NotSerious[0] = returner.ReasonNot_NotSerious[0]$"|  - "@NL_Flushing@NL_Occurs@NL_Heavily$".";
                                                                returner.ReasonNot_Serious[0] = returner.ReasonNot_Serious[0]$"|  - "@NL_Flushing@NL_Occurs@NL_Heavily$".";
                                                        }else{
                                                                returner.ReasonNot_NotSerious[0] = returner.ReasonNot_NotSerious[0]$"|  - "@EN_Flushing@EN_Occurs@EN_Heavily$".";
                                                                returner.ReasonNot_Serious[0] = returner.ReasonNot_Serious[0]$"|  - "@EN_Flushing@EN_Occurs@EN_Heavily$".";
                                                        }
                                                        done = true;
                                                }
                                        }
                                }
                                else if(SigReportWas.FlushingSoil == GEO_No)
                                {
                                        if(returner.States == STA_Reportable || returner.States == STA_NONE)
                                        {
                                                //log("Wa3.9");
                                                returner.States = STA_Relevant;
                                                continue;
                                        }
                                        else if(returner.States == STA_Critical)
                                        {
                                                //do nothing, something else is more important
                                                //log("WA3.10 done");
                                                done = true;
                                        }
                                        else
                                        {
                                                //log("WA3.11 = done");
                                                if(GeoPC.Dutch){
                                                        returner.ReasonNot_VerySerious[0] = returner.ReasonNot_VerySerious[0]$"|  - "@NL_Flushing@NL_NotOccurs$".";
                                                }else{
                                                        returner.ReasonNot_VerySerious[0] = returner.ReasonNot_VerySerious[0]$"|  - "@EN_Flushing@EN_NotOccurs$".";
                                                }
                                                done = true;
                                        }
                                }
                        }//eof while

                        //log("####################### EOF OVERTOPPING #######################");
                        break;

                case SIG_FloatingWasteOther:
                        // floating waste is always critical!
                        SigFlo = SignalFloatingWaste(Sig);
                                
                        returner.ReasonNot_NotSerious.Remove(0,returner.ReasonNot_NotSerious.Length);
                        returner.ReasonNot_Serious.Remove(0,returner.ReasonNot_Serious.Length);
                        returner.ReasonNot_VerySerious.Remove(0,returner.ReasonNot_VerySerious.Length);

                        returner.ReasonNot_NotSerious.Insert(0,1);
                        returner.ReasonNot_Serious.Insert(0,1);
                        returner.ReasonNot_VerySerious.Insert(0,1);

                        if(GeoPC.dutch)
                        {
                                Tempstring = SigFlo.NL_DamageName@"zorgt er voor dat de schade altijd als zeer serieus wordt gezien.";
                        }else
                        {
                                Tempstring = SigFlo.EN_DamageName@"damage will always make a situation very serious.";
                        }
                        returner.ReasonNot_NotSerious[0] = Tempstring;
                        returner.ReasonNot_Serious[0] = Tempstring;
                        returner.ReasonNot_VerySerious[0] = Tempstring;
                        returner.States = STA_Critical;

                        break;

                case SIG_HumanActivity:
                        // human activity is always reportable!
                        SigHum = SignalHumanActivity(Sig);

                        returner.ReasonNot_NotSerious.Remove(0,returner.ReasonNot_NotSerious.Length);
                        returner.ReasonNot_Serious.Remove(0,returner.ReasonNot_Serious.Length);
                        returner.ReasonNot_VerySerious.Remove(0,returner.ReasonNot_VerySerious.Length);

                        returner.ReasonNot_NotSerious.Insert(0,1);
                        returner.ReasonNot_Serious.Insert(0,1);
                        returner.ReasonNot_VerySerious.Insert(0,1);
                        if(SigHum.RiskCause !=RISK_NonWaterObjects)
                        {
                                if(GeoPC.dutch)
                                {
                                        Tempstring = "Schade door" @ Lower(SigHum.NL_DamageName) @ "kan er nooit alleen voor zorgen dat de schade aan een dijk serieus of heel serieus is.";
                                }else
                                {
                                        Tempstring = "Damage by" @ Lower(SigHum.EN_DamageName) @ "alone will never make a situation serious or very serious.";
                                }
                        }else
                        {
                                if(GeoPC.dutch)
                                {
                                        Tempstring = "Schade door een" @ Lower(SigHum.NL_DamageName) @ "kan er nooit alleen voor zorgen dat de schade aan een dijk serieus of heel serieus is.";
                                }else
                                {
                                        Tempstring = "Damage by a" @ Lower(SigHum.EN_DamageName) @ "alone will never make a situation serious or very serious.";
                                }

                        }

                        returner.ReasonNot_NotSerious[0] = Tempstring;
                        returner.ReasonNot_Serious[0] = Tempstring;
                        returner.ReasonNot_VerySerious[0] = Tempstring;
                        returner.States = STA_Reportable;

                        break;

                case SIG_BioActivity:
                        // bio activity is always reportable!
                        SigBio = SignalBioActivity(Sig);

						/// jln - 15-03-2010 
						if (SigBio.RiskCause == RISK_WaterQuality)
						{
							/// Critical:
							returner.States = STA_Critical;
						} else {
							 /// Not critical:
							 returner.States = STA_Reportable;
						}

                        returner.ReasonNot_NotSerious.Remove(0,returner.ReasonNot_NotSerious.Length);
                        returner.ReasonNot_Serious.Remove(0,returner.ReasonNot_Serious.Length);
                        returner.ReasonNot_VerySerious.Remove(0,returner.ReasonNot_VerySerious.Length);

                        returner.ReasonNot_NotSerious.Insert(0,1);
                        returner.ReasonNot_Serious.Insert(0,1);
                        returner.ReasonNot_VerySerious.Insert(0,1);
                        if(SigBio.RiskCause == RISK_SmallCattle || SigBio.RiskCause == RISK_BigCattle || SigBio.RiskCause == RISK_OtherBioActivity)
                        {
                                if(GeoPC.dutch)
                                {
                                        Tempstring = "Schade door" @ Lower(SigBio.NL_DamageName) @ "kan er nooit alleen voor zorgen dat de schade aan een dijk serieus of heel serieus is.";
                                }else
                                {
                                        Tempstring = "Damage by" @ Lower(SigBio.EN_DamageName) @ "alone will never make a situation serious or very serious.";
                                }
                        }
						else if(SigBio.RiskCause == RISK_WaterQuality)
						{
/// jln - 15-03-2010 droogte [todo]
                                if(GeoPC.dutch)
                                {
                                        Tempstring =  Lower(SigBio.NL_DamageName) @ "kan er nooit alleen voor zorgen dat er schade aan de dijk ontstaat, maar is tijdens droogteperiodes wel belangrijk om te rapporteren.|In dit geval moeten de dode dieren direct verwijderd worden om ziekteverspreiding te voorkomen. ";
                                }else
                                {
                                        Tempstring = "Damage by" @ Lower(SigBio.EN_DamageName) @ "(water quality)";
                                }

						}
                        else
                        {
                                if(GeoPC.dutch)
                                {
                                        Tempstring = "Schade door een" @ Lower(SigBio.NL_DamageName) @ "kan er nooit alleen voor zorgen dat de schade aan een dijk serieus of heel serieus is.";
                                }else
                                {
                                        Tempstring = "Damage by a" @ Lower(SigBio.EN_DamageName) @ "alone will never make a situation serious or very serious.";
                                }
                        }

                        returner.ReasonNot_NotSerious[0] = Tempstring;
                        returner.ReasonNot_Serious[0] = Tempstring;
                        returner.ReasonNot_VerySerious[0] = Tempstring;
                       ;
                        break;
         }

        return returner;
}


defaultproperties
{

        EN_CrossCut_QuestionStrings[0] = "Select the location of the signal";
        EN_CrossCut_AnswerString(0)=(Answers[0]="Top",Answers[1]="Outer slope",Answers[2]="Inner slope",Answers[3]="Foreland",Answers[4]="Hinterland");
        EN_CrossCut_Question_Short[0] = "Location"
        EN_CrossCut_Missing[0]= "The Location of the signal"


        NL_CrossCut_QuestionStrings[0] = "Geef de locatie van het signaal aan";
        NL_CrossCut_AnswerString(0)=(Answers[0]="Kruin",Answers[1]="Buitentalud",Answers[2]="Binnentalud",Answers[3]="Voorland",Answers[4]="Achterland");
        NL_CrossCut_Question_Short[0] = "Locatie"
        NL_CrossCut_Missing[0]="De locatie van het signaal"

        // RIP-RAP / PITCHING STONE

        RipPitching_NrQuestions=7

        EN_RipPitching_QuestionStrings(0) = "1. What type of revetment is it?"
        EN_RipPitching_QuestionStrings(1) = "2. What is the length of the damage? (in cm)"
        EN_RipPitching_QuestionStrings(2) = "3. What is the width of the damage? (in cm)"
        EN_RipPitching_QuestionStrings(3) = "4. Are any elements missing or moved?"
        EN_RipPitching_QuestionStrings(4) = "5. Does flushing of soil (e.g. sand or clay) occur?"
        EN_RipPitching_QuestionStrings(5) = "5A. Does little or much flushing of soil occur?"
        EN_RipPitching_QuestionStrings(6) = "1A. Are any number of elements loose?"

        //The question Strings for the list
        EN_RipPitching_Question_Short[0] = "Revetment type"
        EN_RipPitching_Question_Short[1] = "Length (cm)"
        EN_RipPitching_Question_Short[2] = "Width (cm)"
        EN_RipPitching_Question_Short[3] = "Elements moved"
        EN_RipPitching_Question_Short[4] = "Flushing soil"
        EN_RipPitching_Question_Short[5] = "Amount"
        EN_RipPitching_Question_Short[6] = "Loose elements"

        EN_RipPitching_Missing[0] = "The type of revetment"
        EN_RipPitching_Missing[1] = "The length"
        EN_RipPitching_Missing[2] = "The width"
        EN_RipPitching_Missing[3] = "If elements are missing or moved"
        EN_RipPitching_Missing[4] = "If flushing of soil occurs"
        EN_RipPitching_Missing[5] = "If much or little flushing occurs"
        EN_RipPitching_Missing[6] = "(If elements are loose)"


        EN_RipPitching_AnswerStrings(0)=(Answers[0]="Rip-rap",Answers[1]="Pitching stone")
        // Note: the following has to be all on one line, unfortunately. Initialisation of a struct in default properties with spaces or enters inbetween will not compile.
        EN_RipPitching_AnswerStrings(1)=(Answers[0]="0 - 100",Answers[1]="101 - 200",Answers[2]="201 - 400",Answers[3]="401 - 800",Answers[4]="801 - 1000",Answers[5]="> 1000")
        EN_RipPitching_AnswerStrings(2)=(Answers[0]="0 - 50",Answers[1]="51 - 100",Answers[2]="101 - 200",Answers[3]="201 - 300",Answers[4]="301 - 400",Answers[5]="> 400")
        EN_RipPitching_AnswerStrings(3)=(Answers[0]="Yes",Answers[1]="No")
        EN_RipPitching_AnswerStrings(4)=(Answers[0]="Yes",Answers[1]="No")
        EN_RipPitching_AnswerStrings(5)=(Answers[0]="Little",Answers[1]="Much")
        EN_RipPitching_AnswerStrings(6)=(Answers[0]="Yes",Answers[1]="No")

        NL_RipPitching_QuestionStrings(0) = "1. Om wat voor type bekleding gaat het?"
        NL_RipPitching_QuestionStrings(1) = "2. Wat is de lengte van de beschadiging? (in cm)"
        NL_RipPitching_QuestionStrings(2) = "3. Wat is de breedte van de beschadiging? (in cm)"
        NL_RipPitching_QuestionStrings(3) = "4. Zijn er een aantal elementen uit de bekleding verdwenen of verplaatst?"
        NL_RipPitching_QuestionStrings(4) = "5. Is er sprake van uitspoeling van grond (bijv. zand of klei)?"
        NL_RipPitching_QuestionStrings(5) = "5A. Spoelt er weinig of veel grond (bijv. zand of klei) uit?"
        NL_RipPitching_QuestionStrings(6) = "1A. Zijn er een aantal elementen uit de bekleding los?"



        //The question Strings for the list
        NL_RipPitching_Question_Short[0] = "Type bekleding"
        NL_RipPitching_Question_Short[1] = "Lengte (cm)"
        NL_RipPitching_Question_Short[2] = "Breedte (cm)"
        NL_RipPitching_Question_Short[3] = "Elementen weg"
        NL_RipPitching_Question_Short[4] = "Uitspoeling grond"
        NL_RipPitching_Question_Short[5] = "Hoeveelheid"
        NL_RipPitching_Question_Short[6] = "Elementen los"

        NL_RipPitching_Missing[0] = "De type bekleding"
        NL_RipPitching_Missing[1] = "De lengte"
        NL_RipPitching_Missing[2] = "De breedte"
        NL_RipPitching_Missing[3] = "Of elementen verdwenen of verplaatst zijn"
        NL_RipPitching_Missing[4] = "Of uitspoeling van grond voorkomt"
        NL_RipPitching_Missing[5] = "Of weinig of veel grond uitspoelt"
        NL_RipPitching_Missing[6] = "(Of elementen los zijn)"

        NL_RipPitching_AnswerStrings(0)=(Answers[0]="Stortsteen",Answers[1]="Zetsteen")
        // Note: the following has to be all on one line, unfortunately. Initialisation of a struct in default properties with spaces or enters inbetween will not compile.
        NL_RipPitching_AnswerStrings(1)=(Answers[0]="0 - 100",Answers[1]="101 - 200",Answers[2]="201 - 400",Answers[3]="401 - 800",Answers[4]="801 - 1000",Answers[5]="> 1000")
        NL_RipPitching_AnswerStrings(2)=(Answers[0]="0 - 50",Answers[1]="51 - 100",Answers[2]="101 - 200",Answers[3]="201 - 300",Answers[4]="301 - 400",Answers[5]="> 400")
        NL_RipPitching_AnswerStrings(3)=(Answers[0]="Ja",Answers[1]="Nee")
        NL_RipPitching_AnswerStrings(4)=(Answers[0]="Ja",Answers[1]="Nee")
        NL_RipPitching_AnswerStrings(5)=(Answers[0]="Weinig",Answers[1]="Veel")
        NL_RipPitching_AnswerStrings(6)=(Answers[0]="Ja",Answers[1]="Nee")

        //  GRASS REVETMENT

        Grass_NrQuestions=2

        EN_Grass_QuestionStrings(0) = "1. What is the length of the damage? (in cm)"
        EN_Grass_QuestionStrings(1) = "2. What is the width of the damage? (in cm)"
        //EN_Grass_QuestionStrings(2) = "3. What is the depth (in cm) of the damage?"
        // Note: the following has to be all on one line, unfortunately. Initialisation of a struct in default properties with spaces or enters inbetween will not compile.
        EN_Grass_AnswerStrings(0)=(Answers[0]="0 - 300",Answers[1]="301 - 600",Answers[2]="601 - 900",Answers[3]="901 - 1200",Answers[4]="1201 - 1500",Answers[5]="> 1500")
        EN_Grass_AnswerStrings(1)=(Answers[0]="0 - 200",Answers[1]="201 - 400",Answers[2]="401 - 600",Answers[3]="601 - 800",Answers[4]="801 - 1000",Answers[5]="> 1000")
       // EN_Grass_AnswerStrings(2)=(Answers[0]="0 - 2",Answers[1]="2 - 4",Answers[2]="4 - 6",Answers[3]="6 - 8",Answers[4]="8 - 10",Answers[5]="> 10")

        EN_Grass_Question_Short[0]="Length (cm)"
        EN_Grass_Question_Short[1]="Width (cm)"
        //EN_Grass_Question_Short[2]="Depth (cm)"

        EN_Grass_Missing[0] = "The length"
        EN_Grass_Missing[1] = "The width"
        //EN_Grass_Missing[2] = "The depth"

        NL_Grass_QuestionStrings(0) = "1. Wat is de lengte van de beschadiging? (in cm)"
        NL_Grass_QuestionStrings(1) = "2. Wat is de breedte van de beschadiging? (in cm)"
        //NL_Grass_QuestionStrings(2) = "3. Wat is de diepte (in cm) van de beschadiging?"
         // Note: the following has to be all on one line, unfortunately. Initialisation of a struct in default properties with spaces or enters inbetween will not compile.
        NL_Grass_AnswerStrings(0)=(Answers[0]="0 - 300",Answers[1]="301 - 600",Answers[2]="601 - 900",Answers[3]="901 - 1200",Answers[4]="1201 - 1500",Answers[5]="> 1500")
	NL_Grass_AnswerStrings(1)=(Answers[0]="0 - 200",Answers[1]="201 - 400",Answers[2]="401 - 600",Answers[3]="601 - 800",Answers[4]="801 - 1000",Answers[5]="> 1000")
        //NL_Grass_AnswerStrings(2)=(Answers[0]="0 - 2",Answers[1]="2 - 4",Answers[2]="4 - 6",Answers[3]="6 - 8",Answers[4]="8 - 10",Answers[5]="> 10")

        NL_Grass_Question_Short[0]="Lengte (cm)"
        NL_Grass_Question_Short[1]="Breedte (cm)"
        //NL_Grass_Question_Short[2]="Diepte (cm)"

        NL_Grass_Missing[0] = "De lengte"
        NL_Grass_Missing[1] = "De breedte"
        //NL_Grass_Missing[2] = "De diepte"


        //  CRACK

        Crack_NrQuestions=7

        EN_Crack_QuestionStrings(0) = "1. At what type of revetment is the crack located?"
        EN_Crack_QuestionStrings(1) = "2. What kind of crack is it?"
        EN_Crack_QuestionStrings(2) = "3. What is the length of the crack? (in cm)"
        EN_Crack_QuestionStrings(3) = "4. What is the width of the crack? (in cm)"
        EN_Crack_QuestionStrings(4) = "5. Do multiple cracks occur close together?"
        EN_Crack_QuestionStrings(5) = "6. Does flushing of soil (e.g. sand or clay) occur?"
        EN_Crack_QuestionStrings(6) = "6A. Does little or much flushing of soil (bijv. sand or clay) occur?"
        // Note: the following has to be all on one line, unfortunately. Initialisation of a struct in default properties with spaces or enters inbetween will not compile.
        EN_Crack_AnswerStrings(0)=(Answers[0]="Grass",Answers[1]="Asphalt")
        EN_Crack_AnswerStrings(1)=(Answers[0]="Perpendicular / Diagonal crack",Answers[1]="Parallel crack")
        EN_Crack_AnswerStrings(2)=(Answers[0]="0 - 300",Answers[1]="301 - 600",Answers[2]="601 - 1000",Answers[3]="1001 - 1500",Answers[4]="1501 - 2500",Answers[5]=">2500")
        EN_Crack_AnswerStrings(3)=(Answers[0]="0 - 5",Answers[1]="6 - 10",Answers[2]="11 - 20",Answers[3]="21 - 30",Answers[4]="31 - 40",Answers[5]=">41")
        EN_Crack_AnswerStrings(4)=(Answers[0]="Yes",Answers[1]="No")
        EN_Crack_AnswerStrings(5)=(Answers[0]="Yes",Answers[1]="No")
        EN_Crack_AnswerStrings(6)=(Answers[0]="Little",Answers[1]="Much")

        EN_Crack_Question_Short[0]="Revetment type"
        EN_Crack_Question_Short[1]="Direction"
        EN_Crack_Question_Short[2]="Length (cm)"
        EN_Crack_Question_Short[3]="Width (cm)"
        EN_Crack_Question_Short[4]="Multiple cracks"
        EN_Crack_Question_Short[5]="Flushing soil"
        EN_Crack_Question_Short[6]="Quantity"

        EN_Crack_Missing[0] = "The type of revetment"
        EN_Crack_Missing[1] = "The type of crack"
        EN_Crack_Missing[2] = "The length"
        EN_Crack_Missing[3] = "The width"
        EN_Crack_Missing[4] = "If multiple cracks occur close together"
        EN_Crack_Missing[5] = "If flushing of soil occurs"
        EN_Crack_Missing[6] = "If much or little flushing of soil occurs"

        NL_Crack_QuestionStrings(0) = "1. Om wat voor type bekleding gaat het?"
        NL_Crack_QuestionStrings(1) = "2. Wat voor scheur is het?"
        NL_Crack_QuestionStrings(2) = "3. Wat is de lengte van de scheur? (in cm)"
        NL_Crack_QuestionStrings(3) = "4. Wat is de breedte van de scheur? (in cm)"
        NL_Crack_QuestionStrings(4) = "5. Komen meerdere scheuren rond dezelfde plek voor?"
        NL_Crack_QuestionStrings(5) = "6. Is er sprake van uitspoeling van grond (bijv. zand of klei)?"
        NL_Crack_QuestionStrings(6) = "6A. Stroomt er weinig of veel grond (bijv. zand of klei) uit?"
        // Note: the following has to be all on one line, unfortunately. Initialisation of a struct in default properties with spaces or enters inbetween will not compile.
        NL_Crack_AnswerStrings(0)=(Answers[0]="Gras",Answers[1]="Asfalt")
        NL_Crack_AnswerStrings(1)=(Answers[0]="Dwars-/ diagonale scheur",Answers[1]="Lengtescheur")
        NL_Crack_AnswerStrings(2)=(Answers[0]="0 - 300",Answers[1]="301 - 600",Answers[2]="601 - 1000",Answers[3]="1001 - 1500",Answers[4]="1501 - 2500",Answers[5]=">2500")
        NL_Crack_AnswerStrings(3)=(Answers[0]="0 - 5",Answers[1]="6 - 10",Answers[2]="11 - 20",Answers[3]="21 - 30",Answers[4]="31 - 40",Answers[5]=">41")
        NL_Crack_AnswerStrings(4)=(Answers[0]="Ja",Answers[1]="Nee")
        NL_Crack_AnswerStrings(5)=(Answers[0]="Ja",Answers[1]="Nee")
        NL_Crack_AnswerStrings(6)=(Answers[0]="Weinig",Answers[1]="Veel")

        NL_Crack_Question_Short[0]="Type bekleding"
        NL_Crack_Question_Short[1]="Richting"
        NL_Crack_Question_Short[2]="Lengte (cm)"
        NL_Crack_Question_Short[3]="Breedte (cm)"
        NL_Crack_Question_Short[4]="Meerdere scheuren"
        NL_Crack_Question_Short[5]="Uitspoeling grond"
        NL_Crack_Question_Short[6]="Hoeveelheid"

        NL_Crack_Missing[0] = "De type bekleding"
        NL_Crack_Missing[1] = "Het type scheur"
        NL_Crack_Missing[2] = "De lengte"
        NL_Crack_Missing[3] = "De breedte"
        NL_Crack_Missing[4] = "Of meerdere scheuren rond dezelfde plek voorkomen"
        NL_Crack_Missing[5] = "Of er sprake is van uitspoeling van grond"
        NL_Crack_Missing[6] = "Of er veel of weinig grond uitspoelt"


        //  SETTLEMENT

        Settlement_NrQuestions=7

        EN_Settlement_QuestionStrings(0) = "1. At what type of revetment is the settlement located?"
        EN_Settlement_QuestionStrings(1) = "2. To what is the settlement oriented?"
        EN_Settlement_QuestionStrings(2) = "3. What is the length of the settlement? (in cm)"
        EN_Settlement_QuestionStrings(3) = "4. What is the width of the settlement? (in cm)"
        EN_Settlement_QuestionStrings(4) = "5. What is the height difference between the settled elements? (in cm)"
        EN_Settlement_QuestionStrings(5) = "3. What is the length of the settlement? (in cm)"
        EN_Settlement_QuestionStrings(6) = "4. What is the height difference between the settled elements? (in cm)"
	// Note: the following has to be all on one line, unfortunately. Initialisation of a struct in default properties with spaces or enters inbetween will not compile.
        EN_Settlement_AnswerStrings(0)=(Answers[0]="Grass",Answers[1]="Asphalt")
        EN_Settlement_AnswerStrings(1)=(Answers[0]="Hinterland",Answers[1]="Foreland",Answers[2]="Entire levee")
        EN_Settlement_AnswerStrings(2)=(Answers[0]="0 - 500",Answers[1]="501 - 1000",Answers[2]="1001 - 1500",Answers[3]="1501 - 2000",Answers[4]="2001 - 2500",Answers[5]="> 2500")
        EN_Settlement_AnswerStrings(3)=(Answers[0]="0 - 200",Answers[1]="201 - 400",Answers[2]="401 - 600",Answers[3]="601 - 800",Answers[4]="801 - 1000",Answers[5]="> 1000")
	EN_Settlement_AnswerStrings(4)=(Answers[0]="0 - 4",Answers[1]="5 - 8",Answers[2]="9 - 12",Answers[3]="13 - 16",Answers[4]="17 - 20",Answers[5]="> 20")
	EN_Settlement_AnswerStrings(5)=(Answers[0]="0 - 1000",Answers[1]="1001 - 2000",Answers[2]="2001 - 3000",Answers[3]="3001 - 4000",Answers[4]="4001 - 6000",Answers[5]="> 6000")
        EN_Settlement_AnswerStrings(6)=(Answers[0]="0 - 15",Answers[1]="16 - 30",Answers[2]="31 - 55",Answers[3]="56 - 70",Answers[4]="71 - 100",Answers[5]="> 100")



        EN_Settlement_Question_Short[0]="Revetment type"
        EN_Settlement_Question_Short[1]="Orientation"
        EN_Settlement_Question_Short[2]="Length (cm)"
        EN_Settlement_Question_Short[3]="Width (cm)"
        EN_Settlement_Question_Short[4]="Height (cm)"
        EN_Settlement_Question_Short[5]="Length (cm)"
        EN_Settlement_Question_Short[6]="Height (cm)"

        EN_Settlement_Missing[0] = "The type of revetment"
        EN_Settlement_Missing[1] = "The direction"
        EN_Settlement_Missing[2] = "The length"
        EN_Settlement_Missing[3] = "The width"
        EN_Settlement_Missing[4] = "The height difference"
        EN_Settlement_Missing[5] = "The length"
        EN_Settlement_Missing[6] = "The height difference"

        NL_Settlement_QuestionStrings(0) = "1. Om wat voor type bekleding gaat het?"
        NL_Settlement_QuestionStrings(1) = "2. Welke richting heeft de verzakking?"
        NL_Settlement_QuestionStrings(2) = "3. Wat is de lengte van de verzakking? (in cm)"
        NL_Settlement_QuestionStrings(3) = "4. Wat is de breedte van de verzakking? (in cm)"
        NL_Settlement_QuestionStrings(4) = "5. Wat is het hoogteverschil tussen de verzakte elementen? (in cm)"
        NL_Settlement_QuestionStrings(5) = "3. Wat is de lengte van de verzakking? (in cm)"
        NL_Settlement_QuestionStrings(6) = "4. Wat is het hoogteverschil tussen de verzakte elementen (in cm)?"
        

        // Note: the following has to be all on one line, unfortunately. Initialisation of a struct in default properties with spaces or enters inbetween will not compile.
        NL_Settlement_AnswerStrings(0)=(Answers[0]="Gras",Answers[1]="Asfalt")
        NL_Settlement_AnswerStrings(1)=(Answers[0]="Binnendijks",Answers[1]="Buitendijks",Answers[2]="De gehele dijk")
        NL_Settlement_AnswerStrings(2)=(Answers[0]="0 - 500",Answers[1]="501 - 1000",Answers[2]="1001 - 1500",Answers[3]="1501 - 2000",Answers[4]="2001 - 2500",Answers[5]="> 2500")
        NL_Settlement_AnswerStrings(3)=(Answers[0]="0 - 200",Answers[1]="201 - 400",Answers[2]="401 - 600",Answers[3]="601 - 800",Answers[4]="801 - 1000",Answers[5]="> 1000")
		NL_Settlement_AnswerStrings(4)=(Answers[0]="0 - 4",Answers[1]="5 - 8",Answers[2]="9 - 12",Answers[3]="13 - 16",Answers[4]="17 - 20",Answers[5]="> 20")
		NL_Settlement_AnswerStrings(5)=(Answers[0]="0 - 1000",Answers[1]="1001 - 2000",Answers[2]="2001 - 3000",Answers[3]="3001 - 4000",Answers[4]="4001 - 6000",Answers[5]="> 6000")
        NL_Settlement_AnswerStrings(6)=(Answers[0]="0 - 15",Answers[1]="16 - 30",Answers[2]="31 - 55",Answers[3]="56 - 70",Answers[4]="71 - 100",Answers[5]="> 100")

        NL_Settlement_Question_Short[0]="Type bekleding"
        NL_Settlement_Question_Short[1]="Oriëntatie"
        NL_Settlement_Question_Short[2]="Lengte (cm)"
        NL_Settlement_Question_Short[3]="Breedte (cm)"
        NL_Settlement_Question_Short[4]="Diepte (cm)"
        NL_Settlement_Question_Short[5]="Lengte (cm)"
        NL_Settlement_Question_Short[6]="Diepte (cm)"

        NL_Settlement_Missing[0] = "Het type bekleding"
        NL_Settlement_Missing[1] = "De richting"
        NL_Settlement_Missing[2] = "De lengte"
        NL_Settlement_Missing[3] = "De breedte"
        NL_Settlement_Missing[4] = "Het hoogteverschil"
        NL_Settlement_Missing[5] = "De lengte"
        NL_Settlement_Missing[6] = "Het hoogteverschil"

        //  HORIZONTAL MOVEMENT

        HorizontalMovement_NrQuestions=3

        EN_HorizontalMovement_QuestionStrings(0) = "1. What type of revetment is it?"
        EN_HorizontalMovement_QuestionStrings(1) = "2. What is the length of the horizontal movement? (in cm)"
        EN_HorizontalMovement_QuestionStrings(2) = "3. What is the width of the horizontal movement? (in cm)"
	// Note: the following has to be all on one line, unfortunately. Initialisation of a struct in default properties with spaces or enters inbetween will not compile.
        EN_HorizontalMovement_AnswerStrings(0)=(Answers[0]="Grass",Answers[1]="Asphalt")
        EN_HorizontalMovement_AnswerStrings(1)=(Answers[0]="0 - 1000",Answers[1]="1001 - 2000",Answers[2]="2001 - 3000",Answers[3]="3001 - 4000",Answers[4]="4001 - 5000",Answers[5]="> 5000")
        EN_HorizontalMovement_AnswerStrings(2)=(Answers[0]="0 - 200",Answers[1]="201 - 300",Answers[2]="301 - 400",Answers[3]="401 - 500",Answers[4]="501 - 600",Answers[5]="> 600")

        EN_HorizontalMovement_Question_Short[0]="Revetment type"
        EN_HorizontalMovement_Question_Short[1]="Length (cm)"
        EN_HorizontalMovement_Question_Short[2]="Width (cm)"

        EN_HorizontalMovement_Missing[0] = "The type of revetment"
        EN_HorizontalMovement_Missing[1] = "The length"
        EN_HorizontalMovement_Missing[2] = "The width"

        NL_HorizontalMovement_QuestionStrings(0) = "1. Om wat voor type bekleding gaat het?"
        NL_HorizontalMovement_QuestionStrings(1) = "2. Wat is de lengte van de horizontale verplaatsing? (in cm)"
        NL_HorizontalMovement_QuestionStrings(2) = "3. Wat is de breedte van de horizontale verplaatsing? (in cm)"
        // Note: the following has to be all on one line, unfortunately. Initialisation of a struct in default properties with spaces or enters inbetween will not compile.
	NL_HorizontalMovement_AnswerStrings(0)=(Answers[0]="Gras",Answers[1]="Asfalt")
        NL_HorizontalMovement_AnswerStrings(1)=(Answers[0]="0 - 1000",Answers[1]="1001 - 2000",Answers[2]="2001 - 3000",Answers[3]="3001 - 4000",Answers[4]="4001 - 5000",Answers[5]="> 5000")
        NL_HorizontalMovement_AnswerStrings(2)=(Answers[0]="0 - 200",Answers[1]="201 - 300",Answers[2]="301 - 400",Answers[3]="401 - 500",Answers[4]="501 - 600",Answers[5]="> 600")

        NL_HorizontalMovement_Question_Short[0]="Type bekleding"
        NL_HorizontalMovement_Question_Short[1]="Lengte (cm)"
        NL_HorizontalMovement_Question_Short[2]="Breedte (cm)"

        NL_HorizontalMovement_Missing[0] = "Het type bekleding"
        NL_HorizontalMovement_Missing[1] = "De lengte"
        NL_HorizontalMovement_Missing[2] = "De breedte"

        //  UPRISE

        Uprise_NrQuestions=2

        EN_Uprise_QuestionStrings(0) = "1. What is the length of the uprise? (in cm)"
        EN_Uprise_QuestionStrings(1) = "2. What is the width of the uprise? (in cm)"
        // Note: the following has to be all on one line, unfortunately. Initialisation of a struct in default properties with spaces or enters inbetween will not compile.
        EN_Uprise_AnswerStrings(0)=(Answers[0]="0 - 200",Answers[1]="201 - 400",Answers[2]="401 - 600",Answers[3]="601 - 800",Answers[4]="801 - 1000",Answers[5]=">1000")
        EN_Uprise_AnswerStrings(1)=(Answers[0]="0 - 100",Answers[1]="101 - 200",Answers[2]="201 - 300",Answers[3]="301 - 400",Answers[4]="401 - 500",Answers[5]=">500")

        EN_Uprise_Question_Short[0]="Length (cm)"
        EN_Uprise_Question_Short[1]="Width (cm)"

        EN_Uprise_Missing[0] = "The length"
        EN_Uprise_Missing[1] = "The width"

        NL_Uprise_QuestionStrings(0) = "1. Wat is de lengte van de opbolling? (in cm)"
        NL_Uprise_QuestionStrings(1) = "2. Wat is de breedte van de opbolling? (in cm)"
	// Note: the following has to be all on one line, unfortunately. Initialisation of a struct in default properties with spaces or enters inbetween will not compile.
        NL_Uprise_AnswerStrings(0)=(Answers[0]="0 - 200",Answers[1]="201 - 400",Answers[2]="401 - 600",Answers[3]="601 - 800",Answers[4]="801 - 1000",Answers[5]=">1000")
        NL_Uprise_AnswerStrings(1)=(Answers[0]="0 - 100",Answers[1]="101 - 200",Answers[2]="201 - 300",Answers[3]="301 - 400",Answers[4]="401 - 500",Answers[5]=">500")

        NL_Uprise_Question_Short[0]="Lengte (cm)"
        NL_Uprise_Question_Short[1]="Breedte (cm)"

        NL_Uprise_Missing[0] = "De lengte"
        NL_Uprise_Missing[1] = "De breedte"

        //  LIQUEFACTION

        Liquefaction_NrQuestions=4

        EN_Liquefaction_QuestionStrings(0) = "1. What is the length of the liquefaction? (in cm)"
        EN_Liquefaction_QuestionStrings(1) = "2. What is the width of the liquefaction? (in cm)"
        EN_Liquefaction_QuestionStrings(2) = "3. Does flushing of soil (e.g. sand or clay) occur?"
        EN_Liquefaction_QuestionStrings(3) = "3A. Does little or much flushing of soil occur?"

        // Note: the following has to be all on one line, unfortunately. Initialisation of a struct in default properties with spaces or enters inbetween will not compile.
        EN_Liquefaction_AnswerStrings(0)=(Answers[0]="0 - 200",Answers[1]="201 - 400",Answers[2]="401 - 600",Answers[3]="601 - 800",Answers[4]="801 - 1000",Answers[5]=">1000")
        EN_Liquefaction_AnswerStrings(1)=(Answers[0]="0 - 100",Answers[1]="101 - 200",Answers[2]="201 - 300",Answers[3]="301 - 400",Answers[4]="401 - 500",Answers[5]=">500")
        EN_Liquefaction_AnswerStrings(2)=(Answers[0]="Yes",Answers[1]="No")
        EN_Liquefaction_AnswerStrings(3)=(Answers[0]="Little",Answers[1]="Much")
        

        EN_Liquefaction_Question_Short[0]="Length (cm)"
        EN_Liquefaction_Question_Short[1]="Width (cm)"
        EN_Liquefaction_Question_Short[2] = "Flushing soil"
        EN_Liquefaction_Question_Short[3] = "Amount"

        EN_Liquefaction_Missing[0] = "The length"
        EN_Liquefaction_Missing[1] = "The width"
        EN_Liquefaction_Missing[2] = "If flushing of soil occurs"
        EN_Liquefaction_Missing[3] = "If much or little flushing occurs"

        NL_Liquefaction_QuestionStrings(0) = "1. Wat is de lengte van de verweking? (in cm)"
        NL_Liquefaction_QuestionStrings(1) = "2. Wat is de breedte van de verweking? (in cm)"
        NL_Liquefaction_QuestionStrings(2) = "3. Is er sprake van uitspoeling van grond (bijv. zand of klei)?"
        NL_Liquefaction_QuestionStrings(3) = "3A. Spoelt er weinig of veel grond (bijv. zand of klei) uit?"

        // Note: the following has to be all on one line, unfortunately. Initialisation of a struct in default properties with spaces or enters inbetween will not compile.
        NL_Liquefaction_AnswerStrings(0)=(Answers[0]="0 - 200",Answers[1]="201 - 400",Answers[2]="401 - 600",Answers[3]="601 - 800",Answers[4]="801 - 1000",Answers[5]=">1000")
        NL_Liquefaction_AnswerStrings(1)=(Answers[0]="0 - 100",Answers[1]="101 - 200",Answers[2]="201 - 300",Answers[3]="301 - 400",Answers[4]="401 - 500",Answers[5]=">500")
        NL_Liquefaction_AnswerStrings(2)=(Answers[0]="Ja",Answers[1]="Nee")
        NL_Liquefaction_AnswerStrings(3)=(Answers[0]="Weinig",Answers[1]="Veel")

        NL_Liquefaction_Question_Short[0]="Lengte (cm)"
        NL_Liquefaction_Question_Short[1]="Breedte (cm)"
        NL_Liquefaction_Question_Short[2] = "Uitspoeling grond"
        NL_Liquefaction_Question_Short[3] = "Hoeveelheid"

        NL_Liquefaction_Missing[0] = "De lengte"
        NL_Liquefaction_Missing[1] = "De breedte"
        NL_Liquefaction_Missing[2] = "Of uitspoeling van grond voorkomt"
        NL_Liquefaction_Missing[3] = "Of weinig of veel grond uitspoelt"

        //  WATER OUTFLOW

        WaterOutflow_NrQuestions=7

        EN_WaterOutflow_QuestionStrings(0) = "1. What is the length of the problem area? (in cm)"
        EN_WaterOutflow_QuestionStrings(1) = "2. What is the width of the problem area? (in cm)"
        EN_WaterOutflow_QuestionStrings(2) = "3. What is the velocity of the current?"
        EN_WaterOutflow_QuestionStrings(3) = "4. Does little or much water flow out?"
        EN_WaterOutflow_QuestionStrings(4) = "5. Do multiple locations with water outflow occur close together?"
        EN_WaterOutflow_QuestionStrings(5) = "6. Does flushing of soil (e.g. sand or clay) occur?"
        EN_WaterOutflow_QuestionStrings(6) = "6A. Does little or much flushing of soil occur?"
        // Note: the following has to be all on one line, unfortunately. Initialisation of a struct in default properties with spaces or enters inbetween will not compile.
        EN_WaterOutflow_AnswerStrings(0)=(Answers[0]="0 - 200",Answers[1]="201 - 400",Answers[2]="401 - 600",Answers[3]="601 - 800",Answers[4]="801 - 1000",Answers[5]="> 1000")
        EN_WaterOutflow_AnswerStrings(1)=(Answers[0]="0 - 100",Answers[1]="101 - 200",Answers[2]="201 - 300",Answers[3]="301 - 400",Answers[4]="401 - 500",Answers[5]="> 500")
        EN_WaterOutflow_AnswerStrings(2)=(Answers[0]="Slow",Answers[1]="Fast")
        EN_WaterOutflow_AnswerStrings(3)=(Answers[0]="Little",Answers[1]="Much")
        EN_WaterOutflow_AnswerStrings(4)=(Answers[0]="Yes",Answers[1]="No")
        EN_WaterOutflow_AnswerStrings(5)=(Answers[0]="Yes",Answers[1]="No")
        EN_WaterOutflow_AnswerStrings(6)=(Answers[0]="Little",Answers[1]="Much")

        EN_WaterOutflow_Question_Short[0]="Length (cm)"
        EN_WaterOutflow_Question_Short[1]="Width (cm)"
        EN_WaterOutflow_Question_Short[2]="Velocity"
        EN_WaterOutflow_Question_Short[3]="Quantity"
        EN_WaterOutflow_Question_Short[4]="Multiple places"
        EN_WaterOutflow_Question_Short[5]="Flushing soil"
        EN_WaterOutflow_Question_Short[6]="Quantity"

        EN_WaterOutflow_Missing[0] = "The length"
        EN_WaterOutflow_Missing[1] = "The width"
        EN_WaterOutflow_Missing[2] = "The velocity of the flow"
        EN_WaterOutflow_Missing[3] = "If little or much water flows out"
        EN_WaterOutflow_Missing[4] = "If multiple locations with water outflow exist"
        EN_WaterOutflow_Missing[5] = "If flushing of soil occurs"
        EN_WaterOutflow_Missing[6] = "If little or much flushing of soil occurs"

        NL_WaterOutflow_QuestionStrings(0) = "1. Wat is de lengte van het probleemgebied? (in cm)"
        NL_WaterOutflow_QuestionStrings(1) = "2. Wat is de breedte van het probleemgebied? (in cm)"
        NL_WaterOutflow_QuestionStrings(2) = "3. Wat is de snelheid van de stroming?"
        NL_WaterOutflow_QuestionStrings(3) = "4. Stroomt er veel of weinig water uit?"
        NL_WaterOutflow_QuestionStrings(4) = "5. Zijn er meerdere locaties dicht bij elkaar waar water uit de dijk stroomt?"
        NL_WaterOutflow_QuestionStrings(5) = "6. Komt uitspoeling van grond (bijv. zand of klei) voor?"
        NL_WaterOutflow_QuestionStrings(6) = "6A. Stroomt er veel of weinig grond uit?"
        // Note: the following has to be all on one line, unfortunately. Initialisation of a struct in default properties with spaces or enters inbetween will not compile.
        NL_WaterOutflow_AnswerStrings(0)=(Answers[0]="0 - 200",Answers[1]="201 - 400",Answers[2]="401 - 600",Answers[3]="601 - 800",Answers[4]="801 - 1000",Answers[5]="> 1000")
        NL_WaterOutflow_AnswerStrings(1)=(Answers[0]="0 - 100",Answers[1]="101 - 200",Answers[2]="201 - 300",Answers[3]="301 - 400",Answers[4]="401 - 500",Answers[5]="> 500")
        NL_WaterOutflow_AnswerStrings(2)=(Answers[0]="Langzaam",Answers[1]="Snel")
        NL_WaterOutflow_AnswerStrings(3)=(Answers[0]="Weinig",Answers[1]="Veel")
        NL_WaterOutflow_AnswerStrings(4)=(Answers[0]="Ja",Answers[1]="Nee")
        NL_WaterOutflow_AnswerStrings(5)=(Answers[0]="Ja",Answers[1]="Nee")
	NL_WaterOutflow_AnswerStrings(6)=(Answers[0]="Weinig",Answers[1]="Veel")

        NL_WaterOutflow_Question_Short[0]="Lengte (cm)"
        NL_WaterOutflow_Question_Short[1]="Breedte (cm)"
        NL_WaterOutflow_Question_Short[2]="Snelheid"
        NL_WaterOutflow_Question_Short[3]="Hoeveelheid"
        NL_WaterOutflow_Question_Short[4]="Meerdere plaatsen"
        NL_WaterOutflow_Question_Short[5]="Uitspoeling grond"
        NL_WaterOutflow_Question_Short[6]="Hoeveelheid"

        NL_WaterOutflow_Missing[0] = "De lengte"
        NL_WaterOutflow_Missing[1] = "De breedte"
        NL_WaterOutflow_Missing[2] = "De snelheid van de stroming"
        NL_WaterOutflow_Missing[3] = "Of weinig of veel water uitstroomt"
        NL_WaterOutflow_Missing[4] = "Of meerdere locaties met uitstromend water voorkomen"
        NL_WaterOutflow_Missing[5] = "Of uitspoeling van grond voorkomt"
        NL_WaterOutflow_Missing[6] = "Of weinig of veel grond uitspoelt"

	//  OVERTOPPING/WASH

	OverToppingWash_NrQuestions=7

	EN_OverToppingWash_QuestionStrings(0) = "1. What is occurring?"
        EN_OverToppingWash_QuestionStrings(1) = "2. Is the area of the levee accessible?"
        EN_OverToppingWash_QuestionStrings(2) = "3. Does water infiltrate the top and the inner slope of the levee?"
        EN_OverToppingWash_QuestionStrings(3) = "4. How much water flows over the levee?"
        EN_OverToppingWash_QuestionStrings(4) = "5. Does flushing of soil (e.g. sand or clay) occur?"
        EN_OverToppingWash_QuestionStrings(5) = "5A. Does little or much flushing of soil occur?"
        EN_OverToppingWash_QuestionStrings(6) = "1A. How can the waves be described?"
        // Note: the following has to be all on one line, unfortunately. Initialisation of a struct in default properties with spaces or enters inbetween will not compile.
        EN_OverToppingWash_AnswerStrings(0)=(Answers[0]="Overtopping",Answers[1]="Overwash")
        EN_OverToppingWash_AnswerStrings(1)=(Answers[0]="Yes",Answers[1]="No")
        EN_OverToppingWash_AnswerStrings(2)=(Answers[0]="Yes",Answers[1]="No")
        EN_OverToppingWash_AnswerStrings(3)=(Answers[0]="Little",Answers[1]="Much")
	EN_OverToppingWash_AnswerStrings(4)=(Answers[0]="Yes",Answers[1]="No")
        EN_OverToppingWash_AnswerStrings(5)=(Answers[0]="Little",Answers[1]="Much")
        EN_OverToppingWash_AnswerStrings(6)=(Answers[0]="Medium",Answers[1]="Fierce")

        EN_OverToppingWash_Question_Short[0]="Type"
        EN_OverToppingWash_Question_Short[1]="Accessible"
        EN_OverToppingWash_Question_Short[2]="Infiltration"
        EN_OverToppingWash_Question_Short[3]="Quantity"
        EN_OverToppingWash_Question_Short[4] = "Flushing soil"
        EN_OverToppingWash_Question_Short[5] = "Amount"
        EN_OverToppingWash_Question_Short[6]="Wave strength"

        EN_OverToppingWash_Missing[0] = "The type of signal"
        EN_OverToppingWash_Missing[1] = "The accessibility of the levee"
        EN_OverToppingWash_Missing[2] = "If infiltration occurs"
        EN_OverToppingWash_Missing[3] = "The amount of water flow"
        EN_OverToppingWash_Missing[4] = "If flushing of soil occurs"
        EN_OverToppingWash_Missing[5] = "If much or little flushing occurs"
        EN_OverToppingWash_Missing[6] = "The behavior of the waves"

        NL_OverToppingWash_QuestionStrings(0) = "1. Van wat is er sprake?"
        NL_OverToppingWash_QuestionStrings(1) = "2. Is de omgeving van de dijk begaanbaar?"
        NL_OverToppingWash_QuestionStrings(2) = "3. Is er sprake van infiltratie op de kruin en binnentalud?"
        NL_OverToppingWash_QuestionStrings(3) = "4. Hoeveel water stroomt er over de dijk?"
        NL_OverToppingWash_QuestionStrings(4) = "5. Is er sprake van uitspoeling van grond (bijv.  zand of klei)?"
        NL_OverToppingWash_QuestionStrings(5) = "5A. Spoelt er weinig of veel grond (bijv. zand of klei) uit?"
        NL_OverToppingWash_QuestionStrings(6) = "1A. Hoe kunnen de golven getypeerd worden?"
        // Note: the following has to be all on one line, unfortunately. Initialisation of a struct in default properties with spaces or enters inbetween will not compile.
        NL_OverToppingWash_AnswerStrings(0)=(Answers[0]="Overloop",Answers[1]="Overslag")
        NL_OverToppingWash_AnswerStrings(1)=(Answers[0]="Ja",Answers[1]="Nee")
        NL_OverToppingWash_AnswerStrings(2)=(Answers[0]="Ja",Answers[1]="Nee")
	NL_OverToppingWash_AnswerStrings(3)=(Answers[0]="Weinig",Answers[1]="Veel")
        NL_OverToppingWash_AnswerStrings(4)=(Answers[0]="Ja",Answers[1]="Nee")
        NL_OverToppingWash_AnswerStrings(5)=(Answers[0]="Weinig",Answers[1]="Veel")
        NL_OverToppingWash_AnswerStrings(6)=(Answers[0]="Matig",Answers[1]="Heftig")

        NL_OverToppingWash_Question_Short[0]="Soort"
        NL_OverToppingWash_Question_Short[1]="Begaanbaar"
        NL_OverToppingWash_Question_Short[2]="Infiltratie"
        NL_OverToppingWash_Question_Short[3]="Hoeveelheid"
        NL_OverToppingWash_Question_Short[4] = "Uitspoeling grond"
        NL_OverToppingWash_Question_Short[5] = "Hoeveelheid"
        NL_OverToppingWash_Question_Short[6]= "Golfsterkte"

        NL_OverToppingWash_Missing[0] = "Het type signaal"
        NL_OverToppingWash_Missing[1] = "De begaanbaarheid van de dijk."
        NL_OverToppingWash_Missing[2] = "Of infiltratie voorkomt"
        NL_OverToppingWash_Missing[3] = "De hoeveelheid water dat over de dijk stroomt"
        NL_OverToppingWash_Missing[4] = "Of uitspoeling van grond voorkomt"
        NL_OverToppingWash_Missing[5] = "Of weinig of veel grond uitspoelt"
        NL_OverToppingWash_Missing[6] = "Het gedrag van de golven"

        //  FLOATING WASTE ET AL.

        FloatingWaste_NrQuestions=1

        EN_FloatingWaste_QuestionStrings(0) = "1. What causes the risk?"
        // Note: the following has to be all on one line, unfortunately. Initialisation of a struct in default properties with spaces or enters inbetween will not compile.
        EN_FloatingWaste_AnswerStrings(0)=(Answers[0]="Floating waste",Answers[1]="Strong current",Answers[2]="Ship waves")

        EN_FloatingWaste_Question_Short[0]="Risk factor";
        EN_FloatingWaste_Missing[0] = "The type of signal"

        NL_FloatingWaste_QuestionStrings(0) = "1. Wat veroorzaakt het risico?"
        // Note: the following has to be all on one line, unfortunately. Initialisation of a struct in default properties with spaces or enters inbetween will not compile.
        NL_FloatingWaste_AnswerStrings(0)=(Answers[0]="Drijfvuil",Answers[1]="Stroming",Answers[2]="Scheepsgolven")

        NL_FloatingWaste_Question_Short[0]="Risicofactor"

        NL_FloatingWaste_Missing[0] = "Het type signaal"

        //  HUMAN ACTIVITY

        HumanActivity_NrQuestions=1

        EN_HumanActivity_QuestionStrings(0) = "1. What causes the risk?"
        // Note: the following has to be all on one line, unfortunately. Initialisation of a struct in default properties with spaces or enters inbetween will not compile.
        EN_HumanActivity_AnswerStrings(0)=(Answers[0]="Cables and pipelines",Answers[1]="Construction work",Answers[2]="Traffic",Answers[3]="Changes to the levee",Answers[4]="non-water retaining object")

        EN_HumanActivity_Question_Short[0]="Risk factor";
        EN_HumanActivity_Missing[0] = "The type of signal"

        NL_HumanActivity_QuestionStrings(0) = "1. Wat veroorzaakt het risico?"
        // Note: the following has to be all on one line, unfortunately. Initialisation of a struct in default properties with spaces or enters inbetween will not compile.
        NL_HumanActivity_AnswerStrings(0)=(Answers[0]="Kabels en pijpleidingen",Answers[1]="Grond werkzaamheden",Answers[2]="Verkeer",Answers[3]="Veranderingen aan de dijk",Answers[4]="Niet-waterkerend object")

        NL_HumanActivity_Question_Short[0]="Risicofactor"

        NL_HumanActivity_Missing[0] = "Het type signaal"

        //  BIOLOGICAL ACTIVITY

        BioActivity_NrQuestions=1

        EN_BioActivity_QuestionStrings(0) = "1. What causes the risk?"
        // Note: the following has to be all on one line, unfortunately. Initialisation of a struct in default properties with spaces or enters inbetween will not compile.
        EN_BioActivity_AnswerStrings(0)=(Answers[0]="Tree",Answers[1]="Water quality",Answers[2]="Mole",Answers[3]="Muskrat",Answers[4]="Rabbit",Answers[5]="Small cattle",Answers[6]="Big cattle",Answers[7]="Other")

        EN_BioActivity_Question_Short[0]="Risk factor";

        EN_BioActivity_Missing[0] = "The type of signal"

        NL_BioActivity_QuestionStrings(0) = "1. Wat veroorzaakt het risico?"
        // Note: the following has to be all on one line, unfortunately. Initialisation of a struct in default properties with spaces or enters inbetween will not compile.
        NL_BioActivity_AnswerStrings(0)=(Answers[0]="Boom",Answers[1]="Waterkwaliteit",Answers[2]="Mol",Answers[3]="Muskusrat",Answers[4]="Konijn",Answers[5]="Kleinvee",Answers[6]="Grootvee",Answers[7]="Anders")

        NL_BioActivity_Question_Short[0]="Risicofactor"

        NL_BioActivity_Missing[0] = "Het type signaal"

        //Formated answers
        EN_About="About"
        NL_About="Betreffende"


        EN_SignalLocation="The signal is located at"
        NL_SignalLocation="De lokatie van het signaal is"

        EN_De="the"
        NL_De="de"

        EN_Het="the"
        NL_Het="het"

        EN_Quite="quite"
        NL_Quite="redelijk"

        EN_Length="It has a length of"
        NL_Length="Het heeft een lengte van"

        EN_Width="It has a width of"
        NL_Width="Het heeft een breedte van"

        EN_Dept="It has a depth of"
        NL_Dept="Het heeft een diepte van"

        EN_Dept1="The depth of"
        NL_Dept1="De diepte van de"

        EN_Deep="deep";
        NL_Deep="diep";

        EN_Flushing="Flushing of soil"
        NL_Flushing="Uitspoeling van grond"

        EN_M="m"
        NL_M="m"

        EN_CM="cm"
        NL_CM="cm"

        EN_NoMissingElements="There are no elements missing or moved."
        NL_NoMissingElements="Geen van de stenen ontbreekt of is verplaatst."

        EN_MissingElements="Some elements are missing or moved."
        NL_MissingElements="Sommige elementen zijn verdwenen of verplaatst."

        EN_Occurs="occurs"
        NL_Occurs="komt voor"

        EN_NotOccurs="does not occur"
        NL_NotOccurs="komt niet voor"

        EN_NotOccur="do not occur"
        NL_NotOccur="komen niet voor"

        EN_ALittle="a little"
        NL_ALittle="in geringe mate"

        EN_Little="little"
        NL_Little="in geringe mate"

        EN_Heavily="heavily"
        NL_Heavily="in grote mate"

        EN_Huge="huge"
        NL_Huge="in grote mate"

        EN_NoLooseElements="None of the stones are loose."
        NL_NoLooseElements="Geen van de stenen is los."

        EN_LooseElements="Some stones are loose."
        NL_LooseElements="Sommige stenen zijn los."

        EN_Located="It is located at the"
        NL_Located="Het bevindt zich op het"

        EN_IsA="It is a"
        NL_IsA="Het is een"

        EN_Perp="perpendicular / diagonal crack."
        NL_Perp="dwars-/ diagonale scheur."

        EN_Par="parallel crack."
        NL_Par="lengtescheur."

        EN_Grass="grass"
        NL_Grass="gras"

        EN_Asphalt="asphalt"
        NL_Asphalt="asfalt"

        EN_MultipleCracks="Multiple cracks are located close together."
        NL_MultipleCracks="Meerdere scheuren bevinden zich rond dezelfde plek."

        EN_NoMultipleCracks="Multiple cracks are not located close together."
        NL_NoMultipleCracks="Meerdere scheuren bevinden zich niet rond dezelfde plek."

        EN_Directed="It is directed toward"
        NL_Directed="Het is"

        EN_Hinter="the hinterland"
        NL_Hinter="binnendijks"

        EN_Fore="the foreland"
        NL_Fore="buitendijks"

        EN_EntireL="the Entire levee "
        NL_EntireL="over de gehele dijk"

        EN_Velocity="The velocity of the current is"
        NL_Velocity="De snelheid van de stroming is"

        EN_AmountOut="The amount of water outflow is"
        NL_AmountOut="De hoeveelheid uitstromend water is"

        EN_Outflow="Outflow"
        NL_Outflow="Uitstroming"

        EN_Multiple="at multiple locations"
        NL_Multiple="op meerdere locaties"

        EN_Slow="slow"
        NL_Slow="langzaam"

        EN_Fast="fast"
        NL_Fast="snel"

        EN_Levee="The levee is"
        NL_Levee="De dijk is"

        EN_Acc="accessible"
        NL_Acc="begaanbaar"

        EN_Infi="Infiltration"
        NL_Infi="Infiltratie"

        EN_AmountOver="The amount of water flow is"
        NL_AmountOver="De hoeveelheid water dat over de dijk stroomt is"

        EN_Waves="The waves are"
        NL_Waves="De golven zijn"

        EN_OverT="overtopping"
        NL_OverT="overloop"

        EN_OverW="overwash"
        NL_OverW="overslag"

        EN_Not="not"
        NL_Not="niet"

        EN_Surface="The surface of the"
        NL_Surface="Het oppervlak van de"

        NL_Surface2="Het oppervlak van het"
        
        EN_Surface3="The surface"
        NL_Surface3="Het oppervlak"

        EN_Damage="damage"
        NL_Damage="schade"

        EN_Small="small"
        NL_Small="klein"

        EN_Large="large"
        NL_Large="groot"
        NL_Large2="grote"

        EN_Very="very"
        NL_Very="heel"

        EN_At="at"
        NL_At="bij"

        EN_On="on"
        NL_On="op"

        EN_Is="is"
        NL_Is="is"

        EN_Of="of"
        NL_Of="van"

        EN_WhatA="What about";
        NL_WhatA="Wat betreft";

        EN_Width2="width"
        NL_Width2="breedte"

        EN_Wide="wide"
        NL_Wide="brede"

        EN_Length2="length"
        NL_Length2="lengte"

        EN_And="and"
        NL_And="en"
        
        EN_Or="or"
        NL_Or="of"

        EN_But="but"
        NL_But="maar"

        EN_A="a"
        NL_A="een"

        EN_Signal ="signal"
        NL_Signal = "signaal"
        
        EN_Observation = "observation"
        NL_Observation = "observatie"

        EN_AC = "Action Center"
        NL_AC = "Actiecentrum"

        EN_TelWoorden[0]="first"
        EN_TelWoorden[1]="second"
        EN_TelWoorden[2]="third"
        EN_TelWoorden[3]="fourth"
        EN_TelWoorden[4]="fifth"
        EN_TelWoorden[5]="sixth"
        EN_TelWoorden[6]="seventh"
        EN_TelWoorden[7]="eighth"
        EN_TelWoorden[8]="ninth"
        EN_TelWoorden[9]="tenth"
        EN_TelWoorden[10]="eleventh"
        EN_TelWoorden[11]="twelfth"
        EN_TelWoorden[12]="thirteenth"
        EN_TelWoorden[13]="fourteenth"
        EN_TelWoorden[14]="fifteenth"
        EN_TelWoorden[15]="sixteenth"
        EN_TelWoorden[16]="seventeenth"
        EN_TelWoorden[17]="eighteenth"
        EN_TelWoorden[18]="nineteenth"
        EN_TelWoorden[19]="twentieth"

        NL_TelWoorden[0]="eerste"
        NL_TelWoorden[1]="tweede"
        NL_TelWoorden[2]="derde"
        NL_TelWoorden[3]="vierde"
        NL_TelWoorden[4]="vijfde"
        NL_TelWoorden[5]="zesde"
        NL_TelWoorden[6]="zevende"
        NL_TelWoorden[7]="achtste"
        NL_TelWoorden[8]="negende"
        NL_TelWoorden[9]="tiende"
        NL_TelWoorden[10]="elfde"
        NL_TelWoorden[11]="twaalfde"
        NL_TelWoorden[12]="dertiende"
        NL_TelWoorden[13]="veertiende"
        NL_TelWoorden[14]="vijftiende"
        NL_TelWoorden[15]="zestiende"
        NL_TelWoorden[16]="zeventiende"
        NL_TelWoorden[17]="achtiende"
        NL_TelWoorden[18]="negentiende"
        NL_TelWoorden[19]="twintigste"

}