@magic-xpa/engine 4.1100.0-dev4110.26 → 4.1100.0-dev4110.260

package/esm2022/src/tasks/Task.mjs

@@ -0,0 +1,2499 @@
+import { Debug, HashUtils, List, NNumber, NString, RefParam, Stack, StringBuilder, isNullOrUndefined } from '@magic-xpa/mscorelib';
+import { Constants, InternalInterface, Logger, Logger_LogLevels, StorageAttribute, StrUtil, WindowType, XMLConstants, XmlParser } from '@magic-xpa/utils';
+import { Commands, DataModificationTypes, DisplayConvertor, Events, GuiDataCollection, Helps, Manager, NUM_TYPE, PIC, PropInterface, RecordUtils, RuntimeContextBase, Styles, TaskDefinitionId } from '@magic-xpa/gui';
+import { DataView } from '../data/DataView';
+import { DvCache } from '../data/DvCache';
+import { DataViewCommandType } from '../commands/ClientToServer/DataviewCommand';
+import { CommandsProcessorBase_SendingInstruction } from '../CommandsProcessorBase';
+import { TaskServiceBase } from './TaskServiceBase';
+import { TaskTransactionManager } from '../data/TaskTransactionManager';
+import { DataviewManager } from '../data/DataviewManager';
+import { SortCollection } from './sort/SortCollection';
+import { MgForm } from '../gui/MgForm';
+import { RemoteTaskService } from './RemoteTaskService';
+import { ReturnResult } from '../util/ReturnResult';
+import { RunTimeEvent } from '../event/RunTimeEvent';
+import { CommandFactory } from '../commands/ClientToServer/CommandFactory';
+import { DataviewHeaders } from '../rt/DataviewHeaders';
+import { Transaction } from '../rt/Transaction';
+import { TasksTable } from './TasksTable';
+import { HandlersTable } from '../rt/HandlersTable';
+import { RecomputeTable } from '../rt/RecomputeTable';
+import { ExpTable } from '../exp/ExpTable';
+import { UserEventsTable } from '../event/UserEventsTable';
+import { FormsTable } from '../gui/FormsTable';
+import { FlowMonitorQueue } from '../util/FlowMonitorQueue';
+import { ActionManager } from '../event/ActionManager';
+import { ConstInterface } from '../ConstInterface';
+import { GUIManager } from '../GUIManager';
+import { CommandsProcessorManager } from '../CommandsProcessorManager';
+import { EventSubType } from '../enums';
+import { OpeningTaskDetails, Task_SubformExecModeEnum, TaskBase } from './TaskBase';
+import { LanguageData } from '../env/LanguageData';
+import { Environment } from '../env/Environment';
+import { LastFocusedManager } from '../rt/LastFocusedManager';
+import { GlobalCommandsManager } from '../GlobalCommandsManager';
+import { EventsAllowedType } from '../event/IEventsManager';
+import { AccessHelper } from '../AccessHelper';
+import { MGDataCollection } from './MGDataCollection';
+import { RemoteCommandsProcessor } from "../remote/RemoteCommandsProcessor";
+import { EventHandlerPosition } from '../event/EventHandlerPosition';
+import { ClientManager } from "../ClientManager";
+export var Task_Flow;
+(function (Task_Flow) {
+    Task_Flow[Task_Flow["NONE"] = 0] = "NONE";
+    Task_Flow[Task_Flow["STEP"] = 1] = "STEP";
+    Task_Flow[Task_Flow["FAST"] = 2] = "FAST";
+})(Task_Flow || (Task_Flow = {}));
+export var Task_Direction;
+(function (Task_Direction) {
+    Task_Direction[Task_Direction["BACK"] = -1] = "BACK";
+    Task_Direction[Task_Direction["NONE"] = 0] = "NONE";
+    Task_Direction[Task_Direction["FORE"] = 1] = "FORE";
+})(Task_Direction || (Task_Direction = {}));
+export class Task extends TaskBase {
+    _dvCache = null;
+    _mgData = null;
+    _aborting = false;
+    _bExecEndTask = false;
+    _isStarted = false;
+    _evalOldValues = false;
+    _inRecordSuffix = false;
+    _cancelWasRaised = false;
+    _counter = 0;
+    _currStartProgLevel = 0;
+    _destinationSubform = false;
+    _enableZoomHandler = false;
+    _firstRecordCycle = false;
+    _originalTaskMode = ' ';
+    _inCreateLine = false;
+    InSelect = false;
+    InStartProcess = false;
+    _isDestinationCall = false;
+    _knownToServer = true;
+    _loopStack = null;
+    allowRemoteCmdExecution;
+    DelayCommandExecution = false;
+    _parentTask = null;
+    get ParentTask() {
+        return this._parentTask;
+    }
+    ContextTask = null;
+    _triggeringTask = null;
+    PathParentTask = null;
+    _preventControlChange = false;
+    _preventRecordSuffix = false;
+    _taskPath = null;
+    _tryingToCommit = false;
+    set TryingToCommit(value) {
+        this._tryingToCommit = value;
+    }
+    get TryingToCommit() {
+        return this._tryingToCommit;
+    }
+    _useLoopStack = false;
+    _inProcessingTopMostEndTaskSaved = false;
+    InHandleActCancel = false;
+    RuntimeSorts = null;
+    VewFirst = 0;
+    dataViewContent = null;
+    PerformParentRecordPrefix = false;
+    ModeAsParent = false;
+    TaskTransactionManager = null;
+    ExecuteClientSubformRefresh = false;
+    InCommonHandlerBeforeRP = false;
+    _taskService = null;
+    get TaskService() {
+        if (this._taskService == null)
+            this._taskService = new RemoteTaskService();
+        return this._taskService;
+    }
+    static get CommandsProcessor() {
+        return CommandsProcessorManager.GetCommandsProcessor();
+    }
+    hasLocate = false;
+    taskDefinitionId = null;
+    ArgumentsList = null;
+    get LogicalStudioParentTask() {
+        if (this.StudioParentTask === null && !super.isMainProg()) {
+            return GuiDataCollection.MGDataTable.GetMainProgByCtlIdx(this.ContextID, this._ctlIdx);
+        }
+        return this.StudioParentTask;
+    }
+    get KnownToServer() {
+        return this._knownToServer;
+    }
+    ConfirmUpdateNo = false;
+    DataSynced = false;
+    UniqueSort = null;
+    set Transaction(value) {
+        this.DataviewManager.CurrentDataviewManager.Transaction = value;
+    }
+    get Transaction() {
+        return this.DataviewManager.CurrentDataviewManager.Transaction;
+    }
+    RefreshOnVars = null;
+    DvPosDescriptor = null;
+    SubTasks = null;
+    ExpTab = null;
+    UserEvtTab = null;
+    DataviewHeadersTable = null;
+    HandlersTab = null;
+    _forms = null;
+    Name = null;
+    PublicName = null;
+    TaskSuffixExecuted = false;
+    get TaskDefinitionId() {
+        if (this.taskDefinitionId === null) {
+            this.taskDefinitionId = new TaskDefinitionId(this._ctlIdx, this.ProgramIsn, this.TaskIsn, this._isPrg);
+        }
+        return this.taskDefinitionId;
+    }
+    RetrunValueExp = 0;
+    SubformControl = null;
+    static StartProgLevel = 0;
+    static _idleTimerStarted = false;
+    static get IsBlockingBatch() {
+        return false;
+    }
+    constructor(parent) {
+        super();
+        if (isNullOrUndefined(parent)) {
+            this.constructor_0();
+            return;
+        }
+        this.constructor_1(parent);
+    }
+    constructor_0() {
+        this.ActionManager = new ActionManager();
+        this.DataView = new DataView(this);
+        this._flowMonitor = FlowMonitorQueue.Instance;
+        this.ContextTask = this;
+        this._dvCache = new DvCache(this);
+        this.PerformParentRecordPrefix = true;
+        this.DataviewManager = new DataviewManager(this);
+        this.allowRemoteCmdExecution = true;
+        this.TaskTransactionManager = new TaskTransactionManager(this);
+    }
+    Init() {
+        this.DataView.Init();
+    }
+    constructor_1(parent) {
+        this.constructor_0();
+        this.PathParentTask = parent;
+        this._parentTask = parent;
+        this._triggeringTask = null;
+        this.buildTaskPath();
+    }
+    static CreateTask() {
+        let task = new Task();
+        task.Init();
+        return task;
+    }
+    isAborting() {
+        return this._aborting;
+    }
+    buildTaskPath() {
+        this._taskPath = new List();
+        if (this._parentTask._taskPath !== null)
+            this._taskPath.AddRange(this._parentTask._taskPath.GetEnumerator());
+        this._taskPath.push(this);
+    }
+    async fillData(mgd, openingTaskDetails) {
+        if (!super.isMainProg()) {
+            if (this._parentTask === null && openingTaskDetails.CallingTask !== null) {
+                this._parentTask = openingTaskDetails.CallingTask;
+                this.buildTaskPath();
+                openingTaskDetails.CallingTask.addSubTask(this);
+            }
+            if (this.PathParentTask === null && openingTaskDetails.PathParentTask !== null) {
+                this.PathParentTask = openingTaskDetails.PathParentTask;
+            }
+        }
+        if (this._parentTask !== null && this._parentTask.getEnableZoomHandler()) {
+            this.setEnableZoomHandler();
+        }
+        this._mgData = mgd;
+        this.fillAttributes();
+        this._mgData.addTask(this);
+        let parentForm = (this._parentTask !== null) ? this._parentTask.getForm() : null;
+        while (await this.initInnerObjects(RuntimeContextBase.Instance.Parser.getNextTag(), parentForm)) {
+        }
+        this.TaskTransactionManager.PrepareTransactionProperties(this.DataviewManager.RemoteDataviewManager.Transaction, false);
+        this.HandleTriggerTask();
+        this.HandlePreviouslyActiveTaskId();
+        this.CheckAndSetSubForm();
+        if (this.IsSubForm) {
+            let subFormCtrl = this.getParent().getForm().getSubFormCtrlForTask(this._taskTag);
+            if (subFormCtrl !== null) {
+                subFormCtrl.setSubformTaskId(this._taskTag);
+            }
+            if (this.Form !== null) {
+                this.Form.setSubFormCtrl(subFormCtrl);
+            }
+        }
+    }
+    HandlePreviouslyActiveTaskId() {
+        if (this._parentTask !== null && this._parentTask.GetContextTask() !== null && this._mgData !== this._parentTask.getMGData())
+            this.PreviouslyActiveTaskId = (this._parentTask.GetContextTask()).getTaskTag();
+        else if (this._parentTask !== null)
+            this.PreviouslyActiveTaskId = this._parentTask.getTaskTag();
+    }
+    HandleTriggerTask() {
+        this._triggeringTask = this._parentTask;
+    }
+    FillTaskTables(taskTablesData) {
+        if (arguments.length === 1) {
+            this.FillTaskTables_0();
+            return;
+        }
+        this.FillTaskTables_1();
+    }
+    FillTaskTables_0() {
+    }
+    fillAttributes() {
+        let parser = RuntimeContextBase.Instance.Parser;
+        let endContext = parser.getXMLdata().indexOf(XMLConstants.TAG_CLOSE, parser.getCurrIndex());
+        if (endContext !== -1 && endContext < parser.getXMLdata().length) {
+            super.fillAttributes(parser);
+            if (super.isMainProg())
+                this._mgData = AccessHelper.mgDataTable.getMGData(0);
+        }
+        else {
+            Logger.Instance.WriteExceptionToLogWithMsg("in Task.fillAttributes() out of string bounds");
+        }
+    }
+    setAttribute(attribute, valueStr) {
+        let isTagProcessed;
+        isTagProcessed = super.setAttribute(attribute, valueStr);
+        if (!isTagProcessed) {
+            isTagProcessed = true;
+            switch (attribute) {
+                case ConstInterface.MG_ATTR_REFRESHON:
+                    if (!(valueStr.trim() === ""))
+                        this.SetRefreshOnVars(valueStr);
+                    break;
+                case XMLConstants.MG_ATTR_NAME:
+                    this.Name = valueStr;
+                    break;
+                case ConstInterface.MG_ATTR_DVPOS_DEC:
+                    if (!(valueStr.trim() === ""))
+                        this.setDescriptor(valueStr);
+                    break;
+                case ConstInterface.MG_ATTR_HAS_LOCATE:
+                    if (+valueStr == 1)
+                        this.hasLocate = true;
+                    break;
+                case ConstInterface.MG_ATTR_AS_PARENT:
+                    if (+valueStr == 1)
+                        this.ModeAsParent = true;
+                    break;
+                case ConstInterface.MG_ATTR_TASK_UNIQUE_SORT:
+                    this.UniqueSort = valueStr[0];
+                    break;
+                case ConstInterface.MG_ATTR_TRANS_ID:
+                    this.setRemoteTransaction(valueStr);
+                    break;
+                case ConstInterface.MG_ATTR_PUBLIC:
+                    this.PublicName = XmlParser.unescape(valueStr);
+                    break;
+                case XMLConstants.MG_ATTR_IS_OFFLINE:
+                    this.IsOffline = XmlParser.getBoolean(valueStr);
+                    break;
+                case XMLConstants.MG_ATTR_RETURN_VALUE_EXP:
+                    this.RetrunValueExp = XmlParser.getInt(valueStr);
+                    break;
+                case XMLConstants.MG_ATTR_MENUS_FILE_NAME:
+                    break;
+                default:
+                    isTagProcessed = false;
+                    break;
+            }
+        }
+        if (!isTagProcessed)
+            Logger.Instance.WriteExceptionToLogWithMsg(NString.Format("Unrecognized attribute: '{0}'", attribute));
+        return true;
+    }
+    async initInnerObjects(foundTagName, parentForm) {
+        if (foundTagName == null)
+            return false;
+        let parser = RuntimeContextBase.Instance.Parser;
+        switch (foundTagName) {
+            case XMLConstants.MG_TAG_HELPTABLE:
+                if (this._helpTab == null)
+                    this._helpTab = new Helps();
+                if (Events.ShouldLog(Logger_LogLevels.Development))
+                    Events.WriteDevToLog(NString.Format("{0} ...", foundTagName));
+                this._helpTab.fillData(parser);
+                break;
+            case XMLConstants.MG_TAG_DVHEADER:
+                if (Events.ShouldLog(Logger_LogLevels.Development))
+                    Events.WriteDevToLog(NString.Format("{0} ...", foundTagName));
+                this.DataView.fillHeaderData(parser);
+                break;
+            case XMLConstants.MG_TAG_PROP:
+                this._propTab.fillData(this, 'T', parser);
+                break;
+            case XMLConstants.MG_TAG_FORM:
+                this.Form = this.FormInitData(parentForm);
+                break;
+            case XMLConstants.MG_ATTR_MENU_CONTENT:
+                break;
+            case "assemblies":
+                let endContext = parser.getXMLdata().indexOf('/assemblies', parser.getCurrIndex());
+                parser.setCurrIndex(endContext);
+                parser.setCurrIndex2EndOfTag();
+                break;
+            case XMLConstants.MG_TAG_FORMS:
+                this._forms = new FormsTable(this, parentForm);
+                Logger.Instance.WriteDevToLog(NString.Format("{0} ...", foundTagName));
+                await this._forms.fillData();
+                break;
+            case XMLConstants.MG_TAG_TASK:
+                if (this.SubTasks == null)
+                    this.SubTasks = new TasksTable();
+                let subtask = new Task(this);
+                subtask.Init();
+                this.SubTasks.addTask(subtask);
+                let mgd = this._mgData;
+                if (this.isMainProg())
+                    mgd = AccessHelper.mgDataTable.GetMGDataForStartupProgram();
+                await subtask.fillData(mgd, new OpeningTaskDetails());
+                break;
+            case ConstInterface.MG_TAG_TASKURL:
+                await Task.ProcessTaskURL();
+                break;
+            case ConstInterface.MG_TAG_EXPTABLE:
+                if (this.ExpTab == null)
+                    this.ExpTab = new ExpTable();
+                Logger.Instance.WriteDevToLog("goes to exp");
+                this.ExpTab.fillData(this, parser);
+                break;
+            case ConstInterface.MG_TAG_USER_EVENTS:
+                if (this.UserEvtTab == null)
+                    this.UserEvtTab = new UserEventsTable();
+                Logger.Instance.WriteDevToLog("goes to user event tab");
+                this.UserEvtTab.fillData(this, parser);
+                break;
+            case ConstInterface.MG_TAG_LINKS:
+                this.DataviewHeadersTable = new DataviewHeaders(this);
+                this.DataviewHeadersTable.fillData(parser);
+                break;
+            case ConstInterface.MG_TAG_SORTS:
+                this.RuntimeSorts = new SortCollection();
+                this.RuntimeSorts.fillData(parser);
+                break;
+            case ConstInterface.MG_TAG_TASK_TABLES:
+                this.FillTaskTables();
+                break;
+            case XMLConstants.MG_TAG_RECOMPUTE:
+                Logger.Instance.WriteDevToLog("goes to recompute");
+                this.RecomputeFillData(parser);
+                break;
+            case ConstInterface.MG_TAG_EVENTHANDLERS:
+                Logger.Instance.WriteDevToLog("goes to eventhandlers");
+                if (this.HandlersTab == null)
+                    this.HandlersTab = new HandlersTable();
+                this.HandlersTab.fillData(this, parser);
+                this.addExpHandlersToMGData();
+                break;
+            default:
+                if (foundTagName === ("/" + XMLConstants.MG_TAG_TASK)) {
+                    RuntimeContextBase.Instance.Parser.setCurrIndex2EndOfTag();
+                    return false;
+                }
+                else {
+                    Logger.Instance.WriteDevToLog("There is no such tag in Task.initInnerObjects . Enter case for " + foundTagName);
+                    return false;
+                }
+        }
+        return true;
+    }
+    RecomputeFillData(parser) {
+        let recomputeTable = new RecomputeTable();
+        recomputeTable.fillData_1(this.DataView, this, parser);
+    }
+    FillTaskTables_1() {
+        let parser = RuntimeContextBase.Instance.Parser;
+        let endContext = parser.getXMLdata().indexOf(ConstInterface.MG_TAG_TASK_TABLES_END, parser.getCurrIndex());
+        endContext = parser.getXMLdata().indexOf(XMLConstants.TAG_CLOSE, endContext) + XMLConstants.TAG_CLOSE.length;
+        let taskTablesData = parser.getXMLsubstring(endContext);
+        this.FillTaskTables(taskTablesData);
+        parser.setCurrIndex(endContext);
+    }
+    addExpHandlersToMGData() {
+        let idx = 0;
+        for (let i = this.HandlersTab.getSize() - 1; i >= 0; i--) {
+            let handler = this.HandlersTab.getHandler(i);
+            let evt = handler.getEvent();
+            if (evt.getType() === ConstInterface.EVENT_TYPE_EXPRESSION ||
+                (evt.getType() === ConstInterface.EVENT_TYPE_USER && evt.getUserEventType() === ConstInterface.EVENT_TYPE_EXPRESSION)) {
+                this._mgData.addExpHandler(handler, idx);
+                idx++;
+            }
+        }
+    }
+    SetRefreshOnVars(variables) {
+        let strTok = StrUtil.tokenize(variables, ",");
+        let fldNum;
+        let intVals = new List();
+        let i;
+        for (i = 0; i < strTok.length; i++) {
+            fldNum = NNumber.Parse(strTok[i]);
+            intVals.push(fldNum);
+        }
+        this.RefreshOnVars = new Array(intVals.length);
+        for (i = 0; i < intVals.length; i++) {
+            fldNum = intVals.get_Item(i);
+            this.RefreshOnVars[i] = fldNum;
+        }
+    }
+    setDataSynced(synced) {
+        this.DataSynced = synced;
+    }
+    getField(fldName) {
+        return this.DataView.getFieldByName(fldName);
+    }
+    getExpById(id) {
+        if (this.ExpTab !== null)
+            return this.ExpTab.getExpById(id);
+        else
+            Logger.Instance.WriteExceptionToLogWithMsg("in Task.GetExpById(): no expression table");
+        return null;
+    }
+    getExpObjectById(id) {
+        return this.getExpById(id);
+    }
+    GetExpressionStorage(expId) {
+        let result = null;
+        if (expId > 0) {
+            let expById = this.getExpById(expId);
+            Debug.Assert(expById !== null);
+            result = expById.GetStorageAttribute();
+        }
+        return result;
+    }
+    async CalculateExpression(expId, resType, length) {
+        let result = null;
+        if (expId > 0) {
+            let expById = this.getExpById(expId);
+            Debug.Assert(expById !== null);
+            result = await expById.evaluateWithResultTypeAndLength(resType, length);
+        }
+        return result;
+    }
+    async insertRecordTable(invalidate, parser) {
+        if (await this.isCached()) {
+            let firstTime = this.DataView.getFirstDv();
+            if (!firstTime && invalidate) {
+                if (!this.hasLocate) {
+                    if (this.DataView.IncludesFirst()) {
+                        if (!this.DataView.getChanged())
+                            this._dvCache.putInCache(this.DataView.replicate());
+                        else
+                            this._dvCache.removeDvFromCache(this.DataView.getDvPosValue(), true);
+                    }
+                }
+                else
+                    this.locatePutInCache();
+            }
+        }
+        await this.DataView.fillData(parser);
+        if (invalidate)
+            this.DataView.setChanged(false);
+    }
+    getHandlersTab() {
+        return this.HandlersTab;
+    }
+    async buildXML(message) {
+        this.IsAfterRetryBeforeBuildXML = this.getAfterRetry();
+        if (this.KnownToServer && !this.IsOffline) {
+            message.Append(XMLConstants.START_TAG + XMLConstants.MG_TAG_TASK);
+            message.Append(" " + XMLConstants.MG_ATTR_TASKID + "=\"" + this.getTaskTag() + "\"");
+            message.Append(" " + ConstInterface.MG_ATTR_TASK_MAINLEVEL + "=\"" + this.getMainLevel() + "\"");
+            message.Append(XMLConstants.TAG_CLOSE);
+            await this.DataView.buildXML(message);
+            if (this.Form != null && this.Form.Opened)
+                message.Append(this.Form.GetHiddenControlListXML());
+            message.Append("\n   </" + XMLConstants.MG_TAG_TASK + XMLConstants.TAG_CLOSE);
+        }
+    }
+    buildXMLForRngs(message, UserRanges, locate) {
+        let i;
+        let fld;
+        let cellAttr = StorageAttribute.SKIP;
+        let toBase64 = (Environment.Instance.GetDebugLevel() <= 1);
+        message.Append(XMLConstants.TAG_CLOSE);
+        for (i = 0; i < UserRanges.length; i++) {
+            message.Append(XMLConstants.START_TAG + ConstInterface.USER_RNG);
+            let rng = UserRanges.get_Item(i);
+            message.Append(" " + XMLConstants.MG_TAG_FLD + "=\"" + rng.veeIdx + "\"");
+            fld = this.DataView.getField(rng.veeIdx - 1);
+            let fldAttr = fld.getType();
+            if (rng.nullMin)
+                message.Append(" " + ConstInterface.NULL_MIN_RNG + "=\"1\"");
+            if (!rng.discardMin && rng.min != null) {
+                let val = RecordUtils.itemValToXML(rng.min, fldAttr, cellAttr, toBase64);
+                message.Append(" " + ConstInterface.MIN_RNG + "=\"" + val + "\"");
+            }
+            if (rng.nullMax)
+                message.Append(" " + ConstInterface.NULL_MAX_RNG + "=\"1\"");
+            if (!rng.discardMax && rng.max != null) {
+                let val = RecordUtils.itemValToXML(rng.max, fldAttr, cellAttr, toBase64);
+                message.Append(" " + ConstInterface.MAX_RNG + "=\"" + val + "\"");
+            }
+            message.Append(XMLConstants.TAG_TERM);
+        }
+        if (locate)
+            message.Append(XMLConstants.END_TAG + ConstInterface.USER_LOCATES + XMLConstants.TAG_CLOSE);
+        else
+            message.Append(XMLConstants.END_TAG + ConstInterface.USER_RANGES + XMLConstants.TAG_CLOSE);
+    }
+    buildXMLForSorts(message) {
+        if (this.UserSorts != null && this.UserSorts.length > 0) {
+            let i;
+            for (i = 0; i < this.UserSorts.length; i++) {
+                message.Append(XMLConstants.TAG_CLOSE);
+                let srt = this.UserSorts.get_Item(i);
+                message.Append(XMLConstants.START_TAG + ConstInterface.SORT);
+                message.Append(" " + XMLConstants.MG_TAG_FLD + "=\"" + srt.fldIdx + "\"");
+                if (srt.dir)
+                    message.Append(" " + ConstInterface.MG_ATTR_DIR + "=\"1\"");
+                message.Append(XMLConstants.TAG_TERM);
+            }
+            this.UserSorts.Clear();
+            this.UserSorts = null;
+            message.Append(XMLConstants.END_TAG + ConstInterface.MG_TAG_SORTS + XMLConstants.TAG_CLOSE);
+        }
+    }
+    getUserEvent(idx) {
+        Debug.Assert(this.UserEvtTab !== null);
+        let retEvent = null;
+        if (this.UserEvtTab !== null)
+            retEvent = this.UserEvtTab.getEvent(idx);
+        return retEvent;
+    }
+    SetMoveToFirstControl(moveToFirstControl) {
+        if (moveToFirstControl || !this.IsSubForm) {
+            if (this.Form !== null) {
+                let alreadyMoved = this.Form.alreadyMovedToFirstControl();
+                if (!alreadyMoved)
+                    this.Form.MovedToFirstControl = true;
+            }
+        }
+    }
+    async Start(moveToFirstControl, callByDestSubForm) {
+        let nonInteractiveTask = null;
+        if (!this._isStarted) {
+            this._isStarted = true;
+            this.InitializeExecution();
+            this.InStartProcess = true;
+            let result = await this.Setup();
+            if (!result.Success)
+                return null;
+            this._inProcessingTopMostEndTaskSaved = AccessHelper.eventsManager.getProcessingTopMostEndTask();
+            AccessHelper.eventsManager.setProcessingTopMostEndTask(false);
+            await this.EnableActions();
+            result = await this.InitializeForm(moveToFirstControl);
+            if (!result.Success)
+                return null;
+            if (!this.IsInteractive && !this._isMainPrg)
+                nonInteractiveTask = this;
+            this.DataViewWasRetrieved = true;
+            let subTasks = this.SubTasks;
+            if (this.isMainProg())
+                this.SubTasks = null;
+            if (this.isMainProg())
+                this.SubTasks = subTasks;
+            if (!result.Success)
+                return null;
+            if (this._aborting)
+                return null;
+            let dataViewCommand = CommandFactory.CreateDataViewCommand(this.getTaskTag(), DataViewCommandType.FirstChunk);
+            result = await this.DataviewManager.Execute(dataViewCommand);
+            if (!result.Success)
+                return null;
+            this.ResumeSubformLayout();
+        }
+        nonInteractiveTask = await this.StartSubTasks(moveToFirstControl, nonInteractiveTask, callByDestSubForm);
+        this.InStartProcess = false;
+        return nonInteractiveTask;
+    }
+    InitializeExecution() {
+        super.setBrkLevel(ConstInterface.BRK_LEVEL_REC_MAIN, -1);
+        this._firstRecordCycle = true;
+        this._currStartProgLevel = ((this.IsSubForm && this.getParent().getForm().alreadyMovedToFirstControl())
+            ? this.getParent()._currStartProgLevel
+            : Task.StartProgLevel);
+    }
+    async InitializeForm(moveToFirstControl) {
+        if (this.Form !== null) {
+            this.SetMoveToFirstControl(moveToFirstControl);
+            AccessHelper.eventsManager.pushNewExecStacks();
+            this.routeParams = this.DataView.GetRouteParams();
+            await this.InitForm();
+            AccessHelper.eventsManager.popNewExecStacks();
+            this.getMGData().StartTimers();
+            Commands.beginInvoke();
+        }
+        return new ReturnResult();
+    }
+    async StartSubTasks(moveToFirstControl, nonInteractiveTask, callByDestSubForm) {
+        if (this.hasSubTasks()) {
+            for (let i = 0; i < this.SubTasks.getSize(); i = i + 1) {
+                let task = this.SubTasks.getTask(i);
+                let tmpNonInteractiveTask = await task.Start(moveToFirstControl, callByDestSubForm);
+                if (nonInteractiveTask === null)
+                    nonInteractiveTask = tmpNonInteractiveTask;
+                else if (tmpNonInteractiveTask !== null)
+                    Debug.Assert(false, "more than 1 non interactive in task.start");
+            }
+        }
+        return nonInteractiveTask;
+    }
+    async EnableActions() {
+        let actList = ActionManager.actEnabled;
+        this.ActionManager.enableList(actList, true, false);
+        if (this.IsSubForm)
+            this.ActionManager.enable(InternalInterface.MG_ACT_POST_REFRESH_BY_PARENT, true);
+        await this.enableModes();
+        if (await this.checkProp(PropInterface.PROP_TYPE_SELECTION, false)) {
+            this.ActionManager.enable(InternalInterface.MG_ACT_SELECT, true);
+        }
+        let enablePrintdata = await this.checkProp(PropInterface.PROP_TYPE_PRINT_DATA, false);
+        this.ActionManager.enable(InternalInterface.MG_ACT_PRINT_DATA, enablePrintdata);
+        if (this.getEnableZoomHandler())
+            this.ActionManager.enable(InternalInterface.MG_ACT_ZOOM, true);
+    }
+    async ShowError(text) {
+        let mlsTransText = LanguageData.Instance.translate(text);
+        let mlsTransTitle = LanguageData.Instance.translate(ConstInterface.ERROR_STRING);
+        await GUIManager.Instance.MessageBox(mlsTransTitle, mlsTransText, Styles.MSGBOX_ICON_ERROR | Styles.MSGBOX_BUTTON_OK);
+    }
+    async EndTaskOnError(result, displayError) {
+        if (!result.Success && !this.isAborting()) {
+            if (this.InStartProcess) {
+                await this.endTask(false, false, false);
+                if (displayError)
+                    await this.ShowError(result.ErrorDescription);
+                this.InStartProcess = false;
+                return true;
+            }
+            else {
+                if (displayError)
+                    await this.ShowError(result.ErrorDescription);
+                await AccessHelper.eventsManager.handleInternalEventWithTask(this, InternalInterface.MG_ACT_EXIT);
+            }
+        }
+        return false;
+    }
+    async Setup() {
+        let result;
+        this.TaskService.InitTaskPrefixExecutedFlag(this);
+        this.TaskSuffixExecuted = false;
+        TaskServiceBase.CreateFirstRecord(this);
+        let dataViewCommand = CommandFactory.CreateDataViewCommand(this.getTaskTag(), DataViewCommandType.Init);
+        result = await this.DataviewManager.Execute(dataViewCommand);
+        if (!result.Success)
+            return result;
+        if (result.Success) {
+            let commands = GlobalCommandsManager.Instance.getCommandsExecutedAfterTaskStarted();
+            for (let cmdIdx = 0; cmdIdx < commands.length; cmdIdx++) {
+                let command = (commands.get_Item(cmdIdx));
+                if (command.TaskTag === this.getTaskTag()) {
+                    await command.Execute(null);
+                    GlobalCommandsManager.Instance.removeCommandsExecutedAfterTaskStarted(command);
+                }
+            }
+            dataViewCommand = CommandFactory.CreateDataViewCommand(this.getTaskTag(), DataViewCommandType.Prepare);
+            result = await this.DataviewManager.Execute(dataViewCommand);
+        }
+        if (result.Success) {
+            result = this.TaskService.PrepareTask(this);
+            if (!result.Success)
+                await this.EndTaskOnError(result, true);
+        }
+        if (result.Success) {
+            dataViewCommand = CommandFactory.CreateDataViewCommand(this.getTaskTag(), DataViewCommandType.InitDataControlViews);
+            result = await this.DataviewManager.Execute(dataViewCommand);
+        }
+        return result;
+    }
+    async doFirstRecordCycle() {
+        if (!this._isMainPrg) {
+            AccessHelper.eventsManager.pushNewExecStacks();
+            this.SubformExecMode = Task_SubformExecModeEnum.FIRST_TIME;
+            await AccessHelper.eventsManager.handleInternalEventWithTaskAndSubformRefresh(this, InternalInterface.MG_ACT_REC_PREFIX, this.IsSubForm);
+            if (!AccessHelper.eventsManager.GetStopExecutionFlag()) {
+                if (this.IsSubForm) {
+                    if (this.hasSubTasks())
+                        for (let i = 0; i < this.SubTasks.getSize(); i++) {
+                            let subTask = this.SubTasks.getTask(i);
+                            if (subTask.IsSubForm) {
+                                subTask.getForm().IgnoreFirstRecordCycle = true;
+                                await subTask.doFirstRecordCycle();
+                            }
+                        }
+                    await AccessHelper.eventsManager.handleInternalEventWithTask(this, InternalInterface.MG_ACT_REC_SUFFIX);
+                }
+            }
+            this.SubformExecMode = Task_SubformExecModeEnum.SET_FOCUS;
+            AccessHelper.eventsManager.popNewExecStacks();
+        }
+    }
+    CheckAndSetSubForm() {
+        this.IsSubForm = (!super.isMainProg() && this !== this._mgData.getFirstTask());
+    }
+    IsRoute() {
+        return (this.RouterPath != null);
+    }
+    async stop() {
+        let task;
+        if (this._aborting)
+            return;
+        if (this.hasSubTasks()) {
+            while ((task = this.SubTasks.getTask(0)) != null) {
+                task.setDestinationSubform(this._destinationSubform);
+                await task.stop();
+            }
+        }
+        if (!this._isMainPrg)
+            this._aborting = true;
+        if (this._parentTask != null) {
+            this._parentTask.removeSubTask(this);
+            if (this.IsSubForm) {
+                let oldTimers = new List(), newTimers = new List();
+                let mgd = this.getMGData();
+                if (mgd.getTimerHandlers() != null)
+                    oldTimers = mgd.getTimerHandlers().getTimersVector();
+                mgd.removeTimerHandler(this);
+                mgd.removeExpressionHandler(this);
+                if (mgd.getTimerHandlers() != null)
+                    newTimers = mgd.getTimerHandlers().getTimersVector();
+                mgd.changeTimers(oldTimers, newTimers);
+                mgd.removeTask(this);
+                GUIManager.Instance.abort(this.getForm());
+            }
+        }
+        this.AbortTransaction();
+        if (this.getClickedControl() != null)
+            RuntimeContextBase.Instance.CurrentClickedCtrl = null;
+        if (this.Form != null)
+            this.Form.removeRefsToCtrls();
+        if (this.IsSubForm) {
+            let subForm = this.Form.getSubFormCtrl();
+            subForm.setSubformTaskId(null);
+            subForm.initSubformTask();
+            if (LastFocusedManager.Instance.getLastFocusedTask() === this)
+                LastFocusedManager.Instance.setLastFocusedTask(this._parentTask);
+            if (subForm.SubformLoaded)
+                await (subForm.getProp(PropInterface.PROP_TYPE_VISIBLE)).RefreshDisplay(true);
+        }
+        let clearDataViewCommand = CommandFactory.CreateDataViewCommand(this.getTaskTag(), DataViewCommandType.Clear);
+        await this.DataviewManager.Execute(clearDataViewCommand);
+    }
+    abort() {
+        this.getMGData().abort();
+    }
+    hasSubTasks() {
+        return this.SubTasks !== null && this.SubTasks.getSize() > 0;
+    }
+    getTaskDepth(byParentOrder) {
+        if (byParentOrder)
+            return this.getTaskDepth_(byParentOrder);
+        let depth = this.GetContextTask().getTaskDepth_(byParentOrder);
+        if (this.isMainProg() && this.getCtlIdx() !== ConstInterface.TOP_LEVEL_CONTAINER)
+            depth = depth + 1;
+        return depth;
+    }
+    getTaskDepth_(byParentOrder) {
+        let tmpTask = this.getTriggeringTask();
+        if (tmpTask == null || byParentOrder)
+            if (this._parentTask == null)
+                return 1;
+            else {
+                if (byParentOrder && this.getCtlIdx() !== this._parentTask.getCtlIdx())
+                    return 2 + this._parentTask.getTaskDepth_(byParentOrder);
+                return 1 + this._parentTask.getTaskDepth_(byParentOrder);
+            }
+        return 1 + (tmpTask).getTaskDepth_(byParentOrder);
+    }
+    GetTaskAncestor(generation) {
+        return this.getTaskAncestor_(generation);
+    }
+    getTaskAncestor_(generation) {
+        let retTask = null;
+        if (generation === 0)
+            retTask = this;
+        else {
+            let tmpTask = this.getTriggeringTask();
+            if (tmpTask === null)
+                tmpTask = this._parentTask;
+            if (tmpTask !== null)
+                retTask = tmpTask.getTaskAncestor_(--generation);
+        }
+        return retTask;
+    }
+    GetTaskDepth() {
+        return this.getTaskDepth(false);
+    }
+    pathContains(task) {
+        return this._taskPath.Contains(task);
+    }
+    SetContextTask(context) {
+        this.ContextTask = context;
+    }
+    GetContextTask() {
+        let currRec = (this.DataView.getCurrRec());
+        if (this.InStartProcess
+            || currRec !== null && (currRec.InCompute || currRec.InRecompute)
+            || this.Form !== null && this.Form.inRefreshDisplay())
+            return this;
+        return this.ContextTask;
+    }
+    getTriggeringTask() {
+        if (this._triggeringTask !== null && this._triggeringTask.getMGData().IsAborting)
+            this._triggeringTask = this._parentTask;
+        return this._triggeringTask;
+    }
+    setLastParkedCtrl(ctrl) {
+        super.setLastParkedCtrl(ctrl);
+        LastFocusedManager.setLastFocusedControl(this, ctrl);
+    }
+    queryTaskPath() {
+        let insertedNames = 0;
+        let result = new StringBuilder(7936);
+        let treeRoute = new Array(this.getTaskDepth(false));
+        this.pathToRoot(treeRoute, false);
+        for (let tsk = treeRoute.length - 1; tsk >= 0; tsk--) {
+            let currTsk = treeRoute[tsk];
+            if (currTsk.isMainProg())
+                continue;
+            let nameProp = currTsk.getProp(PropInterface.PROP_TYPE_NAME);
+            if (nameProp == null)
+                continue;
+            let name = nameProp.GetComputedValue();
+            if (!NString.IsNullOrEmpty(name)) {
+                if (insertedNames++ !== 0)
+                    result.Append(';');
+                result.Append(name);
+            }
+        }
+        return result;
+    }
+    ctl_itm_2_parent_vee(itm) {
+        let currTsk;
+        let currItm = 0;
+        let lastItm = 0;
+        let treeRoute = new Array(this.getTaskDepth(true));
+        this.pathToRoot(treeRoute, true);
+        for (let tsk = treeRoute.length - 1; tsk >= 0; tsk--) {
+            currTsk = treeRoute[tsk];
+            currItm += currTsk.DataView.GetFieldsTab().getSize();
+            if (itm < currItm) {
+                itm -= lastItm;
+                return currTsk.DataView.getField(itm);
+            }
+            lastItm = currItm;
+        }
+        return null;
+    }
+    GetControlIDFromVarItem(item) {
+        let currTask;
+        let currItem = 0;
+        let lastItem = 0;
+        let noOfControlsBeforeCurrTask = 0;
+        let treeRoute = new Array(this.getTaskDepth(true));
+        this.pathToRoot(treeRoute, true);
+        for (let task = treeRoute.length - 1; task >= 0; task--) {
+            currTask = treeRoute[task];
+            currItem += currTask.DataView.GetFieldsTab().getSize();
+            if (item < currItem) {
+                item -= lastItem;
+                let field = currTask.DataView.getField(item);
+                if (field.getCtrl() != null)
+                    return noOfControlsBeforeCurrTask = noOfControlsBeforeCurrTask + currTask.Form.getControlIdx(field.getCtrl()) + 1;
+                return 0;
+            }
+            if (currTask.Form != null)
+                noOfControlsBeforeCurrTask += currTask.Form.getCtrlCount();
+            lastItem = currItem;
+        }
+        return 0;
+    }
+    GetControlFromControlID(controlID, parent) {
+        let control = null;
+        parent.value = -1;
+        if (controlID >= 0) {
+            let currTask = null;
+            let callerTask = null;
+            let noOfControlsInCurrtask = 0;
+            let noOfControlsBeforeCurrTask = 0;
+            let controlIdx = 0;
+            let treeRoute = new Array(this.getTaskDepth(true));
+            this.pathToRoot(treeRoute, true);
+            for (let task = treeRoute.length - 1; task >= 0; task--) {
+                currTask = treeRoute[task];
+                if (currTask.Form != null) {
+                    noOfControlsInCurrtask = currTask.Form.getCtrlCount();
+                    if (controlID < (noOfControlsBeforeCurrTask + noOfControlsInCurrtask)) {
+                        controlIdx = controlID - noOfControlsBeforeCurrTask;
+                        control = currTask.Form.CtrlTab.getCtrl(controlIdx);
+                        callerTask = currTask;
+                        break;
+                    }
+                    noOfControlsBeforeCurrTask += noOfControlsInCurrtask;
+                }
+            }
+            if (control != null) {
+                parent.value = 0;
+                let prevCtlIdx = treeRoute[0].TaskDefinitionId.CtlIndex;
+                for (let task = 0; task < treeRoute.length - 1; task++) {
+                    currTask = treeRoute[task];
+                    if (prevCtlIdx !== currTask.TaskDefinitionId.CtlIndex)
+                        parent.value++;
+                    if (callerTask.TaskDefinitionId.CtlIndex === currTask.TaskDefinitionId.CtlIndex)
+                        break;
+                    prevCtlIdx = currTask.TaskDefinitionId.CtlIndex;
+                }
+            }
+        }
+        return control;
+    }
+    ctl_itm_4_parent_vee(parent, vee) {
+        let tsk;
+        let depth = this.getTaskDepth(true);
+        if (parent !== TaskBase.MAIN_PRG_PARENT_ID && depth <= parent)
+            return vee;
+        let treeRoute = new Array(depth);
+        if (vee !== 0) {
+            this.pathToRoot(treeRoute, true);
+            let indOfParentInTaskTree = this.getIndOfParentInTaskTree(parent, treeRoute);
+            let i;
+            for (i = treeRoute.length - 1; i > indOfParentInTaskTree; i--) {
+                tsk = treeRoute[i];
+                vee += tsk.DataView.GetFieldsTab().getSize();
+            }
+        }
+        return vee;
+    }
+    getIndOfParentInTaskTree(parent, taskTree) {
+        let indOfParentInTaskTree = 0;
+        if (parent === TaskBase.MAIN_PRG_PARENT_ID) {
+            for (let i = 1; i < taskTree.length; i = i + 1) {
+                if (taskTree[i].isMainProg() && this._ctlIdx === taskTree[i].getCtlIdx()) {
+                    indOfParentInTaskTree = i;
+                    break;
+                }
+            }
+        }
+        else
+            indOfParentInTaskTree = parent;
+        return indOfParentInTaskTree;
+    }
+    getFieldByName(fldName) {
+        return (this.GetContextTask()).getFieldByName_(fldName);
+    }
+    getFieldByName_(fldName) {
+        let tmpTask;
+        if (fldName == null)
+            return null;
+        let fld = this.getField(fldName);
+        if (fld == null) {
+            tmpTask = this.getTriggeringTask() != null ? this.getTriggeringTask() : this._parentTask;
+            if (tmpTask != null) {
+                if (!this.isMainProg() && this.getCtlIdx() !== tmpTask.getCtlIdx()) {
+                    let mainPrg = AccessHelper.mgDataTable.GetMainProgByCtlIdx(-1, this.getCtlIdx());
+                    fld = mainPrg.getFieldByName_(fldName);
+                }
+                if (fld == null)
+                    fld = tmpTask.getFieldByName_(fldName);
+            }
+        }
+        return fld;
+    }
+    getIndexOfFieldByName(fldName) {
+        let depth = this.getTaskDepth(true);
+        let index = 0;
+        let fld = this.getFieldByName(fldName);
+        let fldTab;
+        if (fld == null)
+            return 0;
+        let treeRoute = new Array(depth);
+        this.pathToRoot(treeRoute, true);
+        for (let curr = depth - 1; curr >= 0; curr--) {
+            let currTask = treeRoute[curr];
+            if (currTask === fld.getTask()) {
+                curr = fld.getId();
+                index += ++curr;
+                break;
+            }
+            fldTab = currTask.DataView.GetFieldsTab();
+            index += fldTab.getSize();
+        }
+        return index;
+    }
+    pathToRoot(path, byParentOrder) {
+        let task = (byParentOrder ? this : this.GetContextTask());
+        for (let i = 0; i < path.length; i++) {
+            path[i] = task;
+            let ctlIdx = task.getCtlIdx();
+            let tmpTask = byParentOrder ? null : task.getTriggeringTask();
+            if (tmpTask != null)
+                task = tmpTask;
+            else {
+                task = task.getParent();
+                if (task == null) {
+                    if (!byParentOrder && this.isMainProg() && this.getCtlIdx() !== ConstInterface.TOP_LEVEL_CONTAINER)
+                        path[i + 1] = this;
+                    break;
+                }
+                if (byParentOrder && ctlIdx !== task.getCtlIdx())
+                    path[++i] = AccessHelper.mgDataTable.GetMainProgByCtlIdx(-1, ctlIdx);
+            }
+        }
+    }
+    shouldBeRefreshed() {
+        let dataView = this._parentTask.DataView;
+        let result = false;
+        if (this._parentTask === null || dataView.isPrevCurrRecNull() ||
+            (this.RefreshOnVars !== null && !dataView.currEqualsPrev(this.RefreshOnVars)))
+            result = true;
+        return result;
+    }
+    async CheckRefreshSubTasks() {
+        let ret = false;
+        if (this._enteredRecLevel) {
+            let subformsToRefresh = await this.GetSubformsToRefresh();
+            if (subformsToRefresh.length > 0)
+                ret = true;
+        }
+        return ret;
+    }
+    GetSubTasks() {
+        let subTasks = new List();
+        if (this.hasSubTasks()) {
+            for (let i = 0; i < this.SubTasks.getSize(); i = i + 1)
+                subTasks.push(this.SubTasks.getTask(i));
+        }
+        return subTasks;
+    }
+    async GetSubformsToRefresh() {
+        let subTasks = this.GetSubTasks();
+        let subTasksToRefresh = new List();
+        for (let i = 0; i < subTasks.length; i++) {
+            let subTask = subTasks.get_Item(i);
+            if (await this.ShouldRefreshSubformTask(subTask))
+                subTasksToRefresh.push(subTask);
+        }
+        return subTasksToRefresh;
+    }
+    async ShouldRefreshSubformTask(subTask) {
+        let refresh = false;
+        let subformCtrl = subTask.getForm().getSubFormCtrl();
+        subTask.DoSubformPrefixSuffix = false;
+        if (subformCtrl != null && !subTask.InSelect && subTask.AfterFirstRecordPrefix) {
+            let parentMode = this.getMode();
+            let modeProperty = (parentMode === Constants.TASK_MODE_QUERY ? PropInterface.PROP_TYPE_ALLOW_QUERY
+                : parentMode === Constants.TASK_MODE_MODIFY
+                    ? PropInterface.PROP_TYPE_ALLOW_MODIFY
+                    : PropInterface.PROP_TYPE_ALLOW_CREATE);
+            if (subTask.ModeAsParent && parentMode !== subTask.getMode() &&
+                this.getLevel() === Constants.TASK_LEVEL_RECORD &&
+                await (subTask.getProp(PropInterface.PROP_TYPE_ALLOW_OPTION)).getValueBoolean() &&
+                await subTask.checkProp(modeProperty, true)) {
+                if (!subformCtrl.isVisible() &&
+                    !await subformCtrl.checkProp(PropInterface.PROP_TYPE_REFRESH_WHEN_HIDDEN, false)) {
+                    subformCtrl.RefreshOnVisible = true;
+                    refresh = false;
+                }
+                else
+                    refresh = true;
+                await subTask.SetModeAsParent(parentMode);
+            }
+            else {
+                refresh = await subformCtrl.checkProp(PropInterface.PROP_TYPE_AUTO_REFRESH, true) && subTask.shouldBeRefreshed();
+                if (refresh) {
+                    if (!subformCtrl.isVisible() &&
+                        !await subformCtrl.checkProp(PropInterface.PROP_TYPE_REFRESH_WHEN_HIDDEN, false)) {
+                        subformCtrl.RefreshOnVisible = true;
+                        refresh = false;
+                    }
+                }
+            }
+            if (refresh)
+                subTask.DoSubformPrefixSuffix = true;
+        }
+        return refresh;
+    }
+    async SetModeAsParent(parentMode) {
+        await this.enableModes();
+        if (parentMode === Constants.TASK_MODE_CREATE) {
+            let cmd = CommandFactory.CreateEventCommand(this.getTaskTag(), InternalInterface.MG_ACT_RTO_CREATE);
+            await this.DataviewManager.Execute(cmd);
+        }
+        else if (this.getMode() === Constants.TASK_MODE_CREATE) {
+            this.setPreventRecordSuffix(true);
+            this.setPreventControlChange(true);
+            await AccessHelper.eventsManager.handleInternalEventWithTask(this, InternalInterface.MG_ACT_RT_REFRESH_VIEW);
+            this.setPreventRecordSuffix(false);
+            this.setPreventControlChange(false);
+            let subTaskDv = this.DataView;
+            if (!subTaskDv.isEmpty() && (subTaskDv.getCurrRec()).getMode() !== DataModificationTypes.Insert)
+                this.setMode(parentMode);
+            else
+                this.setMode(Constants.TASK_MODE_CREATE);
+            await this.getForm().RefreshDisplay(Constants.TASK_REFRESH_CURR_REC);
+        }
+        else
+            this.setMode(parentMode);
+        this.setOriginalTaskMode(parentMode);
+        await this.setCreateDeleteActsEnableState();
+    }
+    async doSubformRecPrefixSuffix() {
+        let subTasks = this.GetSubTasks();
+        for (let i = 0; i < subTasks.length; i++) {
+            let subTask = subTasks.get_Item(i);
+            if (subTask.DoSubformPrefixSuffix) {
+                await AccessHelper.eventsManager.handleInternalEventWithTaskAndSubformRefresh(subTask, InternalInterface.MG_ACT_REC_PREFIX, true);
+                if (!AccessHelper.eventsManager.GetStopExecutionFlag())
+                    await AccessHelper.eventsManager.handleInternalEventWithTask(subTask, InternalInterface.MG_ACT_REC_SUFFIX);
+            }
+        }
+    }
+    CleanDoSubformPrefixSuffix() {
+        let subTasks = this.GetSubTasks();
+        for (let i = 0; i < subTasks.length; i++) {
+            let subTask = subTasks.get_Item(i);
+            subTask.DoSubformPrefixSuffix = false;
+        }
+    }
+    mustConfirmInDeleteMode() {
+        let prop = this.getProp(PropInterface.PROP_TYPE_CONFIRM_UPDATE);
+        return !prop.isExpression();
+    }
+    addSubTask(subTask) {
+        if (this.SubTasks === null)
+            this.SubTasks = new TasksTable();
+        this.SubTasks.addTask(subTask);
+    }
+    removeSubTask(subTask) {
+        if (this.SubTasks !== null)
+            this.SubTasks.removeTask(subTask);
+    }
+    setTransactionFailed(val) {
+        this._transactionFailed = val;
+        if (!val)
+            this.TransactionErrorHandlingsRetry = null;
+    }
+    transactionFailed(level) {
+        if (level === ConstInterface.TRANS_NONE ||
+            (this.Transaction != null && this.Transaction.getLevel() === level))
+            return this._transactionFailed;
+        else if (level === ConstInterface.TRANS_NONE ||
+            (this.TransactionErrorHandlingsRetry != null && this.TransactionErrorHandlingsRetry.getLevel() === level))
+            return this._transactionFailed;
+        return false;
+    }
+    setAfterRetry(val) {
+        if (this.Transaction != null)
+            this.Transaction.setAfterRetry(val);
+        else if (this.TransactionErrorHandlingsRetry != null) {
+            if (val === ConstInterface.RECOVERY_NONE)
+                this.TransactionErrorHandlingsRetry = null;
+            else
+                this.TransactionErrorHandlingsRetry.setAfterRetry(val);
+        }
+    }
+    getAfterRetry(recovery) {
+        if (arguments.length === 0) {
+            return this.getAfterRetry_0();
+        }
+        return this.getAfterRetry_1(recovery);
+    }
+    getAfterRetry_0() {
+        if (this.Transaction != null)
+            return this.Transaction.getAfterRetry();
+        else if (this.TransactionErrorHandlingsRetry != null)
+            return this.TransactionErrorHandlingsRetry.getAfterRetry();
+        return false;
+    }
+    getAfterRetry_1(recovery) {
+        if (this.Transaction != null)
+            return this.Transaction.getAfterRetry(recovery);
+        else if (this.TransactionErrorHandlingsRetry != null)
+            return this.TransactionErrorHandlingsRetry.getAfterRetry(recovery);
+        return false;
+    }
+    getExecEndTask() {
+        return this._bExecEndTask;
+    }
+    resetExecEndTask() {
+        this._bExecEndTask = false;
+    }
+    setExecEndTask() {
+        this._bExecEndTask = true;
+    }
+    async evalEndCond(mode) {
+        let endTaskCondProp;
+        let evalEndCondProp = this.getProp(PropInterface.PROP_TYPE_EVAL_END_CONDITION);
+        if (this.InEndTask)
+            return false;
+        if (this._bExecEndTask)
+            return true;
+        if (evalEndCondProp != null && (NString.Compare(await evalEndCondProp.getValue(), ConstInterface.END_COND_EVAL_IMMIDIATE, true) === 0 || ((await evalEndCondProp.getValue()).toLowerCase() === mode.toLowerCase()))) {
+            endTaskCondProp = this.getProp(PropInterface.PROP_TYPE_END_CONDITION);
+            if (endTaskCondProp == null)
+                return false;
+            let endTask = await endTaskCondProp.getValue();
+            if (DisplayConvertor.toBoolean(endTask)) {
+                this._bExecEndTask = true;
+                return true;
+            }
+            return false;
+        }
+        return false;
+    }
+    setTryingToStop(val) {
+        if (this.hasSubTasks()) {
+            for (let i = 0; i < this.SubTasks.getSize(); i = i + 1) {
+                let task = this.SubTasks.getTask(i);
+                task.setTryingToStop(val);
+            }
+        }
+        this.IsTryingToStop = val;
+    }
+    getInRecordSuffix() {
+        return this._inRecordSuffix;
+    }
+    setInRecordSuffix(bValue) {
+        if (bValue !== this._inRecordSuffix) {
+            this._inRecordSuffix = bValue;
+            return true;
+        }
+        return false;
+    }
+    setEvalOldValues(bFlag) {
+        if (bFlag !== this._evalOldValues) {
+            this._evalOldValues = bFlag;
+            return true;
+        }
+        return false;
+    }
+    getEvalOldValues() {
+        return this._evalOldValues;
+    }
+    async endTask(reversibleExit, onlyDescs, dueToVerifyError, subformDestination) {
+        if (isNullOrUndefined(subformDestination))
+            return await this.endTask_1(reversibleExit, onlyDescs, false, dueToVerifyError);
+        else
+            return await this.endTask_1(reversibleExit, onlyDescs, subformDestination, dueToVerifyError);
+    }
+    async endTask_1(reversibleExit, onlyDescs, subformDestination, dueToVerifyError) {
+        let succeeded = true;
+        let closedSubForm = false;
+        let subTask;
+        let mgdTab = AccessHelper.mgDataTable;
+        if ((this.IsSubForm && !subformDestination) && !this._parentTask.InEndTask) {
+            succeeded = await this._parentTask.endTask(reversibleExit, onlyDescs, dueToVerifyError);
+        }
+        else if (!this.isAborting() && !this.InEndTask) {
+            try {
+                this.InEndTask = true;
+                if ((MGDataCollection.Instance.StartupMgData.getFirstTask().InEndTask && MGDataCollection.Instance.StartupMgData.getFirstTask().ClosingFormUI) && AccessHelper.eventsManager.GetStopExecutionFlag()) {
+                    let cmd = CommandFactory.CreateUnloadCommand();
+                    MGDataCollection.Instance.getMGData(0).CmdsToServer.Add(cmd);
+                    await CommandsProcessorManager.GetCommandsProcessor().Execute(CommandsProcessorBase_SendingInstruction.TASKS_AND_COMMANDS);
+                    return;
+                }
+                if (!this.IsTryingToStop)
+                    this.setTryingToStop(true);
+                let i;
+                if (reversibleExit) {
+                    if (this.hasSubTasks()) {
+                        if (!RemoteCommandsProcessor.GetInstance().DelayCommandExecution) {
+                            let pendingTransactions = true;
+                            let clientOperExist = await this.CheckIfClientOperationExistsInSubformTasks(this, InternalInterface.MG_ACT_TASK_SUFFIX);
+                            if (!clientOperExist) {
+                                clientOperExist = await this.CheckIfClientOperationExistsInSubformTasks(this, InternalInterface.MG_ACT_REC_SUFFIX);
+                                if (!clientOperExist)
+                                    pendingTransactions = this.CheckIfPendingTransactions(this);
+                            }
+                            if (!clientOperExist && !pendingTransactions) {
+                                this.allowRemoteCmdExecution = false;
+                                this.SetServerSideTaskSuffix(this);
+                                RemoteCommandsProcessor.GetInstance().DelayCommandExecution = true;
+                            }
+                        }
+                        else
+                            this.SetServerSideTaskSuffix(this);
+                        for (i = 0; i < this.SubTasks.getSize() && succeeded; i++) {
+                            subTask = this.SubTasks.getTask(i);
+                            closedSubForm = closedSubForm || subTask.IsSubForm;
+                            await AccessHelper.eventsManager.handleInternalEventWithTask(subTask, InternalInterface.MG_ACT_EXIT);
+                            succeeded = (!AccessHelper.eventsManager.GetStopExecutionFlag() || dueToVerifyError);
+                        }
+                    }
+                    else {
+                        if (RemoteCommandsProcessor.GetInstance().DelayCommandExecution)
+                            this.SetServerSideTaskSuffix(this);
+                    }
+                    if (this === mgdTab.StartupMgData.getFirstTask()) {
+                        for (i = mgdTab.getSize() - 1; i > 0 && succeeded; i--) {
+                            if (mgdTab.getMGData(i) != null) {
+                                await AccessHelper.eventsManager.handleInternalEventWithTask(mgdTab.getMGData(i).getFirstTask(), InternalInterface.MG_ACT_EXIT);
+                                succeeded = (!AccessHelper.eventsManager.GetStopExecutionFlag() || dueToVerifyError);
+                            }
+                        }
+                    }
+                }
+                if (succeeded) {
+                    if (reversibleExit && !dueToVerifyError) {
+                        let forceSuffix = await this.checkProp(PropInterface.PROP_TYPE_FORCE_SUFFIX, false);
+                        if (!this.IsInteractive && forceSuffix === true && this.getMode() === Constants.TASK_MODE_CREATE)
+                            this.setProp(PropInterface.PROP_TYPE_FORCE_SUFFIX, "0");
+                        await AccessHelper.eventsManager.handleInternalEventWithTask(this, InternalInterface.MG_ACT_REC_SUFFIX);
+                        if (!this.IsInteractive && forceSuffix === true && this.getMode() === Constants.TASK_MODE_CREATE)
+                            this.setProp(PropInterface.PROP_TYPE_FORCE_SUFFIX, "1");
+                    }
+                    succeeded = (!AccessHelper.eventsManager.GetStopExecutionFlag() || dueToVerifyError);
+                    if (succeeded && !onlyDescs)
+                        this.HandleTransactionInfo();
+                    let preTskSuffix = succeeded;
+                    if (succeeded && !onlyDescs && reversibleExit && !dueToVerifyError &&
+                        (!this.IsSubForm || subformDestination) &&
+                        this.TaskPrefixExecuted && !this.TaskSuffixExecuted)
+                        succeeded = await this.handleTaskSuffix(true);
+                    if (reversibleExit && this.hasSubTasks())
+                        for (i = 0; i < this.SubTasks.getSize(); i++) {
+                            subTask = this.SubTasks.getTask(i);
+                            if (!subTask.IsSubForm)
+                                await AccessHelper.eventsManager.handleNonReversibleEvent(subTask, InternalInterface.MG_ACT_EXIT);
+                        }
+                    if (reversibleExit)
+                        succeeded = (!AccessHelper.eventsManager.GetStopExecutionFlag() || dueToVerifyError);
+                    if (preTskSuffix)
+                        AccessHelper.eventsManager.setStopExecution(false);
+                    this.setAfterRetry(ConstInterface.RECOVERY_NONE);
+                    if (!this.isAborting() && succeeded && !onlyDescs) {
+                        if (reversibleExit) {
+                            this.setTransactionFailed(false);
+                            await this.TaskTransactionManager.checkAndCommit(false, ConstInterface.TRANS_TASK_PREFIX, false);
+                            succeeded = (!AccessHelper.eventsManager.GetStopExecutionFlag() || dueToVerifyError) && !this.isAborting() && !this.transactionFailed(ConstInterface.TRANS_TASK_PREFIX);
+                        }
+                        this.setAfterRetry(ConstInterface.RECOVERY_NONE);
+                        if (succeeded) {
+                            if (!this.allowRemoteCmdExecution) {
+                                this.allowRemoteCmdExecution = true;
+                                RemoteCommandsProcessor.GetInstance().DelayCommandExecution = false;
+                            }
+                            else if (this.DelayCommandExecution) {
+                                this.DelayCommandExecution = false;
+                                RemoteCommandsProcessor.GetInstance().DelayCommandExecution = true;
+                            }
+                            let baseMgd = AccessHelper.mgDataTable.StartupMgData;
+                            if (reversibleExit && baseMgd.getFirstTask().getTaskTag() === this.getTaskTag()) {
+                                AccessHelper.eventsManager.setProcessingTopMostEndTask(true);
+                                await AccessHelper.eventsManager.handleEvents(baseMgd, 0);
+                                AccessHelper.eventsManager.setProcessingTopMostEndTask(false);
+                                if (this.isAborting()) {
+                                    RemoteCommandsProcessor.GetInstance().DelayCommandExecution = false;
+                                    this.DelayCommandExecution = false;
+                                    this.allowRemoteCmdExecution = true;
+                                    return true;
+                                }
+                            }
+                            await TaskServiceBase.Exit(this, reversibleExit, subformDestination);
+                            if (this._parentTask != null && this._parentTask.isMainProg()) {
+                                let mgd = AccessHelper.mgDataTable.getMGData(0);
+                                let mainPrgTask = mgd.getMainProg(0);
+                                let rootTask = AccessHelper.mgDataTable.StartupMgData.getFirstTask();
+                                let endMainPrg = await mainPrgTask.checkProp(PropInterface.PROP_TYPE_END_CONDITION, false);
+                                if (this !== rootTask && endMainPrg) {
+                                    let rtEvt = new RunTimeEvent(rootTask);
+                                    rtEvt.setInternal(InternalInterface.MG_ACT_CLOSE);
+                                    rtEvt.setCtrl(null);
+                                    rtEvt.setArgList(null);
+                                    AccessHelper.eventsManager.addToTail(rtEvt);
+                                }
+                            }
+                            MgForm.CreatedForms.remove(this.Form);
+                        }
+                    }
+                }
+            }
+            finally {
+                if (!this.IsSubForm || subformDestination)
+                    this.handleFinallyEndTask(succeeded, reversibleExit);
+            }
+        }
+        else if (this.InEndTask)
+            succeeded = false;
+        AccessHelper.eventsManager.setProcessingTopMostEndTask(this._inProcessingTopMostEndTaskSaved);
+        return succeeded;
+    }
+    SetServerSideTaskSuffix(task) {
+        var rtEvt = new RunTimeEvent(task);
+        rtEvt.setInternal(InternalInterface.MG_ACT_TASK_SUFFIX);
+        let handler = null;
+        var evtHanPos = new EventHandlerPosition();
+        evtHanPos.init(rtEvt);
+        handler = evtHanPos.getNext();
+        if (handler != null) {
+            for (let i = 0; i < handler.getOperationTab().getSize(); i++) {
+                let oper = handler.getOperationTab().getOperation(i);
+                oper.setExecOnServer(true);
+            }
+        }
+        if (task.hasSubTasks()) {
+            for (let i = 0; i < task.GetSubTasks().length; i++) {
+                let subTask = task.SubTasks.getTask(i);
+                this.SetServerSideTaskSuffix(subTask);
+            }
+        }
+    }
+    async CheckIfClientOperationExistsInSubformTasks(task, eventCode) {
+        let clientOperationExist = false;
+        var rtEvt = new RunTimeEvent(task);
+        rtEvt.setInternal(eventCode);
+        let handler = null;
+        var evtHanPos = new EventHandlerPosition();
+        evtHanPos.init(rtEvt);
+        handler = evtHanPos.getNext();
+        if (eventCode == InternalInterface.MG_ACT_REC_SUFFIX) {
+            let currRecord = task.DataView.getCurrRec();
+            if (task.DataView.modifiedRecordsNumber() > 0 || (currRecord != null && currRecord.Modified))
+                clientOperationExist = true;
+            if (!clientOperationExist) {
+                let forceSuffix = await task.checkProp(PropInterface.PROP_TYPE_FORCE_SUFFIX, false);
+                if (forceSuffix === true)
+                    if (task.IsInteractive || task.getMode() !== Constants.TASK_MODE_CREATE)
+                        clientOperationExist = true;
+            }
+        }
+        if (handler != null && !clientOperationExist) {
+            let cnt = handler.getOperationTab().getSize();
+            for (let i = 0; i < cnt; i++) {
+                let oper = handler.getOperationTab().getOperation(i);
+                if (oper.getExecOnClient()) {
+                    clientOperationExist = true;
+                    break;
+                }
+                else {
+                    if (oper.getType() == ConstInterface.MG_OPER_RAISE_EVENT) {
+                        if (oper.GetRuntimeEvent().getType() == ConstInterface.EVENT_TYPE_INTERNAL &&
+                            oper.GetRuntimeEvent().getInternalCode() === InternalInterface.MG_ACT_RT_REFRESH_VIEW) {
+                            clientOperationExist = true;
+                            break;
+                        }
+                    }
+                }
+            }
+        }
+        if (!clientOperationExist && task.hasSubTasks()) {
+            for (let i = 0; (!clientOperationExist && i < task.getSubTasks().getSize()); i++) {
+                let subTask = task.SubTasks.getTask(i);
+                clientOperationExist = await this.CheckIfClientOperationExistsInSubformTasks(subTask, eventCode);
+            }
+        }
+        return clientOperationExist;
+    }
+    CheckIfPendingTransactions(task) {
+        let pendingTransactions = false;
+        let currRecord = task.DataView.getCurrRec();
+        if (task.DataView.modifiedRecordsNumber() > 0 || (currRecord != null && currRecord.Modified))
+            pendingTransactions = true;
+        if (!pendingTransactions && task.hasSubTasks()) {
+            for (let i = 0; (!pendingTransactions && i < task.getSubTasks().getSize()); i++) {
+                let subTask = task.SubTasks.getTask(i);
+                pendingTransactions = this.CheckIfPendingTransactions(subTask);
+            }
+        }
+        return pendingTransactions;
+    }
+    HandleTransactionInfo() {
+        let transaction = this.DataviewManager.RemoteDataviewManager.Transaction;
+        if (transaction !== null && transaction.isOwner(this) && transaction.getLevel() === 'P') {
+            this.DataviewManager.RemoteDataviewManager.Transaction = null;
+            this.DataView.setTransCleared();
+        }
+    }
+    async Exit(reversibleExit, subformDestination) {
+        let cmd = reversibleExit ?
+            CommandFactory.CreateBrowserEscEventCommand(this.getTaskTag(), subformDestination) :
+            CommandFactory.CreateNonReversibleExitCommand(this.getTaskTag(), subformDestination);
+        this._mgData.CmdsToServer.Add(cmd);
+        if (!subformDestination) {
+            try {
+                if (this.getTaskTag() == MGDataCollection.Instance.StartupMgData.getFirstTask().getTaskTag() ||
+                    !(MGDataCollection.Instance.StartupMgData.getFirstTask().InEndTask && MGDataCollection.Instance.StartupMgData.getFirstTask().ClosingFormUI))
+                    await Task.CommandsProcessor.Execute(CommandsProcessorBase_SendingInstruction.TASKS_AND_COMMANDS);
+            }
+            catch (err) {
+                if (this.isMainProg()) {
+                    this._mgData.CmdsToServer.Add(cmd);
+                }
+                else
+                    throw err;
+            }
+        }
+    }
+    handleFinallyEndTask(succeeded, reversibleExit) {
+        let subTask;
+        if (this.hasSubTasks()) {
+            for (let i = 0; i < this.SubTasks.getSize(); i++) {
+                subTask = this.SubTasks.getTask(i);
+                subTask.handleFinallyEndTask(succeeded, reversibleExit);
+            }
+        }
+        this.InEndTask = false;
+        if (succeeded)
+            this._isStarted = false;
+        if (!succeeded && reversibleExit && this.IsTryingToStop)
+            this.setTryingToStop(false);
+    }
+    async handleTaskSuffix(withSubTasks) {
+        let succeeded = true;
+        let subTask;
+        if (withSubTasks) {
+            if (this.hasSubTasks()) {
+                for (let i = 0; i < this.SubTasks.getSize() && succeeded; i++) {
+                    subTask = this.SubTasks.getTask(i);
+                    succeeded = await subTask.handleTaskSuffix(withSubTasks);
+                }
+            }
+        }
+        if (succeeded)
+            await AccessHelper.eventsManager.handleInternalEventWithTask(this, InternalInterface.MG_ACT_TASK_SUFFIX);
+        succeeded = !AccessHelper.eventsManager.GetStopExecutionFlag();
+        this.TaskSuffixExecuted = true;
+        return succeeded;
+    }
+    setInCreateLine(inCreateLine) {
+        this._inCreateLine = inCreateLine;
+    }
+    getInCreateLine() {
+        return this._inCreateLine;
+    }
+    async handleEventOnSlaveTasks(internalEvtCode) {
+        let i;
+        let task = null;
+        let failureTask = null;
+        let mgdTab = AccessHelper.mgDataTable;
+        let triggeredTasks = mgdTab.getTriggeredTasks(this);
+        let orphans = null;
+        let sameTrans;
+        let hasSlaves = false;
+        let isOwner = this.Transaction != null && this.Transaction.isOwner(this);
+        if (isOwner) {
+            AccessHelper.eventsManager.setEventScopeTrans();
+            orphans = new List();
+            mgdTab.startTasksIteration();
+            while ((task = mgdTab.getNextTask()) != null) {
+                sameTrans = task.Transaction != null && this.Transaction.getTransId() === task.Transaction.getTransId();
+                if (task !== this && sameTrans && task.PreviouslyActiveTaskId != null && mgdTab.GetTaskByID(task.PreviouslyActiveTaskId) == null)
+                    orphans.push(task);
+            }
+        }
+        let scopeTrans = AccessHelper.eventsManager.isEventScopeTrans();
+        for (i = 0; i < triggeredTasks.length && !AccessHelper.eventsManager.GetStopExecutionFlag(); i++) {
+            task = triggeredTasks.get_Item(i);
+            sameTrans = this.Transaction != null && task.Transaction != null && this.Transaction.getTransId() === task.Transaction.getTransId();
+            if (!task.IsSubForm && (scopeTrans && sameTrans) && task.isStarted()) {
+                if (task.getForm().FormRefreshed && internalEvtCode === InternalInterface.MG_ACT_REC_PREFIX && task.getLevel() === Constants.TASK_LEVEL_TASK)
+                    await task.DataView.currRecCompute(false);
+                await AccessHelper.eventsManager.handleInternalEventWithTask(task, internalEvtCode);
+                hasSlaves = true;
+            }
+        }
+        for (; isOwner && i < orphans.length && !AccessHelper.eventsManager.GetStopExecutionFlag(); i++) {
+            task = orphans.get_Item(i);
+            if (task.getForm().FormRefreshed && internalEvtCode === InternalInterface.MG_ACT_REC_PREFIX && task.getLevel() === Constants.TASK_LEVEL_TASK)
+                await task.DataView.currRecCompute(false);
+            await AccessHelper.eventsManager.handleInternalEventWithTask(task, internalEvtCode);
+            hasSlaves = true;
+        }
+        if (hasSlaves && AccessHelper.eventsManager.GetStopExecutionFlag())
+            failureTask = task;
+        if (isOwner)
+            AccessHelper.eventsManager.clearEventScope();
+        return failureTask;
+    }
+    async enableRecordActions() {
+        let dataview = this.DataView;
+        await this.setCreateDeleteActsEnableState();
+        if (dataview.IncludesFirst() || dataview.IsOneWayKey) {
+            if (dataview.isEmptyDataview() || dataview.getCurrRecIdx() === 0) {
+                this.ActionManager.enable(InternalInterface.MG_ACT_TBL_PRVLINE, false);
+                if (dataview.IsOneWayKey)
+                    this.ActionManager.enable(InternalInterface.MG_ACT_TBL_BEGTBL, true);
+                else
+                    this.ActionManager.enable(InternalInterface.MG_ACT_TBL_BEGTBL, false);
+                if (this.Form.isScreenMode())
+                    this.ActionManager.enable(InternalInterface.MG_ACT_TBL_PRVPAGE, false);
+            }
+            else {
+                this.ActionManager.enable(InternalInterface.MG_ACT_TBL_PRVLINE, true);
+                this.ActionManager.enable(InternalInterface.MG_ACT_TBL_BEGTBL, true);
+                if (this.Form.isScreenMode())
+                    this.ActionManager.enable(InternalInterface.MG_ACT_TBL_PRVPAGE, true);
+            }
+            if (!this.Form.isScreenMode())
+                if (dataview.isEmptyDataview() || (dataview.getCurrRecIdx() === 0) || (dataview.getTopRecIdx() === 0))
+                    this.ActionManager.enable(InternalInterface.MG_ACT_TBL_PRVPAGE, false);
+                else
+                    this.ActionManager.enable(InternalInterface.MG_ACT_TBL_PRVPAGE, true);
+        }
+        else {
+            this.ActionManager.enable(InternalInterface.MG_ACT_TBL_BEGTBL, true);
+            this.ActionManager.enable(InternalInterface.MG_ACT_TBL_PRVPAGE, true);
+            this.ActionManager.enable(InternalInterface.MG_ACT_TBL_PRVLINE, true);
+        }
+        if (dataview.IncludesLast()) {
+            if (((this.getMode() === Constants.TASK_MODE_QUERY) || dataview.isEmptyDataview() ||
+                ((this.getMode() === Constants.TASK_MODE_MODIFY) &&
+                    (!Environment.Instance.allowCreateInModifyMode(this.getCompIdx()) ||
+                        !await this.checkProp(PropInterface.PROP_TYPE_ALLOW_CREATE, true)))) && (dataview.getCurrRecIdx() + 1) === dataview.getSize()) {
+                this.ActionManager.enable(InternalInterface.MG_ACT_TBL_NXTLINE, false);
+                this.ActionManager.enable(InternalInterface.MG_ACT_TBL_ENDTBL, false);
+                if (this.Form.isScreenMode())
+                    this.ActionManager.enable(InternalInterface.MG_ACT_TBL_NXTPAGE, false);
+            }
+            else {
+                this.ActionManager.enable(InternalInterface.MG_ACT_TBL_NXTLINE, true);
+                this.ActionManager.enable(InternalInterface.MG_ACT_TBL_ENDTBL, true);
+                if (this.Form.isScreenMode())
+                    this.ActionManager.enable(InternalInterface.MG_ACT_TBL_NXTPAGE, true);
+            }
+            if (!this.Form.isScreenMode()) {
+                if (dataview.isEmptyDataview() || ((dataview.getSize() - dataview.getTopRecIdx()) <= this.Form.getRowsInPage()))
+                    this.ActionManager.enable(InternalInterface.MG_ACT_TBL_NXTPAGE, false);
+                else
+                    this.ActionManager.enable(InternalInterface.MG_ACT_TBL_NXTPAGE, true);
+            }
+        }
+        else {
+            this.ActionManager.enable(InternalInterface.MG_ACT_TBL_NXTLINE, true);
+            this.ActionManager.enable(InternalInterface.MG_ACT_TBL_NXTPAGE, true);
+            this.ActionManager.enable(InternalInterface.MG_ACT_TBL_ENDTBL, true);
+        }
+        if (dataview.isEmptyDataview())
+            this.ActionManager.enable(InternalInterface.MG_ACT_CANCEL, false);
+        else
+            this.ActionManager.enable(InternalInterface.MG_ACT_CANCEL, true);
+        this.ActionManager.enable(InternalInterface.MG_ACT_ENTER_ROW_EDITING, true);
+        this.ActionManager.enable(InternalInterface.MG_ACT_NO_PROG_EXE_RIGHTS, true);
+    }
+    isStarted() {
+        return this._isStarted;
+    }
+    getSubTasks() {
+        return this.SubTasks;
+    }
+    refreshesOn(fldId) {
+        let result = false;
+        for (let i = 0; !result && this.RefreshOnVars !== null && i < this.RefreshOnVars.length; i++) {
+            result = (this.RefreshOnVars[i] === fldId);
+        }
+        return result;
+    }
+    AbortTransaction() {
+        this.DataviewManager.RemoteDataviewManager.Transaction = null;
+    }
+    setPreventRecordSuffix(val) {
+        this._preventRecordSuffix = val;
+    }
+    getPreventRecordSuffix() {
+        return this._preventRecordSuffix;
+    }
+    setPreventControlChange(val) {
+        this._preventControlChange = val;
+    }
+    getPreventControlChange() {
+        return this._preventControlChange;
+    }
+    resetKnownToServer() {
+        this._knownToServer = false;
+    }
+    evaluateDescriptor() {
+        let result = "";
+        let res;
+        if (this.DvPosDescriptor == null)
+            return HashUtils.GetHashCode(result);
+        let first = true;
+        for (let i = 0; i < this.DvPosDescriptor.length; i++) {
+            if (!first)
+                result += ";";
+            let currentCell = this.DvPosDescriptor.get_Item(i);
+            let currentTag = currentCell[0];
+            let currentVeeIdx = NNumber.Parse(currentCell[1]);
+            let currentTask = AccessHelper.mgDataTable.GetTaskByID(currentTag);
+            let currentField = currentTask.DataView.getField(currentVeeIdx);
+            let dispVal = currentField.getDispValue();
+            if (currentField.isNull())
+                dispVal = "";
+            let pic;
+            switch (currentField.getType()) {
+                case StorageAttribute.BOOLEAN:
+                case StorageAttribute.ALPHA:
+                case StorageAttribute.UNICODE:
+                case StorageAttribute.BLOB:
+                case StorageAttribute.BLOB_VECTOR:
+                    result += dispVal;
+                    break;
+                case StorageAttribute.DATE:
+                case StorageAttribute.TIME:
+                    if (dispVal !== "") {
+                        pic = new PIC(currentField.getPicture(), currentField.getType(), 0);
+                        let conv = DisplayConvertor.Instance;
+                        result += conv.mg2disp(dispVal, "", pic, false, this.getCompIdx(), false);
+                    }
+                    break;
+                case StorageAttribute.NUMERIC:
+                    if (dispVal !== "") {
+                        res = new NUM_TYPE(dispVal);
+                        pic = new PIC(currentField.getPicture(), currentField.getType(), 0);
+                        result += res.to_a(pic);
+                    }
+                    break;
+            }
+            first = false;
+        }
+        let tmpStr2 = StrUtil.stringToHexaDump(result, 4);
+        return HashUtils.GetHashCode(tmpStr2);
+    }
+    setDescriptor(newDesc) {
+        if (!(newDesc.trim() === "")) {
+            let desc = StrUtil.tokenize(newDesc, ";");
+            this.DvPosDescriptor = new List();
+            for (let i = 0; i < desc.length; i = i + 1) {
+                let cell = new Array(2);
+                let tagVeePair = StrUtil.tokenize(desc[i], ",");
+                cell[0] = tagVeePair[0];
+                cell[1] = tagVeePair[1];
+                this.DvPosDescriptor.push(cell);
+            }
+        }
+    }
+    getTaskCache() {
+        return this._dvCache;
+    }
+    async prepareCache(ignoreCurr) {
+        let success = true;
+        if (!ignoreCurr) {
+            if (await this.isCached()) {
+                if (this.DataView.getChanged()) {
+                    this._dvCache.removeDvFromCache(this.DataView.getDvPosValue(), true);
+                    success = false;
+                }
+            }
+            else {
+                if (this.IsSubForm && !await this.isCached()) {
+                    success = false;
+                }
+            }
+        }
+        let curretTask;
+        if (this.hasSubTasks()) {
+            for (let i = 0; i < this.SubTasks.getSize(); i = i + 1) {
+                curretTask = this.SubTasks.getTask(i);
+                if (!await curretTask.prepareCache(false)) {
+                    success = false;
+                }
+            }
+        }
+        return success;
+    }
+    async testAndSet(ignoreCurr) {
+        if (!ignoreCurr && await this.isCached()) {
+            let requestedDv = this.evaluateDescriptor();
+            if (requestedDv !== this.DataView.getDvPosValue()) {
+                let fromCache = this._dvCache.getCachedDataView(requestedDv);
+                if (fromCache == null)
+                    return false;
+                await this.changeDv(fromCache);
+            }
+            this.DoSubformPrefixSuffix = true;
+        }
+        if (this.hasSubTasks()) {
+            for (let i = 0; i < this.SubTasks.getSize(); i++) {
+                if (!await this.SubTasks.getTask(i).testAndSet(false))
+                    return false;
+            }
+        }
+        return true;
+    }
+    async changeDv(fromCache) {
+        let dataview = this.DataView;
+        if (!this.hasLocate) {
+            if (!dataview.getChanged() && dataview.IncludesFirst())
+                this._dvCache.putInCache(dataview.replicate());
+        }
+        else
+            this.locatePutInCache();
+        await dataview.setSameAs(fromCache);
+        dataview.takeFldValsFromCurrRec();
+        this.Form.SetTableItemsCount(0, true);
+        this.Form.setTableItemsCount(false);
+        await this.Form.RefreshDisplay(Constants.TASK_REFRESH_FORM);
+        this.setOriginalTaskMode(this.getMode());
+    }
+    setOriginalTaskMode(originalTaskMode) {
+        this._originalTaskMode = originalTaskMode.charAt(0);
+    }
+    getOriginalTaskMode() {
+        return this._originalTaskMode;
+    }
+    async isCached() {
+        return this.IsSubForm && await this.Form.getSubFormCtrl().checkProp(PropInterface.PROP_TYPE_IS_CACHED, false);
+    }
+    locatePutInCache() {
+        let cached = this._dvCache.getCachedDataView(this.DataView.getDvPosValue());
+        if (cached != null) {
+            if (this.DataView.checkFirst(cached.getLocateFirstRec()) && !this.DataView.getChanged()) {
+                this.DataView.setLocateFirstRec(cached.getLocateFirstRec());
+                this._dvCache.putInCache(this.DataView.replicate());
+            }
+            else
+                this._dvCache.removeDvFromCache(this.DataView.getDvPosValue(), true);
+        }
+        else {
+            if (!this.DataView.getChanged())
+                this._dvCache.putInCache(this.DataView.replicate());
+        }
+    }
+    HasLoacte() {
+        return this.hasLocate;
+    }
+    setRemoteTransaction(transId) {
+        let mgdTab = AccessHelper.mgDataTable;
+        let transTask;
+        let isFind = false;
+        mgdTab.startTasksIteration();
+        while ((transTask = mgdTab.getNextTask()) != null) {
+            if (transTask.DataviewManager.RemoteDataviewManager.Transaction != null &&
+                transTask.DataviewManager.RemoteDataviewManager.Transaction.getTransId() === transId) {
+                isFind = true;
+                break;
+            }
+        }
+        this.DataviewManager.RemoteDataviewManager.Transaction = (isFind ?
+            transTask.DataviewManager.RemoteDataviewManager.Transaction :
+            new Transaction(this, transId));
+    }
+    setTransOwnerTask() {
+        this.Transaction.setOwnerTask(this);
+        this.Transaction.setTransBegin('T');
+    }
+    getLoopCounter() {
+        let result = 0;
+        if (this._useLoopStack && this._loopStack !== null && !(this._loopStack.count() === 0)) {
+            result = this._loopStack.peek();
+        }
+        return result;
+    }
+    enterLoop() {
+        if (this._loopStack === null)
+            this._loopStack = new Stack();
+        this._loopStack.push(0);
+    }
+    leaveLoop() {
+        this.popLoopCounter();
+    }
+    popLoopCounter() {
+        let result = 0;
+        if (this._loopStack !== null && !(this._loopStack.count() === 0))
+            result = this._loopStack.pop();
+        return result;
+    }
+    increaseLoopCounter() {
+        this._loopStack.push(this.popLoopCounter() + 1);
+    }
+    getLoopStackSize() {
+        if (this._loopStack !== null)
+            return this._loopStack.count();
+        return 0;
+    }
+    setUseLoopStack(val) {
+        this._useLoopStack = val;
+    }
+    getDataviewHeaders() {
+        return this.DataviewHeadersTable;
+    }
+    isFirstRecordCycle(Value_) {
+        if (arguments.length === 0) {
+            return this.isFirstRecordCycle_0();
+        }
+        return this.isFirstRecordCycle_1(Value_);
+    }
+    isFirstRecordCycle_0() {
+        return this._firstRecordCycle;
+    }
+    isFirstRecordCycle_1(Value_) {
+        this._firstRecordCycle = Value_;
+    }
+    getPublicName() {
+        return this.PublicName;
+    }
+    async isAllowEvents() {
+        let prop = this.getProp(PropInterface.PROP_TYPE_TASK_PROPERTIES_ALLOW_EVENTS);
+        return await prop.getValueBoolean();
+    }
+    getExternalTaskId() {
+        let taskId = "";
+        let prop = this.getProp(PropInterface.PROP_TYPE_TASK_ID);
+        if (prop != null)
+            taskId = prop.GetComputedValue();
+        return taskId;
+    }
+    isTransactionOwner() {
+        let isTransOwner = false;
+        if (this.Transaction != null && this.Transaction.isOwner(this))
+            isTransOwner = true;
+        return isTransOwner;
+    }
+    isTransactionOnLevel(level) {
+        return this.isTransactionOwner() && this.Transaction.getLevel() === level;
+    }
+    isProgram() {
+        return this._isPrg;
+    }
+    async enableModes() {
+        let enable = await this.checkProp(PropInterface.PROP_TYPE_ALLOW_MODIFY, true);
+        this.ActionManager.enable(InternalInterface.MG_ACT_RTO_MODIFY, enable);
+        enable = await this.checkProp(PropInterface.PROP_TYPE_ALLOW_CREATE, true);
+        this.ActionManager.enable(InternalInterface.MG_ACT_RTO_CREATE, enable);
+        enable = await this.checkProp(PropInterface.PROP_TYPE_ALLOW_QUERY, true);
+        this.ActionManager.enable(InternalInterface.MG_ACT_RTO_QUERY, enable);
+        enable = await this.checkProp(PropInterface.PROP_TYPE_ALLOW_RANGE, true);
+        this.ActionManager.enable(InternalInterface.MG_ACT_RTO_RANGE, enable);
+        enable = await this.checkProp(PropInterface.PROP_TYPE_ALLOW_LOCATE, true);
+        this.ActionManager.enable(InternalInterface.MG_ACT_RTO_LOCATE, enable);
+        this.ActionManager.enable(InternalInterface.MG_ACT_RTO_SEARCH, enable);
+        enable = await this.checkProp(PropInterface.PROP_TYPE_ALLOW_SORT, true);
+        this.ActionManager.enable(InternalInterface.MG_ACT_SORT_RECORDS, enable);
+        enable = await this.checkProp(PropInterface.PROP_TYPE_TASK_PROPERTIES_ALLOW_INDEX, true);
+        this.ActionManager.enable(InternalInterface.MG_ACT_VIEW_BY_KEY, enable);
+        this.ActionManager.enable(InternalInterface.MG_ACT_DUMP_ENVIRONMENT, true);
+    }
+    setEnableZoomHandler() {
+        this._enableZoomHandler = true;
+    }
+    getEnableZoomHandler() {
+        return this._enableZoomHandler;
+    }
+    isDestinationSubform() {
+        return this._destinationSubform;
+    }
+    setDestinationSubform(destinationSubform) {
+        this._destinationSubform = destinationSubform;
+    }
+    getIsDestinationCall() {
+        return this._isDestinationCall;
+    }
+    setIsDestinationCall(isDestinationCall) {
+        this._isDestinationCall = isDestinationCall;
+    }
+    setCancelWasRaised(val) {
+        this._cancelWasRaised = val;
+    }
+    cancelWasRaised() {
+        return this._cancelWasRaised;
+    }
+    enableCreateActs(val) {
+        this.ActionManager.enable(InternalInterface.MG_ACT_CRELINE, val);
+        this.ActionManager.enable(InternalInterface.MG_ACT_CRELINE_ABOVE, (this.getForm().HasTable()) ? val : false);
+    }
+    async setCreateDeleteActsEnableState() {
+        if (!(this.DataView).isEmptyDataview() && await this.checkProp(PropInterface.PROP_TYPE_ALLOW_DELETE, true) &&
+            this.getMode() === Constants.TASK_MODE_MODIFY && this.DataView.HasMainTable)
+            this.ActionManager.enable(InternalInterface.MG_ACT_DELLINE, true);
+        else
+            this.ActionManager.enable(InternalInterface.MG_ACT_DELLINE, false);
+        if ((await this.checkProp(PropInterface.PROP_TYPE_ALLOW_CREATE, true)) &&
+            (this.DataView.HasMainTable &&
+                (this.getMode() === Constants.TASK_MODE_MODIFY && Environment.Instance.allowCreateInModifyMode(this.getCompIdx())) ||
+                (this.getMode() === Constants.TASK_MODE_CREATE)))
+            this.enableCreateActs(true);
+        else
+            this.enableCreateActs(false);
+    }
+    setEmptyDataview(emptyDataview) {
+        this.DataView.setEmptyDataview(emptyDataview);
+    }
+    getName() {
+        return this.Name;
+    }
+    async emptyDataviewOpen(subformRefresh) {
+        if (this.getLevel() === Constants.TASK_LEVEL_TASK) {
+            this.ActionManager.enable(InternalInterface.MG_ACT_EMPTY_DATAVIEW, true);
+            if (this.IsSubForm) {
+                let rtEvnt = AccessHelper.eventsManager.getLastRtEvent();
+                if ((rtEvnt != null && rtEvnt.getInternalCode() == InternalInterface.MG_ACT_RT_REFRESH_VIEW) || subformRefresh) {
+                    let rtEvt = new RunTimeEvent(this);
+                    rtEvt.setInternal(InternalInterface.MG_ACT_EMPTY_DATAVIEW);
+                    rtEvt.SetEventSubType(EventSubType.Normal);
+                    await AccessHelper.eventsManager.handleEvent(rtEvt, false);
+                }
+            }
+            else
+                AccessHelper.eventsManager.addInternalEventWithItaskAndCode(this, InternalInterface.MG_ACT_EMPTY_DATAVIEW);
+            this.setLevel(Constants.TASK_LEVEL_RECORD);
+            if (this.SubformExecMode !== Task_SubformExecModeEnum.FIRST_TIME && subformRefresh && await this.CheckRefreshSubTasks()) {
+                await this.DataView.computeSubForms();
+                await this.doSubformRecPrefixSuffix();
+            }
+            await this.enableRecordActions();
+            this.ActionManager.enable(InternalInterface.MG_ACT_RT_REFRESH_RECORD, false);
+            this.ActionManager.enable(InternalInterface.MG_ACT_RT_REFRESH_SCREEN, false);
+        }
+    }
+    emptyDataviewClose() {
+        this.ActionManager.enable(InternalInterface.MG_ACT_EMPTY_DATAVIEW, false);
+        this.setLevel(Constants.TASK_LEVEL_TASK);
+        this.ActionManager.enable(InternalInterface.MG_ACT_RT_REFRESH_RECORD, true);
+        this.ActionManager.enable(InternalInterface.MG_ACT_RT_REFRESH_SCREEN, true);
+    }
+    async SubformRefresh(subformTask, explicitSubformRefresh) {
+        let currTask = LastFocusedManager.Instance.getLastFocusedTask();
+        let isInside = await subformTask.ExecuteNestedRS(currTask);
+        if (AccessHelper.eventsManager.GetStopExecutionFlag())
+            return;
+        if (subformTask.getLevel() !== Constants.TASK_LEVEL_TASK && !AccessHelper.eventsManager.GetStopExecutionFlag()) {
+            AccessHelper.eventsManager.pushNewExecStacks();
+            await AccessHelper.eventsManager.handleInternalEventWithTaskAndSubformRefresh(subformTask, InternalInterface.MG_ACT_REC_SUFFIX, true);
+            AccessHelper.eventsManager.popNewExecStacks();
+            isInside = true;
+            if (AccessHelper.eventsManager.GetStopExecutionFlag())
+                return;
+        }
+        let cmd = CommandFactory.CreateSubformRefreshCommand(this.getTaskTag(), subformTask.getTaskTag(), explicitSubformRefresh);
+        await subformTask.DataviewManager.Execute(cmd);
+        if (subformTask.isAborting())
+            return;
+        if (explicitSubformRefresh) {
+            AccessHelper.eventsManager.pushNewExecStacks();
+            let performParentRecordPrefixOrg = subformTask.PerformParentRecordPrefix;
+            subformTask.PerformParentRecordPrefix = false;
+            await AccessHelper.eventsManager.handleInternalEventWithTaskAndSubformRefresh(subformTask, InternalInterface.MG_ACT_REC_PREFIX, true);
+            subformTask.PerformParentRecordPrefix = performParentRecordPrefixOrg;
+            AccessHelper.eventsManager.popNewExecStacks();
+            if (AccessHelper.eventsManager.GetStopExecutionFlag())
+                return;
+        }
+        if (isInside) {
+        }
+        else {
+            if (!AccessHelper.eventsManager.GetStopExecutionFlag()) {
+                if (explicitSubformRefresh) {
+                    await AccessHelper.eventsManager.handleInternalEventWithTask(subformTask, InternalInterface.MG_ACT_REC_SUFFIX);
+                    if (currTask != null)
+                        currTask.DataView.setPrevCurrRec();
+                    subformTask.DoSubformPrefixSuffix = false;
+                }
+            }
+        }
+    }
+    async ExecuteNestedRS(lastTask) {
+        let isExecuteNestedRS = false;
+        if (lastTask == null)
+            return isExecuteNestedRS;
+        if (this.getLevel() !== Constants.TASK_LEVEL_TASK && lastTask.getMgdID() !== this.getMgdID())
+            return isExecuteNestedRS;
+        for (let task = lastTask; task !== this && task.pathContains(this) && task.getLevel() !== Constants.TASK_LEVEL_TASK; task = task.getParent()) {
+            AccessHelper.eventsManager.pushNewExecStacks();
+            await AccessHelper.eventsManager.handleInternalEventWithTask(task, InternalInterface.MG_ACT_REC_SUFFIX);
+            AccessHelper.eventsManager.popNewExecStacks();
+            isExecuteNestedRS = true;
+        }
+        return isExecuteNestedRS;
+    }
+    async execSubformRecSuffix(newTask) {
+        let subfTask;
+        let i, idx = 0;
+        for (i = this._taskPath.length; i > 0; i--) {
+            subfTask = this._taskPath.get_Item(i - 1);
+            if (!newTask._taskPath.Contains(subfTask)) {
+                await AccessHelper.eventsManager.handleInternalEventWithTask(subfTask, InternalInterface.MG_ACT_REC_SUFFIX);
+                if (AccessHelper.eventsManager.GetStopExecutionFlag())
+                    break;
+                if (subfTask.getMode() === Constants.TASK_MODE_CREATE && !(subfTask.DataView.getCurrRec()).isNewRec())
+                    subfTask.setMode(Constants.TASK_MODE_MODIFY);
+            }
+            else {
+                idx = newTask._taskPath.indexOf(subfTask);
+                break;
+            }
+        }
+        Debug.Assert(i > 0);
+        return idx;
+    }
+    getCounter() {
+        return this._counter;
+    }
+    increaseCounter() {
+        this._counter = this._counter + 1;
+    }
+    setCounter(cnt) {
+        this._counter = cnt;
+    }
+    isCurrentStartProgLevel() {
+        return this._currStartProgLevel === Task.StartProgLevel;
+    }
+    static isMainProgramField(fieldStr) {
+        let Field = XmlParser.getTokens(fieldStr, ',');
+        let mainProgField = false;
+        if (Field.length === 2) {
+            let parent = NNumber.Parse(Field.get_Item(0));
+            if (parent === TaskBase.MAIN_PRG_PARENT_ID)
+                mainProgField = true;
+        }
+        return mainProgField;
+    }
+    getTaskInfo() {
+        let taskName = (this.getProp(PropInterface.PROP_TYPE_NAME)).GetComputedValue();
+        return NString.Format('{0} {1}', this.isProgram() ? 'Program' : 'Subtask', taskName);
+    }
+    toString() {
+        return NString.Format("(task {0}-\"{1}\"{2})", this._taskTag, this.Name, super.isMainProg() ? (" ctl " + this._ctlIdx) : "");
+    }
+    ConstructMgForm(alreadySetParentForm) {
+        let form = new MgForm();
+        let parentForm = (this.ParentTask != null ? this.ParentTask.getForm() : null);
+        while (parentForm != null && !parentForm.getTask().isOpenWin()) {
+            parentForm = parentForm.ParentForm;
+        }
+        form.ParentForm = parentForm;
+        alreadySetParentForm.value = true;
+        return form;
+    }
+    getMgdID() {
+        return this._mgData.GetId();
+    }
+    getMGData() {
+        return this._mgData;
+    }
+    async RefreshDisplay() {
+        if (this.Form !== null && !this.isAborting() && this.isStarted()) {
+            Logger.Instance.WriteDevToLog("Start task.RefreshDisplay()");
+            if (this._refreshType !== Constants.TASK_REFRESH_NONE) {
+                let form = this.Form;
+                let wasRefreshed = await form.RefreshDisplay(Constants.TASK_REFRESH_FORM);
+                if (wasRefreshed) {
+                    this._refreshType = Constants.TASK_REFRESH_NONE;
+                }
+            }
+            Logger.Instance.WriteDevToLog("End task.RefreshDisplay()");
+        }
+    }
+    getFieldDisplayValue(fieldDef, value, isNull) {
+        value.value = fieldDef.getDispValue();
+        isNull.value = fieldDef.isNull();
+    }
+    async UpdateFieldValueAndStartRecompute(fieldDef, value, isNull) {
+        if (this.TaskPrefixExecuted) {
+            await fieldDef.setValueAndStartRecompute(value, isNull, true, false, false);
+        }
+    }
+    ShouldNonInteractiveChildBeModal() {
+        return this.ShouldChildBeModal();
+    }
+    ShouldChildBeModal() {
+        let childShouldBehaveAsModal = false;
+        if ((this.Form.ConcreteWindowType === WindowType.Overlay) && this.getForm().Opened)
+            childShouldBehaveAsModal = true;
+        else if (!this.IsInteractive) {
+            childShouldBehaveAsModal = true;
+        }
+        return childShouldBehaveAsModal;
+    }
+    getParent() {
+        return this._parentTask;
+    }
+    isDescendentOf(chkTask) {
+        if (chkTask === this)
+            return true;
+        else if (chkTask === null || this._parentTask === null)
+            return false;
+        return this._parentTask.isDescendentOf(chkTask);
+    }
+    GetSubformModalParentTask() {
+        let currTask = this;
+        while (currTask._parentTask != null && currTask._parentTask.getIsDestinationCall()) {
+            let subformCtrl = (currTask._parentTask.getForm().getSubFormCtrl());
+            if (subformCtrl.IsModal()) {
+                return subformCtrl;
+            }
+            currTask = currTask._parentTask;
+        }
+        return null;
+    }
+    ShouldEvaluatePropertyLocally(propId) {
+        return this.TaskService.ShouldEvaluatePropertyLocally(propId);
+    }
+    EnsureValidForm() {
+        if (this._isMainPrg && this.Form !== null) {
+            if (!this._openWin || !this.Form.isLegalForm) {
+                this.Form = null;
+            }
+        }
+    }
+    async ComputeMainDisplay() {
+        let propMainDisplay = this.getProp(PropInterface.PROP_TYPE_MAIN_DISPLAY);
+        let mainDisplayIndex = await propMainDisplay.getValueInt();
+        mainDisplayIndex = this.GetRealMainDisplayIndexOnCurrentTask(mainDisplayIndex);
+        this._forms.InitFormFromXmlString(mainDisplayIndex);
+        this.EnsureValidForm();
+    }
+    async PrepareTaskForm() {
+        await TaskServiceBase.PreparePropOpenTaskWindow(this);
+        return await RemoteTaskService.PreparePropMainDisplay(this);
+    }
+    FormIsLegal() {
+        let isFormIsLegal = super.isMainProg();
+        return isFormIsLegal || super.getForm().isLegalForm;
+    }
+    GetRealMainDisplayIndexOnDepth(mainDspIdx) {
+        let task = this.LogicalStudioParentTask;
+        while (task != null) {
+            mainDspIdx += task._forms.Count;
+            task = task.LogicalStudioParentTask;
+        }
+        return mainDspIdx;
+    }
+    GetRealMainDisplayIndexOnCurrentTask(mainDspIdx) {
+        if (mainDspIdx > 1) {
+            let task = this.LogicalStudioParentTask;
+            while (task != null) {
+                mainDspIdx -= task._forms.Count;
+                task = task.LogicalStudioParentTask;
+            }
+        }
+        return mainDspIdx;
+    }
+    GetAncestorTaskByTaskDefinitionId(findTaskDefinitionId) {
+        let currentTask = this;
+        if (findTaskDefinitionId.IsMainProgram())
+            return GuiDataCollection.MGDataTable.GetMainProgByCtlIdx(this.ContextID, findTaskDefinitionId.CtlIndex);
+        while (currentTask != null) {
+            if (currentTask.TaskDefinitionId.Equals(findTaskDefinitionId))
+                return currentTask;
+            currentTask = currentTask._parentTask;
+        }
+        return null;
+    }
+    SetDataControlValuesReference(controlId, dcValuesId) {
+        let ctrl = super.getForm().getCtrl(controlId);
+        ctrl.setDcValId(dcValuesId);
+    }
+    DisplayMessageToStatusBar(text) {
+        let taskToVerifyOn = this.GetContextTask();
+        if (taskToVerifyOn.getForm() == null)
+            taskToVerifyOn = LastFocusedManager.Instance.getLastFocusedTask();
+        taskToVerifyOn.WriteToMessagePane(text);
+    }
+    isTableWithAbsolutesScrollbar() {
+        let isTableWithAbsolutesScrollbar = false;
+        if (this.getForm() != null)
+            isTableWithAbsolutesScrollbar = this.getForm().isTableWithAbsoluteScrollbar();
+        return isTableWithAbsolutesScrollbar;
+    }
+    GetTaskDetails() {
+        let names = (this.getProp(PropInterface.PROP_TYPE_NAME)).GetComputedValue();
+        let task = this;
+        while (task.ParentTask !== null && !task.ParentTask.isMainProg()) {
+            task = task.ParentTask;
+            names = (task.getProp(PropInterface.PROP_TYPE_NAME)).GetComputedValue() + "." + names;
+        }
+        return names;
+    }
+    static async ProcessTaskURL() {
+        let xmlData = RuntimeContextBase.Instance.Parser.getXMLdata();
+        let endTaskUrlIdx = xmlData.indexOf(XMLConstants.TAG_CLOSE, RuntimeContextBase.Instance.Parser.getCurrIndex());
+        Debug.Assert(endTaskUrlIdx !== -1 && endTaskUrlIdx < xmlData.length);
+        let tag = RuntimeContextBase.Instance.Parser.getXMLsubstring(endTaskUrlIdx);
+        RuntimeContextBase.Instance.Parser.add2CurrIndex(tag.indexOf(ConstInterface.MG_TAG_TASKURL) + ConstInterface.MG_TAG_TASKURL.length);
+        let tokensVector = XmlParser.getTokens(RuntimeContextBase.Instance.Parser.getXMLsubstring(endTaskUrlIdx), XMLConstants.XML_ATTR_DELIM);
+        let taskCacheURL = tokensVector.get_Item(1);
+        let refListStr = tokensVector.get_Item(3);
+        let taskContentOriginal = "";
+        if (taskCacheURL.trim() != "") {
+            if (taskCacheURL.startsWith("./"))
+                taskCacheURL = NString.Replace(taskCacheURL, './', ClientManager.GetAssetsURL() + '/cache/');
+            taskContentOriginal = await Task.CommandsProcessor.GetContent(taskCacheURL, true);
+        }
+        let taskContentFinal = new StringBuilder(xmlData.substr(0, RuntimeContextBase.Instance.Parser.getCurrIndex() - (ConstInterface.MG_TAG_TASKURL.length + 1)), taskContentOriginal.length);
+        let reflist = this.getReflist(refListStr, ';', true, -1);
+        let refListIdx = 0;
+        let currIdx = taskContentOriginal.indexOf("[:");
+        let prevIdx = 0;
+        while (currIdx !== -1) {
+            taskContentFinal.Append(taskContentOriginal.substr(prevIdx, currIdx - prevIdx));
+            taskContentFinal.Append(reflist.get_Item(refListIdx++));
+            currIdx += 2;
+            prevIdx = currIdx;
+            currIdx = taskContentOriginal.indexOf("[:", prevIdx);
+        }
+        taskContentFinal.Append(taskContentOriginal.substr(prevIdx));
+        taskContentFinal.Append(xmlData.substr(xmlData.indexOf(XMLConstants.TAG_CLOSE, endTaskUrlIdx + 1) + 1));
+        xmlData = taskContentFinal.ToString();
+        Logger.Instance.WriteDevToLog(NString.Format("{0} -------> {1}", taskCacheURL, xmlData));
+        RuntimeContextBase.Instance.Parser.setXMLdata(xmlData);
+        RuntimeContextBase.Instance.Parser.setCurrIndex(RuntimeContextBase.Instance.Parser.getCurrIndex() - (ConstInterface.MG_TAG_TASKURL.length + 1));
+    }
+    static getReflist(data, delim, trunc, maxTokens) {
+        let currStr = new StringBuilder();
+        let list = new List();
+        let tokensCnt = 0;
+        for (let i = 1; i < data.length; i++) {
+            let curr = data.charAt(i);
+            if (curr !== '\\' && curr !== delim)
+                currStr.Append(curr);
+            else if (curr === delim) {
+                list.push(currStr.ToString());
+                currStr = new StringBuilder();
+                tokensCnt++;
+                if (tokensCnt === maxTokens)
+                    break;
+            }
+            else if (curr === '\\') {
+                if (!trunc && data.charAt(i + 1) !== delim)
+                    currStr.Append(data.charAt(i));
+                i++;
+                currStr.Append(data.charAt(i));
+            }
+        }
+        list.push(currStr.ToString());
+        return list;
+    }
+    static async StartProgram(callByDestSubForm, moveToFirstControl) {
+        let orgStopExecution = AccessHelper.eventsManager.GetStopExecutionFlag();
+        let nonInteractiveTaskAlreadyExecuted = null;
+        let allowEvents = AccessHelper.eventsManager.getAllowEvents();
+        AccessHelper.eventsManager.setAllowEvents(EventsAllowedType.ALL);
+        Logger.Instance.WriteDevToLog("Start \"startProg\"");
+        Task.StartProgLevel++;
+        AccessHelper.eventsManager.setStopExecution(false);
+        nonInteractiveTaskAlreadyExecuted = await this.ExecuteComponentMainPrograms(callByDestSubForm, moveToFirstControl);
+        let nonInteractiveTaskAlreadyExecutedRef = new RefParam(nonInteractiveTaskAlreadyExecuted);
+        let currentNonInteractiveTaskRef = new RefParam(null);
+        await Task.ExecuteMainProgram(0, callByDestSubForm, moveToFirstControl, nonInteractiveTaskAlreadyExecutedRef, currentNonInteractiveTaskRef, AccessHelper.mgDataTable);
+        nonInteractiveTaskAlreadyExecuted = nonInteractiveTaskAlreadyExecutedRef.value;
+        if (!Task._idleTimerStarted) {
+            GUIManager.Instance.startTimer(AccessHelper.mgDataTable.getMGData(0), Environment.Instance.getIdleTime(0), true);
+            Task._idleTimerStarted = true;
+        }
+        await this.OpenForms(callByDestSubForm);
+        await this.DoFirstRecordCycle();
+        await this.MoveToFirstControls(callByDestSubForm);
+        if (Task.StartProgLevel === 1) {
+            let resetAllowEvents = false;
+            let canExecuteEvents = true;
+            if (nonInteractiveTaskAlreadyExecuted !== null && nonInteractiveTaskAlreadyExecuted.isStarted()) {
+                resetAllowEvents = true;
+                AccessHelper.eventsManager.setNonInteractiveAllowEvents(await nonInteractiveTaskAlreadyExecuted.isAllowEvents());
+                canExecuteEvents = await nonInteractiveTaskAlreadyExecuted.isAllowEvents();
+            }
+            if (LastFocusedManager.Instance.getLastFocusedTask() !== null && canExecuteEvents) {
+                AccessHelper.eventsManager.pushNewExecStacks();
+                await AccessHelper.eventsManager.handleEvents(AccessHelper.mgDataTable.getCurrMGData(), 0);
+                AccessHelper.eventsManager.popNewExecStacks();
+            }
+            if (resetAllowEvents)
+                AccessHelper.eventsManager.setAllowEvents(allowEvents);
+        }
+        Task.StartProgLevel--;
+        Logger.Instance.WriteDevToLog("End \"startProg\"");
+        if (orgStopExecution && !AccessHelper.eventsManager.GetStopExecutionFlag())
+            if (orgStopExecution && !AccessHelper.eventsManager.GetStopExecutionFlag())
+                AccessHelper.eventsManager.setStopExecution(orgStopExecution);
+        return nonInteractiveTaskAlreadyExecuted;
+    }
+    static async ExecuteComponentMainPrograms(callByDestSubForm, moveToFirstControl) {
+        let currentNonInteractiveTask = new RefParam(null);
+        let nonInteractiveTaskAlreadyExecuted = new RefParam(null);
+        let maxCtlIdx = AccessHelper.mgDataTable.getMGData(0).getMaxCtlIdx();
+        for (let i = 1; i <= maxCtlIdx; i = i + 1) {
+            let componentMainProgram = AccessHelper.mgDataTable.GetMainProgByCtlIdx(-1, i);
+            if (componentMainProgram !== null)
+                await Task.ExecuteMainProgram(i, callByDestSubForm, moveToFirstControl, currentNonInteractiveTask, nonInteractiveTaskAlreadyExecuted, AccessHelper.mgDataTable);
+        }
+        return nonInteractiveTaskAlreadyExecuted.value;
+    }
+    static async ExecuteMainProgram(CtlIndex, callByDestSubForm, moveToFirstControl, currentNonInteractiveTask, nonInteractiveTaskAlreadyExecuted, mgDataTable) {
+        let mainProgramTask = mgDataTable.GetMainProgByCtlIdx(-1, CtlIndex);
+        Logger.Instance.WriteDevToLog(NString.Format("  ClientManager.startProg: ctlIdx={0}, task={1}", CtlIndex, mainProgramTask));
+        currentNonInteractiveTask.value = (await mainProgramTask.Start(moveToFirstControl, callByDestSubForm));
+        if (nonInteractiveTaskAlreadyExecuted.value === null)
+            nonInteractiveTaskAlreadyExecuted.value = currentNonInteractiveTask.value;
+        else if (currentNonInteractiveTask.value !== null) {
+            Debug.Assert(false, "more than 1 non interactive tasks in startProg");
+        }
+    }
+    static async OpenForms(callByDestSubForm) {
+        let createdForms = MgForm.CreatedForms;
+        if (createdForms.Count() > 0) {
+            let i = 0;
+            while (i < createdForms.Count()) {
+                let mgForm = createdForms.get(i);
+                let canOpen = false;
+                if (mgForm.isSubForm()) {
+                    let opened = mgForm.getSubFormCtrl().getForm().Opened;
+                    if (opened) {
+                        canOpen = true;
+                    }
+                }
+                else {
+                    if (mgForm.getTask().isCurrentStartProgLevel()) {
+                        canOpen = true;
+                    }
+                }
+                if (canOpen) {
+                    Manager.OpenForm(mgForm);
+                    await Manager.DoFirstRefreshTable(mgForm);
+                }
+                if (mgForm.Opened) {
+                    createdForms.remove(mgForm);
+                }
+                else
+                    i++;
+            }
+        }
+    }
+    static async DoFirstRecordCycle() {
+        for (let i = 0; i < AccessHelper.mgDataTable.getSize(); i++) {
+            let mgd = AccessHelper.mgDataTable.getMGData(i);
+            if (mgd === null || mgd.IsAborting)
+                continue;
+            for (let j = 0; j < mgd.getTasksCount(); j++) {
+                let task = mgd.getTask(j);
+                if (task !== null) {
+                    let mgForm = task.getForm();
+                    if (mgForm !== null && task.isCurrentStartProgLevel() && !mgForm.IgnoreFirstRecordCycle) {
+                        mgForm.IgnoreFirstRecordCycle = true;
+                        await task.doFirstRecordCycle();
+                    }
+                }
+            }
+        }
+    }
+    static async MoveToFirstControls(callByDestSubForm) {
+        for (let i = 0; i < AccessHelper.mgDataTable.getSize(); i++) {
+            let mgd = AccessHelper.mgDataTable.getMGData(i);
+            if (mgd === null || mgd.IsAborting)
+                continue;
+            let tasksCount = mgd.getTasksCount();
+            for (let j = 0; j < tasksCount; j++) {
+                let task = mgd.getTask(j);
+                let mgForm = task.getForm();
+                if (task.isCurrentStartProgLevel() && mgForm !== null && mgForm.MovedToFirstControl) {
+                    mgForm.MovedToFirstControl = false;
+                    AccessHelper.eventsManager.pushNewExecStacks();
+                    await mgForm.moveToFirstParkabelControl(callByDestSubForm);
+                    AccessHelper.eventsManager.popNewExecStacks();
+                }
+            }
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"Task.js","sourceRoot":"","sources":["../../../../../../projects/engine/src/tasks/Task.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,KAAK,EAAE,SAAS,EAAE,IAAI,EAAE,OAAO,EAAE,OAAO,EAAE,QAAQ,EAAE,KAAK,EAAE,aAAa,EAAE,iBAAiB,EAAC,MAAM,sBAAsB,CAAC;AACjI,OAAO,EACL,SAAS,EACT,iBAAiB,EACjB,MAAM,EACN,gBAAgB,EAChB,gBAAgB,EAChB,OAAO,EAEP,UAAU,EACV,YAAY,EACZ,SAAS,EACV,MAAM,kBAAkB,CAAC;AAC1B,OAAO,EACL,QAAQ,EACR,qBAAqB,EACrB,gBAAgB,EAChB,MAAM,EAEN,iBAAiB,EACjB,KAAK,EAEL,OAAO,EAGP,QAAQ,EACR,GAAG,EAEH,aAAa,EACb,WAAW,EACX,kBAAkB,EAClB,MAAM,EACN,gBAAgB,EACjB,MAAM,gBAAgB,CAAC;AAExB,OAAO,EAAC,QAAQ,EAAC,MAAM,kBAAkB,CAAC;AAC1C,OAAO,EAAC,OAAO,EAAC,MAAM,iBAAiB,CAAC;AAExC,OAAO,EAAC,mBAAmB,EAAC,MAAM,4CAA4C,CAAC;AAC/E,OAAO,EAAwB,wCAAwC,EAAC,MAAM,0BAA0B,CAAC;AACzG,OAAO,EAAC,eAAe,EAAC,MAAM,mBAAmB,CAAC;AAElD,OAAO,EAAC,sBAAsB,EAAC,MAAM,gCAAgC,CAAC;AACtE,OAAO,EAAC,eAAe,EAAC,MAAM,yBAAyB,CAAC;AACxD,OAAO,EAAC,cAAc,EAAC,MAAM,uBAAuB,CAAC;AAErD,OAAO,EAAC,MAAM,EAAC,MAAM,eAAe,CAAC;AAErC,OAAO,EAAC,iBAAiB,EAAC,MAAM,qBAAqB,CAAC;AACtD,OAAO,EAAC,YAAY,EAAC,MAAM,sBAAsB,CAAC;AAClD,OAAO,EAAC,YAAY,EAAC,MAAM,uBAAuB,CAAC;AAEnD,OAAO,EAAC,cAAc,EAAC,MAAM,2CAA2C,CAAC;AACzE,OAAO,EAAC,eAAe,EAAC,MAAM,uBAAuB,CAAC;AACtD,OAAO,EAAC,WAAW,EAAC,MAAM,mBAAmB,CAAC;AAC9C,OAAO,EAAC,UAAU,EAAC,MAAM,cAAc,CAAC;AAExC,OAAO,EAAC,aAAa,EAAC,MAAM,qBAAqB,CAAC;AAClD,OAAO,EAAC,cAAc,EAAC,MAAM,sBAAsB,CAAC;AACpD,OAAO,EAAC,QAAQ,EAAC,MAAM,iBAAiB,CAAC;AACzC,OAAO,EAAC,eAAe,EAAC,MAAM,0BAA0B,CAAC;AACzD,OAAO,EAAC,UAAU,EAAC,MAAM,mBAAmB,CAAC;AAC7C,OAAO,EAAC,gBAAgB,EAAC,MAAM,0BAA0B,CAAC;AAE1D,OAAO,EAAC,aAAa,EAAC,MAAM,wBAAwB,CAAC;AACrD,OAAO,EAAC,cAAc,EAAC,MAAM,mBAAmB,CAAC;AAIjD,OAAO,EAAC,UAAU,EAAC,MAAM,eAAe,CAAC;AACzC,OAAO,EAAC,wBAAwB,EAAC,MAAM,6BAA6B,CAAC;AAErE,OAAO,EAAC,YAAY,EAAC,MAAM,UAAU,CAAC;AACtC,OAAO,EAAC,kBAAkB,EAAE,wBAAwB,EAAE,QAAQ,EAAY,MAAM,YAAY,CAAC;AAC7F,OAAO,EAAC,YAAY,EAAC,MAAM,qBAAqB,CAAC;AACjD,OAAO,EAAC,WAAW,EAAC,MAAM,oBAAoB,CAAC;AAC/C,OAAO,EAAC,kBAAkB,EAAC,MAAM,0BAA0B,CAAC;AAC5D,OAAO,EAAC,qBAAqB,EAAC,MAAM,0BAA0B,CAAC;AAC/D,OAAO,EAAC,iBAAiB,EAAC,MAAM,yBAAyB,CAAC;AAE1D,OAAO,EAAC,YAAY,EAAC,MAAM,iBAAiB,CAAC;AAE7C,OAAO,EAAC,gBAAgB,EAAC,MAAM,oBAAoB,CAAC;AACpD,OAAO,EAAC,uBAAuB,EAAC,MAAM,mCAAmC,CAAC;AAC1E,OAAO,EAAC,oBAAoB,EAAC,MAAM,+BAA+B,CAAC;AACnE,OAAO,EAAC,aAAa,EAAC,MAAM,kBAAkB,CAAC;AAE/C,MAAM,CAAN,IAAY,SAIX;AAJD,WAAY,SAAS;IACnB,yCAAI,CAAA;IACJ,yCAAI,CAAA;IACJ,yCAAI,CAAA;AACN,CAAC,EAJW,SAAS,KAAT,SAAS,QAIpB;AAED,MAAM,CAAN,IAAY,cAIX;AAJD,WAAY,cAAc;IACxB,oDAAS,CAAA;IACT,mDAAI,CAAA;IACJ,mDAAI,CAAA;AACN,CAAC,EAJW,cAAc,KAAd,cAAc,QAIzB;AAGD,MAAM,OAAO,IAAK,SAAQ,QAAQ;IACxB,QAAQ,GAAY,IAAI,CAAC;IACzB,OAAO,GAAW,IAAI,CAAC;IACvB,SAAS,GAAY,KAAK,CAAC;IAC3B,aAAa,GAAY,KAAK,CAAC;IAC/B,UAAU,GAAY,KAAK,CAAC;IAC5B,cAAc,GAAY,KAAK,CAAC;IAChC,eAAe,GAAY,KAAK,CAAC;IACjC,gBAAgB,GAAY,KAAK,CAAC;IAClC,QAAQ,GAAW,CAAC,CAAC;IACrB,mBAAmB,GAAW,CAAC,CAAC;IAChC,mBAAmB,GAAY,KAAK,CAAC;IACrC,kBAAkB,GAAY,KAAK,CAAC;IACpC,iBAAiB,GAAY,KAAK,CAAC;IACnC,iBAAiB,GAAW,GAAG,CAAC;IAChC,aAAa,GAAY,KAAK,CAAC;IAChC,QAAQ,GAAY,KAAK,CAAC;IAC1B,cAAc,GAAY,KAAK,CAAC;IAC/B,kBAAkB,GAAY,KAAK,CAAC;IACpC,cAAc,GAAY,IAAI,CAAC;IAC/B,UAAU,GAAkB,IAAI,CAAC;IACjC,uBAAuB,CAAU;IAClC,qBAAqB,GAAY,KAAK,CAAC;IAMtC,WAAW,GAAS,IAAI,CAAC;IAEjC,IAAW,UAAU;QACnB,OAAO,IAAI,CAAC,WAAW,CAAC;IAC1B,CAAC;IAEM,WAAW,GAAS,IAAI,CAAC;IAKxB,eAAe,GAAS,IAAI,CAAC;IAK9B,cAAc,GAAS,IAAI,CAAC;IAE3B,qBAAqB,GAAY,KAAK,CAAC;IACvC,oBAAoB,GAAY,KAAK,CAAC;IACtC,SAAS,GAAe,IAAI,CAAC;IAG7B,eAAe,GAAY,KAAK,CAAC;IAEzC,IAAI,cAAc,CAAC,KAAc;QAC/B,IAAI,CAAC,eAAe,GAAG,KAAK,CAAC;IAC/B,CAAC;IAED,IAAI,cAAc;QAChB,OAAO,IAAI,CAAC,eAAe,CAAC;IAC9B,CAAC;IAEO,aAAa,GAAY,KAAK,CAAC;IAC/B,gCAAgC,GAAY,KAAK,CAAC;IAEnD,iBAAiB,GAAY,KAAK,CAAC;IACnC,YAAY,GAAmB,IAAI,CAAC;IACpC,QAAQ,GAAW,CAAC,CAAC;IACrB,eAAe,GAAW,IAAI,CAAC;IAC/B,yBAAyB,GAAY,KAAK,CAAC;IAY3C,YAAY,GAAY,KAAK,CAAC;IAC9B,sBAAsB,GAA2B,IAAI,CAAC;IAOtD,2BAA2B,GAAY,KAAK,CAAC;IAO7C,uBAAuB,GAAY,KAAK,CAAC;IAKxC,YAAY,GAAoB,IAAI,CAAC;IAE7C,IAAI,WAAW;QACb,IAAI,IAAI,CAAC,YAAY,IAAI,IAAI;YAC3B,IAAI,CAAC,YAAY,GAAG,IAAI,iBAAiB,EAAE,CAAC;QAE9C,OAAO,IAAI,CAAC,YAAY,CAAC;IAC3B,CAAC;IAKD,MAAM,KAAK,iBAAiB;QAC1B,OAAO,wBAAwB,CAAC,oBAAoB,EAAE,CAAC;IACzD,CAAC;IAEO,SAAS,GAAY,KAAK,CAAC;IAC3B,gBAAgB,GAAqB,IAAI,CAAC;IAC3C,aAAa,GAAkB,IAAI,CAAC;IAK3C,IAAI,uBAAuB;QACzB,IAAI,IAAI,CAAC,gBAAgB,KAAK,IAAI,IAAI,CAAC,KAAK,CAAC,UAAU,EAAE,EAAE;YACzD,OAAa,iBAAiB,CAAC,WAAW,CAAC,mBAAmB,CAAC,IAAI,CAAC,SAAS,EAAE,IAAI,CAAC,OAAO,CAAC,CAAC;SAC9F;QAED,OAAa,IAAI,CAAC,gBAAgB,CAAC;IACrC,CAAC;IAED,IAAI,aAAa;QACf,OAAO,IAAI,CAAC,cAAc,CAAC;IAC7B,CAAC;IAEM,eAAe,GAAY,KAAK,CAAC;IACjC,UAAU,GAAY,KAAK,CAAC;IAC5B,UAAU,GAAkB,IAAI,CAAC;IAMxC,IAAI,WAAW,CAAC,KAAkB;QAChC,IAAI,CAAC,eAAe,CAAC,sBAAsB,CAAC,WAAW,GAAG,KAAK,CAAC;IAClE,CAAC;IAED,IAAI,WAAW;QACb,OAAO,IAAI,CAAC,eAAe,CAAC,sBAAsB,CAAC,WAAW,CAAC;IACjE,CAAC;IAEM,aAAa,GAAa,IAAI,CAAC;IAC/B,eAAe,GAAmB,IAAI,CAAC;IACvC,QAAQ,GAAe,IAAI,CAAC;IAC5B,MAAM,GAAa,IAAI,CAAC;IACxB,UAAU,GAAoB,IAAI,CAAC;IACnC,oBAAoB,GAAoB,IAAI,CAAC;IAC7C,WAAW,GAAkB,IAAI,CAAC;IAClC,MAAM,GAAe,IAAI,CAAC;IAC1B,IAAI,GAAW,IAAI,CAAC;IACpB,UAAU,GAAW,IAAI,CAAC;IAK1B,kBAAkB,GAAY,KAAK,CAAC;IAE3C,IAAI,gBAAgB;QAClB,IAAI,IAAI,CAAC,gBAAgB,KAAK,IAAI,EAAE;YAClC,IAAI,CAAC,gBAAgB,GAAG,IAAI,gBAAgB,CAAC,IAAI,CAAC,OAAO,EAAE,IAAI,CAAC,UAAU,EAAE,IAAI,CAAC,OAAO,EAAE,IAAI,CAAC,MAAM,CAAC,CAAC;SACxG;QACD,OAAO,IAAI,CAAC,gBAAgB,CAAC;IAC/B,CAAC;IAEM,cAAc,GAAW,CAAC,CAAC;IAC3B,cAAc,GAAc,IAAI,CAAC;IAExC,MAAM,CAAC,cAAc,GAAW,CAAC,CAAC;IAE1B,MAAM,CAAC,iBAAiB,GAAY,KAAK,CAAC;IAElD,MAAM,KAAK,eAAe;QACxB,OAAO,KAAK,CAAC;IACf,CAAC;IAQD,YAAY,MAAa;QACvB,KAAK,EAAE,CAAC;QAER,IAAI,iBAAiB,CAAC,MAAM,CAAC,EAAE;YAC7B,IAAI,CAAC,aAAa,EAAE,CAAC;YACrB,OAAO;SACR;QACD,IAAI,CAAC,aAAa,CAAC,MAAM,CAAC,CAAC;IAC7B,CAAC;IAEO,aAAa;QACnB,IAAI,CAAC,aAAa,GAAG,IAAI,aAAa,EAAE,CAAC;QACzC,IAAI,CAAC,QAAQ,GAAG,IAAI,QAAQ,CAAC,IAAI,CAAC,CAAC;QACnC,IAAI,CAAC,YAAY,GAAG,gBAAgB,CAAC,QAAQ,CAAC;QAC9C,IAAI,CAAC,WAAW,GAAG,IAAI,CAAC;QACxB,IAAI,CAAC,QAAQ,GAAG,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;QAClC,IAAI,CAAC,yBAAyB,GAAG,IAAI,CAAC;QACtC,IAAI,CAAC,eAAe,GAAG,IAAI,eAAe,CAAC,IAAI,CAAC,CAAC;QACjD,IAAI,CAAC,uBAAuB,GAAG,IAAI,CAAC;QACpC,IAAI,CAAC,sBAAsB,GAAG,IAAI,sBAAsB,CAAC,IAAI,CAAC,CAAC;IACjE,CAAC;IAEM,IAAI;QACT,IAAI,CAAC,QAAQ,CAAC,IAAI,EAAE,CAAC;IACvB,CAAC;IAEO,aAAa,CAAC,MAAY;QAChC,IAAI,CAAC,aAAa,EAAE,CAAC;QACrB,IAAI,CAAC,cAAc,GAAG,MAAM,CAAC;QAC7B,IAAI,CAAC,WAAW,GAAG,MAAM,CAAC;QAC1B,IAAI,CAAC,eAAe,GAAG,IAAI,CAAC;QAC5B,IAAI,CAAC,aAAa,EAAE,CAAC;IACvB,CAAC;IAED,MAAM,CAAC,UAAU;QACf,IAAI,IAAI,GAAI,IAAI,IAAI,EAAE,CAAC;QACvB,IAAI,CAAC,IAAI,EAAE,CAAC;QACZ,OAAO,IAAI,CAAC;IACd,CAAC;IAMD,UAAU;QACR,OAAO,IAAI,CAAC,SAAS,CAAC;IACxB,CAAC;IAEO,aAAa;QACnB,IAAI,CAAC,SAAS,GAAG,IAAI,IAAI,EAAQ,CAAC;QAClC,IAAI,IAAI,CAAC,WAAW,CAAC,SAAS,KAAK,IAAI;YACrC,IAAI,CAAC,SAAS,CAAC,QAAQ,CAAC,IAAI,CAAC,WAAW,CAAC,SAAS,CAAC,aAAa,EAAE,CAAC,CAAC;QACtE,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;IAC5B,CAAC;IAOD,KAAK,CAAC,QAAQ,CAAC,GAAW,EAAE,kBAAsC;QAEhE,IAAI,CAAC,KAAK,CAAC,UAAU,EAAE,EAAE;YACvB,IAAI,IAAI,CAAC,WAAW,KAAK,IAAI,IAAI,kBAAkB,CAAC,WAAW,KAAK,IAAI,EAAE;gBACxE,IAAI,CAAC,WAAW,GAAS,kBAAkB,CAAC,WAAW,CAAC;gBACxD,IAAI,CAAC,aAAa,EAAE,CAAC;gBACd,kBAAkB,CAAC,WAAY,CAAC,UAAU,CAAC,IAAI,CAAC,CAAC;aACzD;YACD,IAAI,IAAI,CAAC,cAAc,KAAK,IAAI,IAAI,kBAAkB,CAAC,cAAc,KAAK,IAAI,EAAE;gBAC9E,IAAI,CAAC,cAAc,GAAS,kBAAkB,CAAC,cAAc,CAAC;aAC/D;SACF;QAED,IAAI,IAAI,CAAC,WAAW,KAAK,IAAI,IAAI,IAAI,CAAC,WAAW,CAAC,oBAAoB,EAAE,EAAE;YACxE,IAAI,CAAC,oBAAoB,EAAE,CAAC;SAC7B;QAED,IAAI,CAAC,OAAO,GAAG,GAAG,CAAC;QACnB,IAAI,CAAC,cAAc,EAAE,CAAC;QAEtB,IAAI,CAAC,OAAO,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC;QAE3B,IAAI,UAAU,GAAe,CAAC,IAAI,CAAC,WAAW,KAAK,IAAI,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,WAAW,CAAC,OAAO,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC;QAE7F,OAAO,MAAM,IAAI,CAAC,gBAAgB,CAAC,kBAAkB,CAAC,QAAQ,CAAC,MAAM,CAAC,UAAU,EAAE,EAAE,UAAU,CAAC,EAAE;SAChG;QAED,IAAI,CAAC,sBAAsB,CAAC,4BAA4B,CAAC,IAAI,CAAC,eAAe,CAAC,qBAAqB,CAAC,WAAW,EAAE,KAAK,CAAC,CAAC;QAExH,IAAI,CAAC,iBAAiB,EAAE,CAAC;QACzB,IAAI,CAAC,4BAA4B,EAAE,CAAC;QAGpC,IAAI,CAAC,kBAAkB,EAAE,CAAC;QAE1B,IAAI,IAAI,CAAC,SAAS,EAAE;YAElB,IAAI,WAAW,GAAuB,IAAI,CAAC,SAAS,EAAE,CAAC,OAAO,EAAG,CAAC,qBAAqB,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;YACvG,IAAI,WAAW,KAAK,IAAI,EAAE;gBACxB,WAAW,CAAC,gBAAgB,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;aAC7C;YAGD,IAAI,IAAI,CAAC,IAAI,KAAK,IAAI,EAAE;gBACb,IAAI,CAAC,IAAK,CAAC,cAAc,CAAC,WAAW,CAAC,CAAC;aACjD;SACF;IACH,CAAC;IAID,4BAA4B;QAC1B,IAAI,IAAI,CAAC,WAAW,KAAK,IAAI,IAAI,IAAI,CAAC,WAAW,CAAC,cAAc,EAAE,KAAK,IAAI,IAAI,IAAI,CAAC,OAAO,KAAK,IAAI,CAAC,WAAW,CAAC,SAAS,EAAE;YAC1H,IAAI,CAAC,sBAAsB,GAAG,CAAC,IAAI,CAAC,WAAW,CAAC,cAAc,EAAE,CAAC,CAAC,UAAU,EAAE,CAAC;aAC5E,IAAI,IAAI,CAAC,WAAW,KAAK,IAAI;YAChC,IAAI,CAAC,sBAAsB,GAAG,IAAI,CAAC,WAAW,CAAC,UAAU,EAAE,CAAC;IAChE,CAAC;IAKD,iBAAiB;QACf,IAAI,CAAC,eAAe,GAAG,IAAI,CAAC,WAAW,CAAC;IAC1C,CAAC;IAID,cAAc,CAAC,cAAuB;QACpC,IAAI,SAAS,CAAC,MAAM,KAAK,CAAC,EAAE;YAC1B,IAAI,CAAC,gBAAgB,EAAE,CAAC;YACxB,OAAO;SACR;QACD,IAAI,CAAC,gBAAgB,EAAE,CAAC;IAC1B,CAAC;IAEO,gBAAgB;IACxB,CAAC;IAKD,cAAc;QACZ,IAAI,MAAM,GAAc,kBAAkB,CAAC,QAAQ,CAAC,MAAM,CAAC;QAC3D,IAAI,UAAU,GAAW,MAAM,CAAC,UAAU,EAAE,CAAC,OAAO,CAAC,YAAY,CAAC,SAAS,EAAE,MAAM,CAAC,YAAY,EAAE,CAAC,CAAC;QACpG,IAAI,UAAU,KAAK,CAAC,CAAC,IAAI,UAAU,GAAG,MAAM,CAAC,UAAU,EAAE,CAAC,MAAM,EAAE;YAChE,KAAK,CAAC,cAAc,CAAC,MAAM,CAAC,CAAC;YAI7B,IAAI,KAAK,CAAC,UAAU,EAAE;gBACpB,IAAI,CAAC,OAAO,GAAG,YAAY,CAAC,WAAW,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC;SACxD;aACI;YACH,MAAM,CAAC,QAAQ,CAAC,0BAA0B,CAAC,+CAA+C,CAAC,CAAC;SAC7F;IACH,CAAC;IAKM,YAAY,CAAC,SAAiB,EAAE,QAAgB;QACrD,IAAI,cAAuB,CAAC;QAC5B,cAAc,GAAG,KAAK,CAAC,YAAY,CAAC,SAAS,EAAE,QAAQ,CAAC,CAAC;QACzD,IAAI,CAAC,cAAc,EAAE;YACnB,cAAc,GAAG,IAAI,CAAC;YACtB,QAAQ,SAAS,EAAE;gBACjB,KAAK,cAAc,CAAC,iBAAiB;oBACnC,IAAI,CAAC,CAAC,QAAQ,CAAC,IAAI,EAAE,KAAK,EAAE,CAAC;wBAC3B,IAAI,CAAC,gBAAgB,CAAC,QAAQ,CAAC,CAAC;oBAClC,MAAM;gBACR,KAAK,YAAY,CAAC,YAAY;oBAC5B,IAAI,CAAC,IAAI,GAAG,QAAQ,CAAC;oBACrB,MAAM;gBACR,KAAK,cAAc,CAAC,iBAAiB;oBACnC,IAAI,CAAC,CAAC,QAAQ,CAAC,IAAI,EAAE,KAAK,EAAE,CAAC;wBAC3B,IAAI,CAAC,aAAa,CAAC,QAAQ,CAAC,CAAC;oBAC/B,MAAM;gBACR,KAAK,cAAc,CAAC,kBAAkB;oBACpC,IAAI,CAAC,QAAQ,IAAI,CAAC;wBAChB,IAAI,CAAC,SAAS,GAAG,IAAI,CAAC;oBACxB,MAAM;gBACR,KAAK,cAAc,CAAC,iBAAiB;oBACnC,IAAI,CAAC,QAAQ,IAAI,CAAC;wBAChB,IAAI,CAAC,YAAY,GAAG,IAAI,CAAC;oBAC3B,MAAM;gBACR,KAAK,cAAc,CAAC,wBAAwB;oBAC1C,IAAI,CAAC,UAAU,GAAkB,QAAQ,CAAC,CAAC,CAAC,CAAC;oBAC7C,MAAM;gBACR,KAAK,cAAc,CAAC,gBAAgB;oBAClC,IAAI,CAAC,oBAAoB,CAAC,QAAQ,CAAC,CAAC;oBACpC,MAAM;gBACR,KAAK,cAAc,CAAC,cAAc;oBAChC,IAAI,CAAC,UAAU,GAAG,SAAS,CAAC,QAAQ,CAAC,QAAQ,CAAC,CAAC;oBAC/C,MAAM;gBACR,KAAK,YAAY,CAAC,kBAAkB;oBAClC,IAAI,CAAC,SAAS,GAAG,SAAS,CAAC,UAAU,CAAC,QAAQ,CAAC,CAAC;oBAChD,MAAM;gBACR,KAAK,YAAY,CAAC,wBAAwB;oBACxC,IAAI,CAAC,cAAc,GAAG,SAAS,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC;oBACjD,MAAM;gBACR,KAAK,YAAY,CAAC,uBAAuB;oBAEvC,MAAM;gBACR;oBACE,cAAc,GAAG,KAAK,CAAC;oBACvB,MAAM;aACT;SACF;QACD,IAAI,CAAC,cAAc;YACjB,MAAM,CAAC,QAAQ,CAAC,0BAA0B,CAAC,OAAO,CAAC,MAAM,CAAC,+BAA+B,EAAE,SAAS,CAAC,CAAC,CAAC;QACzG,OAAO,IAAI,CAAC;IACd,CAAC;IAMD,KAAK,CAAC,gBAAgB,CAAC,YAAoB,EAAE,UAAsB;QACjE,IAAI,YAAY,IAAI,IAAI;YACtB,OAAO,KAAK,CAAC;QACf,IAAI,MAAM,GAAc,kBAAkB,CAAC,QAAQ,CAAC,MAAM,CAAC;QAC3D,QAAQ,YAAY,EAAE;YACpB,KAAK,YAAY,CAAC,gBAAgB;gBAChC,IAAI,IAAI,CAAC,QAAQ,IAAI,IAAI;oBACvB,IAAI,CAAC,QAAQ,GAAG,IAAI,KAAK,EAAE,CAAC;gBAE9B,IAAI,MAAM,CAAC,SAAS,CAAC,gBAAgB,CAAC,WAAW,CAAC;oBAChD,MAAM,CAAC,aAAa,CAAC,OAAO,CAAC,MAAM,CAAC,SAAS,EAAE,YAAY,CAAC,CAAC,CAAC;gBAEhE,IAAI,CAAC,QAAQ,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAC;gBAC/B,MAAM;YAER,KAAK,YAAY,CAAC,eAAe;gBAC/B,IAAI,MAAM,CAAC,SAAS,CAAC,gBAAgB,CAAC,WAAW,CAAC;oBAChD,MAAM,CAAC,aAAa,CAAC,OAAO,CAAC,MAAM,CAAC,SAAS,EAAE,YAAY,CAAC,CAAC,CAAC;gBAEhE,IAAI,CAAC,QAAQ,CAAC,cAAc,CAAC,MAAM,CAAC,CAAC;gBACrC,MAAM;YAER,KAAK,YAAY,CAAC,WAAW;gBAC3B,IAAI,CAAC,QAAQ,CAAC,QAAQ,CAAC,IAAI,EAAE,GAAG,EAAE,MAAM,CAAC,CAAC;gBAC1C,MAAM;YAER,KAAK,YAAY,CAAC,WAAW;gBAC3B,IAAI,CAAC,IAAI,GAAG,IAAI,CAAC,YAAY,CAAC,UAAU,CAAC,CAAC;gBAC1C,MAAM;YAER,KAAK,YAAY,CAAC,oBAAoB;gBAEpC,MAAM;YAER,KAAK,YAAY;gBACf,IAAI,UAAU,GAAG,MAAM,CAAC,UAAU,EAAE,CAAC,OAAO,CAAC,aAAa,EAAE,MAAM,CAAC,YAAY,EAAE,CAAC,CAAC;gBACnF,MAAM,CAAC,YAAY,CAAC,UAAU,CAAC,CAAC;gBAChC,MAAM,CAAC,qBAAqB,EAAE,CAAC;gBAC/B,MAAM;YAER,KAAK,YAAY,CAAC,YAAY;gBAC5B,IAAI,CAAC,MAAM,GAAG,IAAI,UAAU,CAAC,IAAI,EAAE,UAAU,CAAC,CAAC;gBAC/C,MAAM,CAAC,QAAQ,CAAC,aAAa,CAAC,OAAO,CAAC,MAAM,CAAC,SAAS,EAAE,YAAY,CAAC,CAAC,CAAC;gBACvE,MAAM,IAAI,CAAC,MAAM,CAAC,QAAQ,EAAE,CAAC;gBAC7B,MAAM;YACR,KAAK,YAAY,CAAC,WAAW;gBAC3B,IAAI,IAAI,CAAC,QAAQ,IAAI,IAAI;oBACvB,IAAI,CAAC,QAAQ,GAAG,IAAI,UAAU,EAAE,CAAC;gBACnC,IAAI,OAAO,GAAG,IAAI,IAAI,CAAC,IAAI,CAAC,CAAC;gBAC7B,OAAO,CAAC,IAAI,EAAE,CAAC;gBACf,IAAI,CAAC,QAAQ,CAAC,OAAO,CAAC,OAAO,CAAC,CAAC;gBAC/B,IAAI,GAAG,GAAW,IAAI,CAAC,OAAO,CAAC;gBAC/B,IAAI,IAAI,CAAC,UAAU,EAAE;oBACnB,GAAG,GAAG,YAAY,CAAC,WAAW,CAAC,0BAA0B,EAAE,CAAC;gBAC9D,MAAM,OAAO,CAAC,QAAQ,CAAC,GAAG,EAAE,IAAI,kBAAkB,EAAE,CAAC,CAAC;gBACtD,MAAM;YACR,KAAK,cAAc,CAAC,cAAc;gBAChC,MAAM,IAAI,CAAC,cAAc,EAAE,CAAC;gBAC5B,MAAM;YACR,KAAK,cAAc,CAAC,eAAe;gBACjC,IAAI,IAAI,CAAC,MAAM,IAAI,IAAI;oBACrB,IAAI,CAAC,MAAM,GAAG,IAAI,QAAQ,EAAE,CAAC;gBAC/B,MAAM,CAAC,QAAQ,CAAC,aAAa,CAAC,aAAa,CAAC,CAAC;gBAC7C,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC,CAAC;gBACnC,MAAM;YACR,KAAK,cAAc,CAAC,kBAAkB;gBACpC,IAAI,IAAI,CAAC,UAAU,IAAI,IAAI;oBACzB,IAAI,CAAC,UAAU,GAAG,IAAI,eAAe,EAAE,CAAC;gBAC1C,MAAM,CAAC,QAAQ,CAAC,aAAa,CAAC,wBAAwB,CAAC,CAAC;gBACxD,IAAI,CAAC,UAAU,CAAC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC,CAAC;gBACvC,MAAM;YACR,KAAK,cAAc,CAAC,YAAY;gBAC9B,IAAI,CAAC,oBAAoB,GAAG,IAAI,eAAe,CAAC,IAAI,CAAC,CAAC;gBACtD,IAAI,CAAC,oBAAoB,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAC;gBAC3C,MAAM;YACR,KAAK,cAAc,CAAC,YAAY;gBAC9B,IAAI,CAAC,YAAY,GAAG,IAAI,cAAc,EAAE,CAAC;gBACzC,IAAI,CAAC,YAAY,CAAC,QAAQ,CAAE,MAAM,CAAC,CAAC;gBACpC,MAAM;YACR,KAAK,cAAc,CAAC,kBAAkB;gBACpC,IAAI,CAAC,cAAc,EAAE,CAAC;gBACtB,MAAM;YACR,KAAK,YAAY,CAAC,gBAAgB;gBAChC,MAAM,CAAC,QAAQ,CAAC,aAAa,CAAC,mBAAmB,CAAC,CAAC;gBACnD,IAAI,CAAC,iBAAiB,CAAC,MAAM,CAAC,CAAC;gBAC/B,MAAM;YACR,KAAK,cAAc,CAAC,oBAAoB;gBACtC,MAAM,CAAC,QAAQ,CAAC,aAAa,CAAC,uBAAuB,CAAC,CAAC;gBACvD,IAAI,IAAI,CAAC,WAAW,IAAI,IAAI;oBAC1B,IAAI,CAAC,WAAW,GAAG,IAAI,aAAa,EAAE,CAAC;gBACzC,IAAI,CAAC,WAAW,CAAC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC,CAAC;gBACxC,IAAI,CAAC,sBAAsB,EAAE,CAAC;gBAC9B,MAAM;YACR;gBACE,IAAI,YAAY,KAAK,CAAC,GAAG,GAAG,YAAY,CAAC,WAAW,CAAC,EAAE;oBACrD,kBAAkB,CAAC,QAAQ,CAAC,MAAM,CAAC,qBAAqB,EAAE,CAAC;oBAC3D,OAAO,KAAK,CAAC;iBACd;qBACI;oBACH,MAAM,CAAC,QAAQ,CAAC,aAAa,CAAC,iEAAiE,GAAG,YAAY,CAAC,CAAC;oBAChH,OAAO,KAAK,CAAC;iBACd;SACJ;QACD,OAAO,IAAI,CAAC;IACd,CAAC;IAED,iBAAiB,CAAC,MAAiB;QACjC,IAAI,cAAc,GAAmB,IAAI,cAAc,EAAE,CAAC;QAC1D,cAAc,CAAC,UAAU,CAAW,IAAI,CAAC,QAAQ,EAAE,IAAI,EAAE,MAAM,CAAC,CAAC;IACnE,CAAC;IAEO,gBAAgB;QACtB,IAAI,MAAM,GAAc,kBAAkB,CAAC,QAAQ,CAAC,MAAM,CAAC;QAE3D,IAAI,UAAU,GAAW,MAAM,CAAC,UAAU,EAAE,CAAC,OAAO,CAAC,cAAc,CAAC,sBAAsB,EAAE,MAAM,CAAC,YAAY,EAAE,CAAC,CAAC;QACnH,UAAU,GAAG,MAAM,CAAC,UAAU,EAAE,CAAC,OAAO,CAAC,YAAY,CAAC,SAAS,EAAE,UAAU,CAAC,GAAG,YAAY,CAAC,SAAS,CAAC,MAAM,CAAC;QAE7G,IAAI,cAAc,GAAW,MAAM,CAAC,eAAe,CAAC,UAAU,CAAC,CAAC;QAChE,IAAI,CAAC,cAAc,CAAC,cAAc,CAAC,CAAC;QACpC,MAAM,CAAC,YAAY,CAAC,UAAU,CAAC,CAAC;IAClC,CAAC;IAMO,sBAAsB;QAC5B,IAAI,GAAG,GAAW,CAAC,CAAC;QACpB,KAAK,IAAI,CAAC,GAAW,IAAI,CAAC,WAAW,CAAC,OAAO,EAAE,GAAG,CAAC,EAAE,CAAC,IAAI,CAAC,EAAE,CAAC,EAAE,EAAE;YAChE,IAAI,OAAO,GAAiB,IAAI,CAAC,WAAW,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC;YAC3D,IAAI,GAAG,GAAU,OAAO,CAAC,QAAQ,EAAE,CAAC;YACpC,IAAI,GAAG,CAAC,OAAO,EAAE,KAAK,cAAc,CAAC,qBAAqB;gBACxD,CAAC,GAAG,CAAC,OAAO,EAAE,KAAK,cAAc,CAAC,eAAe,IAAI,GAAG,CAAC,gBAAgB,EAAE,KAAK,cAAc,CAAC,qBAAqB,CAAC,EAAE;gBACvH,IAAI,CAAC,OAAO,CAAC,aAAa,CAAC,OAAO,EAAE,GAAG,CAAC,CAAC;gBACzC,GAAG,EAAE,CAAC;aACP;SACF;IACH,CAAC;IAKM,gBAAgB,CAAC,SAAiB;QACvC,IAAI,MAAM,GAAa,OAAO,CAAC,QAAQ,CAAC,SAAS,EAAE,GAAG,CAAC,CAAC;QACxD,IAAI,MAAc,CAAC;QACnB,IAAI,OAAO,GAAG,IAAI,IAAI,EAAU,CAAC;QACjC,IAAI,CAAS,CAAC;QACd,KAAK,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE;YAClC,MAAM,GAAG,OAAO,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC;YAClC,OAAO,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;SACtB;QACD,IAAI,CAAC,aAAa,GAAG,IAAI,KAAK,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC;QAC/C,KAAK,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE;YACnC,MAAM,GAAG,OAAO,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC;YAC7B,IAAI,CAAC,aAAa,CAAC,CAAC,CAAC,GAAG,MAAM,CAAC;SAChC;IACH,CAAC;IAKD,aAAa,CAAC,MAAe;QAC3B,IAAI,CAAC,UAAU,GAAG,MAAM,CAAC;IAC3B,CAAC;IAOD,QAAQ,CAAC,OAAe;QACtB,OAAkB,IAAI,CAAC,QAAS,CAAC,cAAc,CAAC,OAAO,CAAC,CAAC;IAC3D,CAAC;IAMD,UAAU,CAAC,EAAU;QACnB,IAAI,IAAI,CAAC,MAAM,KAAK,IAAI;YACtB,OAAO,IAAI,CAAC,MAAM,CAAC,UAAU,CAAC,EAAE,CAAC,CAAC;;YAElC,MAAM,CAAC,QAAQ,CAAC,0BAA0B,CAAC,2CAA2C,CAAC,CAAC;QAC1F,OAAO,IAAI,CAAC;IACd,CAAC;IAED,gBAAgB,CAAC,EAAU;QACzB,OAAO,IAAI,CAAC,UAAU,CAAC,EAAE,CAAC,CAAC;IAC7B,CAAC;IAED,oBAAoB,CAAC,KAAa;QAChC,IAAI,MAAM,GAAW,IAAI,CAAC;QAC1B,IAAI,KAAK,GAAG,CAAC,EAAE;YACb,IAAI,OAAO,GAAe,IAAI,CAAC,UAAU,CAAC,KAAK,CAAC,CAAC;YACjD,KAAK,CAAC,MAAM,CAAC,OAAO,KAAK,IAAI,CAAC,CAAC;YAC/B,MAAM,GAAG,OAAO,CAAC,mBAAmB,EAAE,CAAC;SACxC;QACD,OAAO,MAAM,CAAC;IAChB,CAAC;IAWD,KAAK,CAAC,mBAAmB,CAAC,KAAa,EAAE,OAAyB,EAAE,MAAc;QAChF,IAAI,MAAM,GAAW,IAAI,CAAC;QAC1B,IAAI,KAAK,GAAG,CAAC,EAAE;YACb,IAAI,OAAO,GAAe,IAAI,CAAC,UAAU,CAAC,KAAK,CAAC,CAAC;YACjD,KAAK,CAAC,MAAM,CAAC,OAAO,KAAK,IAAI,CAAC,CAAC;YAC/B,MAAM,GAAG,MAAM,OAAO,CAAC,+BAA+B,CAAC,OAAO,EAAE,MAAM,CAAC,CAAC;SACzE;QACD,OAAO,MAAM,CAAC;IAChB,CAAC;IAKD,KAAK,CAAC,iBAAiB,CAAC,UAAmB,EAAE,MAAiB;QAE5D,IAAI,MAAM,IAAI,CAAC,QAAQ,EAAE,EAAE;YACzB,IAAI,SAAS,GAAuB,IAAI,CAAC,QAAS,CAAC,UAAU,EAAE,CAAC;YAGhE,IAAI,CAAC,SAAS,IAAI,UAAU,EAAE;gBAC5B,IAAI,CAAC,IAAI,CAAC,SAAS,EAAE;oBAEnB,IAAe,IAAI,CAAC,QAAS,CAAC,aAAa,EAAE,EAAE;wBAC7C,IAAI,CAAY,IAAI,CAAC,QAAS,CAAC,UAAU,EAAE;4BACzC,IAAI,CAAC,QAAQ,CAAC,UAAU,CAAY,IAAI,CAAC,QAAS,CAAC,SAAS,EAAE,CAAC,CAAC;;4BAEhE,IAAI,CAAC,QAAQ,CAAC,iBAAiB,CAAY,IAAI,CAAC,QAAS,CAAC,aAAa,EAAE,EAAE,IAAI,CAAC,CAAC;qBACpF;iBACF;;oBACI,IAAI,CAAC,gBAAgB,EAAE,CAAC;aAC9B;SACF;QAED,MAAiB,IAAI,CAAC,QAAS,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAC;QAEjD,IAAI,UAAU;YACD,IAAI,CAAC,QAAS,CAAC,UAAU,CAAC,KAAK,CAAC,CAAC;IAChD,CAAC;IAKD,cAAc;QACZ,OAAO,IAAI,CAAC,WAAW,CAAC;IAC1B,CAAC;IAKD,KAAK,CAAC,QAAQ,CAAC,OAAsB;QACnC,IAAI,CAAC,0BAA0B,GAAG,IAAI,CAAC,aAAa,EAAE,CAAC;QACvD,IAAI,IAAI,CAAC,aAAa,IAAI,CAAC,IAAI,CAAC,SAAS,EAAE;YACzC,OAAO,CAAC,MAAM,CAAC,YAAY,CAAC,SAAS,GAAG,YAAY,CAAC,WAAW,CAAC,CAAC;YAClE,OAAO,CAAC,MAAM,CAAC,GAAG,GAAG,YAAY,CAAC,cAAc,GAAG,KAAK,GAAG,IAAI,CAAC,UAAU,EAAE,GAAG,IAAI,CAAC,CAAC;YACrF,OAAO,CAAC,MAAM,CAAC,GAAG,GAAG,cAAc,CAAC,sBAAsB,GAAG,KAAK,GAAG,IAAI,CAAC,YAAY,EAAE,GAAG,IAAI,CAAC,CAAC;YACjG,OAAO,CAAC,MAAM,CAAC,YAAY,CAAC,SAAS,CAAC,CAAC;YACvC,MAAiB,IAAI,CAAC,QAAS,CAAC,QAAQ,CAAC,OAAO,CAAC,CAAC;YAClD,IAAI,IAAI,CAAC,IAAI,IAAI,IAAI,IAAI,IAAI,CAAC,IAAI,CAAC,MAAM;gBACvC,OAAO,CAAC,MAAM,CAAU,IAAI,CAAC,IAAK,CAAC,uBAAuB,EAAE,CAAC,CAAC;YAChE,OAAO,CAAC,MAAM,CAAC,SAAS,GAAG,YAAY,CAAC,WAAW,GAAG,YAAY,CAAC,SAAS,CAAC,CAAC;SAC/E;IACH,CAAC;IAKD,eAAe,CAAC,OAAsB,EAAE,UAA2B,EAAE,MAAe;QAClF,IAAI,CAAS,CAAC;QACd,IAAI,GAAU,CAAC;QACf,IAAI,QAAQ,GAAqB,gBAAgB,CAAC,IAAI,CAAC;QACvD,IAAI,QAAQ,GAAY,CAAC,WAAW,CAAC,QAAQ,CAAC,aAAa,EAAE,IAAI,CAAC,CAAC,CAAC;QAEpE,OAAO,CAAC,MAAM,CAAC,YAAY,CAAC,SAAS,CAAC,CAAC;QACvC,KAAK,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,UAAU,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE;YACtC,OAAO,CAAC,MAAM,CAAC,YAAY,CAAC,SAAS,GAAG,cAAc,CAAC,QAAQ,CAAC,CAAC;YAEjE,IAAI,GAAG,GAAc,UAAU,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC;YAE5C,OAAO,CAAC,MAAM,CAAC,GAAG,GAAG,YAAY,CAAC,UAAU,GAAG,KAAK,GAAG,GAAG,CAAC,MAAM,GAAG,IAAI,CAAC,CAAC;YAE1E,GAAG,GAAU,IAAI,CAAC,QAAQ,CAAC,QAAQ,CAAS,GAAG,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC;YAC5D,IAAI,OAAO,GAAqB,GAAG,CAAC,OAAO,EAAE,CAAC;YAE9C,IAAI,GAAG,CAAC,OAAO;gBACb,OAAO,CAAC,MAAM,CAAC,GAAG,GAAG,cAAc,CAAC,YAAY,GAAG,QAAQ,CAAC,CAAC;YAE/D,IAAI,CAAC,GAAG,CAAC,UAAU,IAAI,GAAG,CAAC,GAAG,IAAI,IAAI,EAAE;gBACtC,IAAI,GAAG,GAAW,WAAW,CAAC,YAAY,CAAC,GAAG,CAAC,GAAG,EAAE,OAAO,EAAE,QAAQ,EAAE,QAAQ,CAAC,CAAC;gBACjF,OAAO,CAAC,MAAM,CAAC,GAAG,GAAG,cAAc,CAAC,OAAO,GAAG,KAAK,GAAG,GAAG,GAAG,IAAI,CAAC,CAAC;aACnE;YAED,IAAI,GAAG,CAAC,OAAO;gBACb,OAAO,CAAC,MAAM,CAAC,GAAG,GAAG,cAAc,CAAC,YAAY,GAAG,QAAQ,CAAC,CAAC;YAE/D,IAAI,CAAC,GAAG,CAAC,UAAU,IAAI,GAAG,CAAC,GAAG,IAAI,IAAI,EAAE;gBACtC,IAAI,GAAG,GAAW,WAAW,CAAC,YAAY,CAAC,GAAG,CAAC,GAAG,EAAE,OAAO,EAAE,QAAQ,EAAE,QAAQ,CAAC,CAAC;gBACjF,OAAO,CAAC,MAAM,CAAC,GAAG,GAAG,cAAc,CAAC,OAAO,GAAG,KAAK,GAAG,GAAG,GAAG,IAAI,CAAC,CAAC;aACnE;YAED,OAAO,CAAC,MAAM,CAAC,YAAY,CAAC,QAAQ,CAAC,CAAC;SACvC;QACD,IAAI,MAAM;YACR,OAAO,CAAC,MAAM,CAAC,YAAY,CAAC,OAAO,GAAG,cAAc,CAAC,YAAY,GAAG,YAAY,CAAC,SAAS,CAAC,CAAC;;YAE5F,OAAO,CAAC,MAAM,CAAC,YAAY,CAAC,OAAO,GAAG,cAAc,CAAC,WAAW,GAAG,YAAY,CAAC,SAAS,CAAC,CAAC;IAC/F,CAAC;IAKD,gBAAgB,CAAC,OAAsB;QACrC,IAAI,IAAI,CAAC,SAAS,IAAI,IAAI,IAAI,IAAI,CAAC,SAAS,CAAC,MAAM,GAAG,CAAC,EAAE;YACvD,IAAI,CAAS,CAAC;YACd,KAAK,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,IAAI,CAAC,SAAS,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE;gBAC1C,OAAO,CAAC,MAAM,CAAC,YAAY,CAAC,SAAS,CAAC,CAAC;gBACvC,IAAI,GAAG,GAAS,IAAI,CAAC,SAAS,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC;gBAE3C,OAAO,CAAC,MAAM,CAAC,YAAY,CAAC,SAAS,GAAG,cAAc,CAAC,IAAI,CAAC,CAAC;gBAC7D,OAAO,CAAC,MAAM,CAAC,GAAG,GAAG,YAAY,CAAC,UAAU,GAAG,KAAK,GAAG,GAAG,CAAC,MAAM,GAAG,IAAI,CAAC,CAAC;gBAC1E,IAAI,GAAG,CAAC,GAAG;oBACT,OAAO,CAAC,MAAM,CAAC,GAAG,GAAG,cAAc,CAAC,WAAW,GAAG,QAAQ,CAAC,CAAC;gBAE9D,OAAO,CAAC,MAAM,CAAC,YAAY,CAAC,QAAQ,CAAC,CAAC;aACvC;YACD,IAAI,CAAC,SAAS,CAAC,KAAK,EAAE,CAAC;YACvB,IAAI,CAAC,SAAS,GAAG,IAAI,CAAC;YACtB,OAAO,CAAC,MAAM,CAAC,YAAY,CAAC,OAAO,GAAG,cAAc,CAAC,YAAY,GAAG,YAAY,CAAC,SAAS,CAAC,CAAC;SAC7F;IACH,CAAC;IAMD,YAAY,CAAC,GAAW;QACtB,KAAK,CAAC,MAAM,CAAC,IAAI,CAAC,UAAU,KAAK,IAAI,CAAC,CAAC;QACvC,IAAI,QAAQ,GAAU,IAAI,CAAC;QAC3B,IAAI,IAAI,CAAC,UAAU,KAAK,IAAI;YAC1B,QAAQ,GAAG,IAAI,CAAC,UAAU,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC;QAC3C,OAAO,QAAQ,CAAC;IAClB,CAAC;IAIO,qBAAqB,CAAC,kBAA2B;QACvD,IAAI,kBAAkB,IAAI,CAAC,IAAI,CAAC,SAAS,EAAE;YACzC,IAAI,IAAI,CAAC,IAAI,KAAK,IAAI,EAAE;gBAGtB,IAAI,YAAY,GAAqB,IAAI,CAAC,IAAK,CAAC,0BAA0B,EAAE,CAAC;gBAC7E,IAAI,CAAC,YAAY;oBACN,IAAI,CAAC,IAAK,CAAC,mBAAmB,GAAG,IAAI,CAAC;aAClD;SACF;IACH,CAAC;IAKD,KAAK,CAAC,KAAK,CAAC,kBAA2B,EAAE,iBAA0B;QACjE,IAAI,kBAAkB,GAAS,IAAI,CAAC;QAEpC,IAAI,CAAC,IAAI,CAAC,UAAU,EAAE;YACpB,IAAI,CAAC,UAAU,GAAG,IAAI,CAAC;YAEvB,IAAI,CAAC,mBAAmB,EAAE,CAAC;YAE3B,IAAI,CAAC,cAAc,GAAG,IAAI,CAAC;YAC3B,IAAI,MAAM,GAAiB,MAAM,IAAI,CAAC,KAAK,EAAE,CAAC;YAG9C,IAAI,CAAC,MAAM,CAAC,OAAO;gBACjB,OAAO,IAAI,CAAC;YAEd,IAAI,CAAC,gCAAgC,GAAG,YAAY,CAAC,aAAa,CAAC,2BAA2B,EAAE,CAAC;YACjG,YAAY,CAAC,aAAa,CAAC,2BAA2B,CAAC,KAAK,CAAC,CAAC;YAE9D,MAAM,IAAI,CAAC,aAAa,EAAE,CAAC;YAE3B,MAAM,GAAG,MAAM,IAAI,CAAC,cAAc,CAAC,kBAAkB,CAAC,CAAC;YAEvD,IAAI,CAAC,MAAM,CAAC,OAAO;gBACjB,OAAO,IAAI,CAAC;YAEd,IAAI,CAAC,IAAI,CAAC,aAAa,IAAI,CAAC,IAAI,CAAC,UAAU;gBACzC,kBAAkB,GAAG,IAAI,CAAC;YAE5B,IAAI,CAAC,oBAAoB,GAAG,IAAI,CAAC;YAQjC,IAAI,QAAQ,GAAe,IAAI,CAAC,QAAQ,CAAC;YACzC,IAAI,IAAI,CAAC,UAAU,EAAE;gBACnB,IAAI,CAAC,QAAQ,GAAG,IAAI,CAAC;YACvB,IAAI,IAAI,CAAC,UAAU,EAAE;gBACnB,IAAI,CAAC,QAAQ,GAAG,QAAQ,CAAC;YAE3B,IAAI,CAAC,MAAM,CAAC,OAAO;gBACjB,OAAO,IAAI,CAAC;YACd,IAAI,IAAI,CAAC,SAAS;gBAChB,OAAO,IAAI,CAAC;YAEd,IAAI,eAAe,GAAmB,cAAc,CAAC,qBAAqB,CAAC,IAAI,CAAC,UAAU,EAAE,EAAE,mBAAmB,CAAC,UAAU,CAAC,CAAC;YAC9H,MAAM,GAAG,MAAM,IAAI,CAAC,eAAe,CAAC,OAAO,CAAC,eAAe,CAAC,CAAC;YAE7D,IAAI,CAAC,MAAM,CAAC,OAAO;gBACjB,OAAO,IAAI,CAAC;YAEd,IAAI,CAAC,mBAAmB,EAAE,CAAC;SAE5B;QAED,kBAAkB,GAAG,MAAM,IAAI,CAAC,aAAa,CAAC,kBAAkB,EAAE,kBAAkB,EAAE,iBAAiB,CAAC,CAAC;QACzG,IAAI,CAAC,cAAc,GAAG,KAAK,CAAC;QAC5B,OAAO,kBAAkB,CAAC;IAC5B,CAAC;IAMO,mBAAmB;QAGzB,KAAK,CAAC,WAAW,CAAC,cAAc,CAAC,kBAAkB,EAAE,CAAC,CAAC,CAAC,CAAC;QACzD,IAAI,CAAC,iBAAiB,GAAG,IAAI,CAAC;QAE9B,IAAI,CAAC,mBAAmB,GAAG,CAAC,CAAC,IAAI,CAAC,SAAS,IAAa,IAAI,CAAC,SAAS,EAAE,CAAC,OAAO,EAAG,CAAC,0BAA0B,EAAE,CAAC;YAC/G,CAAC,CAAQ,IAAI,CAAC,SAAS,EAAG,CAAC,mBAAmB;YAC9C,CAAC,CAAC,IAAI,CAAC,cAAc,CAAC,CAAC;IAC3B,CAAC;IAOO,KAAK,CAAC,cAAc,CAAC,kBAA2B;QACtD,IAAI,IAAI,CAAC,IAAI,KAAK,IAAI,EAAE;YAEtB,IAAI,CAAC,qBAAqB,CAAC,kBAAkB,CAAC,CAAC;YAG/C,YAAY,CAAC,aAAa,CAAC,iBAAiB,EAAE,CAAC;YAE/C,IAAI,CAAC,WAAW,GAAc,IAAI,CAAC,QAAS,CAAC,cAAc,EAAE,CAAC;YAG9D,MAAM,IAAI,CAAC,QAAQ,EAAE,CAAC;YAEtB,YAAY,CAAC,aAAa,CAAC,gBAAgB,EAAE,CAAC;YAE9C,IAAI,CAAC,SAAS,EAAE,CAAC,WAAW,EAAE,CAAC;YAC/B,QAAQ,CAAC,WAAW,EAAE,CAAC;SACxB;QAED,OAAO,IAAI,YAAY,EAAE,CAAC;IAC5B,CAAC;IAQO,KAAK,CAAC,aAAa,CAAC,kBAA2B,EAAE,kBAAwB,EAAE,iBAA0B;QAC3G,IAAI,IAAI,CAAC,WAAW,EAAE,EAAE;YACtB,KAAK,IAAI,CAAC,GAAW,CAAC,EAAE,CAAC,GAAG,IAAI,CAAC,QAAQ,CAAC,OAAO,EAAE,EAAE,CAAC,GAAG,CAAC,GAAG,CAAC,EAAE;gBAC9D,IAAI,IAAI,GAAe,IAAI,CAAC,QAAQ,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC;gBAChD,IAAI,qBAAqB,GAAiB,MAAM,IAAI,CAAC,KAAK,CAAC,kBAAkB,EAAE,iBAAiB,CAAC,CAAC;gBAClG,IAAI,kBAAkB,KAAK,IAAI;oBAC7B,kBAAkB,GAAG,qBAAqB,CAAC;qBACxC,IAAI,qBAAqB,KAAK,IAAI;oBACrC,KAAK,CAAC,MAAM,CAAC,KAAK,EAAE,2CAA2C,CAAC,CAAC;aACpE;SACF;QAED,OAAO,kBAAkB,CAAC;IAC5B,CAAC;IAEO,KAAK,CAAC,aAAa;QACzB,IAAI,OAAO,GAAa,aAAa,CAAC,UAAU,CAAC;QACjD,IAAI,CAAC,aAAa,CAAC,UAAU,CAAC,OAAO,EAAE,IAAI,EAAE,KAAK,CAAC,CAAC;QAEpD,IAAI,IAAI,CAAC,SAAS;YAChB,IAAI,CAAC,aAAa,CAAC,MAAM,CAAC,iBAAiB,CAAC,6BAA6B,EAAE,IAAI,CAAC,CAAC;QAInF,MAAM,IAAI,CAAC,WAAW,EAAE,CAAC;QACzB,IAAI,MAAM,IAAI,CAAC,SAAS,CAAC,aAAa,CAAC,mBAAmB,EAAE,KAAK,CAAC,EAAE;YAClE,IAAI,CAAC,aAAa,CAAC,MAAM,CAAC,iBAAiB,CAAC,aAAa,EAAE,IAAI,CAAC,CAAC;SAClE;QAED,IAAI,eAAe,GAAY,MAAM,IAAI,CAAC,SAAS,CAAC,aAAa,CAAC,oBAAoB,EAAE,KAAK,CAAC,CAAC;QAC/F,IAAI,CAAC,aAAa,CAAC,MAAM,CAAC,iBAAiB,CAAC,iBAAiB,EAAE,eAAe,CAAC,CAAC;QAGhF,IAAI,IAAI,CAAC,oBAAoB,EAAE;YAC7B,IAAI,CAAC,aAAa,CAAC,MAAM,CAAC,iBAAiB,CAAC,WAAW,EAAE,IAAI,CAAC,CAAC;IACnE,CAAC;IAMD,KAAK,CAAC,SAAS,CAAC,IAAY;QAC1B,IAAI,YAAY,GAAW,YAAY,CAAC,QAAQ,CAAC,SAAS,CAAC,IAAI,CAAC,CAAC;QACjE,IAAI,aAAa,GAAW,YAAY,CAAC,QAAQ,CAAC,SAAS,CAAC,cAAc,CAAC,YAAY,CAAC,CAAC;QAEzF,MAAM,UAAU,CAAC,QAAQ,CAAC,UAAU,CAAC,aAAa,EAAE,YAAY,EAAE,MAAM,CAAC,iBAAiB,GAAG,MAAM,CAAC,gBAAgB,CAAC,CAAC;IACxH,CAAC;IAOD,KAAK,CAAC,cAAc,CAAC,MAAoB,EAAE,YAAqB;QAC9D,IAAI,CAAC,MAAM,CAAC,OAAO,IAAI,CAAC,IAAI,CAAC,UAAU,EAAE,EAAE;YACzC,IAAI,IAAI,CAAC,cAAc,EAAE;gBACvB,MAAM,IAAI,CAAC,OAAO,CAAC,KAAK,EAAE,KAAK,EAAE,KAAK,CAAC,CAAC;gBACxC,IAAI,YAAY;oBACd,MAAM,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC,gBAAgB,CAAC,CAAC;gBAChD,IAAI,CAAC,cAAc,GAAG,KAAK,CAAC;gBAC5B,OAAO,IAAI,CAAC;aACb;iBACI;gBACH,IAAI,YAAY;oBACd,MAAM,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC,gBAAgB,CAAC,CAAC;gBAChD,MAAM,YAAY,CAAC,aAAa,CAAC,2BAA2B,CAAC,IAAI,EAAE,iBAAiB,CAAC,WAAW,CAAC,CAAC;aACnG;SACF;QAED,OAAO,KAAK,CAAC;IACf,CAAC;IAMO,KAAK,CAAC,KAAK;QACjB,IAAI,MAAoB,CAAC;QACzB,IAAI,CAAC,WAAW,CAAC,0BAA0B,CAAC,IAAI,CAAC,CAAC;QAClD,IAAI,CAAC,kBAAkB,GAAG,KAAK,CAAC;QAEhC,eAAe,CAAC,iBAAiB,CAAC,IAAI,CAAC,CAAC;QAIxC,IAAI,eAAe,GAAmB,cAAc,CAAC,qBAAqB,CAAC,IAAI,CAAC,UAAU,EAAE,EAAE,mBAAmB,CAAC,IAAI,CAAC,CAAC;QACxH,MAAM,GAAG,MAAM,IAAI,CAAC,eAAe,CAAC,OAAO,CAAC,eAAe,CAAC,CAAC;QAG7D,IAAI,CAAC,MAAM,CAAC,OAAO;YACjB,OAAO,MAAM,CAAC;QAEhB,IAAI,MAAM,CAAC,OAAO,EAAE;YAElB,IAAI,QAAQ,GAAiC,qBAAqB,CAAC,QAAQ,CAAC,mCAAmC,EAAE,CAAC;YAElH,KAAK,IAAI,MAAM,GAAW,CAAC,EAAE,MAAM,GAAG,QAAQ,CAAC,MAAM,EAAE,MAAM,EAAE,EAAE;gBAC/D,IAAI,OAAO,GAA2B,CAAC,QAAQ,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAC,CAAC;gBAClE,IAAI,OAAO,CAAC,OAAO,KAAK,IAAI,CAAC,UAAU,EAAE,EAAE;oBACzC,MAAM,OAAO,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC;oBAC5B,qBAAqB,CAAC,QAAQ,CAAC,sCAAsC,CAAC,OAAO,CAAC,CAAC;iBAChF;aACF;YAED,eAAe,GAAG,cAAc,CAAC,qBAAqB,CAAC,IAAI,CAAC,UAAU,EAAE,EAAE,mBAAmB,CAAC,OAAO,CAAC,CAAC;YACvG,MAAM,GAAG,MAAM,IAAI,CAAC,eAAe,CAAC,OAAO,CAAC,eAAe,CAAC,CAAC;SAC9D;QAED,IAAI,MAAM,CAAC,OAAO,EAAE;YAClB,MAAM,GAAG,IAAI,CAAC,WAAW,CAAC,WAAW,CAAC,IAAI,CAAC,CAAC;YAC5C,IAAI,CAAC,MAAM,CAAC,OAAO;gBACjB,MAAM,IAAI,CAAC,cAAc,CAAC,MAAM,EAAE,IAAI,CAAC,CAAC;SAC3C;QAED,IAAI,MAAM,CAAC,OAAO,EAAE;YAClB,eAAe,GAAG,cAAc,CAAC,qBAAqB,CAAC,IAAI,CAAC,UAAU,EAAE,EAAE,mBAAmB,CAAC,oBAAoB,CAAC,CAAC;YACpH,MAAM,GAAG,MAAM,IAAI,CAAC,eAAe,CAAC,OAAO,CAAC,eAAe,CAAC,CAAC;SAC9D;QACD,OAAO,MAAM,CAAC;IAChB,CAAC;IASD,KAAK,CAAC,kBAAkB;QACtB,IAAI,CAAC,IAAI,CAAC,UAAU,EAAE;YACpB,YAAY,CAAC,aAAa,CAAC,iBAAiB,EAAE,CAAC;YAC/C,IAAI,CAAC,eAAe,GAAG,wBAAwB,CAAC,UAAU,CAAC;YAC3D,MAAM,YAAY,CAAC,aAAa,CAAC,4CAA4C,CAAC,IAAI,EAAE,iBAAiB,CAAC,iBAAiB,EAAE,IAAI,CAAC,SAAS,CAAC,CAAC;YAEzI,IAAI,CAAC,YAAY,CAAC,aAAa,CAAC,oBAAoB,EAAE,EAAE;gBACtD,IAAI,IAAI,CAAC,SAAS,EAAE;oBAClB,IAAI,IAAI,CAAC,WAAW,EAAE;wBACpB,KAAK,IAAI,CAAC,GAAW,CAAC,EAAE,CAAC,GAAG,IAAI,CAAC,QAAQ,CAAC,OAAO,EAAE,EAAE,CAAC,EAAE,EAAE;4BACxD,IAAI,OAAO,GAAe,IAAI,CAAC,QAAQ,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC;4BACnD,IAAI,OAAO,CAAC,SAAS,EAAE;gCACZ,OAAO,CAAC,OAAO,EAAG,CAAC,sBAAsB,GAAG,IAAI,CAAC;gCAC1D,MAAM,OAAO,CAAC,kBAAkB,EAAE,CAAC;6BACpC;yBACF;oBACH,MAAM,YAAY,CAAC,aAAa,CAAC,2BAA2B,CAAC,IAAI,EAAE,iBAAiB,CAAC,iBAAiB,CAAC,CAAC;iBACzG;aACF;YAED,IAAI,CAAC,eAAe,GAAG,wBAAwB,CAAC,SAAS,CAAC;YAC1D,YAAY,CAAC,aAAa,CAAC,gBAAgB,EAAE,CAAC;SAC/C;IACH,CAAC;IAKO,kBAAkB;QACxB,IAAI,CAAC,SAAS,GAAG,CAAC,CAAC,KAAK,CAAC,UAAU,EAAE,IAAI,IAAI,KAAK,IAAI,CAAC,OAAO,CAAC,YAAY,EAAE,CAAC,CAAC;IACjF,CAAC;IAGD,OAAO;QACL,OAAO,CAAC,IAAI,CAAC,UAAU,IAAI,IAAI,CAAC,CAAC;IACnC,CAAC;IAKD,KAAK,CAAC,IAAI;QACR,IAAI,IAAU,CAAC;QACf,IAAI,IAAI,CAAC,SAAS;YAChB,OAAO;QAET,IAAI,IAAI,CAAC,WAAW,EAAE,EAAE;YACtB,OAAO,CAAC,IAAI,GAAS,IAAI,CAAC,QAAQ,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,IAAI,IAAI,EAAE;gBACtD,IAAI,CAAC,qBAAqB,CAAC,IAAI,CAAC,mBAAmB,CAAC,CAAC;gBACrD,MAAM,IAAI,CAAC,IAAI,EAAE,CAAC;aACnB;SACF;QAED,IAAI,CAAC,IAAI,CAAC,UAAU;YAClB,IAAI,CAAC,SAAS,GAAG,IAAI,CAAC;QAIxB,IAAI,IAAI,CAAC,WAAW,IAAI,IAAI,EAAE;YAC5B,IAAI,CAAC,WAAW,CAAC,aAAa,CAAC,IAAI,CAAC,CAAC;YACrC,IAAI,IAAI,CAAC,SAAS,EAAE;gBAClB,IAAI,SAAS,GAAiB,IAAI,IAAI,EAAU,EAAE,SAAS,GAAG,IAAI,IAAI,EAAU,CAAC;gBACjF,IAAI,GAAG,GAAG,IAAI,CAAC,SAAS,EAAE,CAAC;gBAE3B,IAAI,GAAG,CAAC,gBAAgB,EAAE,IAAI,IAAI;oBAChC,SAAS,GAAG,GAAG,CAAC,gBAAgB,EAAE,CAAC,eAAe,EAAE,CAAC;gBACvD,GAAG,CAAC,kBAAkB,CAAC,IAAI,CAAC,CAAC;gBAC7B,GAAG,CAAC,uBAAuB,CAAC,IAAI,CAAC,CAAC;gBAClC,IAAI,GAAG,CAAC,gBAAgB,EAAE,IAAI,IAAI;oBAChC,SAAS,GAAG,GAAG,CAAC,gBAAgB,EAAE,CAAC,eAAe,EAAE,CAAC;gBACvD,GAAG,CAAC,YAAY,CAAC,SAAS,EAAE,SAAS,CAAC,CAAC;gBAEvC,GAAG,CAAC,UAAU,CAAC,IAAI,CAAC,CAAC;gBACrB,UAAU,CAAC,QAAQ,CAAC,KAAK,CAAS,IAAI,CAAC,OAAO,EAAE,CAAC,CAAC;aACnD;SACF;QAED,IAAI,CAAC,gBAAgB,EAAE,CAAC;QAGxB,IAAI,IAAI,CAAC,iBAAiB,EAAE,IAAI,IAAI;YAClC,kBAAkB,CAAC,QAAQ,CAAC,kBAAkB,GAAG,IAAI,CAAC;QACxD,IAAI,IAAI,CAAC,IAAI,IAAI,IAAI;YACV,IAAI,CAAC,IAAK,CAAC,iBAAiB,EAAE,CAAC;QAE1C,IAAI,IAAI,CAAC,SAAS,EAAE;YAClB,IAAI,OAAO,GAAc,IAAI,CAAC,IAAI,CAAC,cAAc,EAAE,CAAC;YAEpD,OAAO,CAAC,gBAAgB,CAAC,IAAI,CAAC,CAAC;YAC/B,OAAO,CAAC,eAAe,EAAE,CAAC;YAE1B,IAAI,kBAAkB,CAAC,QAAQ,CAAC,kBAAkB,EAAE,KAAK,IAAI;gBAC3D,kBAAkB,CAAC,QAAQ,CAAC,kBAAkB,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC;YAGnE,IAAI,OAAO,CAAC,aAAa;gBACvB,MAAM,CAAC,OAAO,CAAC,OAAO,CAAC,aAAa,CAAC,iBAAiB,CAAC,CAAC,CAAC,cAAc,CAAC,IAAI,CAAC,CAAC;SACjF;QAED,IAAI,oBAAoB,GAAmB,cAAc,CAAC,qBAAqB,CAAC,IAAI,CAAC,UAAU,EAAE,EAAE,mBAAmB,CAAC,KAAK,CAAC,CAAC;QAC9H,MAAM,IAAI,CAAC,eAAe,CAAC,OAAO,CAAC,oBAAoB,CAAC,CAAC;IAC3D,CAAC;IAKD,KAAK;QACH,IAAI,CAAC,SAAS,EAAE,CAAC,KAAK,EAAE,CAAC;IAC3B,CAAC;IAKD,WAAW;QACT,OAAO,IAAI,CAAC,QAAQ,KAAK,IAAI,IAAI,IAAI,CAAC,QAAQ,CAAC,OAAO,EAAE,GAAG,CAAC,CAAC;IAC/D,CAAC;IAOD,YAAY,CAAC,aAAsB;QACjC,IAAI,aAAa;YACf,OAAO,IAAI,CAAC,aAAa,CAAC,aAAa,CAAC,CAAC;QAG3C,IAAI,KAAK,GAAmB,IAAI,CAAC,cAAc,EAAG,CAAC,aAAa,CAAC,aAAa,CAAC,CAAC;QAGhF,IAAI,IAAI,CAAC,UAAU,EAAE,IAAI,IAAI,CAAC,SAAS,EAAE,KAAK,cAAc,CAAC,mBAAmB;YAC9E,KAAK,GAAG,KAAK,GAAG,CAAC,CAAC;QAEpB,OAAO,KAAK,CAAC;IACf,CAAC;IAMO,aAAa,CAAC,aAAsB;QAC1C,IAAI,OAAO,GAAS,IAAI,CAAC,iBAAiB,EAAE,CAAC;QAC7C,IAAI,OAAO,IAAI,IAAI,IAAI,aAAa;YAClC,IAAI,IAAI,CAAC,WAAW,IAAI,IAAI;gBAC1B,OAAO,CAAC,CAAC;iBACN;gBAIH,IAAI,aAAa,IAAI,IAAI,CAAC,SAAS,EAAE,KAAK,IAAI,CAAC,WAAW,CAAC,SAAS,EAAE;oBACpE,OAAO,CAAC,GAAG,IAAI,CAAC,WAAW,CAAC,aAAa,CAAC,aAAa,CAAC,CAAC;gBAC3D,OAAO,CAAC,GAAG,IAAI,CAAC,WAAW,CAAC,aAAa,CAAC,aAAa,CAAC,CAAC;aAC1D;QACH,OAAO,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC,aAAa,CAAC,aAAa,CAAC,CAAC;IACpD,CAAC;IAMD,eAAe,CAAC,UAAkB;QAChC,OAAO,IAAI,CAAC,gBAAgB,CAAC,UAAU,CAAC,CAAC;IAC3C,CAAC;IAKO,gBAAgB,CAAC,UAAkB;QACzC,IAAI,OAAO,GAAU,IAAI,CAAC;QAE1B,IAAI,UAAU,KAAK,CAAC;YAClB,OAAO,GAAG,IAAI,CAAC;aACZ;YACH,IAAI,OAAO,GAAS,IAAI,CAAC,iBAAiB,EAAE,CAAC;YAC7C,IAAI,OAAO,KAAK,IAAI;gBAClB,OAAO,GAAG,IAAI,CAAC,WAAW,CAAC;YAC7B,IAAI,OAAO,KAAK,IAAI;gBAClB,OAAO,GAAG,OAAO,CAAC,gBAAgB,CAAC,EAAE,UAAU,CAAC,CAAC;SACpD;QAED,OAAO,OAAO,CAAC;IACjB,CAAC;IAMD,YAAY;QACV,OAAO,IAAI,CAAC,YAAY,CAAC,KAAK,CAAC,CAAC;IAClC,CAAC;IAID,YAAY,CAAC,IAAc;QACzB,OAAO,IAAI,CAAC,SAAS,CAAC,QAAQ,CAAO,IAAI,CAAC,CAAC;IAC7C,CAAC;IAMD,cAAc,CAAC,OAAiB;QAC9B,IAAI,CAAC,WAAW,GAAS,OAAO,CAAC;IACnC,CAAC;IAKD,cAAc;QACZ,IAAI,OAAO,GAAW,CAAY,IAAI,CAAC,QAAS,CAAC,UAAU,EAAE,CAAC,CAAC;QAE/D,IAAI,IAAI,CAAC,cAAc;eAClB,OAAO,KAAK,IAAI,IAAI,CAAC,OAAO,CAAC,SAAS,IAAI,OAAO,CAAC,WAAW,CAAC;eAC9D,IAAI,CAAC,IAAI,KAAK,IAAI,IAAI,IAAI,CAAC,IAAI,CAAC,gBAAgB,EAAE;YACrD,OAAO,IAAI,CAAC;QAEd,OAAO,IAAI,CAAC,WAAW,CAAC;IAC1B,CAAC;IAKD,iBAAiB;QAMf,IAAI,IAAI,CAAC,eAAe,KAAK,IAAI,IAAI,IAAI,CAAC,eAAe,CAAC,SAAS,EAAE,CAAC,UAAU;YAC9E,IAAI,CAAC,eAAe,GAAG,IAAI,CAAC,WAAW,CAAC;QAE1C,OAAO,IAAI,CAAC,eAAe,CAAC;IAC9B,CAAC;IAMD,iBAAiB,CAAC,IAAmB;QACnC,KAAK,CAAC,iBAAiB,CAAC,IAAI,CAAC,CAAC;QAC9B,kBAAkB,CAAC,qBAAqB,CAAC,IAAI,EAAE,IAAI,CAAC,CAAC;IACvD,CAAC;IAOD,aAAa;QACX,IAAI,aAAa,GAAW,CAAC,CAAC;QAC9B,IAAI,MAAM,GAAG,IAAI,aAAa,CAAC,IAAI,CAAC,CAAC;QACrC,IAAI,SAAS,GAAG,IAAI,KAAK,CAAC,IAAI,CAAC,YAAY,CAAC,KAAK,CAAC,CAAC,CAAC;QACpD,IAAI,CAAC,UAAU,CAAC,SAAS,EAAE,KAAK,CAAC,CAAC;QAClC,KAAK,IAAI,GAAG,GAAW,SAAS,CAAC,MAAM,GAAG,CAAC,EAAE,GAAG,IAAI,CAAC,EAAE,GAAG,EAAE,EAAE;YAC5D,IAAI,OAAO,GAAS,SAAS,CAAC,GAAG,CAAC,CAAC;YACnC,IAAI,OAAO,CAAC,UAAU,EAAE;gBACtB,SAAS;YACX,IAAI,QAAQ,GAAa,OAAO,CAAC,OAAO,CAAC,aAAa,CAAC,cAAc,CAAC,CAAC;YACvE,IAAI,QAAQ,IAAI,IAAI;gBAClB,SAAS;YACX,IAAI,IAAI,GAAW,QAAQ,CAAC,gBAAgB,EAAE,CAAC;YAC/C,IAAI,CAAC,OAAO,CAAC,aAAa,CAAC,IAAI,CAAC,EAAE;gBAGhC,IAAI,aAAa,EAAE,KAAK,CAAC;oBACvB,MAAM,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC;gBACrB,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC;aACrB;SACF;QACD,OAAO,MAAM,CAAC;IAChB,CAAC;IAKD,oBAAoB,CAAC,GAAW;QAC9B,IAAI,OAAa,CAAC;QAClB,IAAI,OAAO,GAAW,CAAC,CAAC;QACxB,IAAI,OAAO,GAAW,CAAC,CAAC;QAExB,IAAI,SAAS,GAAG,IAAI,KAAK,CAAC,IAAI,CAAC,YAAY,CAAC,IAAI,CAAC,CAAC,CAAC;QAEnD,IAAI,CAAC,UAAU,CAAC,SAAS,EAAE,IAAI,CAAC,CAAC;QAEjC,KAAK,IAAI,GAAG,GAAW,SAAS,CAAC,MAAM,GAAG,CAAC,EAAE,GAAG,IAAI,CAAC,EAAE,GAAG,EAAE,EAAE;YAC5D,OAAO,GAAG,SAAS,CAAC,GAAG,CAAC,CAAC;YAEzB,OAAO,IAAI,OAAO,CAAC,QAAQ,CAAC,YAAY,EAAE,CAAC,OAAO,EAAE,CAAC;YAGrD,IAAI,GAAG,GAAG,OAAO,EAAE;gBAEjB,GAAG,IAAI,OAAO,CAAC;gBACf,OAAc,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC;aAC9C;YACD,OAAO,GAAG,OAAO,CAAC;SACnB;QAED,OAAO,IAAI,CAAC;IACd,CAAC;IAOD,uBAAuB,CAAC,IAAY;QAClC,IAAI,QAAc,CAAC;QACnB,IAAI,QAAQ,GAAW,CAAC,CAAC;QACzB,IAAI,QAAQ,GAAW,CAAC,CAAC;QACzB,IAAI,0BAA0B,GAAW,CAAC,CAAC;QAG3C,IAAI,SAAS,GAAG,IAAI,KAAK,CAAC,IAAI,CAAC,YAAY,CAAC,IAAI,CAAC,CAAC,CAAC;QAEnD,IAAI,CAAC,UAAU,CAAC,SAAS,EAAE,IAAI,CAAC,CAAC;QAEjC,KAAK,IAAI,IAAI,GAAW,SAAS,CAAC,MAAM,GAAG,CAAC,EAAE,IAAI,IAAI,CAAC,EAAE,IAAI,EAAE,EAAE;YAC/D,QAAQ,GAAG,SAAS,CAAC,IAAI,CAAC,CAAC;YAC3B,QAAQ,IAAI,QAAQ,CAAC,QAAQ,CAAC,YAAY,EAAE,CAAC,OAAO,EAAE,CAAC;YAGvD,IAAI,IAAI,GAAG,QAAQ,EAAE;gBAEnB,IAAI,IAAI,QAAQ,CAAC;gBAEjB,IAAI,KAAK,GAAiB,QAAQ,CAAC,QAAQ,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC;gBAC3D,IAAI,KAAK,CAAC,OAAO,EAAE,IAAI,IAAI;oBACzB,OAAO,0BAA0B,GAAG,0BAA0B,GAAG,QAAQ,CAAC,IAAI,CAAC,aAAa,CAAC,KAAK,CAAC,OAAO,EAAE,CAAC,GAAG,CAAC,CAAC;gBAEpH,OAAO,CAAC,CAAC;aACV;YAED,IAAI,QAAQ,CAAC,IAAI,IAAI,IAAI;gBACvB,0BAA0B,IAAI,QAAQ,CAAC,IAAI,CAAC,YAAY,EAAE,CAAC;YAE7D,QAAQ,GAAG,QAAQ,CAAC;SACrB;QAGD,OAAO,CAAC,CAAC;IACX,CAAC;IAOD,uBAAuB,CAAC,SAAiB,EAAE,MAAwB;QACjE,IAAI,OAAO,GAAc,IAAI,CAAC;QAC9B,MAAM,CAAC,KAAK,GAAG,CAAC,CAAC,CAAC;QAElB,IAAI,SAAS,IAAI,CAAC,EAAE;YAClB,IAAI,QAAQ,GAAS,IAAI,CAAC;YAC1B,IAAI,UAAU,GAAS,IAAI,CAAC;YAC5B,IAAI,sBAAsB,GAAW,CAAC,CAAC;YACvC,IAAI,0BAA0B,GAAW,CAAC,CAAC;YAC3C,IAAI,UAAU,GAAW,CAAC,CAAC;YAG3B,IAAI,SAAS,GAAG,IAAI,KAAK,CAAC,IAAI,CAAC,YAAY,CAAC,IAAI,CAAC,CAAC,CAAC;YAGnD,IAAI,CAAC,UAAU,CAAC,SAAS,EAAE,IAAI,CAAC,CAAC;YAEjC,KAAK,IAAI,IAAI,GAAW,SAAS,CAAC,MAAM,GAAG,CAAC,EAAE,IAAI,IAAI,CAAC,EAAE,IAAI,EAAE,EAAE;gBAE/D,QAAQ,GAAG,SAAS,CAAC,IAAI,CAAC,CAAC;gBAE3B,IAAI,QAAQ,CAAC,IAAI,IAAI,IAAI,EAAE;oBACzB,sBAAsB,GAAG,QAAQ,CAAC,IAAI,CAAC,YAAY,EAAE,CAAC;oBAGtD,IAAI,SAAS,GAAG,CAAC,0BAA0B,GAAG,sBAAsB,CAAC,EAAE;wBAErE,UAAU,GAAG,SAAS,GAAG,0BAA0B,CAAC;wBACpD,OAAO,GAAc,QAAQ,CAAC,IAAI,CAAC,OAAO,CAAC,OAAO,CAAC,UAAU,CAAC,CAAC;wBAC/D,UAAU,GAAG,QAAQ,CAAC;wBACtB,MAAM;qBACP;oBAED,0BAA0B,IAAI,sBAAsB,CAAC;iBACtD;aACF;YAGD,IAAI,OAAO,IAAI,IAAI,EAAE;gBACnB,MAAM,CAAC,KAAK,GAAG,CAAC,CAAC;gBACjB,IAAI,UAAU,GAAW,SAAS,CAAC,CAAC,CAAC,CAAC,gBAAgB,CAAC,QAAQ,CAAC;gBAEhE,KAAK,IAAI,IAAI,GAAW,CAAC,EAAE,IAAI,GAAG,SAAS,CAAC,MAAM,GAAG,CAAC,EAAE,IAAI,EAAE,EAAE;oBAC9D,QAAQ,GAAG,SAAS,CAAC,IAAI,CAAC,CAAC;oBAE3B,IAAI,UAAU,KAAK,QAAQ,CAAC,gBAAgB,CAAC,QAAQ;wBACnD,MAAM,CAAC,KAAK,EAAE,CAAC;oBAEjB,IAAI,UAAU,CAAC,gBAAgB,CAAC,QAAQ,KAAK,QAAQ,CAAC,gBAAgB,CAAC,QAAQ;wBAC7E,MAAM;oBAER,UAAU,GAAG,QAAQ,CAAC,gBAAgB,CAAC,QAAQ,CAAC;iBACjD;aACF;SACF;QAGD,OAAO,OAAO,CAAC;IACjB,CAAC;IAID,oBAAoB,CAAC,MAAc,EAAE,GAAW;QAC9C,IAAI,GAAS,CAAC;QACd,IAAI,KAAK,GAAW,IAAI,CAAC,YAAY,CAAC,IAAI,CAAC,CAAC;QAE5C,IAAI,MAAM,KAAK,QAAQ,CAAC,kBAAkB,IAAI,KAAK,IAAI,MAAM;YAC3D,OAAO,GAAG,CAAC;QAEb,IAAI,SAAS,GAAG,IAAI,KAAK,CAAC,KAAK,CAAC,CAAC;QAEjC,IAAI,GAAG,KAAK,CAAC,EAAE;YACb,IAAI,CAAC,UAAU,CAAC,SAAS,EAAE,IAAI,CAAC,CAAC;YAGjC,IAAI,qBAAqB,GAAW,IAAI,CAAC,wBAAwB,CAAC,MAAM,EAAE,SAAS,CAAC,CAAC;YAErF,IAAI,CAAS,CAAC;YACd,KAAK,CAAC,GAAG,SAAS,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC,GAAG,qBAAqB,EAAE,CAAC,EAAE,EAAE;gBAC7D,GAAG,GAAG,SAAS,CAAC,CAAC,CAAC,CAAC;gBACnB,GAAG,IAAI,GAAG,CAAC,QAAQ,CAAC,YAAY,EAAE,CAAC,OAAO,EAAE,CAAC;aAC9C;SACF;QACD,OAAO,GAAG,CAAC;IACb,CAAC;IAOD,wBAAwB,CAAC,MAAc,EAAE,QAAgB;QACvD,IAAI,qBAAqB,GAAW,CAAC,CAAC;QACtC,IAAI,MAAM,KAAK,QAAQ,CAAC,kBAAkB,EAAE;YAC1C,KAAK,IAAI,CAAC,GAAW,CAAC,EAAE,CAAC,GAAG,QAAQ,CAAC,MAAM,EAAE,CAAC,GAAG,CAAC,GAAG,CAAC,EAAE;gBACtD,IAAI,QAAQ,CAAC,CAAC,CAAC,CAAC,UAAU,EAAE,IAAI,IAAI,CAAC,OAAO,KAAK,QAAQ,CAAC,CAAC,CAAC,CAAC,SAAS,EAAE,EAAE;oBACxE,qBAAqB,GAAG,CAAC,CAAC;oBAC1B,MAAM;iBACP;aACF;SACF;;YAEC,qBAAqB,GAAG,MAAM,CAAC;QAEjC,OAAO,qBAAqB,CAAC;IAC/B,CAAC;IAMD,cAAc,CAAC,OAAe;QAC5B,OAAe,CAAC,IAAI,CAAC,cAAc,EAAE,CAAE,CAAC,eAAe,CAAC,OAAO,CAAC,CAAC;IACnE,CAAC;IAOO,eAAe,CAAC,OAAe;QACrC,IAAI,OAAa,CAAC;QAElB,IAAI,OAAO,IAAI,IAAI;YACjB,OAAO,IAAI,CAAC;QACd,IAAI,GAAG,GAAU,IAAI,CAAC,QAAQ,CAAC,OAAO,CAAC,CAAC;QAGxC,IAAI,GAAG,IAAI,IAAI,EAAE;YACf,OAAO,GAAG,IAAI,CAAC,iBAAiB,EAAE,IAAI,IAAI,CAAC,CAAC,CAAC,IAAI,CAAC,iBAAiB,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,WAAW,CAAC;YAEzF,IAAI,OAAO,IAAI,IAAI,EAAE;gBACnB,IAAI,CAAC,IAAI,CAAC,UAAU,EAAE,IAAI,IAAI,CAAC,SAAS,EAAE,KAAK,OAAO,CAAC,SAAS,EAAE,EAAE;oBAClE,IAAI,OAAO,GAAe,YAAY,CAAC,WAAW,CAAC,mBAAmB,CAAC,CAAC,CAAC,EAAE,IAAI,CAAC,SAAS,EAAE,CAAC,CAAC;oBAC7F,GAAG,GAAG,OAAO,CAAC,eAAe,CAAC,OAAO,CAAC,CAAC;iBACxC;gBAED,IAAI,GAAG,IAAI,IAAI;oBACb,GAAG,GAAG,OAAO,CAAC,eAAe,CAAC,OAAO,CAAC,CAAC;aAC1C;SACF;QACD,OAAO,GAAG,CAAC;IACb,CAAC;IAOD,qBAAqB,CAAC,OAAe;QACnC,IAAI,KAAK,GAAW,IAAI,CAAC,YAAY,CAAC,IAAI,CAAC,CAAC;QAC5C,IAAI,KAAK,GAAW,CAAC,CAAC;QACtB,IAAI,GAAG,GAAU,IAAI,CAAC,cAAc,CAAC,OAAO,CAAC,CAAC;QAC9C,IAAI,MAAmB,CAAC;QAExB,IAAI,GAAG,IAAI,IAAI;YACb,OAAO,CAAC,CAAC;QAEX,IAAI,SAAS,GAAG,IAAI,KAAK,CAAC,KAAK,CAAC,CAAC;QACjC,IAAI,CAAC,UAAU,CAAC,SAAS,EAAE,IAAI,CAAC,CAAC;QACjC,KAAK,IAAI,IAAI,GAAW,KAAK,GAAG,CAAC,EAAE,IAAI,IAAI,CAAC,EAAE,IAAI,EAAE,EAAE;YACpD,IAAI,QAAQ,GAAS,SAAS,CAAC,IAAI,CAAC,CAAC;YACrC,IAAI,QAAQ,KAAK,GAAG,CAAC,OAAO,EAAE,EAAE;gBAC9B,IAAI,GAAG,GAAG,CAAC,KAAK,EAAE,CAAC;gBACnB,KAAK,IAAI,EAAE,IAAI,CAAC;gBAChB,MAAM;aACP;YACD,MAAM,GAAgB,QAAQ,CAAC,QAAQ,CAAC,YAAY,EAAE,CAAC;YACvD,KAAK,IAAI,MAAM,CAAC,OAAO,EAAE,CAAC;SAC3B;QACD,OAAO,KAAK,CAAC;IACf,CAAC;IAOD,UAAU,CAAC,IAAY,EAAE,aAAsB;QAC7C,IAAI,IAAI,GAAS,CAAC,aAAa,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAQ,IAAI,CAAC,cAAc,EAAE,CAAC,CAAC;QAEvE,KAAK,IAAI,CAAC,GAAW,CAAC,EAAE,CAAC,GAAG,IAAI,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE;YAC5C,IAAI,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC;YACf,IAAI,MAAM,GAAW,IAAI,CAAC,SAAS,EAAE,CAAC;YAEtC,IAAI,OAAO,GAAS,aAAa,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,IAAI,CAAC,iBAAiB,EAAE,CAAC;YAEpE,IAAI,OAAO,IAAI,IAAI;gBACjB,IAAI,GAAG,OAAO,CAAC;iBACZ;gBACH,IAAI,GAAS,IAAI,CAAC,SAAS,EAAE,CAAC;gBAE9B,IAAI,IAAI,IAAI,IAAI,EAAE;oBAEhB,IAAI,CAAC,aAAa,IAAI,IAAI,CAAC,UAAU,EAAE,IAAI,IAAI,CAAC,SAAS,EAAE,KAAK,cAAc,CAAC,mBAAmB;wBAChG,IAAI,CAAC,CAAC,GAAG,CAAC,CAAC,GAAG,IAAI,CAAC;oBACrB,MAAM;iBACP;gBAED,IAAI,aAAa,IAAI,MAAM,KAAK,IAAI,CAAC,SAAS,EAAE;oBAC9C,IAAI,CAAC,EAAE,CAAC,CAAC,GAAS,YAAY,CAAC,WAAW,CAAC,mBAAmB,CAAC,CAAC,CAAC,EAAE,MAAM,CAAC,CAAC;aAC9E;SACF;IACH,CAAC;IAMO,iBAAiB;QACvB,IAAI,QAAQ,GAAuB,IAAI,CAAC,WAAW,CAAC,QAAQ,CAAC;QAC7D,IAAI,MAAM,GAAY,KAAK,CAAC;QAI5B,IAAI,IAAI,CAAC,WAAW,KAAK,IAAI,IAAI,QAAQ,CAAC,iBAAiB,EAAE;YAC3D,CAAC,IAAI,CAAC,aAAa,KAAK,IAAI,IAAI,CAAC,QAAQ,CAAC,cAAc,CAAC,IAAI,CAAC,aAAa,CAAC,CAAC;YAC7E,MAAM,GAAG,IAAI,CAAC;QAEhB,OAAO,MAAM,CAAC;IAChB,CAAC;IAKD,KAAK,CAAC,oBAAoB;QACxB,IAAI,GAAG,GAAY,KAAK,CAAC;QAGzB,IAAI,IAAI,CAAC,gBAAgB,EAAE;YACzB,IAAI,iBAAiB,GAAe,MAAM,IAAI,CAAC,oBAAoB,EAAE,CAAC;YAEtE,IAAI,iBAAiB,CAAC,MAAM,GAAG,CAAC;gBAC9B,GAAG,GAAG,IAAI,CAAC;SACd;QACD,OAAO,GAAG,CAAC;IACb,CAAC;IAMO,WAAW;QACjB,IAAI,QAAQ,GAAe,IAAI,IAAI,EAAQ,CAAC;QAE5C,IAAI,IAAI,CAAC,WAAW,EAAE,EAAE;YACtB,KAAK,IAAI,CAAC,GAAW,CAAC,EAAE,CAAC,GAAG,IAAI,CAAC,QAAQ,CAAC,OAAO,EAAE,EAAE,CAAC,GAAG,CAAC,GAAG,CAAC;gBAC5D,QAAQ,CAAC,IAAI,CAAO,IAAI,CAAC,QAAQ,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,CAAC;SACjD;QAED,OAAO,QAAQ,CAAC;IAClB,CAAC;IAMD,KAAK,CAAC,oBAAoB;QACxB,IAAI,QAAQ,GAAe,IAAI,CAAC,WAAW,EAAE,CAAC;QAC9C,IAAI,iBAAiB,GAAe,IAAI,IAAI,EAAQ,CAAC;QAErD,KAAK,IAAI,CAAC,GAAW,CAAC,EAAE,CAAC,GAAG,QAAQ,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE;YAChD,IAAI,OAAO,GAAS,QAAQ,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC;YACzC,IAAI,MAAM,IAAI,CAAC,wBAAwB,CAAC,OAAO,CAAC;gBAC9C,iBAAiB,CAAC,IAAI,CAAC,OAAO,CAAC,CAAA;SAClC;QAED,OAAO,iBAAiB,CAAC;IAC3B,CAAC;IAQD,KAAK,CAAC,wBAAwB,CAAC,OAAa;QAC1C,IAAI,OAAO,GAAY,KAAK,CAAC;QAC7B,IAAI,WAAW,GAAyB,OAAO,CAAC,OAAO,EAAE,CAAC,cAAc,EAAE,CAAC;QAE3E,OAAO,CAAC,qBAAqB,GAAG,KAAK,CAAC;QAEtC,IAAI,WAAW,IAAI,IAAI,IAAI,CAAC,OAAO,CAAC,QAAQ,IAAI,OAAO,CAAC,sBAAsB,EAAE;YAC9E,IAAI,UAAU,GAAW,IAAI,CAAC,OAAO,EAAE,CAAC;YACxC,IAAI,YAAY,GAAW,CAAC,UAAU,KAAK,SAAS,CAAC,eAAe,CAAC,CAAC,CAAC,aAAa,CAAC,qBAAqB;gBACxG,CAAC,CAAC,UAAU,KAAK,SAAS,CAAC,gBAAgB;oBACf,CAAC,CAAC,aAAa,CAAC,sBAAsB;oBACtC,CAAC,CAAC,aAAa,CAAC,sBAAsB,CAAC,CAAC;YAKtE,IAAI,OAAO,CAAC,YAAY,IAAI,UAAU,KAAK,OAAO,CAAC,OAAO,EAAE;gBAC1D,IAAI,CAAC,QAAQ,EAAE,KAAK,SAAS,CAAC,iBAAiB;gBAC/C,MAAM,CAAC,OAAO,CAAC,OAAO,CAAC,aAAa,CAAC,sBAAsB,CAAC,CAAC,CAAC,eAAe,EAAE;gBAC/E,MAAM,OAAO,CAAC,SAAS,CAAC,YAAY,EAAE,IAAI,CAAC,EAAE;gBAC7C,IAAI,CAAC,WAAW,CAAC,SAAS,EAAE;oBAC1B,CAAC,MAAM,WAAW,CAAC,SAAS,CAAC,aAAa,CAAC,6BAA6B,EAAE,KAAK,CAAC,EAAE;oBAClF,WAAW,CAAC,gBAAgB,GAAG,IAAI,CAAC;oBACpC,OAAO,GAAG,KAAK,CAAC;iBACjB;;oBAEC,OAAO,GAAG,IAAI,CAAC;gBAEjB,MAAM,OAAO,CAAC,eAAe,CAAC,UAAU,CAAC,CAAC;aAC3C;iBACI;gBACH,OAAO,GAAG,MAAM,WAAW,CAAC,SAAS,CAAC,aAAa,CAAC,sBAAsB,EAAE,IAAI,CAAC,IAAI,OAAO,CAAC,iBAAiB,EAAE,CAAC;gBAEjH,IAAI,OAAO,EAAE;oBACX,IAAI,CAAC,WAAW,CAAC,SAAS,EAAE;wBAC1B,CAAC,MAAM,WAAW,CAAC,SAAS,CAAC,aAAa,CAAC,6BAA6B,EAAE,KAAK,CAAC,EAAE;wBAClF,WAAW,CAAC,gBAAgB,GAAG,IAAI,CAAC;wBACpC,OAAO,GAAG,KAAK,CAAC;qBACjB;iBACF;aACF;YAED,IAAI,OAAO;gBACT,OAAO,CAAC,qBAAqB,GAAG,IAAI,CAAC;SACxC;QACD,OAAO,OAAO,CAAC;IACjB,CAAC;IAMD,KAAK,CAAC,eAAe,CAAC,UAAkB;QACtC,MAAM,IAAI,CAAC,WAAW,EAAE,CAAC;QAEzB,IAAI,UAAU,KAAK,SAAS,CAAC,gBAAgB,EAAE;YAC7C,IAAI,GAAG,GAAmB,cAAc,CAAC,kBAAkB,CAAC,IAAI,CAAC,UAAU,EAAE,EAAE,iBAAiB,CAAC,iBAAiB,CAAC,CAAC;YACpH,MAAM,IAAI,CAAC,eAAe,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC;SACzC;aACI,IAAI,IAAI,CAAC,OAAO,EAAE,KAAK,SAAS,CAAC,gBAAgB,EAAE;YACtD,IAAI,CAAC,sBAAsB,CAAC,IAAI,CAAC,CAAC;YAClC,IAAI,CAAC,uBAAuB,CAAC,IAAI,CAAC,CAAC;YACnC,MAAM,YAAY,CAAC,aAAa,CAAC,2BAA2B,CAAC,IAAI,EAAE,iBAAiB,CAAC,sBAAsB,CAAC,CAAC;YAC7G,IAAI,CAAC,sBAAsB,CAAC,KAAK,CAAC,CAAC;YACnC,IAAI,CAAC,uBAAuB,CAAC,KAAK,CAAC,CAAC;YACpC,IAAI,SAAS,GAAuB,IAAI,CAAC,QAAQ,CAAC;YAClD,IAAI,CAAC,SAAS,CAAC,OAAO,EAAE,IAAI,CAAC,SAAS,CAAC,UAAU,EAAE,CAAC,CAAC,OAAO,EAAE,KAAK,qBAAqB,CAAC,MAAM;gBAC7F,IAAI,CAAC,OAAO,CAAC,UAAU,CAAC,CAAC;;gBAEzB,IAAI,CAAC,OAAO,CAAC,SAAS,CAAC,gBAAgB,CAAC,CAAC;YAC3C,MAAe,IAAI,CAAC,OAAO,EAAG,CAAC,cAAc,CAAC,SAAS,CAAC,qBAAqB,CAAC,CAAC;SAChF;;YAEC,IAAI,CAAC,OAAO,CAAC,UAAU,CAAC,CAAC;QAE3B,IAAI,CAAC,mBAAmB,CAAC,UAAU,CAAC,CAAC;QACrC,MAAM,IAAI,CAAC,8BAA8B,EAAE,CAAC;IAC9C,CAAC;IAGD,KAAK,CAAC,wBAAwB;QAC5B,IAAI,QAAQ,GAAe,IAAI,CAAC,WAAW,EAAE,CAAC;QAG9C,KAAK,IAAI,CAAC,GAAW,CAAC,EAAE,CAAC,GAAG,QAAQ,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE;YAChD,IAAI,OAAO,GAAS,QAAQ,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC;YACzC,IAAI,OAAO,CAAC,qBAAqB,EAAE;gBACjC,MAAM,YAAY,CAAC,aAAa,CAAC,4CAA4C,CAAC,OAAO,EAAE,iBAAiB,CAAC,iBAAiB,EAAE,IAAI,CAAC,CAAC;gBAClI,IAAI,CAAC,YAAY,CAAC,aAAa,CAAC,oBAAoB,EAAE;oBACpD,MAAM,YAAY,CAAC,aAAa,CAAC,2BAA2B,CAAC,OAAO,EAAE,iBAAiB,CAAC,iBAAiB,CAAC,CAAC;aAC9G;SACF;IACH,CAAC;IAGD,0BAA0B;QACxB,IAAI,QAAQ,GAAe,IAAI,CAAC,WAAW,EAAE,CAAC;QAE9C,KAAK,IAAI,CAAC,GAAW,CAAC,EAAE,CAAC,GAAG,QAAQ,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE;YAChD,IAAI,OAAO,GAAS,QAAQ,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC;YACzC,OAAO,CAAC,qBAAqB,GAAG,KAAK,CAAC;SACvC;IACH,CAAC;IAKD,uBAAuB;QACrB,IAAI,IAAI,GAAa,IAAI,CAAC,OAAO,CAAC,aAAa,CAAC,wBAAwB,CAAC,CAAC;QAI1E,OAAO,CAAC,IAAI,CAAC,YAAY,EAAE,CAAC;IAC9B,CAAC;IAMD,UAAU,CAAC,OAAa;QACtB,IAAI,IAAI,CAAC,QAAQ,KAAK,IAAI;YACxB,IAAI,CAAC,QAAQ,GAAG,IAAI,UAAU,EAAE,CAAC;QACnC,IAAI,CAAC,QAAQ,CAAC,OAAO,CAAC,OAAO,CAAC,CAAC;IACjC,CAAC;IAMD,aAAa,CAAC,OAAa;QACzB,IAAI,IAAI,CAAC,QAAQ,KAAK,IAAI;YACxB,IAAI,CAAC,QAAQ,CAAC,UAAU,CAAC,OAAO,CAAC,CAAC;IACtC,CAAC;IAMD,oBAAoB,CAAC,GAAY;QAC/B,IAAI,CAAC,kBAAkB,GAAG,GAAG,CAAC;QAE9B,IAAI,CAAC,GAAG;YACN,IAAI,CAAC,8BAA8B,GAAG,IAAI,CAAC;IAC/C,CAAC;IAQD,iBAAiB,CAAC,KAAa;QAC7B,IAAI,KAAK,KAAK,cAAc,CAAC,UAAU;YACrC,CAAC,IAAI,CAAC,WAAW,IAAI,IAAI,IAAI,IAAI,CAAC,WAAW,CAAC,QAAQ,EAAE,KAAK,KAAK,CAAC;YACnE,OAAO,IAAI,CAAC,kBAAkB,CAAC;aAC5B,IAAI,KAAK,KAAK,cAAc,CAAC,UAAU;YAC1C,CAAC,IAAI,CAAC,8BAA8B,IAAI,IAAI,IAAI,IAAI,CAAC,8BAA8B,CAAC,QAAQ,EAAE,KAAK,KAAK,CAAC;YACzG,OAAO,IAAI,CAAC,kBAAkB,CAAC;QACjC,OAAO,KAAK,CAAC;IACf,CAAC;IAMD,aAAa,CAAC,GAAW;QACvB,IAAI,IAAI,CAAC,WAAW,IAAI,IAAI;YAC1B,IAAI,CAAC,WAAW,CAAC,aAAa,CAAC,GAAG,CAAC,CAAC;aACjC,IAAI,IAAI,CAAC,8BAA8B,IAAI,IAAI,EAAE;YACpD,IAAI,GAAG,KAAK,cAAc,CAAC,aAAa;gBACtC,IAAI,CAAC,8BAA8B,GAAG,IAAI,CAAC;;gBAE3C,IAAI,CAAC,8BAA8B,CAAC,aAAa,CAAC,GAAG,CAAC,CAAC;SAC1D;IACH,CAAC;IAID,aAAa,CAAC,QAAiB;QAC7B,IAAI,SAAS,CAAC,MAAM,KAAK,CAAC,EAAE;YAC1B,OAAO,IAAI,CAAC,eAAe,EAAE,CAAC;SAC/B;QACD,OAAO,IAAI,CAAC,eAAe,CAAC,QAAQ,CAAC,CAAC;IACxC,CAAC;IAGO,eAAe;QACrB,IAAI,IAAI,CAAC,WAAW,IAAI,IAAI;YAC1B,OAAO,IAAI,CAAC,WAAW,CAAC,aAAa,EAAE,CAAC;aACrC,IAAI,IAAI,CAAC,8BAA8B,IAAI,IAAI;YAClD,OAAO,IAAI,CAAC,8BAA8B,CAAC,aAAa,EAAE,CAAC;QAC7D,OAAO,KAAK,CAAC;IACf,CAAC;IAGO,eAAe,CAAC,QAAgB;QACtC,IAAI,IAAI,CAAC,WAAW,IAAI,IAAI;YAC1B,OAAO,IAAI,CAAC,WAAW,CAAC,aAAa,CAAC,QAAQ,CAAC,CAAC;aAC7C,IAAI,IAAI,CAAC,8BAA8B,IAAI,IAAI;YAClD,OAAO,IAAI,CAAC,8BAA8B,CAAC,aAAa,CAAC,QAAQ,CAAC,CAAC;QACrE,OAAO,KAAK,CAAC;IACf,CAAC;IAMD,cAAc;QACZ,OAAO,IAAI,CAAC,aAAa,CAAC;IAC5B,CAAC;IAKD,gBAAgB;QACd,IAAI,CAAC,aAAa,GAAG,KAAK,CAAC;IAC7B,CAAC;IAKD,cAAc;QACZ,IAAI,CAAC,aAAa,GAAG,IAAI,CAAC;IAC5B,CAAC;IAOD,KAAK,CAAC,WAAW,CAAC,IAAY;QAC5B,IAAI,eAAyB,CAAC;QAC9B,IAAI,eAAe,GAAa,IAAI,CAAC,OAAO,CAAC,aAAa,CAAC,4BAA4B,CAAC,CAAC;QAGzF,IAAI,IAAI,CAAC,SAAS;YAChB,OAAO,KAAK,CAAC;QAEf,IAAI,IAAI,CAAC,aAAa;YACpB,OAAO,IAAI,CAAC;QAEd,IAAI,eAAe,IAAI,IAAI,IAAI,CAAE,OAAO,CAAC,OAAO,CAAC,MAAM,eAAe,CAAC,QAAQ,EAAE,EAAE,cAAc,CAAC,uBAAuB,EACrH,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC,MAAM,eAAe,CAAC,QAAQ,EAAE,CAAC,CAAC,WAAW,EAAE,KAAK,IAAI,CAAC,WAAW,EAAE,CAAC,CAAC,EAAE;YAE7F,eAAe,GAAG,IAAI,CAAC,OAAO,CAAC,aAAa,CAAC,uBAAuB,CAAC,CAAC;YACtE,IAAI,eAAe,IAAI,IAAI;gBACzB,OAAO,KAAK,CAAC;YACf,IAAI,OAAO,GAAW,MAAM,eAAe,CAAC,QAAQ,EAAE,CAAC;YAEvD,IAAI,gBAAgB,CAAC,SAAS,CAAC,OAAO,CAAC,EAAE;gBACvC,IAAI,CAAC,aAAa,GAAG,IAAI,CAAC;gBAC1B,OAAO,IAAI,CAAC;aACb;YACD,OAAO,KAAK,CAAC;SACd;QACD,OAAO,KAAK,CAAC;IACf,CAAC;IAMD,eAAe,CAAC,GAAY;QAC1B,IAAI,IAAI,CAAC,WAAW,EAAE,EAAE;YACtB,KAAK,IAAI,CAAC,GAAW,CAAC,EAAE,CAAC,GAAG,IAAI,CAAC,QAAQ,CAAC,OAAO,EAAE,EAAE,CAAC,GAAG,CAAC,GAAG,CAAC,EAAE;gBAC9D,IAAI,IAAI,GAAe,IAAI,CAAC,QAAQ,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC;gBAChD,IAAI,CAAC,eAAe,CAAC,GAAG,CAAC,CAAC;aAC3B;SACF;QACD,IAAI,CAAC,cAAc,GAAG,GAAG,CAAC;IAC5B,CAAC;IAKD,iBAAiB;QACf,OAAO,IAAI,CAAC,eAAe,CAAC;IAC9B,CAAC;IAKD,iBAAiB,CAAC,MAAe;QAC/B,IAAI,MAAM,KAAK,IAAI,CAAC,eAAe,EAAE;YACnC,IAAI,CAAC,eAAe,GAAG,MAAM,CAAC;YAC9B,OAAO,IAAI,CAAC;SACb;QACD,OAAO,KAAK,CAAC;IACf,CAAC;IAOD,gBAAgB,CAAC,KAAc;QAC7B,IAAI,KAAK,KAAK,IAAI,CAAC,cAAc,EAAE;YACjC,IAAI,CAAC,cAAc,GAAG,KAAK,CAAC;YAC5B,OAAO,IAAI,CAAC;SACb;QACD,OAAO,KAAK,CAAC;IACf,CAAC;IAMD,gBAAgB;QACd,OAAO,IAAI,CAAC,cAAc,CAAC;IAC7B,CAAC;IAEA,KAAK,CAAC,OAAO,CAAC,cAAuB,EAAE,SAAkB,EAAE,gBAAyB,EAAE,kBAA4B;QACjH,IAAI,iBAAiB,CAAC,kBAAkB,CAAC;YACvC,OAAO,MAAM,IAAI,CAAC,SAAS,CAAC,cAAc,EAAE,SAAS,EAAE,KAAK,EAAE,gBAAgB,CAAC,CAAC;;YAEhF,OAAO,MAAM,IAAI,CAAC,SAAS,CAAC,cAAc,EAAE,SAAS,EAAE,kBAAkB,EAAE,gBAAgB,CAAC,CAAC;IACjG,CAAC;IAQO,KAAK,CAAC,SAAS,CAAC,cAAuB,EAAE,SAAkB,EAAE,kBAA2B,EAAE,gBAAyB;QACzH,IAAI,SAAS,GAAY,IAAI,CAAC;QAC9B,IAAI,aAAa,GAAY,KAAK,CAAC;QACnC,IAAI,OAAa,CAAC;QAClB,IAAI,MAAM,GAAsB,YAAY,CAAC,WAAW,CAAC;QAEzD,IAAI,CAAC,IAAI,CAAC,SAAS,IAAI,CAAC,kBAAkB,CAAC,IAAI,CAAC,IAAI,CAAC,WAAW,CAAC,SAAS,EAAE;YAG1E,SAAS,GAAG,MAAM,IAAI,CAAC,WAAW,CAAC,OAAO,CAAC,cAAc,EAAE,SAAS,EAAE,gBAAgB,CAAC,CAAC;SACzF;aACI,IAAI,CAAC,IAAI,CAAC,UAAU,EAAE,IAAI,CAAC,IAAI,CAAC,SAAS,EAAE;YAC9C,IAAI;gBACF,IAAI,CAAC,SAAS,GAAG,IAAI,CAAC;gBAGtB,IAAG,CAAC,gBAAgB,CAAC,QAAQ,CAAC,aAAa,CAAC,YAAY,EAAE,CAAC,SAAS,IAAI,gBAAgB,CAAC,QAAQ,CAAC,aAAa,CAAC,YAAY,EAAE,CAAC,aAAa,CAAC,IAAI,YAAY,CAAC,aAAa,CAAC,oBAAoB,EAAE,EAClM;oBACE,IAAI,GAAG,GAAmB,cAAc,CAAC,mBAAmB,EAAE,CAAC;oBAC/D,gBAAgB,CAAC,QAAQ,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,YAAY,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;oBAC7D,MAAM,wBAAwB,CAAC,oBAAoB,EAAE,CAAC,OAAO,CAAC,wCAAwC,CAAC,kBAAkB,CAAC,CAAC;oBAC3H,OAAO;iBACR;gBAED,IAAI,CAAC,IAAI,CAAC,cAAc;oBACtB,IAAI,CAAC,eAAe,CAAC,IAAI,CAAC,CAAC;gBAG7B,IAAI,CAAS,CAAC;gBACd,IAAI,cAAc,EAAE;oBAElB,IAAI,IAAI,CAAC,WAAW,EAAE,EAAE;wBAEtB,IAAI,CAAC,uBAAuB,CAAC,WAAW,EAAE,CAAC,qBAAqB,EAAE;4BAChE,IAAI,mBAAmB,GAAY,IAAI,CAAC;4BACxC,IAAI,eAAe,GAAY,MAAM,IAAI,CAAC,0CAA0C,CAAC,IAAI,EACvF,iBAAiB,CAAC,kBAAkB,CAAC,CAAC;4BACxC,IAAI,CAAC,eAAe,EAAE;gCACpB,eAAe,GAAG,MAAM,IAAI,CAAC,0CAA0C,CAAC,IAAI,EAC1E,iBAAiB,CAAC,iBAAiB,CAAC,CAAC;gCACzC,IAAI,CAAC,eAAe;oCAChB,mBAAmB,GAAG,IAAI,CAAC,0BAA0B,CAAC,IAAI,CAAC,CAAC;6BAC/D;4BACD,IAAI,CAAC,eAAe,IAAI,CAAC,mBAAmB,EAAE;gCAC5C,IAAI,CAAC,uBAAuB,GAAG,KAAK,CAAC;gCACrC,IAAI,CAAC,uBAAuB,CAAC,IAAI,CAAC,CAAC;gCAEnC,uBAAuB,CAAC,WAAW,EAAE,CAAC,qBAAqB,GAAG,IAAI,CAAC;6BACpE;yBACF;;4BAEC,IAAI,CAAC,uBAAuB,CAAC,IAAI,CAAC,CAAC;wBACrC,KAAK,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,IAAI,CAAC,QAAQ,CAAC,OAAO,EAAE,IAAI,SAAS,EAAE,CAAC,EAAE,EAAE;4BACzD,OAAO,GAAS,IAAI,CAAC,QAAQ,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC;4BACzC,aAAa,GAAG,aAAa,IAAI,OAAO,CAAC,SAAS,CAAC;4BACnD,MAAM,YAAY,CAAC,aAAa,CAAC,2BAA2B,CAAC,OAAO,EAAE,iBAAiB,CAAC,WAAW,CAAC,CAAC;4BACrG,SAAS,GAAG,CAAC,CAAC,YAAY,CAAC,aAAa,CAAC,oBAAoB,EAAE,IAAI,gBAAgB,CAAC,CAAC;yBACtF;qBACF;yBAED;wBACE,IAAI,uBAAuB,CAAC,WAAW,EAAE,CAAC,qBAAqB;4BAC7D,IAAI,CAAC,uBAAuB,CAAC,IAAI,CAAC,CAAC;qBACtC;oBAED,IAAI,IAAI,KAAK,MAAM,CAAC,aAAa,CAAC,YAAY,EAAE,EAAE;wBAChD,KAAK,CAAC,GAAG,MAAM,CAAC,OAAO,EAAE,GAAG,CAAC,EAAE,CAAC,GAAG,CAAC,IAAI,SAAS,EAAE,CAAC,EAAE,EAAE;4BACtD,IAAI,MAAM,CAAC,SAAS,CAAC,CAAC,CAAC,IAAI,IAAI,EAAE;gCAC/B,MAAM,YAAY,CAAC,aAAa,CAAC,2BAA2B,CAAC,MAAM,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,YAAY,EAAE,EACxC,iBAAiB,CAAC,WAAW,CAAC,CAAC;gCACtF,SAAS,GAAG,CAAC,CAAC,YAAY,CAAC,aAAa,CAAC,oBAAoB,EAAE,IAAI,gBAAgB,CAAC,CAAC;6BACtF;yBACF;qBACF;iBACF;gBAED,IAAI,SAAS,EAAE;oBAEb,IAAI,cAAc,IAAI,CAAC,gBAAgB,EAAE;wBACvC,IAAI,WAAW,GAAY,MAAM,IAAI,CAAC,SAAS,CAAC,aAAa,CAAC,sBAAsB,EAAE,KAAK,CAAC,CAAC;wBAG7F,IAAI,CAAC,IAAI,CAAC,aAAa,IAAI,WAAW,KAAK,IAAI,IAAI,IAAI,CAAC,OAAO,EAAE,KAAK,SAAS,CAAC,gBAAgB;4BAC9F,IAAI,CAAC,OAAO,CAAC,aAAa,CAAC,sBAAsB,EAAE,GAAG,CAAC,CAAC;wBAE1D,MAAM,YAAY,CAAC,aAAa,CAAC,2BAA2B,CAAC,IAAI,EAAE,iBAAiB,CAAC,iBAAiB,CAAC,CAAC;wBAGxG,IAAI,CAAC,IAAI,CAAC,aAAa,IAAI,WAAW,KAAK,IAAI,IAAI,IAAI,CAAC,OAAO,EAAE,KAAK,SAAS,CAAC,gBAAgB;4BAC9F,IAAI,CAAC,OAAO,CAAC,aAAa,CAAC,sBAAsB,EAAE,GAAG,CAAC,CAAC;qBAC3D;oBAED,SAAS,GAAG,CAAC,CAAC,YAAY,CAAC,aAAa,CAAC,oBAAoB,EAAE,IAAI,gBAAgB,CAAC,CAAC;oBAErF,IAAI,SAAS,IAAI,CAAC,SAAS;wBACzB,IAAI,CAAC,qBAAqB,EAAE,CAAC;oBAE/B,IAAI,YAAY,GAAY,SAAS,CAAC;oBAGtC,IAAI,SAAS,IAAI,CAAC,SAAS,IAAI,cAAc,IAAI,CAAC,gBAAgB;wBAChE,CAAC,CAAC,IAAI,CAAC,SAAS,IAAI,kBAAkB,CAAC;wBACvC,IAAI,CAAC,kBAAkB,IAAI,CAAC,IAAI,CAAC,kBAAkB;wBACnD,SAAS,GAAG,MAAM,IAAI,CAAC,gBAAgB,CAAC,IAAI,CAAC,CAAC;oBAGhD,IAAI,cAAc,IAAI,IAAI,CAAC,WAAW,EAAE;wBACtC,KAAK,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,IAAI,CAAC,QAAQ,CAAC,OAAO,EAAE,EAAE,CAAC,EAAE,EAAE;4BAE5C,OAAO,GAAS,IAAI,CAAC,QAAQ,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC;4BAEzC,IAAI,CAAC,OAAO,CAAC,SAAS;gCACpB,MAAM,YAAY,CAAC,aAAa,CAAC,wBAAwB,CAAC,OAAO,EAAE,iBAAiB,CAAC,WAAW,CAAC,CAAC;yBACrG;oBAGH,IAAI,cAAc;wBAChB,SAAS,GAAG,CAAC,CAAC,YAAY,CAAC,aAAa,CAAC,oBAAoB,EAAE,IAAI,gBAAgB,CAAC,CAAC;oBAGvF,IAAI,YAAY;wBACd,YAAY,CAAC,aAAa,CAAC,gBAAgB,CAAC,KAAK,CAAC,CAAC;oBAErD,IAAI,CAAC,aAAa,CAAC,cAAc,CAAC,aAAa,CAAC,CAAC;oBAEjD,IAAI,CAAC,IAAI,CAAC,UAAU,EAAE,IAAI,SAAS,IAAI,CAAC,SAAS,EAAE;wBAEjD,IAAI,cAAc,EAAE;4BAClB,IAAI,CAAC,oBAAoB,CAAC,KAAK,CAAC,CAAC;4BACjC,MAAM,IAAI,CAAC,sBAAsB,CAAC,cAAc,CAAC,KAAK,EAAE,cAAc,CAAC,iBAAiB,EAAE,KAAK,CAAC,CAAC;4BACjG,SAAS,GAAG,CAAC,CAAC,YAAY,CAAC,aAAa,CAAC,oBAAoB,EAAE,IAAI,gBAAgB,CAAC,IAAI,CAAC,IAAI,CAAC,UAAU,EAAE,IAAI,CAAC,IAAI,CAAC,iBAAiB,CAAC,cAAc,CAAC,iBAAiB,CAAC,CAAC;yBACzK;wBAED,IAAI,CAAC,aAAa,CAAC,cAAc,CAAC,aAAa,CAAC,CAAC;wBAEjD,IAAI,SAAS,EAAE;4BAGb,IAAI,CAAC,IAAI,CAAC,uBAAuB,EAAE;gCACjC,IAAI,CAAC,uBAAuB,GAAG,IAAI,CAAC;gCACpC,uBAAuB,CAAC,WAAW,EAAE,CAAC,qBAAqB,GAAG,KAAK,CAAC;6BACrE;iCACI,IAAI,IAAI,CAAC,qBAAqB,EAAC;gCAClC,IAAI,CAAC,qBAAqB,GAAG,KAAK,CAAC;gCACnC,uBAAuB,CAAC,WAAW,EAAE,CAAC,qBAAqB,GAAG,IAAI,CAAC;6BACpE;4BAED,IAAI,OAAO,GAAW,YAAY,CAAC,WAAW,CAAC,aAAa,CAAC;4BAE7D,IAAI,cAAc,IAAI,OAAO,CAAC,YAAY,EAAE,CAAC,UAAU,EAAE,KAAK,IAAI,CAAC,UAAU,EAAE,EAAE;gCAC/E,YAAY,CAAC,aAAa,CAAC,2BAA2B,CAAC,IAAI,CAAC,CAAC;gCAC7D,MAAM,YAAY,CAAC,aAAa,CAAC,YAAY,CAAC,OAAO,EAAE,CAAC,CAAC,CAAC;gCAC1D,YAAY,CAAC,aAAa,CAAC,2BAA2B,CAAC,KAAK,CAAC,CAAC;gCAK9D,IAAI,IAAI,CAAC,UAAU,EAAE,EAAE;oCAErB,uBAAuB,CAAC,WAAW,EAAE,CAAC,qBAAqB,GAAG,KAAK,CAAC;oCACpE,IAAI,CAAC,qBAAqB,GAAG,KAAK,CAAC;oCACnC,IAAI,CAAC,uBAAuB,GAAG,IAAI,CAAC;oCACpC,OAAO,IAAI,CAAC;iCACb;6BACF;4BAED,MAAM,eAAe,CAAC,IAAI,CAAC,IAAI,EAAE,cAAc,EAAE,kBAAkB,CAAC,CAAC;4BAIrE,IAAI,IAAI,CAAC,WAAW,IAAI,IAAI,IAAI,IAAI,CAAC,WAAW,CAAC,UAAU,EAAE,EAAE;gCAC7D,IAAI,GAAG,GAAW,YAAY,CAAC,WAAW,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC;gCACxD,IAAI,WAAW,GAAS,GAAG,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC;gCAC3C,IAAI,QAAQ,GAAS,YAAY,CAAC,WAAW,CAAC,aAAa,CAAC,YAAY,EAAE,CAAC;gCAC3E,IAAI,UAAU,GAAY,MAAM,WAAW,CAAC,SAAS,CAAC,aAAa,CAAC,uBAAuB,EAAE,KAAK,CAAC,CAAC;gCAGpG,IAAI,IAAI,KAAK,QAAQ,IAAI,UAAU,EAAE;oCACnC,IAAI,KAAK,GAAG,IAAI,YAAY,CAAC,QAAQ,CAAC,CAAC;oCACvC,KAAK,CAAC,WAAW,CAAC,iBAAiB,CAAC,YAAY,CAAC,CAAC;oCAClD,KAAK,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC;oCACpB,KAAK,CAAC,UAAU,CAAC,IAAI,CAAC,CAAC;oCACvB,YAAY,CAAC,aAAa,CAAC,SAAS,CAAC,KAAK,CAAC,CAAC;iCAC7C;6BACF;4BACD,MAAM,CAAC,YAAY,CAAC,MAAM,CAAS,IAAI,CAAC,IAAI,CAAC,CAAC;yBAC/C;qBACF;iBACF;aACF;oBAEO;gBACN,IAAI,CAAC,IAAI,CAAC,SAAS,IAAI,kBAAkB;oBACvC,IAAI,CAAC,oBAAoB,CAAC,SAAS,EAAE,cAAc,CAAC,CAAC;aACxD;SACF;aAQI,IAAI,IAAI,CAAC,SAAS;YACrB,SAAS,GAAG,KAAK,CAAC;QAGpB,YAAY,CAAC,aAAa,CAAC,2BAA2B,CAAC,IAAI,CAAC,gCAAgC,CAAC,CAAC;QAE9F,OAAO,SAAS,CAAC;IACnB,CAAC;IAMO,uBAAuB,CAAE,IAAW;QAE1C,IAAI,KAAK,GAAG,IAAI,YAAY,CAAC,IAAI,CAAC,CAAC;QACnC,KAAK,CAAC,WAAW,CAAC,iBAAiB,CAAC,kBAAkB,CAAC,CAAC;QAExD,IAAK,OAAO,GAAiB,IAAI,CAAC;QAElC,IAAI,SAAS,GAAG,IAAI,oBAAoB,EAAE,CAAC;QAC3C,SAAS,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;QACtB,OAAO,GAAG,SAAS,CAAC,OAAO,EAAE,CAAC;QAE9B,IAAI,OAAO,IAAI,IAAI,EACnB;YACE,KAAK,IAAK,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,OAAO,CAAC,eAAe,EAAE,CAAC,OAAO,EAAE,EAAE,CAAC,EAAE,EAC7D;gBACE,IAAI,IAAI,GAAG,OAAO,CAAC,eAAe,EAAE,CAAC,YAAY,CAAC,CAAC,CAAC,CAAC;gBACrD,IAAI,CAAC,eAAe,CAAC,IAAI,CAAC,CAAC;aAC5B;SACF;QACD,IAAI,IAAI,CAAC,WAAW,EAAE,EAAI;YACxB,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,IAAI,CAAC,WAAW,EAAE,CAAC,MAAM,EAAE,CAAC,EAAE,EAClD;gBACE,IAAI,OAAO,GAAe,IAAI,CAAC,QAAQ,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC;gBACnD,IAAI,CAAC,uBAAuB,CAAC,OAAO,CAAC,CAAC;aACvC;SACF;IAEH,CAAC;IAMO,KAAK,CAAC,0CAA0C,CAAE,IAAU,EAAE,SAAiB;QACrF,IAAI,oBAAoB,GAAG,KAAK,CAAC;QACjC,IAAI,KAAK,GAAG,IAAI,YAAY,CAAC,IAAI,CAAC,CAAC;QACnC,KAAK,CAAC,WAAW,CAAC,SAAS,CAAC,CAAC;QAE7B,IAAI,OAAO,GAAiB,IAAI,CAAC;QAEjC,IAAI,SAAS,GAAG,IAAI,oBAAoB,EAAE,CAAC;QAC3C,SAAS,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;QACtB,OAAO,GAAG,SAAS,CAAC,OAAO,EAAE,CAAC;QAE9B,IAAI,SAAS,IAAI,iBAAiB,CAAC,iBAAiB,EAAE;YACpD,IAAI,UAAU,GAAc,IAAI,CAAC,QAAS,CAAC,UAAU,EAAE,CAAC;YACxD,IAAe,IAAI,CAAC,QAAS,CAAC,qBAAqB,EAAE,GAAG,CAAC,IAAI,CAAC,UAAU,IAAI,IAAI,IAAI,UAAU,CAAC,QAAQ,CAAC;gBACtG,oBAAoB,GAAG,IAAI,CAAC;YAE9B,IAAI,CAAC,oBAAoB,EAAE;gBACzB,IAAI,WAAW,GAAY,MAAM,IAAI,CAAC,SAAS,CAAC,aAAa,CAAC,sBAAsB,EAAE,KAAK,CAAC,CAAC;gBAG7F,IAAI,WAAW,KAAK,IAAI;oBACxB,IAAI,IAAI,CAAC,aAAa,IAAK,IAAI,CAAC,OAAO,EAAE,KAAK,SAAS,CAAC,gBAAgB;wBACtE,oBAAoB,GAAG,IAAI,CAAC;aAE/B;SACF;QAED,IAAI,OAAO,IAAI,IAAI,IAAI,CAAC,oBAAoB,EAAE;YAC1C,IAAI,GAAG,GAAG,OAAO,CAAC,eAAe,EAAE,CAAC,OAAO,EAAE,CAAC;YAE9C,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,GAAG,EAAE,CAAC,EAAE,EAAE;gBAC5B,IAAI,IAAI,GAAG,OAAO,CAAC,eAAe,EAAE,CAAC,YAAY,CAAC,CAAC,CAAC,CAAC;gBACrD,IAAI,IAAI,CAAC,eAAe,EAAE,EAAE;oBAC1B,oBAAoB,GAAG,IAAI,CAAC;oBAC5B,MAAM;iBACP;qBACI;oBACH,IAAI,IAAI,CAAC,OAAO,EAAE,IAAI,cAAc,CAAC,mBAAmB,EAAC;wBACvD,IAAI,IAAI,CAAC,eAAe,EAAE,CAAC,OAAO,EAAE,IAAI,cAAc,CAAC,mBAAmB;4BAC1E,IAAI,CAAC,eAAe,EAAE,CAAC,eAAe,EAAE,KAAK,iBAAiB,CAAC,sBAAsB,EAAE;4BACrF,oBAAoB,GAAG,IAAI,CAAC;4BAC5B,MAAM;yBACP;qBACF;iBACF;aACF;SACF;QAED,IAAI,CAAC,oBAAoB,IAAI,IAAI,CAAC,WAAW,EAAE,EAAE;YAC/C,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC,oBAAoB,IAAI,CAAC,GAAG,IAAI,CAAC,WAAW,EAAE,CAAC,OAAO,EAAE,CAAC,EAAE,CAAC,EAAE,EAAE;gBAChF,IAAI,OAAO,GAAS,IAAI,CAAC,QAAQ,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC;gBAC7C,oBAAoB,GAAG,MAAM,IAAI,CAAC,0CAA0C,CAAC,OAAO,EAAE,SAAS,CAAC,CAAC;aAClG;SACF;QAED,OAAO,oBAAoB,CAAC;IAChC,CAAC;IAOO,0BAA0B,CAAC,IAAW;QAE5C,IAAI,mBAAmB,GAAG,KAAK,CAAC;QAChC,IAAI,UAAU,GAAe,IAAI,CAAC,QAAS,CAAC,UAAU,EAAE,CAAC;QACzD,IAAe,IAAI,CAAC,QAAS,CAAC,qBAAqB,EAAE,GAAG,CAAC,IAAI,CAAC,UAAU,IAAI,IAAI,IAAI,UAAU,CAAC,QAAQ,CAAC;YACtG,mBAAmB,GAAG,IAAI,CAAC;QAE7B,IAAI,CAAC,mBAAmB,IAAI,IAAI,CAAC,WAAW,EAAE,EAC9C;YACE,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC,mBAAmB,IAAI,CAAC,GAAG,IAAI,CAAC,WAAW,EAAE,CAAC,OAAO,EAAE,CAAC,EAAE,CAAC,EAAE,EAC/E;gBACE,IAAI,OAAO,GAAS,IAAI,CAAC,QAAQ,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC;gBAC7C,mBAAmB,GAAG,IAAI,CAAC,0BAA0B,CAAC,OAAO,CAAC,CAAC;aAChE;SACF;QAED,OAAO,mBAAmB,CAAC;IAC7B,CAAC;IAOO,qBAAqB;QAO3B,IAAI,WAAW,GAAgB,IAAI,CAAC,eAAe,CAAC,qBAAqB,CAAC,WAAW,CAAC;QACtF,IAAI,WAAW,KAAK,IAAI,IAAI,WAAW,CAAC,OAAO,CAAC,IAAI,CAAC,IAAI,WAAW,CAAC,QAAQ,EAAE,KAAK,GAAG,EAAE;YACvF,IAAI,CAAC,eAAe,CAAC,qBAAqB,CAAC,WAAW,GAAG,IAAI,CAAC;YACnD,IAAI,CAAC,QAAS,CAAC,eAAe,EAAE,CAAC;SAC7C;IACH,CAAC;IAOD,KAAK,CAAC,IAAI,CAAC,cAAuB,EAAE,kBAA2B;QAI7D,IAAI,GAAG,GAAmB,cAAc,CAAC,CAAC;YACA,cAAc,CAAC,4BAA4B,CAAC,IAAI,CAAC,UAAU,EAAE,EAAE,kBAAkB,CAAC,CAAC,CAAC;YACpF,cAAc,CAAC,8BAA8B,CAAC,IAAI,CAAC,UAAU,EAAE,EAAE,kBAAkB,CAAC,CAAC;QAE/H,IAAI,CAAC,OAAO,CAAC,YAAY,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;QACnC,IAAI,CAAC,kBAAkB,EAAE;YACvB,IAAI;gBAKF,IAAG,IAAI,CAAC,UAAU,EAAE,IAAI,gBAAgB,CAAC,QAAQ,CAAC,aAAa,CAAC,YAAY,EAAE,CAAC,UAAU,EAAE;oBACxF,CAAC,CAAC,gBAAgB,CAAC,QAAQ,CAAC,aAAa,CAAC,YAAY,EAAE,CAAC,SAAS,IAAI,gBAAgB,CAAC,QAAQ,CAAC,aAAa,CAAC,YAAY,EAAE,CAAC,aAAa,CAAC;oBAC5I,MAAM,IAAI,CAAC,iBAAiB,CAAC,OAAO,CAAC,wCAAwC,CAAC,kBAAkB,CAAC,CAAC;aACrG;YACD,OAAO,GAAG,EAAE;gBAGV,IAAI,IAAI,CAAC,UAAU,EAAE,EAAE;oBACrB,IAAI,CAAC,OAAO,CAAC,YAAY,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;iBACpC;;oBAEC,MAAM,GAAG,CAAC;aACb;SAEF;IACH,CAAC;IAQO,oBAAoB,CAAC,SAAkB,EAAE,cAAuB;QACtE,IAAI,OAAa,CAAC;QAElB,IAAI,IAAI,CAAC,WAAW,EAAE,EAAE;YACtB,KAAK,IAAI,CAAC,GAAW,CAAC,EAAE,CAAC,GAAG,IAAI,CAAC,QAAQ,CAAC,OAAO,EAAE,EAAE,CAAC,EAAE,EAAE;gBACxD,OAAO,GAAS,IAAI,CAAC,QAAQ,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC;gBACzC,OAAO,CAAC,oBAAoB,CAAC,SAAS,EAAE,cAAc,CAAC,CAAC;aACzD;SACF;QAED,IAAI,CAAC,SAAS,GAAG,KAAK,CAAC;QAEvB,IAAI,SAAS;YACX,IAAI,CAAC,UAAU,GAAG,KAAK,CAAC;QAE1B,IAAI,CAAC,SAAS,IAAI,cAAc,IAAI,IAAI,CAAC,cAAc;YACrD,IAAI,CAAC,eAAe,CAAC,KAAK,CAAC,CAAC;IAChC,CAAC;IAMD,KAAK,CAAC,gBAAgB,CAAC,YAAqB;QAC1C,IAAI,SAAS,GAAY,IAAI,CAAC;QAC9B,IAAI,OAAa,CAAC;QAElB,IAAI,YAAY,EAAE;YAChB,IAAI,IAAI,CAAC,WAAW,EAAE,EAAE;gBACtB,KAAK,IAAI,CAAC,GAAW,CAAC,EAAE,CAAC,GAAG,IAAI,CAAC,QAAQ,CAAC,OAAO,EAAE,IAAI,SAAS,EAAE,CAAC,EAAE,EAAE;oBACrE,OAAO,GAAS,IAAI,CAAC,QAAQ,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC;oBACzC,SAAS,GAAG,MAAM,OAAO,CAAC,gBAAgB,CAAC,YAAY,CAAC,CAAC;iBAC1D;aACF;SACF;QAED,IAAI,SAAS;YACX,MAAM,YAAY,CAAC,aAAa,CAAC,2BAA2B,CAAC,IAAI,EAAE,iBAAiB,CAAC,kBAAkB,CAAC,CAAC;QAC3G,SAAS,GAAG,CAAC,YAAY,CAAC,aAAa,CAAC,oBAAoB,EAAE,CAAC;QAC/D,IAAI,CAAC,kBAAkB,GAAG,IAAI,CAAC;QAC/B,OAAO,SAAS,CAAC;IACnB,CAAC;IAMD,eAAe,CAAC,YAAqB;QACnC,IAAI,CAAC,aAAa,GAAG,YAAY,CAAC;IACpC,CAAC;IAKD,eAAe;QACb,OAAO,IAAI,CAAC,aAAa,CAAC;IAC5B,CAAC;IAUD,KAAK,CAAC,uBAAuB,CAAC,eAAuB;QACnD,IAAI,CAAS,CAAC;QACd,IAAI,IAAI,GAAS,IAAI,CAAC;QACtB,IAAI,WAAW,GAAS,IAAI,CAAC;QAC7B,IAAI,MAAM,GAAsB,YAAY,CAAC,WAAW,CAAC;QACzD,IAAI,cAAc,GAAmB,MAAM,CAAC,iBAAiB,CAAC,IAAI,CAAC,CAAC;QACpE,IAAI,OAAO,GAAe,IAAI,CAAC;QAC/B,IAAI,SAAkB,CAAC;QACvB,IAAI,SAAS,GAAY,KAAK,CAAC;QAC/B,IAAI,OAAO,GAAY,IAAI,CAAC,WAAW,IAAI,IAAI,IAAI,IAAI,CAAC,WAAW,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC;QAGlF,IAAI,OAAO,EAAE;YACX,YAAY,CAAC,aAAa,CAAC,kBAAkB,EAAE,CAAC;YAChD,OAAO,GAAG,IAAI,IAAI,EAAQ,CAAC;YAK3B,MAAM,CAAC,mBAAmB,EAAE,CAAC;YAC7B,OAAO,CAAC,IAAI,GAAS,MAAM,CAAC,WAAW,EAAE,CAAC,IAAI,IAAI,EAAE;gBAClD,SAAS,GAAG,IAAI,CAAC,WAAW,IAAI,IAAI,IAAI,IAAI,CAAC,WAAW,CAAC,UAAU,EAAE,KAAK,IAAI,CAAC,WAAW,CAAC,UAAU,EAAE,CAAC;gBACxG,IAAI,IAAI,KAAK,IAAI,IAAI,SAAS,IAAI,IAAI,CAAC,sBAAsB,IAAI,IAAI,IAAI,MAAM,CAAC,WAAW,CAAC,IAAI,CAAC,sBAAsB,CAAC,IAAI,IAAI;oBAC9H,OAAO,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;aACtB;SACF;QAED,IAAI,UAAU,GAAY,YAAY,CAAC,aAAa,CAAC,iBAAiB,EAAE,CAAC;QAGzE,KAAK,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,cAAc,CAAC,MAAM,IAAI,CAAC,YAAY,CAAC,aAAa,CAAC,oBAAoB,EAAE,EAAE,CAAC,EAAE,EAAE;YAChG,IAAI,GAAS,cAAc,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC;YACxC,SAAS,GAAG,IAAI,CAAC,WAAW,IAAI,IAAI,IAAI,IAAI,CAAC,WAAW,IAAI,IAAI,IAAI,IAAI,CAAC,WAAW,CAAC,UAAU,EAAE,KAAK,IAAI,CAAC,WAAW,CAAC,UAAU,EAAE,CAAC;YAEpI,IAAI,CAAC,IAAI,CAAC,SAAS,IAAI,CAAC,UAAU,IAAI,SAAS,CAAC,IAAI,IAAI,CAAC,SAAS,EAAE,EAAE;gBAEpE,IAAI,IAAI,CAAC,OAAO,EAAE,CAAC,aAAa,IAAI,eAAe,KAAK,iBAAiB,CAAC,iBAAiB,IAAI,IAAI,CAAC,QAAQ,EAAE,KAAK,SAAS,CAAC,eAAe;oBAC1I,MAAiB,IAAI,CAAC,QAAS,CAAC,cAAc,CAAC,KAAK,CAAC,CAAC;gBACxD,MAAM,YAAY,CAAC,aAAa,CAAC,2BAA2B,CAAC,IAAI,EAAE,eAAe,CAAC,CAAC;gBACpF,SAAS,GAAG,IAAI,CAAC;aAClB;SACF;QAGD,OAAO,OAAO,IAAI,CAAC,GAAG,OAAO,CAAC,MAAM,IAAI,CAAC,YAAY,CAAC,aAAa,CAAC,oBAAoB,EAAE,EAAE,CAAC,EAAE,EAAE;YAC/F,IAAI,GAAG,OAAO,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC;YAG3B,IAAI,IAAI,CAAC,OAAO,EAAE,CAAC,aAAa,IAAI,eAAe,KAAK,iBAAiB,CAAC,iBAAiB,IAAI,IAAI,CAAC,QAAQ,EAAE,KAAK,SAAS,CAAC,eAAe;gBAC1I,MAAiB,IAAI,CAAC,QAAS,CAAC,cAAc,CAAC,KAAK,CAAC,CAAC;YACxD,MAAM,YAAY,CAAC,aAAa,CAAC,2BAA2B,CAAC,IAAI,EAAE,eAAe,CAAC,CAAC;YACpF,SAAS,GAAG,IAAI,CAAC;SAClB;QAED,IAAI,SAAS,IAAI,YAAY,CAAC,aAAa,CAAC,oBAAoB,EAAE;YAChE,WAAW,GAAG,IAAI,CAAC;QAErB,IAAI,OAAO;YACT,YAAY,CAAC,aAAa,CAAC,eAAe,EAAE,CAAC;QAE/C,OAAO,WAAW,CAAC;IACrB,CAAC;IAKD,KAAK,CAAC,mBAAmB;QACvB,IAAI,QAAQ,GAAuB,IAAI,CAAC,QAAQ,CAAC;QAEjD,MAAM,IAAI,CAAC,8BAA8B,EAAE,CAAC;QAE5C,IAAI,QAAQ,CAAC,aAAa,EAAE,IAAI,QAAQ,CAAC,WAAW,EAAE;YACpD,IAAI,QAAQ,CAAC,eAAe,EAAE,IAAI,QAAQ,CAAC,aAAa,EAAE,KAAK,CAAC,EAAE;gBAChE,IAAI,CAAC,aAAa,CAAC,MAAM,CAAC,iBAAiB,CAAC,kBAAkB,EAAE,KAAK,CAAC,CAAC;gBACvE,IAAI,QAAQ,CAAC,WAAW;oBACtB,IAAI,CAAC,aAAa,CAAC,MAAM,CAAC,iBAAiB,CAAC,iBAAiB,EAAE,IAAI,CAAC,CAAC;;oBAClE,IAAI,CAAC,aAAa,CAAC,MAAM,CAAC,iBAAiB,CAAC,iBAAiB,EAAE,KAAK,CAAC,CAAC;gBAC3E,IAAI,IAAI,CAAC,IAAI,CAAC,YAAY,EAAE;oBAC1B,IAAI,CAAC,aAAa,CAAC,MAAM,CAAC,iBAAiB,CAAC,kBAAkB,EAAE,KAAK,CAAC,CAAC;aAC1E;iBACI;gBACH,IAAI,CAAC,aAAa,CAAC,MAAM,CAAC,iBAAiB,CAAC,kBAAkB,EAAE,IAAI,CAAC,CAAC;gBACtE,IAAI,CAAC,aAAa,CAAC,MAAM,CAAC,iBAAiB,CAAC,iBAAiB,EAAE,IAAI,CAAC,CAAC;gBACrE,IAAI,IAAI,CAAC,IAAI,CAAC,YAAY,EAAE;oBAC1B,IAAI,CAAC,aAAa,CAAC,MAAM,CAAC,iBAAiB,CAAC,kBAAkB,EAAE,IAAI,CAAC,CAAC;aACzE;YACD,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,YAAY,EAAE;gBAC3B,IAAI,QAAQ,CAAC,eAAe,EAAE,IAAI,CAAC,QAAQ,CAAC,aAAa,EAAE,KAAK,CAAC,CAAC,IAAI,CAAC,QAAQ,CAAC,YAAY,EAAE,KAAK,CAAC,CAAC;oBACnG,IAAI,CAAC,aAAa,CAAC,MAAM,CAAC,iBAAiB,CAAC,kBAAkB,EAAE,KAAK,CAAC,CAAC;;oBACpE,IAAI,CAAC,aAAa,CAAC,MAAM,CAAC,iBAAiB,CAAC,kBAAkB,EAAE,IAAI,CAAC,CAAC;SAC9E;aACI;YACH,IAAI,CAAC,aAAa,CAAC,MAAM,CAAC,iBAAiB,CAAC,iBAAiB,EAAE,IAAI,CAAC,CAAC;YACrE,IAAI,CAAC,aAAa,CAAC,MAAM,CAAC,iBAAiB,CAAC,kBAAkB,EAAE,IAAI,CAAC,CAAC;YACtE,IAAI,CAAC,aAAa,CAAC,MAAM,CAAC,iBAAiB,CAAC,kBAAkB,EAAE,IAAI,CAAC,CAAC;SACvE;QAED,IAAI,QAAQ,CAAC,YAAY,EAAE,EAAE;YAC3B,IAAI,CAAC,CAAC,IAAI,CAAC,OAAO,EAAE,KAAK,SAAS,CAAC,eAAe,CAAC,IAAI,QAAQ,CAAC,eAAe,EAAE;gBAC7E,CAAC,CAAC,IAAI,CAAC,OAAO,EAAE,KAAK,SAAS,CAAC,gBAAgB,CAAC;oBAC9C,CAAC,CAAC,WAAW,CAAC,QAAQ,CAAC,uBAAuB,CAAC,IAAI,CAAC,UAAU,EAAE,CAAC;wBAC/D,CAAC,MAAM,IAAI,CAAC,SAAS,CAAC,aAAa,CAAC,sBAAsB,EAAE,IAAI,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,QAAQ,CAAC,aAAa,EAAE,GAAG,CAAC,CAAC,KAAK,QAAQ,CAAC,OAAO,EAAE,EAAE;gBACrI,IAAI,CAAC,aAAa,CAAC,MAAM,CAAC,iBAAiB,CAAC,kBAAkB,EAAE,KAAK,CAAC,CAAC;gBACvE,IAAI,CAAC,aAAa,CAAC,MAAM,CAAC,iBAAiB,CAAC,iBAAiB,EAAE,KAAK,CAAC,CAAC;gBACtE,IAAI,IAAI,CAAC,IAAI,CAAC,YAAY,EAAE;oBAC1B,IAAI,CAAC,aAAa,CAAC,MAAM,CAAC,iBAAiB,CAAC,kBAAkB,EAAE,KAAK,CAAC,CAAC;aAC1E;iBACI;gBACH,IAAI,CAAC,aAAa,CAAC,MAAM,CAAC,iBAAiB,CAAC,kBAAkB,EAAE,IAAI,CAAC,CAAC;gBACtE,IAAI,CAAC,aAAa,CAAC,MAAM,CAAC,iBAAiB,CAAC,iBAAiB,EAAE,IAAI,CAAC,CAAC;gBACrE,IAAI,IAAI,CAAC,IAAI,CAAC,YAAY,EAAE;oBAC1B,IAAI,CAAC,aAAa,CAAC,MAAM,CAAC,iBAAiB,CAAC,kBAAkB,EAAE,IAAI,CAAC,CAAC;aACzE;YAED,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,YAAY,EAAE,EAAE;gBAC7B,IAAI,QAAQ,CAAC,eAAe,EAAE,IAAI,CAAC,CAAC,QAAQ,CAAC,OAAO,EAAE,GAAG,QAAQ,CAAC,YAAY,EAAE,CAAC,IAAI,IAAI,CAAC,IAAI,CAAC,aAAa,EAAE,CAAC;oBAC7G,IAAI,CAAC,aAAa,CAAC,MAAM,CAAC,iBAAiB,CAAC,kBAAkB,EAAE,KAAK,CAAC,CAAC;;oBACpE,IAAI,CAAC,aAAa,CAAC,MAAM,CAAC,iBAAiB,CAAC,kBAAkB,EAAE,IAAI,CAAC,CAAC;aAC5E;SACF;aACI;YACH,IAAI,CAAC,aAAa,CAAC,MAAM,CAAC,iBAAiB,CAAC,kBAAkB,EAAE,IAAI,CAAC,CAAC;YACtE,IAAI,CAAC,aAAa,CAAC,MAAM,CAAC,iBAAiB,CAAC,kBAAkB,EAAE,IAAI,CAAC,CAAC;YACtE,IAAI,CAAC,aAAa,CAAC,MAAM,CAAC,iBAAiB,CAAC,iBAAiB,EAAE,IAAI,CAAC,CAAC;SACtE;QAED,IAAI,QAAQ,CAAC,eAAe,EAAE;YAC5B,IAAI,CAAC,aAAa,CAAC,MAAM,CAAC,iBAAiB,CAAC,aAAa,EAAE,KAAK,CAAC,CAAC;;YAElE,IAAI,CAAC,aAAa,CAAC,MAAM,CAAC,iBAAiB,CAAC,aAAa,EAAE,IAAI,CAAC,CAAC;QAEnE,IAAI,CAAC,aAAa,CAAC,MAAM,CAAC,iBAAiB,CAAC,wBAAwB,EAAE,IAAI,CAAC,CAAC;QAE5E,IAAI,CAAC,aAAa,CAAC,MAAM,CAAC,iBAAiB,CAAC,yBAAyB,EAAE,IAAI,CAAC,CAAC;IAC/E,CAAC;IAKD,SAAS;QACP,OAAO,IAAI,CAAC,UAAU,CAAC;IACzB,CAAC;IAKD,WAAW;QACT,OAAO,IAAI,CAAC,QAAQ,CAAC;IACvB,CAAC;IAMD,WAAW,CAAC,KAAa;QACvB,IAAI,MAAM,GAAY,KAAK,CAAC;QAE5B,KAAK,IAAI,CAAC,GAAW,CAAC,EAAE,CAAC,MAAM,IAAI,IAAI,CAAC,aAAa,KAAK,IAAI,IAAI,CAAC,GAAG,IAAI,CAAC,aAAa,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE;YACpG,MAAM,GAAG,CAAC,IAAI,CAAC,aAAa,CAAC,CAAC,CAAC,KAAK,KAAK,CAAC,CAAC;SAC5C;QAED,OAAO,MAAM,CAAC;IAChB,CAAC;IAKO,gBAAgB;QACtB,IAAI,CAAC,eAAe,CAAC,qBAAqB,CAAC,WAAW,GAAG,IAAI,CAAC;IAChE,CAAC;IAMD,sBAAsB,CAAC,GAAY;QACjC,IAAI,CAAC,oBAAoB,GAAG,GAAG,CAAC;IAClC,CAAC;IAKD,sBAAsB;QACpB,OAAO,IAAI,CAAC,oBAAoB,CAAC;IACnC,CAAC;IAED,uBAAuB,CAAC,GAAY;QAClC,IAAI,CAAC,qBAAqB,GAAG,GAAG,CAAC;IACnC,CAAC;IAED,uBAAuB;QACrB,OAAO,IAAI,CAAC,qBAAqB,CAAC;IACpC,CAAC;IAKD,kBAAkB;QAChB,IAAI,CAAC,cAAc,GAAG,KAAK,CAAC;IAC9B,CAAC;IAMD,kBAAkB;QAChB,IAAI,MAAM,GAAW,EAAE,CAAC;QACxB,IAAI,GAAa,CAAC;QAClB,IAAI,IAAI,CAAC,eAAe,IAAI,IAAI;YAC9B,OAAO,SAAS,CAAC,WAAW,CAAC,MAAM,CAAC,CAAC;QAEvC,IAAI,KAAK,GAAY,IAAI,CAAC;QAG1B,KAAK,IAAI,CAAC,GAAW,CAAC,EAAE,CAAC,GAAG,IAAI,CAAC,eAAe,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE;YAC5D,IAAI,CAAC,KAAK;gBACR,MAAM,IAAI,GAAG,CAAC;YAEhB,IAAI,WAAW,GAAa,IAAI,CAAC,eAAe,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC;YAG7D,IAAI,UAAU,GAAW,WAAW,CAAC,CAAC,CAAC,CAAC;YACxC,IAAI,aAAa,GAAW,OAAO,CAAC,KAAK,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC,CAAC;YAC1D,IAAI,WAAW,GAAS,YAAY,CAAC,WAAW,CAAC,WAAW,CAAC,UAAU,CAAC,CAAC;YACzE,IAAI,YAAY,GAAU,WAAW,CAAC,QAAQ,CAAC,QAAQ,CAAC,aAAa,CAAC,CAAC;YACvE,IAAI,OAAO,GAAW,YAAY,CAAC,YAAY,EAAE,CAAC;YAGlD,IAAI,YAAY,CAAC,MAAM,EAAE;gBACvB,OAAO,GAAG,EAAE,CAAC;YAGf,IAAI,GAAQ,CAAC;YACb,QAAQ,YAAY,CAAC,OAAO,EAAE,EAAE;gBAC9B,KAAK,gBAAgB,CAAC,OAAO,CAAC;gBAG9B,KAAK,gBAAgB,CAAC,KAAK,CAAC;gBAC5B,KAAK,gBAAgB,CAAC,OAAO,CAAC;gBAC9B,KAAK,gBAAgB,CAAC,IAAI,CAAC;gBAC3B,KAAK,gBAAgB,CAAC,WAAW;oBAC/B,MAAM,IAAI,OAAO,CAAC;oBAClB,MAAM;gBAER,KAAK,gBAAgB,CAAC,IAAI,CAAC;gBAC3B,KAAK,gBAAgB,CAAC,IAAI;oBAExB,IAAI,OAAO,KAAK,EAAE,EAAE;wBAClB,GAAG,GAAG,IAAI,GAAG,CAAC,YAAY,CAAC,UAAU,EAAE,EAAE,YAAY,CAAC,OAAO,EAAE,EAAE,CAAC,CAAC,CAAC;wBACpE,IAAI,IAAI,GAAqB,gBAAgB,CAAC,QAAQ,CAAC;wBACvD,MAAM,IAAI,IAAI,CAAC,OAAO,CAAC,OAAO,EAAE,EAAE,EAAE,GAAG,EAAE,KAAK,EAAE,IAAI,CAAC,UAAU,EAAE,EAAE,KAAK,CAAC,CAAC;qBAC3E;oBACD,MAAM;gBAER,KAAK,gBAAgB,CAAC,OAAO;oBAE3B,IAAI,OAAO,KAAK,EAAE,EAAE;wBAClB,GAAG,GAAG,IAAI,QAAQ,CAAC,OAAO,CAAC,CAAC;wBAC5B,GAAG,GAAG,IAAI,GAAG,CAAC,YAAY,CAAC,UAAU,EAAE,EAAE,YAAY,CAAC,OAAO,EAAE,EAAE,CAAC,CAAC,CAAC;wBACpE,MAAM,IAAI,GAAG,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;qBACzB;oBACD,MAAM;aACT;YAED,KAAK,GAAG,KAAK,CAAC;SACf;QAED,IAAI,OAAO,GAAW,OAAO,CAAC,gBAAgB,CAAC,MAAM,EAAE,CAAC,CAAC,CAAC;QAE1D,OAAO,SAAS,CAAC,WAAW,CAAC,OAAO,CAAC,CAAC;IACxC,CAAC;IAMD,aAAa,CAAC,OAAe;QAC3B,IAAI,CAAC,CAAC,OAAO,CAAC,IAAI,EAAE,KAAK,EAAE,CAAC,EAAE;YAC5B,IAAI,IAAI,GAAa,OAAO,CAAC,QAAQ,CAAC,OAAO,EAAE,GAAG,CAAC,CAAC;YACpD,IAAI,CAAC,eAAe,GAAG,IAAI,IAAI,EAAY,CAAC;YAE5C,KAAK,IAAI,CAAC,GAAW,CAAC,EAAE,CAAC,GAAG,IAAI,CAAC,MAAM,EAAE,CAAC,GAAG,CAAC,GAAG,CAAC,EAAE;gBAClD,IAAI,IAAI,GAAa,IAAI,KAAK,CAAS,CAAC,CAAC,CAAC;gBAC1C,IAAI,UAAU,GAAa,OAAO,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,GAAG,CAAC,CAAC;gBAC1D,IAAI,CAAC,CAAC,CAAC,GAAG,UAAU,CAAC,CAAC,CAAC,CAAC;gBACxB,IAAI,CAAC,CAAC,CAAC,GAAG,UAAU,CAAC,CAAC,CAAC,CAAC;gBAGxB,IAAI,CAAC,eAAe,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;aACjC;SACF;IACH,CAAC;IAKD,YAAY;QACV,OAAO,IAAI,CAAC,QAAQ,CAAC;IACvB,CAAC;IAOD,KAAK,CAAC,YAAY,CAAC,UAAmB;QACpC,IAAI,OAAO,GAAY,IAAI,CAAC;QAG5B,IAAI,CAAC,UAAU,EAAE;YACf,IAAI,MAAM,IAAI,CAAC,QAAQ,EAAE,EAAE;gBACzB,IAAe,IAAI,CAAC,QAAS,CAAC,UAAU,EAAE,EAAE;oBAE1C,IAAI,CAAC,QAAQ,CAAC,iBAAiB,CAAY,IAAI,CAAC,QAAS,CAAC,aAAa,EAAE,EAAE,IAAI,CAAC,CAAC;oBACjF,OAAO,GAAG,KAAK,CAAC;iBACjB;aACF;iBACI;gBAEH,IAAI,IAAI,CAAC,SAAS,IAAI,CAAE,MAAM,IAAI,CAAC,QAAQ,EAAE,EAAE;oBAC7C,OAAO,GAAG,KAAK,CAAC;iBACjB;aACF;SACF;QAED,IAAI,UAAgB,CAAC;QAGrB,IAAI,IAAI,CAAC,WAAW,EAAE,EAAE;YAEtB,KAAK,IAAI,CAAC,GAAW,CAAC,EAAE,CAAC,GAAG,IAAI,CAAC,QAAQ,CAAC,OAAO,EAAE,EAAE,CAAC,GAAG,CAAC,GAAG,CAAC,EAAE;gBAC9D,UAAU,GAAS,IAAI,CAAC,QAAQ,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC;gBAE5C,IAAI,CAAE,MAAM,UAAU,CAAC,YAAY,CAAC,KAAK,CAAC,EAAE;oBAC1C,OAAO,GAAG,KAAK,CAAC;iBACjB;aACF;SACF;QACD,OAAO,OAAO,CAAC;IACjB,CAAC;IAOD,KAAK,CAAC,UAAU,CAAC,UAAmB;QAElC,IAAI,CAAC,UAAU,IAAI,MAAM,IAAI,CAAC,QAAQ,EAAE,EAAE;YACxC,IAAI,WAAW,GAAW,IAAI,CAAC,kBAAkB,EAAE,CAAC;YAGpD,IAAI,WAAW,KAAgB,IAAI,CAAC,QAAS,CAAC,aAAa,EAAE,EAAE;gBAC7D,IAAI,SAAS,GAAa,IAAI,CAAC,QAAQ,CAAC,iBAAiB,CAAC,WAAW,CAAC,CAAC;gBACvE,IAAI,SAAS,IAAI,IAAI;oBACnB,OAAO,KAAK,CAAC;gBACf,MAAM,IAAI,CAAC,QAAQ,CAAC,SAAS,CAAC,CAAC;aAEhC;YAGD,IAAI,CAAC,qBAAqB,GAAG,IAAI,CAAC;SACnC;QAGD,IAAI,IAAI,CAAC,WAAW,EAAE,EAAE;YAGtB,KAAK,IAAI,CAAC,GAAW,CAAC,EAAE,CAAC,GAAG,IAAI,CAAC,QAAQ,CAAC,OAAO,EAAE,EAAE,CAAC,EAAE,EAAE;gBAExD,IAAI,CAAC,MAAM,IAAI,CAAC,QAAQ,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,UAAU,CAAC,KAAK,CAAC;oBACnD,OAAO,KAAK,CAAC;aAChB;SACF;QACD,OAAO,IAAI,CAAC;IACd,CAAC;IAUO,KAAK,CAAC,QAAQ,CAAC,SAAmB;QACxC,IAAI,QAAQ,GAAuB,IAAI,CAAC,QAAQ,CAAC;QAGjD,IAAI,CAAC,IAAI,CAAC,SAAS,EAAE;YACnB,IAAI,CAAC,QAAQ,CAAC,UAAU,EAAE,IAAI,QAAQ,CAAC,aAAa,EAAE;gBACpD,IAAI,CAAC,QAAQ,CAAC,UAAU,CAAC,QAAQ,CAAC,SAAS,EAAE,CAAC,CAAC;SAClD;;YAEC,IAAI,CAAC,gBAAgB,EAAE,CAAC;QAG1B,MAAM,QAAQ,CAAC,SAAS,CAAC,SAAS,CAAC,CAAC;QACpC,QAAQ,CAAC,sBAAsB,EAAE,CAAC;QAElC,IAAI,CAAC,IAAI,CAAC,kBAAkB,CAAC,CAAC,EAAE,IAAI,CAAC,CAAC;QAC7B,IAAI,CAAC,IAAK,CAAC,kBAAkB,CAAC,KAAK,CAAC,CAAC;QAE9C,MAAe,IAAI,CAAC,IAAK,CAAC,cAAc,CAAC,SAAS,CAAC,iBAAiB,CAAC,CAAC;QAGtE,IAAI,CAAC,mBAAmB,CAAC,IAAI,CAAC,OAAO,EAAE,CAAC,CAAC;IAC3C,CAAC;IAED,mBAAmB,CAAC,gBAAwB;QAC1C,IAAI,CAAC,iBAAiB,GAAG,gBAAgB,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC;IACtD,CAAC;IAMD,mBAAmB;QACjB,OAAO,IAAI,CAAC,iBAAiB,CAAC;IAChC,CAAC;IAOD,KAAK,CAAC,QAAQ;QACZ,OAAO,IAAI,CAAC,SAAS,IAAI,MAAsB,IAAI,CAAC,IAAI,CAAC,cAAc,EAAG,CAAC,SAAS,CAAC,aAAa,CAAC,mBAAmB,EAAE,KAAK,CAAC,CAAC;IACjI,CAAC;IAKO,gBAAgB;QACtB,IAAI,MAAM,GAAa,IAAI,CAAC,QAAQ,CAAC,iBAAiB,CAAY,IAAI,CAAC,QAAS,CAAC,aAAa,EAAE,CAAC,CAAC;QAGlG,IAAI,MAAM,IAAI,IAAI,EAAE;YAClB,IAAe,IAAI,CAAC,QAAS,CAAC,UAAU,CAAC,MAAM,CAAC,iBAAiB,EAAE,CAAC,IAAI,CAAY,IAAI,CAAC,QAAS,CAAC,UAAU,EAAE,EAAE;gBACpG,IAAI,CAAC,QAAS,CAAC,iBAAiB,CAAC,MAAM,CAAC,iBAAiB,EAAE,CAAC,CAAC;gBACxE,IAAI,CAAC,QAAQ,CAAC,UAAU,CAAY,IAAI,CAAC,QAAS,CAAC,SAAS,EAAE,CAAC,CAAC;aACjE;;gBAEC,IAAI,CAAC,QAAQ,CAAC,iBAAiB,CAAY,IAAI,CAAC,QAAS,CAAC,aAAa,EAAE,EAAE,IAAI,CAAC,CAAC;SACpF;aAEI;YACH,IAAI,CAAY,IAAI,CAAC,QAAS,CAAC,UAAU,EAAE;gBACzC,IAAI,CAAC,QAAQ,CAAC,UAAU,CAAY,IAAI,CAAC,QAAS,CAAC,SAAS,EAAE,CAAC,CAAC;SACnE;IACH,CAAC;IAKD,SAAS;QACP,OAAO,IAAI,CAAC,SAAS,CAAC;IACxB,CAAC;IAKO,oBAAoB,CAAC,OAAe;QAC1C,IAAI,MAAM,GAAsB,YAAY,CAAC,WAAW,CAAC;QACzD,IAAI,SAAe,CAAC;QACpB,IAAI,MAAM,GAAY,KAAK,CAAC;QAE5B,MAAM,CAAC,mBAAmB,EAAE,CAAC;QAC7B,OAAO,CAAC,SAAS,GAAS,MAAM,CAAC,WAAW,EAAE,CAAC,IAAI,IAAI,EAAE;YAEvD,IAAI,SAAS,CAAC,eAAe,CAAC,qBAAqB,CAAC,WAAW,IAAI,IAAI;gBACrE,SAAS,CAAC,eAAe,CAAC,qBAAqB,CAAC,WAAW,CAAC,UAAU,EAAE,KAAK,OAAO,EAAE;gBACtF,MAAM,GAAG,IAAI,CAAC;gBACd,MAAM;aACP;SACF;QAED,IAAI,CAAC,eAAe,CAAC,qBAAqB,CAAC,WAAW,GAAG,CAAC,MAAM,CAAC,CAAC;YACR,SAAS,CAAC,eAAe,CAAC,qBAAqB,CAAC,WAAW,CAAC,CAAC;YAC7D,IAAI,WAAW,CAAC,IAAI,EAAE,OAAO,CAAC,CAAC,CAAC;IAC5F,CAAC;IAKD,iBAAiB;QACf,IAAI,CAAC,WAAW,CAAC,YAAY,CAAC,IAAI,CAAC,CAAC;QACpC,IAAI,CAAC,WAAW,CAAC,aAAa,CAAC,GAAG,CAAC,CAAQ;IAC7C,CAAC;IAMD,cAAc;QACZ,IAAI,MAAM,GAAW,CAAC,CAAC;QACvB,IAAI,IAAI,CAAC,aAAa,IAAI,IAAI,CAAC,UAAU,KAAK,IAAI,IAAI,CAAC,CAAC,IAAI,CAAC,UAAU,CAAC,KAAK,EAAE,KAAK,CAAC,CAAC,EAAE;YACtF,MAAM,GAAW,IAAI,CAAC,UAAU,CAAC,IAAI,EAAE,CAAC;SACzC;QACD,OAAO,MAAM,CAAC;IAChB,CAAC;IAKD,SAAS;QACP,IAAI,IAAI,CAAC,UAAU,KAAK,IAAI;YAC1B,IAAI,CAAC,UAAU,GAAG,IAAI,KAAK,EAAE,CAAC;QAEhC,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;IAC1B,CAAC;IAKD,SAAS;QACP,IAAI,CAAC,cAAc,EAAE,CAAC;IACxB,CAAC;IAKD,cAAc;QACZ,IAAI,MAAM,GAAW,CAAC,CAAC;QAEvB,IAAI,IAAI,CAAC,UAAU,KAAK,IAAI,IAAI,CAAC,CAAC,IAAI,CAAC,UAAU,CAAC,KAAK,EAAE,KAAK,CAAC,CAAC;YAC9D,MAAM,GAAW,IAAI,CAAC,UAAU,CAAC,GAAG,EAAE,CAAC;QAEzC,OAAO,MAAM,CAAC;IAChB,CAAC;IAKD,mBAAmB;QACjB,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,IAAI,CAAC,cAAc,EAAE,GAAG,CAAC,CAAC,CAAC;IAClD,CAAC;IAKD,gBAAgB;QACd,IAAI,IAAI,CAAC,UAAU,KAAK,IAAI;YAC1B,OAAO,IAAI,CAAC,UAAU,CAAC,KAAK,EAAE,CAAC;QAEjC,OAAO,CAAC,CAAC;IACX,CAAC;IAMD,eAAe,CAAC,GAAY;QAC1B,IAAI,CAAC,aAAa,GAAG,GAAG,CAAC;IAC3B,CAAC;IAKD,kBAAkB;QAChB,OAAO,IAAI,CAAC,oBAAoB,CAAC;IACnC,CAAC;IAED,kBAAkB,CAAC,MAAgB;QACjC,IAAI,SAAS,CAAC,MAAM,KAAK,CAAC,EAAE;YAC1B,OAAO,IAAI,CAAC,oBAAoB,EAAE,CAAC;SACpC;QACD,OAAO,IAAI,CAAC,oBAAoB,CAAC,MAAM,CAAC,CAAC;IAC3C,CAAC;IAEO,oBAAoB;QAC1B,OAAO,IAAI,CAAC,iBAAiB,CAAC;IAChC,CAAC;IAEO,oBAAoB,CAAC,MAAe;QAC1C,IAAI,CAAC,iBAAiB,GAAG,MAAM,CAAC;IAClC,CAAC;IAGD,aAAa;QACX,OAAO,IAAI,CAAC,UAAU,CAAC;IACzB,CAAC;IAGD,KAAK,CAAC,aAAa;QACjB,IAAI,IAAI,GAAa,IAAI,CAAC,OAAO,CAAC,aAAa,CAAC,sCAAsC,CAAC,CAAC;QACxF,OAAO,MAAM,IAAI,CAAC,eAAe,EAAE,CAAC;IACtC,CAAC;IAGD,iBAAiB;QACf,IAAI,MAAM,GAAW,EAAE,CAAC;QACxB,IAAI,IAAI,GAAa,IAAI,CAAC,OAAO,CAAC,aAAa,CAAC,iBAAiB,CAAC,CAAC;QAEnE,IAAI,IAAI,IAAI,IAAI;YACd,MAAM,GAAG,IAAI,CAAC,gBAAgB,EAAE,CAAC;QAEnC,OAAO,MAAM,CAAC;IAChB,CAAC;IAMD,kBAAkB;QAChB,IAAI,YAAY,GAAY,KAAK,CAAC;QAElC,IAAI,IAAI,CAAC,WAAW,IAAI,IAAI,IAAI,IAAI,CAAC,WAAW,CAAC,OAAO,CAAC,IAAI,CAAC;YAC5D,YAAY,GAAG,IAAI,CAAC;QAEtB,OAAO,YAAY,CAAC;IACtB,CAAC;IAED,oBAAoB,CAAC,KAAa;QAChC,OAAO,IAAI,CAAC,kBAAkB,EAAE,IAAI,IAAI,CAAC,WAAW,CAAC,QAAQ,EAAE,KAAK,KAAK,CAAC;IAC5E,CAAC;IAKD,SAAS;QACP,OAAO,IAAI,CAAC,MAAM,CAAC;IACrB,CAAC;IAKD,KAAK,CAAC,WAAW;QACf,IAAI,MAAM,GAAY,MAAM,IAAI,CAAC,SAAS,CAAC,aAAa,CAAC,sBAAsB,EAAE,IAAI,CAAC,CAAC;QACvF,IAAI,CAAC,aAAa,CAAC,MAAM,CAAC,iBAAiB,CAAC,iBAAiB,EAAE,MAAM,CAAC,CAAC;QAEvE,MAAM,GAAG,MAAM,IAAI,CAAC,SAAS,CAAC,aAAa,CAAC,sBAAsB,EAAE,IAAI,CAAC,CAAC;QAC1E,IAAI,CAAC,aAAa,CAAC,MAAM,CAAC,iBAAiB,CAAC,iBAAiB,EAAE,MAAM,CAAC,CAAC;QAEvE,MAAM,GAAG,MAAM,IAAI,CAAC,SAAS,CAAC,aAAa,CAAC,qBAAqB,EAAE,IAAI,CAAC,CAAC;QACzE,IAAI,CAAC,aAAa,CAAC,MAAM,CAAC,iBAAiB,CAAC,gBAAgB,EAAE,MAAM,CAAC,CAAC;QAEtE,MAAM,GAAG,MAAM,IAAI,CAAC,SAAS,CAAC,aAAa,CAAC,qBAAqB,EAAE,IAAI,CAAC,CAAC;QACzE,IAAI,CAAC,aAAa,CAAC,MAAM,CAAC,iBAAiB,CAAC,gBAAgB,EAAE,MAAM,CAAC,CAAC;QAEtE,MAAM,GAAG,MAAM,IAAI,CAAC,SAAS,CAAC,aAAa,CAAC,sBAAsB,EAAE,IAAI,CAAC,CAAC;QAC1E,IAAI,CAAC,aAAa,CAAC,MAAM,CAAC,iBAAiB,CAAC,iBAAiB,EAAE,MAAM,CAAC,CAAC;QACvE,IAAI,CAAC,aAAa,CAAC,MAAM,CAAC,iBAAiB,CAAC,iBAAiB,EAAE,MAAM,CAAC,CAAC;QAEvE,MAAM,GAAG,MAAM,IAAI,CAAC,SAAS,CAAC,aAAa,CAAC,oBAAoB,EAAE,IAAI,CAAC,CAAC;QACxE,IAAI,CAAC,aAAa,CAAC,MAAM,CAAC,iBAAiB,CAAC,mBAAmB,EAAE,MAAM,CAAC,CAAC;QAEzE,MAAM,GAAG,MAAM,IAAI,CAAC,SAAS,CAAC,aAAa,CAAC,qCAAqC,EAAE,IAAI,CAAC,CAAC;QACzF,IAAI,CAAC,aAAa,CAAC,MAAM,CAAC,iBAAiB,CAAC,kBAAkB,EAAE,MAAM,CAAC,CAAC;QAExE,IAAI,CAAC,aAAa,CAAC,MAAM,CAAC,iBAAiB,CAAC,uBAAuB,EAAE,IAAI,CAAC,CAAC;IAC7E,CAAC;IAKD,oBAAoB;QAClB,IAAI,CAAC,kBAAkB,GAAG,IAAI,CAAC;IACjC,CAAC;IAKD,oBAAoB;QAClB,OAAO,IAAI,CAAC,kBAAkB,CAAC;IACjC,CAAC;IAGD,oBAAoB;QAClB,OAAO,IAAI,CAAC,mBAAmB,CAAC;IAClC,CAAC;IAMD,qBAAqB,CAAC,kBAA2B;QAC/C,IAAI,CAAC,mBAAmB,GAAG,kBAAkB,CAAC;IAChD,CAAC;IAGD,oBAAoB;QAClB,OAAO,IAAI,CAAC,kBAAkB,CAAC;IACjC,CAAC;IAMD,oBAAoB,CAAC,iBAA0B;QAC7C,IAAI,CAAC,kBAAkB,GAAG,iBAAiB,CAAC;IAC9C,CAAC;IAKD,kBAAkB,CAAC,GAAY;QAC7B,IAAI,CAAC,gBAAgB,GAAG,GAAG,CAAC;IAC9B,CAAC;IAID,eAAe;QACb,OAAO,IAAI,CAAC,gBAAgB,CAAC;IAC/B,CAAC;IAED,gBAAgB,CAAC,GAAY;QAC3B,IAAI,CAAC,aAAa,CAAC,MAAM,CAAC,iBAAiB,CAAC,cAAc,EAAE,GAAG,CAAC,CAAC;QAEjE,IAAI,CAAC,aAAa,CAAC,MAAM,CAAC,iBAAiB,CAAC,oBAAoB,EAAG,CAAC,IAAI,CAAC,OAAO,EAAE,CAAC,QAAQ,EAAE,CAAE,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC;IACjH,CAAC;IAKD,KAAK,CAAC,8BAA8B;QAClC,IAAI,CAAC,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC,eAAe,EAAE,IAAI,MAAM,IAAI,CAAC,SAAS,CAAC,aAAa,CAAC,sBAAsB,EAAE,IAAI,CAAC;YACxG,IAAI,CAAC,OAAO,EAAE,KAAK,SAAS,CAAC,gBAAgB,IAAe,IAAI,CAAC,QAAS,CAAC,YAAY;YACvF,IAAI,CAAC,aAAa,CAAC,MAAM,CAAC,iBAAiB,CAAC,cAAc,EAAE,IAAI,CAAC,CAAC;;YAElE,IAAI,CAAC,aAAa,CAAC,MAAM,CAAC,iBAAiB,CAAC,cAAc,EAAE,KAAK,CAAC,CAAC;QAErE,IAAI,CAAC,MAAM,IAAI,CAAC,SAAS,CAAC,aAAa,CAAC,sBAAsB,EAAE,IAAI,CAAC,CAAC;YACpE,CAAY,IAAI,CAAC,QAAS,CAAC,YAAY;gBACrC,CAAC,IAAI,CAAC,OAAO,EAAE,KAAK,SAAS,CAAC,gBAAgB,IAAI,WAAW,CAAC,QAAQ,CAAC,uBAAuB,CAAC,IAAI,CAAC,UAAU,EAAE,CAAC,CAAC;gBAClH,CAAC,IAAI,CAAC,OAAO,EAAE,KAAK,SAAS,CAAC,gBAAgB,CAAC,CAAC;YAClD,IAAI,CAAC,gBAAgB,CAAC,IAAI,CAAC,CAAC;;YAE5B,IAAI,CAAC,gBAAgB,CAAC,KAAK,CAAC,CAAC;IACjC,CAAC;IAGD,gBAAgB,CAAC,aAAsB;QACrC,IAAI,CAAC,QAAQ,CAAC,gBAAgB,CAAC,aAAa,CAAC,CAAC;IAChD,CAAC;IAGD,OAAO;QACL,OAAO,IAAI,CAAC,IAAI,CAAC;IACnB,CAAC;IAKD,KAAK,CAAC,iBAAiB,CAAC,cAAuB;QAE7C,IAAI,IAAI,CAAC,QAAQ,EAAE,KAAK,SAAS,CAAC,eAAe,EAAE;YACjD,IAAI,CAAC,aAAa,CAAC,MAAM,CAAC,iBAAiB,CAAC,qBAAqB,EAAE,IAAI,CAAC,CAAC;YAGzE,IAAI,IAAI,CAAC,SAAS,EAAE;gBAClB,IAAI,MAAM,GAAG,YAAY,CAAC,aAAa,CAAC,cAAc,EAAE,CAAC;gBACzD,IAAI,CAAC,MAAM,IAAI,IAAI,IAAI,MAAM,CAAC,eAAe,EAAE,IAAI,iBAAiB,CAAC,sBAAsB,CAAC,IAAI,cAAc,EAC9G;oBACE,IAAI,KAAK,GAAiB,IAAI,YAAY,CAAC,IAAI,CAAC,CAAC;oBACjD,KAAK,CAAC,WAAW,CAAC,iBAAiB,CAAC,qBAAqB,CAAC,CAAC;oBAC3D,KAAK,CAAC,eAAe,CAAC,YAAY,CAAC,MAAM,CAAC,CAAC;oBAC3C,MAAM,YAAY,CAAC,aAAa,CAAC,WAAW,CAAC,KAAK,EAAE,KAAK,CAAC,CAAC;iBAC5D;aACF;;gBAEC,YAAY,CAAC,aAAa,CAAC,gCAAgC,CAAC,IAAI,EAAE,iBAAiB,CAAC,qBAAqB,CAAC,CAAC;YAE7G,IAAI,CAAC,QAAQ,CAAC,SAAS,CAAC,iBAAiB,CAAC,CAAC;YAO3C,IAAI,IAAI,CAAC,eAAe,KAAK,wBAAwB,CAAC,UAAU,IAAI,cAAc,IAAI,MAAM,IAAI,CAAC,oBAAoB,EAAE,EAAE;gBACvH,MAAiB,IAAI,CAAC,QAAS,CAAC,eAAe,EAAE,CAAC;gBAClD,MAAM,IAAI,CAAC,wBAAwB,EAAE,CAAC;aACvC;YAED,MAAM,IAAI,CAAC,mBAAmB,EAAE,CAAC;YACjC,IAAI,CAAC,aAAa,CAAC,MAAM,CAAC,iBAAiB,CAAC,wBAAwB,EAAE,KAAK,CAAC,CAAC;YAC7E,IAAI,CAAC,aAAa,CAAC,MAAM,CAAC,iBAAiB,CAAC,wBAAwB,EAAE,KAAK,CAAC,CAAC;SAC9E;IACH,CAAC;IAKD,kBAAkB;QAChB,IAAI,CAAC,aAAa,CAAC,MAAM,CAAC,iBAAiB,CAAC,qBAAqB,EAAE,KAAK,CAAC,CAAC;QAC1E,IAAI,CAAC,QAAQ,CAAC,SAAS,CAAC,eAAe,CAAC,CAAC;QAEzC,IAAI,CAAC,aAAa,CAAC,MAAM,CAAC,iBAAiB,CAAC,wBAAwB,EAAE,IAAI,CAAC,CAAC;QAC5E,IAAI,CAAC,aAAa,CAAC,MAAM,CAAC,iBAAiB,CAAC,wBAAwB,EAAE,IAAI,CAAC,CAAC;IAC9E,CAAC;IAMD,KAAK,CAAC,cAAc,CAAC,WAAqB,EAAE,sBAA+B;QACzE,IAAI,QAAQ,GAAS,kBAAkB,CAAC,QAAQ,CAAC,kBAAkB,EAAE,CAAC;QACtE,IAAI,QAAQ,GAAY,MAAa,WAAY,CAAC,eAAe,CAAC,QAAQ,CAAC,CAAC;QAE5E,IAAI,YAAY,CAAC,aAAa,CAAC,oBAAoB,EAAE;YACnD,OAAO;QAGT,IAAI,WAAW,CAAC,QAAQ,EAAE,KAAK,SAAS,CAAC,eAAe,IAAI,CAAC,YAAY,CAAC,aAAa,CAAC,oBAAoB,EAAE,EAAE;YAC9G,YAAY,CAAC,aAAa,CAAC,iBAAiB,EAAE,CAAC;YAC/C,MAAM,YAAY,CAAC,aAAa,CAAC,4CAA4C,CAAC,WAAW,EAAE,iBAAiB,CAAC,iBAAiB,EAAE,IAAI,CAAC,CAAC;YACtI,YAAY,CAAC,aAAa,CAAC,gBAAgB,EAAE,CAAC;YAC9C,QAAQ,GAAG,IAAI,CAAC;YAGhB,IAAI,YAAY,CAAC,aAAa,CAAC,oBAAoB,EAAE;gBACnD,OAAO;SACV;QAGD,IAAI,GAAG,GAAmB,cAAc,CAAC,2BAA2B,CAAC,IAAI,CAAC,UAAU,EAAE,EAAE,WAAW,CAAC,UAAU,EAAE,EAAE,sBAAsB,CAAC,CAAC;QAC1I,MAAM,WAAW,CAAC,eAAe,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC;QAC/C,IAAI,WAAW,CAAC,UAAU,EAAE;YAC1B,OAAO;QAET,IAAI,sBAAsB,EAAE;YAE1B,YAAY,CAAC,aAAa,CAAC,iBAAiB,EAAE,CAAC;YAG/C,IAAI,4BAA4B,GAAmB,WAAY,CAAC,yBAAyB,CAAC;YACnF,WAAY,CAAC,yBAAyB,GAAG,KAAK,CAAC;YACtD,MAAM,YAAY,CAAC,aAAa,CAAC,4CAA4C,CAAC,WAAW,EAAE,iBAAiB,CAAC,iBAAiB,EAAE,IAAI,CAAC,CAAC;YAC/H,WAAY,CAAC,yBAAyB,GAAG,4BAA4B,CAAC;YAC7E,YAAY,CAAC,aAAa,CAAC,gBAAgB,EAAE,CAAC;YAC9C,IAAI,YAAY,CAAC,aAAa,CAAC,oBAAoB,EAAE;gBACnD,OAAO;SACV;QAID,IAAI,QAAQ,EAAE;SAKb;aACI;YACH,IAAI,CAAC,YAAY,CAAC,aAAa,CAAC,oBAAoB,EAAE,EAAE;gBACtD,IAAI,sBAAsB,EAAE;oBAC1B,MAAM,YAAY,CAAC,aAAa,CAAC,2BAA2B,CAAC,WAAW,EAAE,iBAAiB,CAAC,iBAAiB,CAAC,CAAC;oBAC/G,IAAI,QAAQ,IAAI,IAAI;wBACP,QAAQ,CAAC,QAAS,CAAC,cAAc,EAAE,CAAC;oBACjD,WAAW,CAAC,qBAAqB,GAAG,KAAK,CAAC;iBAC3C;aACF;SACF;IACH,CAAC;IAQD,KAAK,CAAC,eAAe,CAAC,QAAc;QAClC,IAAI,iBAAiB,GAAY,KAAK,CAAC;QAIvC,IAAI,QAAQ,IAAI,IAAI;YAClB,OAAO,iBAAiB,CAAC;QAI3B,IAAI,IAAI,CAAC,QAAQ,EAAE,KAAK,SAAS,CAAC,eAAe,IAAI,QAAQ,CAAC,QAAQ,EAAE,KAAK,IAAI,CAAC,QAAQ,EAAE;YAC1F,OAAO,iBAAiB,CAAC;QAE3B,KAAK,IAAI,IAAI,GAAS,QAAQ,EAAE,IAAI,KAAK,IAAI,IAAI,IAAI,CAAC,YAAY,CAAC,IAAI,CAAC,IAAI,IAAI,CAAC,QAAQ,EAAE,KAAK,SAAS,CAAC,eAAe,EAAE,IAAI,GAAS,IAAI,CAAC,SAAS,EAAE,EAAE;YACxJ,YAAY,CAAC,aAAa,CAAC,iBAAiB,EAAE,CAAC;YAC/C,MAAM,YAAY,CAAC,aAAa,CAAC,2BAA2B,CAAC,IAAI,EAAE,iBAAiB,CAAC,iBAAiB,CAAC,CAAC;YACxG,YAAY,CAAC,aAAa,CAAC,gBAAgB,EAAE,CAAC;YAC9C,iBAAiB,GAAG,IAAI,CAAC;SAC1B;QAED,OAAO,iBAAiB,CAAC;IAC3B,CAAC;IAQD,KAAK,CAAC,oBAAoB,CAAC,OAAa;QACtC,IAAI,QAAc,CAAC;QACnB,IAAI,CAAS,EAAE,GAAG,GAAG,CAAC,CAAC;QACvB,KAAK,CAAC,GAAG,IAAI,CAAC,SAAS,CAAC,MAAM,EAAE,CAAC,GAAG,CAAC,EAAE,CAAC,EAAE,EAAE;YAC1C,QAAQ,GAAG,IAAI,CAAC,SAAS,CAAC,QAAQ,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC;YAC1C,IAAI,CAAC,OAAO,CAAC,SAAS,CAAC,QAAQ,CAAC,QAAQ,CAAC,EAAE;gBACzC,MAAM,YAAY,CAAC,aAAa,CAAC,2BAA2B,CAAC,QAAQ,EAAE,iBAAiB,CAAC,iBAAiB,CAAC,CAAC;gBAC5G,IAAI,YAAY,CAAC,aAAa,CAAC,oBAAoB,EAAE;oBACnD,MAAM;gBAIR,IAAI,QAAQ,CAAC,OAAO,EAAE,KAAK,SAAS,CAAC,gBAAgB,IAAI,CAAC,CAAY,QAAQ,CAAC,QAAS,CAAC,UAAU,EAAE,CAAC,CAAC,QAAQ,EAAE;oBAC/G,QAAQ,CAAC,OAAO,CAAC,SAAS,CAAC,gBAAgB,CAAC,CAAC;aAChD;iBACI;gBACH,GAAG,GAAG,OAAO,CAAC,SAAS,CAAC,OAAO,CAAC,QAAQ,CAAC,CAAC;gBAC1C,MAAM;aACP;SACF;QACD,KAAK,CAAC,MAAM,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC;QACpB,OAAO,GAAG,CAAC;IACb,CAAC;IAMD,UAAU;QACR,OAAO,IAAI,CAAC,QAAQ,CAAC;IACvB,CAAC;IAMD,eAAe;QACb,IAAI,CAAC,QAAQ,GAAG,IAAI,CAAC,QAAQ,GAAG,CAAC,CAAC;IACpC,CAAC;IAED,UAAU,CAAC,GAAW;QACpB,IAAI,CAAC,QAAQ,GAAG,GAAG,CAAC;IACtB,CAAC;IAMD,uBAAuB;QACrB,OAAO,IAAI,CAAC,mBAAmB,KAAK,IAAI,CAAC,cAAc,CAAC;IAC1D,CAAC;IAQD,MAAM,CAAC,kBAAkB,CAAC,QAAgB;QACxC,IAAI,KAAK,GAAiB,SAAS,CAAC,SAAS,CAAC,QAAQ,EAAE,GAAG,CAAC,CAAC;QAC7D,IAAI,aAAa,GAAY,KAAK,CAAC;QAEnC,IAAI,KAAK,CAAC,MAAM,KAAK,CAAC,EAAE;YACtB,IAAI,MAAM,GAAW,OAAO,CAAC,KAAK,CAAC,KAAK,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,CAAC;YACtD,IAAI,MAAM,KAAK,QAAQ,CAAC,kBAAkB;gBACxC,aAAa,GAAG,IAAI,CAAC;SACxB;QAED,OAAO,aAAa,CAAC;IACvB,CAAC;IAED,WAAW;QAET,IAAI,QAAQ,GAAW,CAAC,IAAI,CAAC,OAAO,CAAC,aAAa,CAAC,cAAc,CAAC,CAAC,CAAC,gBAAgB,EAAE,CAAC;QACvF,OAAO,OAAO,CAAC,MAAM,CAAC,SAAS,EAAC,IAAI,CAAC,SAAS,EAAE,CAAC,CAAC,CAAC,SAAS,CAAA,CAAC,CAAC,SAAS,EAAE,QAAQ,CAAC,CAAC;IACrF,CAAC;IAED,QAAQ;QACN,OAAO,OAAO,CAAC,MAAM,CAAC,uBAAuB,EAAE,IAAI,CAAC,QAAQ,EAAE,IAAI,CAAC,IAAI,EAAE,KAAK,CAAC,UAAU,EAAE,CAAC,CAAC,CAAC,CAAC,OAAO,GAAG,IAAI,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC;IAC/H,CAAC;IAOD,eAAe,CAAC,oBAAuC;QACrD,IAAI,IAAI,GAAW,IAAI,MAAM,EAAE,CAAC;QAChC,IAAI,UAAU,GAAe,CAAC,IAAI,CAAC,UAAU,IAAI,IAAI,CAAC,CAAC,CAAC,IAAI,CAAC,UAAU,CAAC,OAAO,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC;QAK1F,OAAO,UAAU,IAAI,IAAI,IAAI,CAAC,UAAU,CAAC,OAAO,EAAE,CAAC,SAAS,EAAE,EAAE;YAC9D,UAAU,GAAG,UAAU,CAAC,UAAU,CAAC;SACpC;QAED,IAAI,CAAC,UAAU,GAAG,UAAU,CAAC;QAC7B,oBAAoB,CAAC,KAAK,GAAG,IAAI,CAAC;QAClC,OAAO,IAAI,CAAC;IACd,CAAC;IAKD,QAAQ;QACN,OAAO,IAAI,CAAC,OAAO,CAAC,KAAK,EAAE,CAAC;IAC9B,CAAC;IAKD,SAAS;QACP,OAAO,IAAI,CAAC,OAAO,CAAC;IACtB,CAAC;IAGD,KAAK,CAAC,cAAc;QAClB,IAAI,IAAI,CAAC,IAAI,KAAK,IAAI,IAAI,CAAC,IAAI,CAAC,UAAU,EAAE,IAAI,IAAI,CAAC,SAAS,EAAE,EAAE;YAChE,MAAM,CAAC,QAAQ,CAAC,aAAa,CAAC,6BAA6B,CAAC,CAAC;YAQ7D,IAAI,IAAI,CAAC,YAAY,KAAK,SAAS,CAAC,iBAAiB,EAAE;gBACrD,IAAI,IAAI,GAAmB,IAAI,CAAC,IAAI,CAAC;gBACrC,IAAI,YAAY,GAAY,MAAM,IAAI,CAAC,cAAc,CAAC,SAAS,CAAC,iBAAiB,CAAC,CAAC;gBACnF,IAAI,YAAY,EAAE;oBAChB,IAAI,CAAC,YAAY,GAAG,SAAS,CAAC,iBAAiB,CAAC;iBACjD;aACF;YACD,MAAM,CAAC,QAAQ,CAAC,aAAa,CAAC,2BAA2B,CAAC,CAAC;SAC5D;IACH,CAAC;IAgBD,oBAAoB,CAAC,QAAkB,EAAE,KAAuB,EAAE,MAAyB;QACzF,KAAK,CAAC,KAAK,GAAW,QAAS,CAAC,YAAY,EAAE,CAAC;QAC/C,MAAM,CAAC,KAAK,GAAW,QAAS,CAAC,MAAM,EAAE,CAAC;IAC5C,CAAC;IAMD,KAAK,CAAC,iCAAiC,CAAC,QAAkB,EAAE,KAAa,EAAE,MAAe;QACxF,IAAI,IAAI,CAAC,kBAAkB,EAAE;YAC3B,MAAc,QAAS,CAAC,yBAAyB,CAAC,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,KAAK,EAAE,KAAK,CAAC,CAAC;SACtF;IACH,CAAC;IAMD,gCAAgC;QAC9B,OAAO,IAAI,CAAC,kBAAkB,EAAE,CAAC;IACnC,CAAC;IAOO,kBAAkB;QACxB,IAAI,wBAAwB,GAAY,KAAK,CAAC;QAG9C,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,kBAAkB,KAAK,UAAU,CAAC,OAAO,CAAC,IAAI,IAAI,CAAC,OAAO,EAAE,CAAC,MAAM;YAChF,wBAAwB,GAAG,IAAI,CAAC;aAC7B,IAAI,CAAC,IAAI,CAAC,aAAa,EAAE;YAC1B,wBAAwB,GAAG,IAAI,CAAC;SACnC;QACD,OAAO,wBAAwB,CAAC;IAClC,CAAC;IAKD,SAAS;QACP,OAAO,IAAI,CAAC,WAAW,CAAC;IAC1B,CAAC;IAKD,cAAc,CAAC,OAAiB;QAC9B,IAAI,OAAO,KAAK,IAAI;YAClB,OAAO,IAAI,CAAC;aACT,IAAI,OAAO,KAAK,IAAI,IAAI,IAAI,CAAC,WAAW,KAAK,IAAI;YACpD,OAAO,KAAK,CAAC;QAEf,OAAO,IAAI,CAAC,WAAW,CAAC,cAAc,CAAC,OAAO,CAAC,CAAC;IAClD,CAAC;IAKM,yBAAyB;QAC9B,IAAI,QAAQ,GAAS,IAAI,CAAC;QAC1B,OAAO,QAAQ,CAAC,WAAW,IAAI,IAAI,IAAI,QAAQ,CAAC,WAAW,CAAC,oBAAoB,EAAE,EAAE;YAClF,IAAI,WAAW,GAAyB,CAAC,QAAQ,CAAC,WAAW,CAAC,OAAO,EAAE,CAAC,cAAc,EAAE,CAAC,CAAC;YAC1F,IAAI,WAAW,CAAC,OAAO,EAAE,EACzB;gBACE,OAAO,WAAW,CAAC;aACpB;YACD,QAAQ,GAAG,QAAQ,CAAC,WAAW,CAAC;SACjC;QAED,OAAO,IAAI,CAAC;IACd,CAAC;IAMD,6BAA6B,CAAC,MAAc;QAC1C,OAAO,IAAI,CAAC,WAAW,CAAC,6BAA6B,CAAC,MAAM,CAAC,CAAC;IAChE,CAAC;IAMD,eAAe;QAIb,IAAI,IAAI,CAAC,UAAU,IAAI,IAAI,CAAC,IAAI,KAAK,IAAI,EAAE;YACzC,IAAI,CAAC,IAAI,CAAC,QAAQ,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,WAAW,EAAE;gBAC5C,IAAI,CAAC,IAAI,GAAG,IAAI,CAAC;aAClB;SACF;IACH,CAAC;IAMD,KAAK,CAAC,kBAAkB;QACtB,IAAI,eAAe,GAAa,IAAI,CAAC,OAAO,CAAC,aAAa,CAAC,sBAAsB,CAAC,CAAC;QAEnF,IAAI,gBAAgB,GAAW,MAAM,eAAe,CAAC,WAAW,EAAE,CAAC;QAEnE,gBAAgB,GAAG,IAAI,CAAC,oCAAoC,CAAC,gBAAgB,CAAC,CAAC;QAE/E,IAAI,CAAC,MAAM,CAAC,qBAAqB,CAAC,gBAAgB,CAAC,CAAC;QACpD,IAAI,CAAC,eAAe,EAAE,CAAC;IACzB,CAAC;IAKD,KAAK,CAAC,eAAe;QACnB,MAAM,eAAe,CAAC,yBAAyB,CAAC,IAAI,CAAC,CAAC;QACtD,OAAO,MAAM,iBAAiB,CAAC,sBAAsB,CAAC,IAAI,CAAC,CAAC;IAC9D,CAAC;IAOD,WAAW;QACT,IAAI,aAAa,GAAY,KAAK,CAAC,UAAU,EAAE,CAAC;QAChD,OAAO,aAAa,IAAI,KAAK,CAAC,OAAO,EAAE,CAAC,WAAW,CAAC;IACtD,CAAC;IAOD,8BAA8B,CAAC,UAAkB;QAC/C,IAAI,IAAI,GAAS,IAAI,CAAC,uBAAuB,CAAC;QAE9C,OAAO,IAAI,IAAI,IAAI,EAAE;YACnB,UAAU,IAAI,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC;YAChC,IAAI,GAAG,IAAI,CAAC,uBAAuB,CAAC;SACrC;QAED,OAAO,UAAU,CAAC;IACpB,CAAC;IAOD,oCAAoC,CAAC,UAAkB;QACrD,IAAI,UAAU,GAAG,CAAC,EAAE;YAElB,IAAI,IAAI,GAAS,IAAI,CAAC,uBAAuB,CAAC;YAE9C,OAAO,IAAI,IAAI,IAAI,EAAE;gBACnB,UAAU,IAAI,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC;gBAChC,IAAI,GAAG,IAAI,CAAC,uBAAuB,CAAC;aACrC;SACF;QAED,OAAO,UAAU,CAAC;IACpB,CAAC;IAOD,iCAAiC,CAAC,oBAAsC;QACtE,IAAI,WAAW,GAAS,IAAI,CAAC;QAK7B,IAAI,oBAAoB,CAAC,aAAa,EAAE;YACtC,OAAa,iBAAiB,CAAC,WAAW,CAAC,mBAAmB,CAAC,IAAI,CAAC,SAAS,EAAE,oBAAoB,CAAC,QAAQ,CAAC,CAAC;QAEhH,OAAO,WAAW,IAAI,IAAI,EAAE;YAC1B,IAAI,WAAW,CAAC,gBAAgB,CAAC,MAAM,CAAC,oBAAoB,CAAC;gBAC3D,OAAO,WAAW,CAAC;YAErB,WAAW,GAAG,WAAW,CAAC,WAAW,CAAC;SACvC;QAED,OAAO,IAAI,CAAC;IACd,CAAC;IAED,6BAA6B,CAAC,SAAiB,EAAE,UAAkB;QACjE,IAAI,IAAI,GAAkB,KAAK,CAAC,OAAO,EAAE,CAAC,OAAO,CAAC,SAAS,CAAC,CAAC;QAC7D,IAAI,CAAC,UAAU,CAAC,UAAU,CAAC,CAAC;IAC9B,CAAC;IAOD,yBAAyB,CAAC,IAAY;QAGpC,IAAI,cAAc,GAAgB,IAAI,CAAC,cAAc,EAAE,CAAC;QACxD,IAAI,cAAc,CAAC,OAAO,EAAE,IAAI,IAAI;YAClC,cAAc,GAAG,kBAAkB,CAAC,QAAQ,CAAC,kBAAkB,EAAE,CAAC;QAEpE,cAAc,CAAC,kBAAkB,CAAC,IAAI,CAAC,CAAC;IAC1C,CAAC;IAGD,6BAA6B;QAC3B,IAAI,6BAA6B,GAAY,KAAK,CAAC;QAEnD,IAAI,IAAI,CAAC,OAAO,EAAE,IAAI,IAAI;YACxB,6BAA6B,GAAY,IAAI,CAAC,OAAO,EAAG,CAAC,4BAA4B,EAAE,CAAC;QAE1F,OAAO,6BAA6B,CAAC;IACvC,CAAC;IAED,cAAc;QACZ,IAAI,KAAK,GAAI,CAAC,IAAI,CAAC,OAAO,CAAC,aAAa,CAAC,cAAc,CAAC,CAAC,CAAC,gBAAgB,EAAE,CAAC;QAC7E,IAAI,IAAI,GAAS,IAAI,CAAC;QACtB,OAAO,IAAI,CAAC,UAAU,KAAK,IAAI,IAAI,CAAC,IAAI,CAAC,UAAU,CAAC,UAAU,EAAE,EAAE;YAChE,IAAI,GAAS,IAAI,CAAC,UAAU,CAAC;YAC7B,KAAK,GAAI,CAAC,IAAI,CAAC,OAAO,CAAC,aAAa,CAAC,cAAc,CAAC,CAAC,CAAC,gBAAgB,EAAE,GAAG,GAAG,GAAG,KAAK,CAAC;SACxF;QAED,OAAO,KAAK,CAAC;IACf,CAAC;IAKD,MAAM,CAAC,KAAK,CAAC,cAAc;QACzB,IAAI,OAAO,GAAW,kBAAkB,CAAC,QAAQ,CAAC,MAAM,CAAC,UAAU,EAAE,CAAC;QACtE,IAAI,aAAa,GAAW,OAAO,CAAC,OAAO,CAAC,YAAY,CAAC,SAAS,EAAE,kBAAkB,CAAC,QAAQ,CAAC,MAAM,CAAC,YAAY,EAAE,CAAC,CAAC;QACvH,KAAK,CAAC,MAAM,CAAC,aAAa,KAAK,CAAC,CAAC,IAAI,aAAa,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC;QAGrE,IAAI,GAAG,GAAW,kBAAkB,CAAC,QAAQ,CAAC,MAAM,CAAC,eAAe,CAAC,aAAa,CAAC,CAAC;QACpF,kBAAkB,CAAC,QAAQ,CAAC,MAAM,CAAC,aAAa,CAAC,GAAG,CAAC,OAAO,CAAC,cAAc,CAAC,cAAc,CAAC,GAAG,cAAc,CAAC,cAAc,CAAC,MAAM,CAAC,CAAC;QAEpI,IAAI,YAAY,GAAiB,SAAS,CAAC,SAAS,CAAC,kBAAkB,CAAC,QAAQ,CAAC,MAAM,CAAC,eAAe,CAAC,aAAa,CAAC,EAAE,YAAY,CAAC,cAAc,CAAC,CAAC;QACrJ,IAAI,YAAY,GAAW,YAAY,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC;QACpD,IAAI,UAAU,GAAW,YAAY,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC;QAElD,IAAI,mBAAmB,GAAW,EAAE,CAAC;QAErC,IAAG,YAAY,CAAC,IAAI,EAAE,IAAI,EAAE,EAAE;YAG5B,IAAG,YAAY,CAAC,UAAU,CAAC,IAAI,CAAC;gBAC/B,YAAY,GAAE,OAAO,CAAC,OAAO,CAAC,YAAY,EAAE,IAAI,EAAE,aAAa,CAAC,YAAY,EAAE,GAAG,SAAS,CAAC,CAAC;YAE7F,mBAAmB,GAAG,MAAM,IAAI,CAAC,iBAAiB,CAAC,UAAU,CAAC,YAAY,EAAE,IAAI,CAAC,CAAC;SACnF;QAGD,IAAI,gBAAgB,GAAkB,IAAI,aAAa,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC,EAAE,kBAAkB,CAAC,QAAQ,CAAC,MAAM,CAAC,YAAY,EAAE,GAAG,CAAC,cAAc,CAAC,cAAc,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,EAAE,mBAAmB,CAAC,MAAM,CAAC,CAAC;QAEvM,IAAI,OAAO,GAAiB,IAAI,CAAC,UAAU,CAAC,UAAU,EAAE,GAAG,EAAE,IAAI,EAAE,CAAC,CAAC,CAAC,CAAC;QACvE,IAAI,UAAU,GAAG,CAAC,CAAC;QAEnB,IAAI,OAAO,GAAW,mBAAmB,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC;QACxD,IAAI,OAAO,GAAW,CAAC,CAAC;QACxB,OAAO,OAAO,KAAK,CAAC,CAAC,EAAE;YACrB,gBAAgB,CAAC,MAAM,CAAC,mBAAmB,CAAC,MAAM,CAAC,OAAO,EAAE,OAAO,GAAG,OAAO,CAAC,CAAC,CAAC;YAChF,gBAAgB,CAAC,MAAM,CAAC,OAAO,CAAC,QAAQ,CAAC,UAAU,EAAE,CAAC,CAAC,CAAC;YACxD,OAAO,IAAI,CAAC,CAAC;YACb,OAAO,GAAG,OAAO,CAAC;YAClB,OAAO,GAAG,mBAAmB,CAAC,OAAO,CAAC,IAAI,EAAE,OAAO,CAAC,CAAC;SACtD;QACD,gBAAgB,CAAC,MAAM,CAAC,mBAAmB,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC,CAAC;QAG7D,gBAAgB,CAAC,MAAM,CAAC,OAAO,CAAC,MAAM,CAAC,OAAO,CAAC,OAAO,CAAC,YAAY,CAAC,SAAS,EAAE,aAAa,GAAG,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC;QACxG,OAAO,GAAG,gBAAgB,CAAC,QAAQ,EAAE,CAAC;QAEtC,MAAM,CAAC,QAAQ,CAAC,aAAa,CAAC,OAAO,CAAC,MAAM,CAAC,kBAAkB,EAAE,YAAY,EAAE,OAAO,CAAC,CAAC,CAAC;QAEzF,kBAAkB,CAAC,QAAQ,CAAC,MAAM,CAAC,UAAU,CAAC,OAAO,CAAC,CAAC;QACvD,kBAAkB,CAAC,QAAQ,CAAC,MAAM,CAAC,YAAY,CAAC,kBAAkB,CAAC,QAAQ,CAAC,MAAM,CAAC,YAAY,EAAE,GAAG,CAAC,cAAc,CAAC,cAAc,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,CAAC;IAClJ,CAAC;IAOO,MAAM,CAAC,UAAU,CAAC,IAAY,EAAE,KAAa,EAAE,KAAc,EAAE,SAAiB;QACtF,IAAI,OAAO,GAAkB,IAAI,aAAa,EAAE,CAAC;QACjD,IAAI,IAAI,GAAiB,IAAI,IAAI,EAAU,CAAC;QAC5C,IAAI,SAAS,GAAW,CAAC,CAAC;QAG1B,KAAK,IAAI,CAAC,GAAW,CAAC,EAAE,CAAC,GAAG,IAAI,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE;YAC5C,IAAI,IAAI,GAAW,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC;YAElC,IAAI,IAAI,KAAK,IAAI,IAAI,IAAI,KAAK,KAAK;gBACjC,OAAO,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC;iBAClB,IAAI,IAAI,KAAK,KAAK,EAAE;gBACvB,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,QAAQ,EAAE,CAAC,CAAC;gBAC9B,OAAO,GAAG,IAAI,aAAa,EAAE,CAAC;gBAC9B,SAAS,EAAE,CAAC;gBAEZ,IAAI,SAAS,KAAK,SAAS;oBACzB,MAAM;aACT;iBACI,IAAI,IAAI,KAAK,IAAI,EAAE;gBAEtB,IAAI,CAAC,KAAK,IAAI,IAAI,CAAC,MAAM,CAAC,CAAC,GAAG,CAAC,CAAC,KAAK,KAAK;oBACxC,OAAO,CAAC,MAAM,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC;gBAEjC,CAAC,EAAE,CAAC;gBACJ,OAAO,CAAC,MAAM,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC;aAChC;SACF;QAGD,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,QAAQ,EAAE,CAAC,CAAC;QAE9B,OAAO,IAAI,CAAC;IACd,CAAC;IAKD,MAAM,CAAC,KAAK,CAAC,YAAY,CAAC,iBAA0B,EAAE,kBAA2B;QAC/E,IAAI,gBAAgB,GAAY,YAAY,CAAC,aAAa,CAAC,oBAAoB,EAAE,CAAC;QAClF,IAAI,iCAAiC,GAAS,IAAI,CAAC;QACnD,IAAI,WAAW,GAAsB,YAAY,CAAC,aAAa,CAAC,cAAc,EAAE,CAAC;QACjF,YAAY,CAAC,aAAa,CAAC,cAAc,CAAC,iBAAiB,CAAC,GAAG,CAAC,CAAC;QAEjE,MAAM,CAAC,QAAQ,CAAC,aAAa,CAAC,qBAAqB,CAAC,CAAC;QACrD,IAAI,CAAC,cAAc,EAAE,CAAC;QACtB,YAAY,CAAC,aAAa,CAAC,gBAAgB,CAAC,KAAK,CAAC,CAAC;QAGnD,iCAAiC,GAAG,MAAM,IAAI,CAAC,4BAA4B,CAAC,iBAAiB,EAAE,kBAAkB,CAAC,CAAC;QAGnH,IAAI,oCAAoC,GAAmB,IAAI,QAAQ,CAAC,iCAAiC,CAAC,CAAC;QAC3G,IAAI,4BAA4B,GAAmB,IAAI,QAAQ,CAAC,IAAI,CAAC,CAAC;QACtE,MAAM,IAAI,CAAC,kBAAkB,CAAC,CAAC,EAAE,iBAAiB,EAAE,kBAAkB,EAAE,oCAAoC,EAAE,4BAA4B,EAAE,YAAY,CAAC,WAAW,CAAC,CAAC;QACtK,iCAAiC,GAAG,oCAAoC,CAAC,KAAK,CAAC;QAE/E,IAAI,CAAC,IAAI,CAAC,iBAAiB,EAAE;YAC3B,UAAU,CAAC,QAAQ,CAAC,UAAU,CAAC,YAAY,CAAC,WAAW,CAAC,SAAS,CAAC,CAAC,CAAC,EAAE,WAAW,CAAC,QAAQ,CAAC,WAAW,CAAC,CAAC,CAAC,EAAE,IAAI,CAAC,CAAC;YACjH,IAAI,CAAC,iBAAiB,GAAG,IAAI,CAAC;SAC/B;QAED,MAAM,IAAI,CAAC,SAAS,CAAC,iBAAiB,CAAC,CAAC;QACxC,MAAM,IAAI,CAAC,kBAAkB,EAAE,CAAC;QAChC,MAAM,IAAI,CAAC,mBAAmB,CAAC,iBAAiB,CAAC,CAAC;QAIlD,IAAI,IAAI,CAAC,cAAc,KAAK,CAAC,EAAE;YAC7B,IAAI,gBAAgB,GAAY,KAAK,CAAC;YACtC,IAAI,gBAAgB,GAAY,IAAI,CAAC;YAIrC,IAAI,iCAAiC,KAAK,IAAI,IAAI,iCAAiC,CAAC,SAAS,EAAE,EAAE;gBAC/F,gBAAgB,GAAG,IAAI,CAAC;gBACxB,YAAY,CAAC,aAAa,CAAC,4BAA4B,CAAC,MAAM,iCAAiC,CAAC,aAAa,EAAE,CAAC,CAAC;gBAIjH,gBAAgB,GAAG,MAAO,iCAAiC,CAAC,aAAa,EAAE,CAAC;aAC7E;YAKD,IAAI,kBAAkB,CAAC,QAAQ,CAAC,kBAAkB,EAAE,KAAK,IAAI,IAAI,gBAAgB,EAAE;gBACjF,YAAY,CAAC,aAAa,CAAC,iBAAiB,EAAE,CAAC;gBAC/C,MAAM,YAAY,CAAC,aAAa,CAAC,YAAY,CAAC,YAAY,CAAC,WAAW,CAAC,aAAa,EAAE,EAAE,CAAC,CAAC,CAAC;gBAC3F,YAAY,CAAC,aAAa,CAAC,gBAAgB,EAAE,CAAC;aAC/C;YAGD,IAAI,gBAAgB;gBAClB,YAAY,CAAC,aAAa,CAAC,cAAc,CAAC,WAAW,CAAC,CAAC;SAC1D;QAED,IAAI,CAAC,cAAc,EAAE,CAAC;QAEtB,MAAM,CAAC,QAAQ,CAAC,aAAa,CAAC,mBAAmB,CAAC,CAAC;QAGnD,IAAI,gBAAgB,IAAI,CAAC,YAAY,CAAC,aAAa,CAAC,oBAAoB,EAAE;YACxE,IAAI,gBAAgB,IAAI,CAAC,YAAY,CAAC,aAAa,CAAC,oBAAoB,EAAE;gBACxE,YAAY,CAAC,aAAa,CAAC,gBAAgB,CAAC,gBAAgB,CAAC,CAAC;QAElE,OAAO,iCAAiC,CAAC;IAC3C,CAAC;IASD,MAAM,CAAC,KAAK,CAAC,4BAA4B,CAAC,iBAA0B,EAAE,kBAA2B;QAC/F,IAAI,yBAAyB,GAAmB,IAAI,QAAQ,CAAC,IAAI,CAAC,CAAC;QACnE,IAAI,iCAAiC,GAAmB,IAAI,QAAQ,CAAC,IAAI,CAAC,CAAC;QAE3E,IAAI,SAAS,GAAW,YAAY,CAAC,WAAW,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,YAAY,EAAE,CAAC;QAE7E,KAAK,IAAI,CAAC,GAAW,CAAC,EAAE,CAAC,IAAI,SAAS,EAAE,CAAC,GAAG,CAAC,GAAG,CAAC,EAAE;YACjD,IAAI,oBAAoB,GAAe,YAAY,CAAC,WAAW,CAAC,mBAAmB,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;YAE3F,IAAI,oBAAoB,KAAK,IAAI;gBAC/B,MAAM,IAAI,CAAC,kBAAkB,CAAC,CAAC,EAAE,iBAAiB,EAAE,kBAAkB,EAAE,yBAAyB,EAAE,iCAAiC,EAAE,YAAY,CAAC,WAAW,CAAC,CAAC;SACnK;QAED,OAAO,iCAAiC,CAAC,KAAK,CAAC;IACjD,CAAC;IAWO,MAAM,CAAC,KAAK,CAAC,kBAAkB,CAAC,QAAgB,EAAE,iBAA0B,EAAE,kBAA2B,EAAE,yBAAyC,EAAE,iCAAiD,EAAE,WAA8B;QAC7O,IAAI,eAAe,GAAe,WAAW,CAAC,mBAAmB,CAAC,CAAC,CAAC,EAAE,QAAQ,CAAC,CAAC;QAEhF,MAAM,CAAC,QAAQ,CAAC,aAAa,CAAC,OAAO,CAAC,MAAM,CAAC,iDAAiD,EAAE,QAAQ,EAAE,eAAe,CAAC,CAAC,CAAC;QAE5H,yBAAyB,CAAC,KAAK,GAAU,CAAC,MAAM,eAAe,CAAC,KAAK,CAAC,kBAAkB,EAAE,iBAAiB,CAAC,CAAC,CAAC;QAC9G,IAAI,iCAAiC,CAAC,KAAK,KAAK,IAAI;YAClD,iCAAiC,CAAC,KAAK,GAAG,yBAAyB,CAAC,KAAK,CAAC;aACvE,IAAI,yBAAyB,CAAC,KAAK,KAAK,IAAI,EAAE;YACjD,KAAK,CAAC,MAAM,CAAC,KAAK,EAAE,gDAAgD,CAAC,CAAC;SACvE;IACH,CAAC;IAGD,MAAM,CAAC,KAAK,CAAC,SAAS,CAAC,iBAA0B;QAC/C,IAAI,YAAY,GAAsB,MAAM,CAAC,YAAY,CAAC;QAE1D,IAAI,YAAY,CAAC,KAAK,EAAE,GAAG,CAAC,EAAE;YAC5B,IAAI,CAAC,GAAW,CAAC,CAAC;YAClB,OAAO,CAAC,GAAG,YAAY,CAAC,KAAK,EAAE,EAAE;gBAC/B,IAAI,MAAM,GAAW,YAAY,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC;gBACzC,IAAI,OAAO,GAAY,KAAK,CAAC;gBAI7B,IAAI,MAAM,CAAC,SAAS,EAAE,EAAE;oBACtB,IAAI,MAAM,GAAyB,MAAM,CAAC,cAAc,EAAE,CAAC,OAAO,EAAG,CAAC,MAAM,CAAC;oBAC7E,IAAI,MAAM,EAAE;wBACV,OAAO,GAAG,IAAI,CAAC;qBAChB;iBACF;qBACI;oBACH,IAAW,MAAM,CAAC,OAAO,EAAG,CAAC,uBAAuB,EAAE,EAAE;wBACtD,OAAO,GAAG,IAAI,CAAC;qBAChB;iBACF;gBAED,IAAI,OAAO,EAAE;oBACX,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAC;oBACzB,MAAM,OAAO,CAAC,mBAAmB,CAAC,MAAM,CAAC,CAAC;iBAC3C;gBAED,IAAI,MAAM,CAAC,MAAM,EAAE;oBAEjB,YAAY,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC;iBAC7B;;oBAEC,CAAC,EAAE,CAAC;aACP;SACF;IACH,CAAC;IAGD,MAAM,CAAC,KAAK,CAAC,kBAAkB;QAE7B,KAAK,IAAI,CAAC,GAAW,CAAC,EAAE,CAAC,GAAG,YAAY,CAAC,WAAW,CAAC,OAAO,EAAE,EAAE,CAAC,EAAE,EAAE;YACnE,IAAI,GAAG,GAAW,YAAY,CAAC,WAAW,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC;YACxD,IAAI,GAAG,KAAK,IAAI,IAAI,GAAG,CAAC,UAAU;gBAChC,SAAS;YAEX,KAAK,IAAI,CAAC,GAAW,CAAC,EAAE,CAAC,GAAG,GAAG,CAAC,aAAa,EAAE,EAAE,CAAC,EAAE,EAAE;gBACpD,IAAI,IAAI,GAAS,GAAG,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC;gBAEhC,IAAI,IAAI,KAAK,IAAI,EAAE;oBACjB,IAAI,MAAM,GAAmB,IAAI,CAAC,OAAO,EAAE,CAAC;oBAE5C,IAAI,MAAM,KAAK,IAAI,IAAI,IAAI,CAAC,uBAAuB,EAAE,IAAI,CAAC,MAAM,CAAC,sBAAsB,EAAE;wBACvF,MAAM,CAAC,sBAAsB,GAAG,IAAI,CAAC;wBACrC,MAAM,IAAI,CAAC,kBAAkB,EAAE,CAAC;qBACjC;iBACF;aACF;SACF;IACH,CAAC;IAMO,MAAM,CAAC,KAAK,CAAC,mBAAmB,CAAC,iBAA0B;QAEjE,KAAK,IAAI,CAAC,GAAW,CAAC,EAAE,CAAC,GAAG,YAAY,CAAC,WAAW,CAAC,OAAO,EAAE,EAAE,CAAC,EAAE,EAAE;YACnE,IAAI,GAAG,GAAW,YAAY,CAAC,WAAW,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC;YAExD,IAAI,GAAG,KAAK,IAAI,IAAI,GAAG,CAAC,UAAU;gBAChC,SAAS;YAEX,IAAI,UAAU,GAAW,GAAG,CAAC,aAAa,EAAE,CAAC;YAC7C,KAAK,IAAI,CAAC,GAAW,CAAC,EAAE,CAAC,GAAG,UAAU,EAAE,CAAC,EAAE,EAAE;gBAC3C,IAAI,IAAI,GAAS,GAAG,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC;gBAChC,IAAI,MAAM,GAAmB,IAAI,CAAC,OAAO,EAAE,CAAC;gBAE5C,IAAI,IAAI,CAAC,uBAAuB,EAAE,IAAI,MAAM,KAAK,IAAI,IAAI,MAAM,CAAC,mBAAmB,EAAE;oBACnF,MAAM,CAAC,mBAAmB,GAAG,KAAK,CAAC;oBACnC,YAAY,CAAC,aAAa,CAAC,iBAAiB,EAAE,CAAC;oBAC/C,MAAM,MAAM,CAAC,0BAA0B,CAAC,iBAAiB,CAAC,CAAC;oBAC3D,YAAY,CAAC,aAAa,CAAC,gBAAgB,EAAE,CAAC;iBAC/C;aACF;SACF;IACH,CAAC","sourcesContent":["import {Debug, HashUtils, List, NNumber, NString, RefParam, Stack, StringBuilder, isNullOrUndefined} from '@magic-xpa/mscorelib';\r\nimport {\r\n  Constants,\r\n  InternalInterface,\r\n  Logger,\r\n  Logger_LogLevels,\r\n  StorageAttribute,\r\n  StrUtil,\r\n  UniqueTskSort,\r\n  WindowType,\r\n  XMLConstants,\r\n  XmlParser\r\n} from '@magic-xpa/utils';\r\nimport {\r\n  Commands,\r\n  DataModificationTypes,\r\n  DisplayConvertor,\r\n  Events,\r\n  FieldDef,\r\n  GuiDataCollection,\r\n  Helps,\r\n  ITask,\r\n  Manager,\r\n  MgControlBase,\r\n  MgFormBase,\r\n  NUM_TYPE,\r\n  PIC,\r\n  Property,\r\n  PropInterface,\r\n  RecordUtils,\r\n  RuntimeContextBase,\r\n  Styles,\r\n  TaskDefinitionId\r\n} from '@magic-xpa/gui';\r\nimport {Event} from '../event/Event';\r\nimport {DataView} from '../data/DataView';\r\nimport {DvCache} from '../data/DvCache';\r\nimport {MGData} from './MGData';\r\nimport {DataViewCommandType} from '../commands/ClientToServer/DataviewCommand';\r\nimport {CommandsProcessorBase, CommandsProcessorBase_SendingInstruction} from '../CommandsProcessorBase';\r\nimport {TaskServiceBase} from './TaskServiceBase';\r\nimport {ArgumentsList} from '../rt/ArgumentsList';\r\nimport {TaskTransactionManager} from '../data/TaskTransactionManager';\r\nimport {DataviewManager} from '../data/DataviewManager';\r\nimport {SortCollection} from './sort/SortCollection';\r\nimport {Sort} from './sort/Sort';\r\nimport {MgForm} from '../gui/MgForm';\r\nimport {MgControl} from '../gui/MgControl';\r\nimport {RemoteTaskService} from './RemoteTaskService';\r\nimport {ReturnResult} from '../util/ReturnResult';\r\nimport {RunTimeEvent} from '../event/RunTimeEvent';\r\nimport {IClientCommand} from '../commands/IClientCommand';\r\nimport {CommandFactory} from '../commands/ClientToServer/CommandFactory';\r\nimport {DataviewHeaders} from '../rt/DataviewHeaders';\r\nimport {Transaction} from '../rt/Transaction';\r\nimport {TasksTable} from './TasksTable';\r\nimport {IClientTargetedCommand} from '../commands/IClientTargetedCommand';\r\nimport {HandlersTable} from '../rt/HandlersTable';\r\nimport {RecomputeTable} from '../rt/RecomputeTable';\r\nimport {ExpTable} from '../exp/ExpTable';\r\nimport {UserEventsTable} from '../event/UserEventsTable';\r\nimport {FormsTable} from '../gui/FormsTable';\r\nimport {FlowMonitorQueue} from '../util/FlowMonitorQueue';\r\nimport {Field} from '../data/Field';\r\nimport {ActionManager} from '../event/ActionManager';\r\nimport {ConstInterface} from '../ConstInterface';\r\nimport {EventHandler} from '../event/EventHandler';\r\nimport {Expression} from '../exp/Expression';\r\nimport {FieldsTableExt as FieldsTable} from '../data/FieldsTable';\r\nimport {GUIManager} from '../GUIManager';\r\nimport {CommandsProcessorManager} from '../CommandsProcessorManager';\r\nimport {Record} from '../data/Record';\r\nimport {EventSubType} from '../enums';\r\nimport {OpeningTaskDetails, Task_SubformExecModeEnum, TaskBase, UserRange} from './TaskBase';\r\nimport {LanguageData} from '../env/LanguageData';\r\nimport {Environment} from '../env/Environment';\r\nimport {LastFocusedManager} from '../rt/LastFocusedManager';\r\nimport {GlobalCommandsManager} from '../GlobalCommandsManager';\r\nimport {EventsAllowedType} from '../event/IEventsManager';\r\nimport {CreatedFormVector} from '../gui/CreatedFormVector';\r\nimport {AccessHelper} from '../AccessHelper';\r\nimport {IMGDataCollection} from './IMGDataCollection';\r\nimport {MGDataCollection} from './MGDataCollection';\r\nimport {RemoteCommandsProcessor} from \"../remote/RemoteCommandsProcessor\";\r\nimport {EventHandlerPosition} from '../event/EventHandlerPosition';\r\nimport {ClientManager} from \"../ClientManager\";\r\n\r\nexport enum Task_Flow {\r\n  NONE,\r\n  STEP,\r\n  FAST\r\n}\r\n\r\nexport enum Task_Direction {\r\n  BACK = -1,\r\n  NONE,\r\n  FORE\r\n}\r\n\r\n// @dynamic\r\nexport class Task extends TaskBase {\r\n  private _dvCache: DvCache = null;\r\n  private _mgData: MGData = null;\r\n  private _aborting: boolean = false;                   // true if an abort command was executed for this task or one of its ancestors\r\n  private _bExecEndTask: boolean = false;\r\n  private _isStarted: boolean = false;\r\n  private _evalOldValues: boolean = false;              // indicates for the get value to get the old value of the field\r\n  private _inRecordSuffix: boolean = false;             // indicate we are in record suffix (handle before)\r\n  private _cancelWasRaised: boolean = false;            // was cancel/quit event raised ?\r\n  private _counter: number = 0;                         // increases only in non interval tasks.\r\n  private _currStartProgLevel: number = 0;              // the level of startProg request in which we task is started\r\n  private _destinationSubform: boolean = false;         // if TRUE, the task is a Destination Subform task\r\n  private _enableZoomHandler: boolean = false;          // if TRUE, there is a zoom handler for this field\r\n  private _firstRecordCycle: boolean = false;           // indicates whether we are in the first record cycle\r\n  private _originalTaskMode: string = ' ';\r\n  private _inCreateLine: boolean = false;               // is the task into processing CREATE LINE\r\n  public InSelect: boolean = false;                            // true when the task is executing a SELECT internal event\r\n  public InStartProcess: boolean = false;\r\n  private _isDestinationCall: boolean = false;          // if TRUE, the task is a Destination Subform task by call operation\r\n  private _knownToServer: boolean = true;               // False if the server has\r\n  private _loopStack: Stack<number> = null;\r\n  private allowRemoteCmdExecution: boolean;\r\n  public DelayCommandExecution: boolean = false;\r\n\r\n  ///<summary>\r\n  /// This is the task which invoked the handler containing the Call operation.\r\n  /// This member is used for searching the variables like VarIndex(), etc\r\n  ///</summary>\r\n  private _parentTask: Task = null;\r\n\r\n  public get ParentTask(): TaskBase {\r\n    return this._parentTask;\r\n  }\r\n\r\n  public ContextTask: Task = null;                             // under context of which task this task is currently running\r\n  /// <summary>\r\n  /// This is same as _parentTask except for Modal tasks. In case, the current task is modal, _triggeringTask refers to\r\n  ///  the task which invoked the handler of the _parentTask. This member is used for all generation-based functions and Prog().\r\n  /// </summary>\r\n  private _triggeringTask: Task = null;                 // reference to the task that triggered the handler which created me\r\n  /// <summary>\r\n  ///   This is the task which contained the Call operation. If the task was executed without call\r\n  ///   operation eg. the MP, the startup program, etc., it refers to itself. This member used to search for the event handlers\r\n  /// </summary>\r\n  public PathParentTask: Task = null;\r\n\r\n  private _preventControlChange: boolean = false;\r\n  private _preventRecordSuffix: boolean = false;\r\n  private _taskPath: List<Task> = null;\r\n\r\n  // returns true if the task is currently trying to commit a dynamicDef.transaction\r\n  private _tryingToCommit: boolean = false;\r\n\r\n  set TryingToCommit(value: boolean) {\r\n    this._tryingToCommit = value;\r\n  }\r\n\r\n  get TryingToCommit(): boolean {\r\n    return this._tryingToCommit;\r\n  }\r\n\r\n  private _useLoopStack: boolean = false;               // indicates whether the expression (LOOPCOUNTER()) is in the scope of Block Loop.\r\n  private _inProcessingTopMostEndTaskSaved: boolean = false;\r\n\r\n  public InHandleActCancel: boolean = false;\r\n  public RuntimeSorts: SortCollection = null;\r\n  public VewFirst: number = 0;\r\n  public dataViewContent: string = null;                // dataViewContent retrieved by GetDataViewContent command.\r\n  public PerformParentRecordPrefix: boolean = false;    // In record prefix (commonHandlerBefore) we execute record prefix of all fathers.\r\n\r\n  // But we do not need it in all cases.\r\n  // When we return from the server we do not need it.\r\n  // When we click on the nested subform we need it.\r\n  // if true, do the parent subform record prefix\r\n\r\n  // -1 – The task is not executed as a subform\r\n  //  0 – The task is executed by setting the focus on it\r\n  //  1 – The subtask is executed for the first time\r\n  //  2 – The task is executed because the Automatic Refresh property\r\n  //      or the Subform Refresh event has been triggered\r\n  public ModeAsParent: boolean = false;                 // if the task mode is 'As Parent' we need to care out it specifically\r\n  public TaskTransactionManager: TaskTransactionManager = null;\r\n\r\n\r\n  /// <summary>\r\n  /// Indicates that the subform must be refreshed on the client.\r\n  /// Relevant only for non-offline with local data.\r\n  /// </summary>\r\n  public ExecuteClientSubformRefresh: boolean = false;\r\n\r\n  /// <summary>\r\n  /// Indicates that the task executes CommonHandlerBefore method.\r\n  /// For subforms we do not execute it's RP if the parent didn't finished yet\r\n  /// it's CommandHandlerBefore method.\r\n  /// </summary>\r\n  public InCommonHandlerBeforeRP: boolean = false;\r\n\r\n  /// <summary>\r\n  /// retrieve and return a service object containing functionality that is different in the task level between connected and offline states.\r\n  /// </summary>\r\n  private _taskService: TaskServiceBase = null;\r\n\r\n  get TaskService(): TaskServiceBase {\r\n    if (this._taskService == null)\r\n      this._taskService = new RemoteTaskService();\r\n\r\n    return this._taskService;\r\n  }\r\n\r\n  /// <summary>\r\n  /// retrieve and return a commands processor depending on task type and state.\r\n  /// </summary>\r\n  static get CommandsProcessor(): CommandsProcessorBase {\r\n    return CommandsProcessorManager.GetCommandsProcessor();\r\n  }\r\n\r\n  private hasLocate: boolean = false;\r\n  private taskDefinitionId: TaskDefinitionId = null;\r\n  public ArgumentsList: ArgumentsList = null;           // off-line execution - task argument, to enable the update of field values\r\n\r\n  /// <summary>\r\n  /// parent task of the subtask by toolkit tree include the main program.\r\n  /// </summary>\r\n  get LogicalStudioParentTask(): Task {\r\n    if (this.StudioParentTask === null && !super.isMainProg()) {\r\n      return <Task>GuiDataCollection.MGDataTable.GetMainProgByCtlIdx(this.ContextID, this._ctlIdx);\r\n    }\r\n\r\n    return <Task>this.StudioParentTask;\r\n  }\r\n\r\n  get KnownToServer(): boolean {\r\n    return this._knownToServer;\r\n  }\r\n\r\n  public ConfirmUpdateNo: boolean = false;                  // only for confirms update\r\n  public DataSynced: boolean = false;\r\n  public UniqueSort: UniqueTskSort = null;\r\n\r\n\r\n  /// <summary>\r\n  /// the transaction need to be on the data view manager\r\n  /// </summary>\r\n  set Transaction(value: Transaction) {\r\n    this.DataviewManager.CurrentDataviewManager.Transaction = value;\r\n  }\r\n\r\n  get Transaction(): Transaction {\r\n    return this.DataviewManager.CurrentDataviewManager.Transaction;\r\n  }\r\n\r\n  public RefreshOnVars: number[] = null;\r\n  public DvPosDescriptor: List<string[]> = null;\r\n  public SubTasks: TasksTable = null;\r\n  public ExpTab: ExpTable = null;\r\n  public UserEvtTab: UserEventsTable = null;\r\n  public DataviewHeadersTable: DataviewHeaders = null;\r\n  public HandlersTab: HandlersTable = null;\r\n  public _forms: FormsTable = null;\r\n  public Name: string = null;\r\n  public PublicName: string = null;\r\n\r\n  /// <summary>\r\n  /// indicates whether the task suffix was performed for this task\r\n  /// </summary>\r\n  public TaskSuffixExecuted: boolean = false;\r\n\r\n  get TaskDefinitionId(): TaskDefinitionId {\r\n    if (this.taskDefinitionId === null) {\r\n      this.taskDefinitionId = new TaskDefinitionId(this._ctlIdx, this.ProgramIsn, this.TaskIsn, this._isPrg);\r\n    }\r\n    return this.taskDefinitionId;\r\n  }\r\n\r\n  public RetrunValueExp: number = 0;\r\n  public SubformControl: MgControl = null;\r\n\r\n  static StartProgLevel: number = 0;  // recursive level of \"startProg\" invocations\r\n\r\n  private static _idleTimerStarted: boolean = false;\r\n\r\n  static get IsBlockingBatch(): boolean {\r\n    return false;\r\n  }\r\n\r\n\r\n  /// <summary>\r\n  ///   CTOR\r\n  /// </summary>\r\n  constructor();\r\n  constructor(parent: Task);\r\n  constructor(parent?: Task) {\r\n    super();\r\n\r\n    if (isNullOrUndefined(parent)) {\r\n      this.constructor_0();\r\n      return;\r\n    }\r\n    this.constructor_1(parent);\r\n  }\r\n\r\n  private constructor_0(): void {\r\n    this.ActionManager = new ActionManager();\r\n    this.DataView = new DataView(this);\r\n    this._flowMonitor = FlowMonitorQueue.Instance;\r\n    this.ContextTask = this;\r\n    this._dvCache = new DvCache(this);\r\n    this.PerformParentRecordPrefix = true;\r\n    this.DataviewManager = new DataviewManager(this);\r\n    this.allowRemoteCmdExecution = true;\r\n    this.TaskTransactionManager = new TaskTransactionManager(this);\r\n  }\r\n\r\n  public Init(): void {\r\n    this.DataView.Init();\r\n  }\r\n\r\n  private constructor_1(parent: Task): void {\r\n    this.constructor_0();\r\n    this.PathParentTask = parent;\r\n    this._parentTask = parent;\r\n    this._triggeringTask = null;\r\n    this.buildTaskPath();\r\n  }\r\n\r\n  static CreateTask(): TaskBase {\r\n    let task =  new Task();\r\n    task.Init();\r\n    return task;\r\n  }\r\n\r\n  // ITask Members\r\n  /// <summary>\r\n  ///   tells whether the task is aborting\r\n  /// </summary>\r\n  isAborting(): boolean {\r\n    return this._aborting;\r\n  }\r\n\r\n  private buildTaskPath(): void {\r\n    this._taskPath = new List<Task>();\r\n    if (this._parentTask._taskPath !== null)\r\n      this._taskPath.AddRange(this._parentTask._taskPath.GetEnumerator());\r\n    this._taskPath.push(this);\r\n  }\r\n\r\n  /// <summary>\r\n  ///   get the task data by parsing the xml string\r\n  /// </summary>\r\n  /// <param name = \"mgd\">reference to MGData</param>\r\n  /// <param name=\"openingTaskDetails\">additional information of opening task</param>\r\n  async fillData(mgd: MGData, openingTaskDetails: OpeningTaskDetails): Promise<void> {\r\n    // If this task was opened by an \"open window\" command - connect him to its parent\r\n    if (!super.isMainProg()) {\r\n      if (this._parentTask === null && openingTaskDetails.CallingTask !== null) {\r\n        this._parentTask = <Task>openingTaskDetails.CallingTask;\r\n        this.buildTaskPath();\r\n        (<Task>openingTaskDetails.CallingTask).addSubTask(this);\r\n      }\r\n      if (this.PathParentTask === null && openingTaskDetails.PathParentTask !== null) {\r\n        this.PathParentTask = <Task>openingTaskDetails.PathParentTask;\r\n      }\r\n    }\r\n    // for MG_ACT_ZOOM action enable\r\n    if (this._parentTask !== null && this._parentTask.getEnableZoomHandler()) {\r\n      this.setEnableZoomHandler();\r\n    }\r\n\r\n    this._mgData = mgd;\r\n    this.fillAttributes();\r\n\r\n    this._mgData.addTask(this);\r\n\r\n    let parentForm: MgFormBase = (this._parentTask !== null) ? this._parentTask.getForm() : null;\r\n\r\n    while (await this.initInnerObjects(RuntimeContextBase.Instance.Parser.getNextTag(), parentForm)) {\r\n    }\r\n\r\n    this.TaskTransactionManager.PrepareTransactionProperties(this.DataviewManager.RemoteDataviewManager.Transaction, false);\r\n\r\n    this.HandleTriggerTask();\r\n    this.HandlePreviouslyActiveTaskId();\r\n\r\n    // Set isSubform flag\r\n    this.CheckAndSetSubForm();\r\n\r\n    if (this.IsSubForm) {\r\n      // get the subform control from the parent task\r\n      let subFormCtrl: MgControl = (<MgForm>this.getParent().getForm()).getSubFormCtrlForTask(this._taskTag);\r\n      if (subFormCtrl !== null) {\r\n        subFormCtrl.setSubformTaskId(this._taskTag);\r\n      }\r\n\r\n      // update the form with the subform control from the parent task\r\n      if (this.Form !== null) {\r\n        (<MgForm>this.Form).setSubFormCtrl(subFormCtrl);\r\n      }\r\n    }\r\n  }\r\n\r\n  /// handle the PreviouslyActiveTaskId\r\n  /// </summary>\r\n  HandlePreviouslyActiveTaskId(): void {\r\n    if (this._parentTask !== null && this._parentTask.GetContextTask() !== null && this._mgData !== this._parentTask.getMGData())\r\n      this.PreviouslyActiveTaskId = (this._parentTask.GetContextTask()).getTaskTag();\r\n    else if (this._parentTask !== null)\r\n      this.PreviouslyActiveTaskId = this._parentTask.getTaskTag();\r\n  }\r\n\r\n  /// <summary>\r\n  /// handle the trigger task\r\n  /// </summary>\r\n  HandleTriggerTask(): void {\r\n    this._triggeringTask = this._parentTask;\r\n  }\r\n\r\n  FillTaskTables(taskTablesData: string): void;\r\n  FillTaskTables(): void;\r\n  FillTaskTables(taskTablesData?: string): void {\r\n    if (arguments.length === 1) {\r\n      this.FillTaskTables_0();\r\n      return;\r\n    }\r\n    this.FillTaskTables_1();\r\n  }\r\n\r\n  private FillTaskTables_0(): void {\r\n  }\r\n\r\n  /// <summary>\r\n  ///   get the task attributes\r\n  /// </summary>\r\n  fillAttributes(): void {\r\n    let parser: XmlParser = RuntimeContextBase.Instance.Parser;\r\n    let endContext: number = parser.getXMLdata().indexOf(XMLConstants.TAG_CLOSE, parser.getCurrIndex());\r\n    if (endContext !== -1 && endContext < parser.getXMLdata().length) {\r\n      super.fillAttributes(parser);\r\n\r\n      // QCR #759911: mprg must belong to the main application's MGData.\r\n      // This ensures it will not be discarded until the end of execution.\r\n      if (super.isMainProg())\r\n        this._mgData = AccessHelper.mgDataTable.getMGData(0);\r\n    }\r\n    else {\r\n      Logger.Instance.WriteExceptionToLogWithMsg(\"in Task.fillAttributes() out of string bounds\");\r\n    }\r\n  }\r\n\r\n  /// <summary>\r\n  ///   set the task attributes\r\n  /// </summary>\r\n  public setAttribute(attribute: string, valueStr: string): boolean {\r\n    let isTagProcessed: boolean;\r\n    isTagProcessed = super.setAttribute(attribute, valueStr);\r\n    if (!isTagProcessed) {\r\n      isTagProcessed = true;\r\n      switch (attribute) {\r\n        case ConstInterface.MG_ATTR_REFRESHON:\r\n          if (!(valueStr.trim() === \"\"))\r\n            this.SetRefreshOnVars(valueStr);\r\n          break;\r\n        case XMLConstants.MG_ATTR_NAME:\r\n          this.Name = valueStr;\r\n          break;\r\n        case ConstInterface.MG_ATTR_DVPOS_DEC:\r\n          if (!(valueStr.trim() === \"\"))\r\n            this.setDescriptor(valueStr);\r\n          break;\r\n        case ConstInterface.MG_ATTR_HAS_LOCATE:\r\n          if (+valueStr == 1)\r\n            this.hasLocate = true;\r\n          break;\r\n        case ConstInterface.MG_ATTR_AS_PARENT:\r\n          if (+valueStr == 1)\r\n            this.ModeAsParent = true;\r\n          break;\r\n        case ConstInterface.MG_ATTR_TASK_UNIQUE_SORT:\r\n          this.UniqueSort = <UniqueTskSort>valueStr[0];\r\n          break;\r\n        case ConstInterface.MG_ATTR_TRANS_ID:\r\n          this.setRemoteTransaction(valueStr);\r\n          break;\r\n        case ConstInterface.MG_ATTR_PUBLIC:\r\n          this.PublicName = XmlParser.unescape(valueStr);\r\n          break;\r\n        case XMLConstants.MG_ATTR_IS_OFFLINE:\r\n          this.IsOffline = XmlParser.getBoolean(valueStr);\r\n          break;\r\n        case XMLConstants.MG_ATTR_RETURN_VALUE_EXP:\r\n          this.RetrunValueExp = XmlParser.getInt(valueStr);\r\n          break;\r\n        case XMLConstants.MG_ATTR_MENUS_FILE_NAME:\r\n          // TODO - not to serialize [Story 154547]\r\n          break;\r\n        default:\r\n          isTagProcessed = false;\r\n          break;\r\n      }\r\n    }\r\n    if (!isTagProcessed)\r\n      Logger.Instance.WriteExceptionToLogWithMsg(NString.Format(\"Unrecognized attribute: '{0}'\", attribute));\r\n    return true;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   To allocate and fill inner objects of the class\r\n  /// </summary>\r\n  /// <param name = \"foundTagName\">possible tag name , name of object, which need be allocated</param>\r\n  async initInnerObjects(foundTagName: string, parentForm: MgFormBase): Promise<boolean> {\r\n    if (foundTagName == null)\r\n      return false;\r\n    let parser: XmlParser = RuntimeContextBase.Instance.Parser;\r\n    switch (foundTagName) {\r\n      case XMLConstants.MG_TAG_HELPTABLE:\r\n        if (this._helpTab == null)\r\n          this._helpTab = new Helps();\r\n\r\n        if (Events.ShouldLog(Logger_LogLevels.Development))\r\n          Events.WriteDevToLog(NString.Format(\"{0} ...\", foundTagName));\r\n\r\n        this._helpTab.fillData(parser);\r\n        break;\r\n\r\n      case XMLConstants.MG_TAG_DVHEADER:\r\n        if (Events.ShouldLog(Logger_LogLevels.Development))\r\n          Events.WriteDevToLog(NString.Format(\"{0} ...\", foundTagName));\r\n\r\n        this.DataView.fillHeaderData(parser);\r\n        break;\r\n\r\n      case XMLConstants.MG_TAG_PROP:\r\n        this._propTab.fillData(this, 'T', parser);\r\n        break;\r\n\r\n      case XMLConstants.MG_TAG_FORM:\r\n        this.Form = this.FormInitData(parentForm);\r\n        break;\r\n\r\n      case XMLConstants.MG_ATTR_MENU_CONTENT:\r\n        // TODO - not to serialize [Story 154547]\r\n        break;\r\n\r\n      case \"assemblies\":\r\n        let endContext = parser.getXMLdata().indexOf('/assemblies', parser.getCurrIndex());\r\n        parser.setCurrIndex(endContext);\r\n        parser.setCurrIndex2EndOfTag();\r\n        break;\r\n\r\n      case XMLConstants.MG_TAG_FORMS:\r\n        this._forms = new FormsTable(this, parentForm);\r\n        Logger.Instance.WriteDevToLog(NString.Format(\"{0} ...\", foundTagName));\r\n        await this._forms.fillData();\r\n        break;\r\n      case XMLConstants.MG_TAG_TASK:\r\n        if (this.SubTasks == null)\r\n          this.SubTasks = new TasksTable();\r\n        let subtask = new Task(this);\r\n        subtask.Init();\r\n        this.SubTasks.addTask(subtask);\r\n        let mgd: MGData = this._mgData;\r\n        if (this.isMainProg())\r\n          mgd = AccessHelper.mgDataTable.GetMGDataForStartupProgram();\r\n        await subtask.fillData(mgd, new OpeningTaskDetails());\r\n        break;\r\n      case ConstInterface.MG_TAG_TASKURL:\r\n        await Task.ProcessTaskURL();\r\n        break;\r\n      case ConstInterface.MG_TAG_EXPTABLE:\r\n        if (this.ExpTab == null)\r\n          this.ExpTab = new ExpTable();\r\n        Logger.Instance.WriteDevToLog(\"goes to exp\");\r\n        this.ExpTab.fillData(this, parser);\r\n        break;\r\n      case ConstInterface.MG_TAG_USER_EVENTS:\r\n        if (this.UserEvtTab == null)\r\n          this.UserEvtTab = new UserEventsTable();\r\n        Logger.Instance.WriteDevToLog(\"goes to user event tab\");\r\n        this.UserEvtTab.fillData(this, parser);\r\n        break;\r\n      case ConstInterface.MG_TAG_LINKS:\r\n        this.DataviewHeadersTable = new DataviewHeaders(this);\r\n        this.DataviewHeadersTable.fillData(parser);\r\n        break;\r\n      case ConstInterface.MG_TAG_SORTS:\r\n        this.RuntimeSorts = new SortCollection();\r\n        this.RuntimeSorts.fillData( parser);\r\n        break;\r\n      case ConstInterface.MG_TAG_TASK_TABLES:\r\n        this.FillTaskTables();\r\n        break;\r\n      case XMLConstants.MG_TAG_RECOMPUTE:\r\n        Logger.Instance.WriteDevToLog(\"goes to recompute\");\r\n        this.RecomputeFillData(parser);\r\n        break;\r\n      case ConstInterface.MG_TAG_EVENTHANDLERS:\r\n        Logger.Instance.WriteDevToLog(\"goes to eventhandlers\");\r\n        if (this.HandlersTab == null)\r\n          this.HandlersTab = new HandlersTable();\r\n        this.HandlersTab.fillData(this, parser);\r\n        this.addExpHandlersToMGData();\r\n        break;\r\n      default:\r\n        if (foundTagName === (\"/\" + XMLConstants.MG_TAG_TASK)) {\r\n          RuntimeContextBase.Instance.Parser.setCurrIndex2EndOfTag();\r\n          return false;\r\n        }\r\n        else {\r\n          Logger.Instance.WriteDevToLog(\"There is no such tag in Task.initInnerObjects . Enter case for \" + foundTagName);\r\n          return false;\r\n        }\r\n    }\r\n    return true;\r\n  }\r\n\r\n  RecomputeFillData(parser: XmlParser): void {\r\n    let recomputeTable: RecomputeTable = new RecomputeTable();\r\n    recomputeTable.fillData_1(<DataView>this.DataView, this, parser);\r\n  }\r\n\r\n  private FillTaskTables_1(): void {\r\n    let parser: XmlParser = RuntimeContextBase.Instance.Parser;\r\n    // Get the end of the task table element\r\n    let endContext: number = parser.getXMLdata().indexOf(ConstInterface.MG_TAG_TASK_TABLES_END, parser.getCurrIndex());\r\n    endContext = parser.getXMLdata().indexOf(XMLConstants.TAG_CLOSE, endContext) + XMLConstants.TAG_CLOSE.length;\r\n    // get the task table xml string\r\n    let taskTablesData: string = parser.getXMLsubstring(endContext);\r\n    this.FillTaskTables(taskTablesData);\r\n    parser.setCurrIndex(endContext);\r\n  }\r\n\r\n\r\n  /// <summary>\r\n  ///   add handlers triggered by expressions to mgdata\r\n  /// </summary>\r\n  private addExpHandlersToMGData(): void {\r\n    let idx: number = 0;\r\n    for (let i: number = this.HandlersTab.getSize() - 1; i >= 0; i--) {\r\n      let handler: EventHandler = this.HandlersTab.getHandler(i);\r\n      let evt: Event = handler.getEvent();\r\n      if (evt.getType() === ConstInterface.EVENT_TYPE_EXPRESSION ||\r\n        (evt.getType() === ConstInterface.EVENT_TYPE_USER && evt.getUserEventType() === ConstInterface.EVENT_TYPE_EXPRESSION)) {\r\n        this._mgData.addExpHandler(handler, idx);\r\n        idx++;\r\n      }\r\n    }\r\n  }\r\n\r\n  /// <summary>\r\n  ///   get the refresh on variable list\r\n  /// </summary>\r\n  public SetRefreshOnVars(variables: string): void {\r\n    let strTok: string[] = StrUtil.tokenize(variables, \",\");\r\n    let fldNum: number;\r\n    let intVals = new List<number>();\r\n    let i: number;\r\n    for (i = 0; i < strTok.length; i++) {\r\n      fldNum = NNumber.Parse(strTok[i]);\r\n      intVals.push(fldNum);\r\n    }\r\n    this.RefreshOnVars = new Array(intVals.length);\r\n    for (i = 0; i < intVals.length; i++) {\r\n      fldNum = intVals.get_Item(i);\r\n      this.RefreshOnVars[i] = fldNum;\r\n    }\r\n  }\r\n\r\n  /// <summary>\r\n  ///   set the DataSynced property of task\r\n  /// </summary>\r\n  setDataSynced(synced: boolean): void {\r\n    this.DataSynced = synced;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   get a field by its name\r\n  /// </summary>\r\n  /// <param name = \"fldName\">of the field</param>\r\n  /// <returns> the field by its name</returns>\r\n  getField(fldName: string): Field {\r\n    return (<DataView>this.DataView).getFieldByName(fldName);\r\n  }\r\n\r\n  /// <summary>\r\n  ///   return an expression by its id\r\n  /// </summary>\r\n  /// <param name = \"id\">id of the expression</param>\r\n  getExpById(id: number): Expression {\r\n    if (this.ExpTab !== null)\r\n      return this.ExpTab.getExpById(id);\r\n    else\r\n      Logger.Instance.WriteExceptionToLogWithMsg(\"in Task.GetExpById(): no expression table\");\r\n    return null;\r\n  }\r\n\r\n  getExpObjectById(id: number): any {\r\n    return this.getExpById(id);\r\n  }\r\n\r\n  GetExpressionStorage(expId: number): any {\r\n    let result: string = null;\r\n    if (expId > 0) {\r\n      let expById: Expression = this.getExpById(expId);\r\n      Debug.Assert(expById !== null);\r\n      result = expById.GetStorageAttribute();\r\n    }\r\n    return result;\r\n  }\r\n\r\n  /// <summary>\r\n  /// Calculate expresion\r\n  /// </summary>\r\n  /// <param name=\"expId\">The expression to evaluate</param>\r\n  /// <param name=\"resType\">The expected result type.</param>\r\n  /// <param name=\"length\">The expected length of the result.</param>\r\n  /// <param name=\"contentTypeUnicode\">Denotes whether the result is expected to be a unicode string.</param>\r\n  /// <param name=\"resCellType\">Not used.</param>\r\n  /// <returns></returns>\r\n  async CalculateExpression(expId: number, resType: StorageAttribute, length: number): Promise<string> {\r\n    let result: string = null;\r\n    if (expId > 0) {\r\n      let expById: Expression = this.getExpById(expId);\r\n      Debug.Assert(expById !== null);\r\n      result = await expById.evaluateWithResultTypeAndLength(resType, length);\r\n    }\r\n    return result;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   Insert Record Table to dataview of the task if it came after closing task tag\r\n  /// </summary>\r\n  async insertRecordTable(invalidate: boolean, parser: XmlParser): Promise<void> {\r\n    // check cache logic only for sub-forms\r\n    if (await this.isCached()) {\r\n      let firstTime: boolean = (<DataView>this.DataView).getFirstDv();\r\n      // if it is the first time the task get dv or the old dv is not invalidated or\r\n      // the old dv does not include the first record do not put in cache\r\n      if (!firstTime && invalidate) {\r\n        if (!this.hasLocate) {\r\n          // the old d.v was not updated put it in cache (its replicate)\r\n          if ((<DataView>this.DataView).IncludesFirst()) {\r\n            if (!(<DataView>this.DataView).getChanged())\r\n              this._dvCache.putInCache((<DataView>this.DataView).replicate());\r\n            else\r\n              this._dvCache.removeDvFromCache((<DataView>this.DataView).getDvPosValue(), true);\r\n          }\r\n        }\r\n        else this.locatePutInCache();\r\n      }\r\n    }\r\n    // parse the new dataview\r\n    await (<DataView>this.DataView).fillData(parser);\r\n\r\n    if (invalidate)\r\n      (<DataView>this.DataView).setChanged(false);\r\n  }\r\n\r\n  /// <summary>\r\n  ///   get the handlers table\r\n  /// </summary>\r\n  getHandlersTab(): HandlersTable {\r\n    return this.HandlersTab;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   build the XML string for the dataview\r\n  /// </summary>\r\n  async buildXML(message: StringBuilder): Promise<void> {\r\n    this.IsAfterRetryBeforeBuildXML = this.getAfterRetry();\r\n    if (this.KnownToServer && !this.IsOffline) {\r\n      message.Append(XMLConstants.START_TAG + XMLConstants.MG_TAG_TASK);\r\n      message.Append(\" \" + XMLConstants.MG_ATTR_TASKID + \"=\\\"\" + this.getTaskTag() + \"\\\"\");\r\n      message.Append(\" \" + ConstInterface.MG_ATTR_TASK_MAINLEVEL + \"=\\\"\" + this.getMainLevel() + \"\\\"\");\r\n      message.Append(XMLConstants.TAG_CLOSE);\r\n      await (<DataView>this.DataView).buildXML(message);\r\n      if (this.Form != null && this.Form.Opened)\r\n        message.Append((<MgForm>this.Form).GetHiddenControlListXML());\r\n      message.Append(\"\\n   </\" + XMLConstants.MG_TAG_TASK + XMLConstants.TAG_CLOSE);\r\n    }\r\n  }\r\n\r\n  /// <summary>\r\n  ///   build the XML string for the ranges\r\n  /// </summary>\r\n  buildXMLForRngs(message: StringBuilder, UserRanges: List<UserRange>, locate: boolean): void {\r\n    let i: number;\r\n    let fld: Field;\r\n    let cellAttr: StorageAttribute = StorageAttribute.SKIP;\r\n    let toBase64: boolean = (Environment.Instance.GetDebugLevel() <= 1);\r\n\r\n    message.Append(XMLConstants.TAG_CLOSE);\r\n    for (i = 0; i < UserRanges.length; i++) {\r\n      message.Append(XMLConstants.START_TAG + ConstInterface.USER_RNG);\r\n\r\n      let rng: UserRange = UserRanges.get_Item(i);\r\n\r\n      message.Append(\" \" + XMLConstants.MG_TAG_FLD + \"=\\\"\" + rng.veeIdx + \"\\\"\");\r\n\r\n      fld = <Field>this.DataView.getField(<number>rng.veeIdx - 1);\r\n      let fldAttr: StorageAttribute = fld.getType();\r\n\r\n      if (rng.nullMin)\r\n        message.Append(\" \" + ConstInterface.NULL_MIN_RNG + \"=\\\"1\\\"\");\r\n\r\n      if (!rng.discardMin && rng.min != null) {\r\n        let val: string = RecordUtils.itemValToXML(rng.min, fldAttr, cellAttr, toBase64);\r\n        message.Append(\" \" + ConstInterface.MIN_RNG + \"=\\\"\" + val + \"\\\"\");\r\n      }\r\n\r\n      if (rng.nullMax)\r\n        message.Append(\" \" + ConstInterface.NULL_MAX_RNG + \"=\\\"1\\\"\");\r\n\r\n      if (!rng.discardMax && rng.max != null) {\r\n        let val: string = RecordUtils.itemValToXML(rng.max, fldAttr, cellAttr, toBase64);\r\n        message.Append(\" \" + ConstInterface.MAX_RNG + \"=\\\"\" + val + \"\\\"\");\r\n      }\r\n\r\n      message.Append(XMLConstants.TAG_TERM);\r\n    }\r\n    if (locate)\r\n      message.Append(XMLConstants.END_TAG + ConstInterface.USER_LOCATES + XMLConstants.TAG_CLOSE);\r\n    else\r\n      message.Append(XMLConstants.END_TAG + ConstInterface.USER_RANGES + XMLConstants.TAG_CLOSE);\r\n  }\r\n\r\n  /// <summary>\r\n  ///   build the XML string for the user added sorts\r\n  /// </summary>\r\n  buildXMLForSorts(message: StringBuilder): void {\r\n    if (this.UserSorts != null && this.UserSorts.length > 0) {\r\n      let i: number;\r\n      for (i = 0; i < this.UserSorts.length; i++) {\r\n        message.Append(XMLConstants.TAG_CLOSE);\r\n        let srt: Sort = this.UserSorts.get_Item(i);\r\n\r\n        message.Append(XMLConstants.START_TAG + ConstInterface.SORT);\r\n        message.Append(\" \" + XMLConstants.MG_TAG_FLD + \"=\\\"\" + srt.fldIdx + \"\\\"\");\r\n        if (srt.dir)\r\n          message.Append(\" \" + ConstInterface.MG_ATTR_DIR + \"=\\\"1\\\"\");\r\n\r\n        message.Append(XMLConstants.TAG_TERM);\r\n      }\r\n      this.UserSorts.Clear();\r\n      this.UserSorts = null;\r\n      message.Append(XMLConstants.END_TAG + ConstInterface.MG_TAG_SORTS + XMLConstants.TAG_CLOSE);\r\n    }\r\n  }\r\n\r\n  /// <summary>\r\n  ///   returns a user event by its index\r\n  /// </summary>\r\n  /// <param name = \"idx\">the index of the requested event</param>\r\n  getUserEvent(idx: number): Event {\r\n    Debug.Assert(this.UserEvtTab !== null);\r\n    let retEvent: Event = null;\r\n    if (this.UserEvtTab !== null)\r\n      retEvent = this.UserEvtTab.getEvent(idx);\r\n    return retEvent;\r\n  }\r\n\r\n  /// <summary> Set the MoveToFirstControl flag on the form. </summary>\r\n  /// <param name=\"moveToFirstControl\"></param>\r\n  private SetMoveToFirstControl(moveToFirstControl: boolean): void {\r\n    if (moveToFirstControl || !this.IsSubForm) {\r\n      if (this.Form !== null) {\r\n        // this is a call destination/ subform call\r\n        // We perform move to first control only to one control form per request - the first one that we receive\r\n        let alreadyMoved: boolean = (<MgForm>this.Form).alreadyMovedToFirstControl();\r\n        if (!alreadyMoved)\r\n          (<MgForm>this.Form).MovedToFirstControl = true;\r\n      }\r\n    }\r\n  }\r\n\r\n  /// <summary>\r\n  ///   start the execution of the task and its subTasks\r\n  /// </summary>\r\n  async Start(moveToFirstControl: boolean, callByDestSubForm: boolean): Promise<ITask> {\r\n    let nonInteractiveTask: Task = null;\r\n\r\n    if (!this._isStarted) {\r\n      this._isStarted = true;\r\n\r\n      this.InitializeExecution();\r\n\r\n      this.InStartProcess = true;\r\n      let result: ReturnResult = await this.Setup();\r\n\r\n      // task initialization failed - close the task\r\n      if (!result.Success)\r\n        return null;\r\n\r\n      this._inProcessingTopMostEndTaskSaved = AccessHelper.eventsManager.getProcessingTopMostEndTask();\r\n      AccessHelper.eventsManager.setProcessingTopMostEndTask(false);\r\n\r\n      await this.EnableActions();\r\n\r\n      result = await this.InitializeForm(moveToFirstControl);\r\n\r\n      if (!result.Success)\r\n        return null;\r\n\r\n      if (!this.IsInteractive && !this._isMainPrg)\r\n        nonInteractiveTask = this;\r\n\r\n      this.DataViewWasRetrieved = true;\r\n\r\n      // QCR # 167332 :\r\n      // If we start porgram P1, for which MP is started. MP is calling P2 from it's TP. So, when it calls P2\r\n      // again it starts MP, but from MP it again starts P1. as P1 is in it's subtask and it is not yet started.\r\n      // So, it's wrong to start P1 while executing TP of MP. It should execute only P2.\r\n      // So, in order to avoid this, set MP's subtasks to null before entering TP. and again restore it back, in order to\r\n      // start P1 properly.\r\n      let subTasks: TasksTable = this.SubTasks;\r\n      if (this.isMainProg())\r\n        this.SubTasks = null;\r\n      if (this.isMainProg())\r\n        this.SubTasks = subTasks;\r\n\r\n      if (!result.Success)\r\n        return null;\r\n      if (this._aborting)\r\n        return null;\r\n\r\n      let dataViewCommand: IClientCommand = CommandFactory.CreateDataViewCommand(this.getTaskTag(), DataViewCommandType.FirstChunk);\r\n      result = await this.DataviewManager.Execute(dataViewCommand);\r\n\r\n      if (!result.Success)\r\n        return null;\r\n\r\n      this.ResumeSubformLayout();\r\n\r\n    }\r\n\r\n    nonInteractiveTask = await this.StartSubTasks(moveToFirstControl, nonInteractiveTask, callByDestSubForm);\r\n    this.InStartProcess = false;\r\n    return nonInteractiveTask;\r\n  }\r\n\r\n  /// <summary>\r\n  /// Initialize execution-related stuff.\r\n  /// This method should be called ONLY from Task.Start\r\n  /// </summary>\r\n  private InitializeExecution(): void {\r\n    // currently the is no control executing there for the\r\n    // current executing control index is set to -1\r\n    super.setBrkLevel(ConstInterface.BRK_LEVEL_REC_MAIN, -1);\r\n    this._firstRecordCycle = true;      // While starting a Task, set firstRecordCycle = TRUE\r\n\r\n    this._currStartProgLevel = ((this.IsSubForm && (<MgForm>this.getParent().getForm()).alreadyMovedToFirstControl())\r\n      ? (<Task>this.getParent())._currStartProgLevel\r\n      : Task.StartProgLevel);\r\n  }\r\n\r\n  /// <summary>\r\n  /// initialize form-related stuff\r\n  /// </summary>\r\n  /// <param name=\"moveToFirstControl\"></param>\r\n  /// <returns></returns>\r\n  private async InitializeForm(moveToFirstControl: boolean): Promise<ReturnResult> {\r\n    if (this.Form !== null) {\r\n      // set MoveToFirstControl flag on the form.\r\n      this.SetMoveToFirstControl(moveToFirstControl);\r\n\r\n      // the InitForm might cause execution of code (variable change) so we should do it with a new server execution stack\r\n      AccessHelper.eventsManager.pushNewExecStacks();\r\n\r\n      this.routeParams = (<DataView>this.DataView).GetRouteParams();\r\n\r\n      // initialize the current task's form.\r\n      await this.InitForm();\r\n\r\n      AccessHelper.eventsManager.popNewExecStacks();\r\n\r\n      this.getMGData().StartTimers();\r\n      Commands.beginInvoke();\r\n    }\r\n\r\n    return new ReturnResult();\r\n  }\r\n\r\n  /// <summary>\r\n  /// start sub tasks of this task\r\n  /// </summary>\r\n  /// <param name=\"moveToFirstControl\"></param>\r\n  /// <param name=\"nonInteractiveTask\"></param>\r\n  /// <returns></returns>\r\n  private async StartSubTasks(moveToFirstControl: boolean, nonInteractiveTask: Task, callByDestSubForm: boolean): Promise<Task> {\r\n    if (this.hasSubTasks()) {\r\n      for (let i: number = 0; i < this.SubTasks.getSize(); i = i + 1) {\r\n        let task: Task = <Task>this.SubTasks.getTask(i);\r\n        let tmpNonInteractiveTask: Task =  <Task> await task.Start(moveToFirstControl, callByDestSubForm);\r\n        if (nonInteractiveTask === null)\r\n          nonInteractiveTask = tmpNonInteractiveTask;\r\n        else if (tmpNonInteractiveTask !== null)\r\n          Debug.Assert(false, \"more than 1 non interactive in task.start\");\r\n      }\r\n    }\r\n\r\n    return nonInteractiveTask;\r\n  }\r\n\r\n  private async EnableActions(): Promise<void> {\r\n    let actList: number[] = ActionManager.actEnabled;\r\n    this.ActionManager.enableList(actList, true, false);\r\n\r\n    if (this.IsSubForm)\r\n      this.ActionManager.enable(InternalInterface.MG_ACT_POST_REFRESH_BY_PARENT, true);\r\n\r\n\r\n    // enable actions depending on task properties\r\n    await this.enableModes();\r\n    if (await this.checkProp(PropInterface.PROP_TYPE_SELECTION, false)) {\r\n      this.ActionManager.enable(InternalInterface.MG_ACT_SELECT, true);\r\n    }\r\n\r\n    let enablePrintdata: boolean = await this.checkProp(PropInterface.PROP_TYPE_PRINT_DATA, false);\r\n    this.ActionManager.enable(InternalInterface.MG_ACT_PRINT_DATA, enablePrintdata);\r\n\r\n\r\n    if (this.getEnableZoomHandler())\r\n      this.ActionManager.enable(InternalInterface.MG_ACT_ZOOM, true);\r\n  }\r\n\r\n  /// <summary>\r\n  /// show error on task's form\r\n  /// </summary>\r\n  /// <param name=\"text\"></param>\r\n  async ShowError(text: string): Promise<void> {\r\n    let mlsTransText: string = LanguageData.Instance.translate(text);\r\n    let mlsTransTitle: string = LanguageData.Instance.translate(ConstInterface.ERROR_STRING);\r\n    // mls ???\r\n    await GUIManager.Instance.MessageBox(mlsTransTitle, mlsTransText, Styles.MSGBOX_ICON_ERROR | Styles.MSGBOX_BUTTON_OK);\r\n  }\r\n\r\n  /// <summary>\r\n  /// check the result. If failed - display the error messagebox and end the task\r\n  /// </summary>\r\n  /// <param name=\"result\"></param>\r\n  /// <returns></returns>\r\n  async EndTaskOnError(result: ReturnResult, displayError: boolean): Promise<boolean> {\r\n    if (!result.Success && !this.isAborting()) {\r\n      if (this.InStartProcess) {\r\n        await this.endTask(false, false, false);\r\n        if (displayError)\r\n          await this.ShowError(result.ErrorDescription);\r\n        this.InStartProcess = false;\r\n        return true;\r\n      }\r\n      else {\r\n        if (displayError)\r\n          await this.ShowError(result.ErrorDescription);\r\n        await AccessHelper.eventsManager.handleInternalEventWithTask(this, InternalInterface.MG_ACT_EXIT);\r\n      }\r\n    }\r\n\r\n    return false;\r\n  }\r\n\r\n  /// <summary>\r\n  ///\r\n  /// </summary>\r\n  /// <returns></returns>\r\n  private async Setup(): Promise<ReturnResult> {\r\n    let result: ReturnResult;\r\n    this.TaskService.InitTaskPrefixExecutedFlag(this);\r\n    this.TaskSuffixExecuted = false;\r\n\r\n    TaskServiceBase.CreateFirstRecord(this);\r\n\r\n    // init data view\r\n    // Note: Even if the resultInitMode is false we MUST init the data view\r\n    let dataViewCommand: IClientCommand = CommandFactory.CreateDataViewCommand(this.getTaskTag(), DataViewCommandType.Init);\r\n    result = await this.DataviewManager.Execute(dataViewCommand);\r\n\r\n    // need to check result(of the data view init and if not success then return this error\r\n    if (!result.Success)\r\n      return result;\r\n\r\n    if (result.Success) {\r\n      // Execute the command, whose execution was delayed becuase task was not started. So Excute those commands after task started.\r\n      let commands: List<IClientTargetedCommand> = GlobalCommandsManager.Instance.getCommandsExecutedAfterTaskStarted();\r\n\r\n      for (let cmdIdx: number = 0; cmdIdx < commands.length; cmdIdx++) {\r\n        let command: IClientTargetedCommand = (commands.get_Item(cmdIdx));\r\n        if (command.TaskTag === this.getTaskTag()) {\r\n          await command.Execute(null);\r\n          GlobalCommandsManager.Instance.removeCommandsExecutedAfterTaskStarted(command);\r\n        }\r\n      }\r\n\r\n      dataViewCommand = CommandFactory.CreateDataViewCommand(this.getTaskTag(), DataViewCommandType.Prepare);\r\n      result = await this.DataviewManager.Execute(dataViewCommand);\r\n    }\r\n\r\n    if (result.Success) {\r\n      result = this.TaskService.PrepareTask(this);\r\n      if (!result.Success)\r\n        await this.EndTaskOnError(result, true);\r\n    }\r\n\r\n    if (result.Success) {\r\n      dataViewCommand = CommandFactory.CreateDataViewCommand(this.getTaskTag(), DataViewCommandType.InitDataControlViews);\r\n      result = await this.DataviewManager.Execute(dataViewCommand);\r\n    }\r\n    return result;\r\n  }\r\n\r\n\r\n\r\n  /// <summary>\r\n  ///   do first record prefix & suffix\r\n  ///   This function is executed only for connected task.\r\n  ///   For offline task we run EnterFirstRecord function. There we execute RP and open subforms.\r\n  /// </summary>\r\n  async doFirstRecordCycle(): Promise<void> {\r\n    if (!this._isMainPrg) {\r\n      AccessHelper.eventsManager.pushNewExecStacks();\r\n      this.SubformExecMode = Task_SubformExecModeEnum.FIRST_TIME;\r\n      await AccessHelper.eventsManager.handleInternalEventWithTaskAndSubformRefresh(this, InternalInterface.MG_ACT_REC_PREFIX, this.IsSubForm);\r\n\r\n      if (!AccessHelper.eventsManager.GetStopExecutionFlag()) {\r\n        if (this.IsSubForm) {\r\n          if (this.hasSubTasks())\r\n            for (let i: number = 0; i < this.SubTasks.getSize(); i++) {\r\n              let subTask: Task = <Task>this.SubTasks.getTask(i);\r\n              if (subTask.IsSubForm) {\r\n                (<MgForm>subTask.getForm()).IgnoreFirstRecordCycle = true;\r\n                await subTask.doFirstRecordCycle();\r\n              }\r\n            }\r\n          await AccessHelper.eventsManager.handleInternalEventWithTask(this, InternalInterface.MG_ACT_REC_SUFFIX);\r\n        }\r\n      }\r\n\r\n      this.SubformExecMode = Task_SubformExecModeEnum.SET_FOCUS;\r\n      AccessHelper.eventsManager.popNewExecStacks();\r\n    }\r\n  }\r\n\r\n  /// <summary>\r\n  ///   returns true if this task is a sub form by its mgd definition (used only while initiating task for setting isSubform)\r\n  /// </summary>\r\n  private CheckAndSetSubForm(): void {\r\n    this.IsSubForm = (!super.isMainProg() && this !== this._mgData.getFirstTask());\r\n  }\r\n\r\n\r\n  IsRoute() {\r\n    return (this.RouterPath != null);\r\n  }\r\n\r\n  /// <summary>\r\n  ///   stop the execution of a program\r\n  /// </summary>\r\n  async stop(): Promise<void> {\r\n    let task: Task;\r\n    if (this._aborting)\r\n      return;\r\n\r\n    if (this.hasSubTasks()) {\r\n      while ((task = <Task>this.SubTasks.getTask(0)) != null) {\r\n        task.setDestinationSubform(this._destinationSubform);\r\n        await task.stop();\r\n      }\r\n    }\r\n\r\n    if (!this._isMainPrg)\r\n      this._aborting = true;\r\n\r\n    // if this task and its parent are from different MGDATA objects then disconnect\r\n    // them by removing the reference to this task from its parent\r\n    if (this._parentTask != null) {\r\n      this._parentTask.removeSubTask(this);\r\n      if (this.IsSubForm) {\r\n        let oldTimers: List<number> = new List<number>(), newTimers = new List<number>();\r\n        let mgd = this.getMGData();\r\n\r\n        if (mgd.getTimerHandlers() != null)\r\n          oldTimers = mgd.getTimerHandlers().getTimersVector();\r\n        mgd.removeTimerHandler(this);\r\n        mgd.removeExpressionHandler(this);\r\n        if (mgd.getTimerHandlers() != null)\r\n          newTimers = mgd.getTimerHandlers().getTimersVector();\r\n        mgd.changeTimers(oldTimers, newTimers);\r\n\r\n        mgd.removeTask(this);\r\n        GUIManager.Instance.abort(<MgForm>this.getForm());\r\n      }\r\n    }\r\n\r\n    this.AbortTransaction();\r\n\r\n    // If the task got closed due to a click on same task, then set CurrentClickedCtrl to null\r\n    if (this.getClickedControl() != null)\r\n      RuntimeContextBase.Instance.CurrentClickedCtrl = null;\r\n    if (this.Form != null)\r\n      (<MgForm>this.Form).removeRefsToCtrls();\r\n\r\n    if (this.IsSubForm) {\r\n      let subForm = <MgControl>this.Form.getSubFormCtrl();\r\n\r\n      subForm.setSubformTaskId(null);\r\n      subForm.initSubformTask();\r\n\r\n      if (LastFocusedManager.Instance.getLastFocusedTask() === this)\r\n        LastFocusedManager.Instance.setLastFocusedTask(this._parentTask);\r\n\r\n      // QCR #310113. If the subform task for was not loaded yet, do not refresh it.\r\n      if (subForm.SubformLoaded)\r\n        await (subForm.getProp(PropInterface.PROP_TYPE_VISIBLE)).RefreshDisplay(true);\r\n    }\r\n\r\n    let clearDataViewCommand: IClientCommand = CommandFactory.CreateDataViewCommand(this.getTaskTag(), DataViewCommandType.Clear);\r\n    await this.DataviewManager.Execute(clearDataViewCommand);\r\n  }\r\n\r\n  /// <summary>\r\n  /// abort the MgData to which the task belongs\r\n  /// </summary>\r\n  abort(): void {\r\n    this.getMGData().abort();\r\n  }\r\n\r\n  /// <summary>\r\n  ///   returns true if the task has sub-tasks\r\n  /// </summary>\r\n  hasSubTasks(): boolean {\r\n    return this.SubTasks !== null && this.SubTasks.getSize() > 0;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   A number, 1-24, the current task's depth in the task execution hierarchy.\r\n  /// </summary>\r\n  /// <param name = \"byParentOrder\">if true, we travel the parents, otherwise we travel the triggering tasks</param>\r\n  /// <returns> depth of the task, 1 if called from the root task</returns>\r\n  getTaskDepth(byParentOrder: boolean): number {\r\n    if (byParentOrder)\r\n      return this.getTaskDepth_(byParentOrder);\r\n\r\n\r\n    let depth: number = (<Task> this.GetContextTask()).getTaskDepth_(byParentOrder);\r\n\r\n    // QCR 366748 if we are in a component handler add it to the path\r\n    if (this.isMainProg() && this.getCtlIdx() !== ConstInterface.TOP_LEVEL_CONTAINER)\r\n      depth = depth + 1;\r\n\r\n    return depth;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   helper function which implements the getTaskDepth recursion.\r\n  /// </summary>\r\n  /// <param name = \"byParentOrder\">if true, we travel the parents, otherwise we travel the triggering tasks</param>\r\n  private getTaskDepth_(byParentOrder: boolean): number {\r\n    let tmpTask: Task = this.getTriggeringTask();\r\n    if (tmpTask == null || byParentOrder)\r\n      if (this._parentTask == null)\r\n        return 1;\r\n      else {\r\n        /* if the ctlIdx of the current task and the parent are different,   */\r\n        /* that is the current task is from a component, add the component's */\r\n        /* Main Prg as well. */\r\n        if (byParentOrder && this.getCtlIdx() !== this._parentTask.getCtlIdx())\r\n          return 2 + this._parentTask.getTaskDepth_(byParentOrder);\r\n        return 1 + this._parentTask.getTaskDepth_(byParentOrder);\r\n      }\r\n    return 1 + (tmpTask).getTaskDepth_(byParentOrder);\r\n  }\r\n\r\n  /// <summary>\r\n  ///   get the ancestor of the Task\r\n  /// </summary>\r\n  /// <param name = \"generation\">of the ancestor task</param>\r\n  GetTaskAncestor(generation: number): ITask {\r\n    return this.getTaskAncestor_(generation);\r\n  }\r\n\r\n  /// <summary>\r\n  ///\r\n  /// </summary>\r\n  private getTaskAncestor_(generation: number): ITask {\r\n    let retTask: ITask = null;\r\n\r\n    if (generation === 0)\r\n      retTask = this;\r\n    else {\r\n      let tmpTask: Task = this.getTriggeringTask();\r\n      if (tmpTask === null)\r\n        tmpTask = this._parentTask;\r\n      if (tmpTask !== null)\r\n        retTask = tmpTask.getTaskAncestor_(--generation);\r\n    }\r\n\r\n    return retTask;\r\n  }\r\n\r\n  /// <summary>\r\n  /// Returns task depth\r\n  /// </summary>\r\n  /// <returns></returns>\r\n  GetTaskDepth(): number{\r\n    return this.getTaskDepth(false);\r\n  }\r\n\r\n  /// <param name=\"task\"></param>\r\n  /// <returns>true iff the path of the current task contains the task passed as parameter</returns>\r\n  pathContains(task: TaskBase): boolean {\r\n    return this._taskPath.Contains(<Task>task);\r\n  }\r\n\r\n  /// <summary>\r\n  ///   sets the context task of this task\r\n  /// </summary>\r\n  /// <param name = \"context\">the new context task of the current task</param>\r\n  SetContextTask(context: TaskBase): void {\r\n    this.ContextTask = <Task>context;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   returns the task which is the context of the currently executing handler.\r\n  /// </summary>\r\n  GetContextTask(): ITask {\r\n    let currRec: Record = ((<DataView>this.DataView).getCurrRec());\r\n\r\n    if (this.InStartProcess\r\n      || currRec !== null && (currRec.InCompute || currRec.InRecompute)\r\n      || this.Form !== null && this.Form.inRefreshDisplay())\r\n      return this;\r\n\r\n    return this.ContextTask;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   get a reference to the task that triggered the handler which created me\r\n  /// </summary>\r\n  getTriggeringTask(): Task {\r\n    // This is a semi patch which fixes problems such as the ones in QCR #296428\r\n    // When a modal task gets opened, it might set its triggering task to a task\r\n    // whose 'abort' command arrived and is pending for execution. Under these\r\n    // circumstances, we must check every access to triggeringTask and make sure\r\n    // it points to a valid task.\r\n    if (this._triggeringTask !== null && this._triggeringTask.getMGData().IsAborting)\r\n      this._triggeringTask = this._parentTask;\r\n\r\n    return this._triggeringTask;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   set the last parked control in this task\r\n  /// </summary>\r\n  /// <param name = \"ctrl\">last focused control</param>\r\n  setLastParkedCtrl(ctrl: MgControlBase): void {\r\n    super.setLastParkedCtrl(ctrl);\r\n    LastFocusedManager.setLastFocusedControl(this, ctrl);\r\n  }\r\n\r\n  /// <summary>\r\n  ///   Query Task Path Returns the task path that leads to the current task. The resulting alpha string\r\n  ///   contains the task names, as well as the current name of the task. Names are separated by the ';'\r\n  ///   character. For PROG() using.\r\n  /// </summary>\r\n  queryTaskPath(): StringBuilder {\r\n    let insertedNames: number = 0;        // how mach names inserted to the output string\r\n    let result = new StringBuilder(7936); // 31 * 256 */\r\n    let treeRoute = new Array(this.getTaskDepth(false));\r\n    this.pathToRoot(treeRoute, false);\r\n    for (let tsk: number = treeRoute.length - 1; tsk >= 0; tsk--) {\r\n      let currTsk: Task = treeRoute[tsk];\r\n      if (currTsk.isMainProg())\r\n        continue;\r\n      let nameProp: Property = currTsk.getProp(PropInterface.PROP_TYPE_NAME);\r\n      if (nameProp == null)\r\n        continue;\r\n      let name: string = nameProp.GetComputedValue();\r\n      if (!NString.IsNullOrEmpty(name)) {\r\n        // if there is only 1 name -> don't insert ';'\r\n        // after last name don't insert ';' too.\r\n        if (insertedNames++ !== 0)\r\n          result.Append(';');\r\n        result.Append(name);\r\n      }\r\n    }\r\n    return result;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   Get Field which contain item number itm\r\n  /// </summary>\r\n  ctl_itm_2_parent_vee(itm: number): Field {\r\n    let currTsk: Task;\r\n    let currItm: number = 0;\r\n    let lastItm: number = 0;      // start of the field in fieldeTab number for checked task\r\n    // save the route to the root in the treeRoute array\r\n    let treeRoute = new Array(this.getTaskDepth(true));\r\n    // the route up, the insert (our task) is [0], and exit (root) is [treeRoute.length-1]\r\n    this.pathToRoot(treeRoute, true);\r\n\r\n    for (let tsk: number = treeRoute.length - 1; tsk >= 0; tsk--) {\r\n      currTsk = treeRoute[tsk];\r\n\r\n      currItm += currTsk.DataView.GetFieldsTab().getSize();\r\n\r\n      // found task which contains the needed field\r\n      if (itm < currItm) {\r\n        // number of Field in found task\r\n        itm -= lastItm;\r\n        return <Field>currTsk.DataView.getField(itm);\r\n      }\r\n      lastItm = currItm;\r\n    }\r\n    // not found the field\r\n    return null;\r\n  }\r\n\r\n  /// <summary>\r\n  /// Get the control id which contain field attached to control\r\n  /// </summary>\r\n  /// <param name=\"item\"></param>\r\n  /// <returns></returns>\r\n  GetControlIDFromVarItem(item: number): number {\r\n    let currTask: Task;\r\n    let currItem: number = 0;\r\n    let lastItem: number = 0;   // start of the field in fieldeTab number for checked task\r\n    let noOfControlsBeforeCurrTask: number = 0;\r\n\r\n    // save the route to the root in the treeRoute array\r\n    let treeRoute = new Array(this.getTaskDepth(true));\r\n    // the route up, the insert (our task) is [0], and exit (root) is [treeRoute.length - 1]\r\n    this.pathToRoot(treeRoute, true);\r\n\r\n    for (let task: number = treeRoute.length - 1; task >= 0; task--) {\r\n      currTask = treeRoute[task];\r\n      currItem += currTask.DataView.GetFieldsTab().getSize();\r\n\r\n      // Found the task which contains the needed control & field\r\n      if (item < currItem) {\r\n        // Number of fields in found task\r\n        item -= lastItem;\r\n\r\n        let field: Field = <Field>currTask.DataView.getField(item);\r\n        if (field.getCtrl() != null)\r\n          return noOfControlsBeforeCurrTask = noOfControlsBeforeCurrTask + currTask.Form.getControlIdx(field.getCtrl()) + 1;\r\n\r\n        return 0;\r\n      }\r\n\r\n      if (currTask.Form != null)\r\n        noOfControlsBeforeCurrTask += currTask.Form.getCtrlCount();\r\n\r\n      lastItem = currItem;\r\n    }\r\n\r\n    // Control attached to the variable in same task not found\r\n    return 0;\r\n  }\r\n\r\n  /// <summary>\r\n  /// Get the control from controlID\r\n  /// </summary>\r\n  /// <param name=\"controlID\"></param>\r\n  /// <returns></returns>\r\n  GetControlFromControlID(controlID: number, parent: RefParam<number>): MgControl {\r\n    let control: MgControl = null;\r\n    parent.value = -1;\r\n\r\n    if (controlID >= 0) {\r\n      let currTask: Task = null;\r\n      let callerTask: Task = null;\r\n      let noOfControlsInCurrtask: number = 0;\r\n      let noOfControlsBeforeCurrTask: number = 0;\r\n      let controlIdx: number = 0;\r\n\r\n      // save the route to the root in the treeRoute array\r\n      let treeRoute = new Array(this.getTaskDepth(true));\r\n\r\n      // the route up, the insert (our task) is [0], and exit (root) is [treeRoute.length - 1]\r\n      this.pathToRoot(treeRoute, true);\r\n\r\n      for (let task: number = treeRoute.length - 1; task >= 0; task--) {\r\n\r\n        currTask = treeRoute[task];\r\n\r\n        if (currTask.Form != null) {\r\n          noOfControlsInCurrtask = currTask.Form.getCtrlCount();\r\n\r\n          // Found the task which contains the needed control\r\n          if (controlID < (noOfControlsBeforeCurrTask + noOfControlsInCurrtask)) {\r\n            // Idx of the control in current task\r\n            controlIdx = controlID - noOfControlsBeforeCurrTask;\r\n            control = <MgControl>currTask.Form.CtrlTab.getCtrl(controlIdx);\r\n            callerTask = currTask;\r\n            break;\r\n          }\r\n\r\n          noOfControlsBeforeCurrTask += noOfControlsInCurrtask;\r\n        }\r\n      }\r\n\r\n      // Get parent\r\n      if (control != null) {\r\n        parent.value = 0;\r\n        let prevCtlIdx: number = treeRoute[0].TaskDefinitionId.CtlIndex;\r\n\r\n        for (let task: number = 0; task < treeRoute.length - 1; task++) {\r\n          currTask = treeRoute[task];\r\n\r\n          if (prevCtlIdx !== currTask.TaskDefinitionId.CtlIndex)\r\n            parent.value++;\r\n\r\n          if (callerTask.TaskDefinitionId.CtlIndex === currTask.TaskDefinitionId.CtlIndex)\r\n            break;\r\n\r\n          prevCtlIdx = currTask.TaskDefinitionId.CtlIndex;\r\n        }\r\n      }\r\n    }\r\n\r\n    // Control corresponding to the specified ControlID\r\n    return control;\r\n  }\r\n\r\n  /// <summary>\r\n  /// </summary>\r\n  ctl_itm_4_parent_vee(parent: number, vee: number): number {\r\n    let tsk: Task;\r\n    let depth: number = this.getTaskDepth(true);\r\n\r\n    if (parent !== TaskBase.MAIN_PRG_PARENT_ID && depth <= parent)\r\n      return vee;\r\n\r\n    let treeRoute = new Array(depth);\r\n\r\n    if (vee !== 0) {\r\n      this.pathToRoot(treeRoute, true);\r\n\r\n      // get the index of parent in the task tree\r\n      let indOfParentInTaskTree: number = this.getIndOfParentInTaskTree(parent, treeRoute);\r\n\r\n      let i: number;\r\n      for (i = treeRoute.length - 1; i > indOfParentInTaskTree; i--) {\r\n        tsk = treeRoute[i];\r\n        vee += tsk.DataView.GetFieldsTab().getSize();\r\n      }\r\n    }\r\n    return vee;\r\n  }\r\n\r\n  /// <summary>\r\n  /// </summary>\r\n  /// <param name = \"parent\"></param>\r\n  /// <param name = \"taskTree\"></param>\r\n  /// <returns></returns>\r\n  getIndOfParentInTaskTree(parent: number, taskTree: Task[]): number {\r\n    let indOfParentInTaskTree: number = 0;\r\n    if (parent === TaskBase.MAIN_PRG_PARENT_ID) {\r\n      for (let i: number = 1; i < taskTree.length; i = i + 1) {\r\n        if (taskTree[i].isMainProg() && this._ctlIdx === taskTree[i].getCtlIdx()) {\r\n          indOfParentInTaskTree = i;\r\n          break;\r\n        }\r\n      }\r\n    }\r\n    else\r\n      indOfParentInTaskTree = parent;\r\n\r\n    return indOfParentInTaskTree;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   entry point to the recursion induced by getFieldByName_.\r\n  /// </summary>\r\n  /// <returns> a field which belongs to me or to my parents with the matching name</returns>\r\n  getFieldByName(fldName: string): Field {\r\n    return (<Task> (this.GetContextTask())).getFieldByName_(fldName);\r\n  }\r\n\r\n  /// <summary>\r\n  ///   find field with the name in task or its ancestors\r\n  /// </summary>\r\n  /// <param name = \"fldName\">name, the name can be empty string too</param>\r\n  /// <returns> If the variable name is not found then the function will return NULL.</returns>\r\n  private getFieldByName_(fldName: string): Field{\r\n    let tmpTask: Task;\r\n\r\n    if (fldName == null)\r\n      return null;\r\n    let fld: Field = this.getField(fldName);\r\n\r\n    // if the field is not ours - recursive check the ancestors\r\n    if (fld == null) {\r\n      tmpTask = this.getTriggeringTask() != null ? this.getTriggeringTask() : this._parentTask;\r\n\r\n      if (tmpTask != null) {\r\n        if (!this.isMainProg() && this.getCtlIdx() !== tmpTask.getCtlIdx()) {\r\n          let mainPrg: Task = <Task>AccessHelper.mgDataTable.GetMainProgByCtlIdx(-1, this.getCtlIdx());\r\n          fld = mainPrg.getFieldByName_(fldName);\r\n        }\r\n\r\n        if (fld == null)\r\n          fld = tmpTask.getFieldByName_(fldName);\r\n      }\r\n    }\r\n    return fld;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   get index of the field in the task or its ancestors\r\n  /// </summary>\r\n  /// <param name = \"fldName\">name</param>\r\n  /// <returns> If the variable name is not found then this function will return Zero.</returns>\r\n  getIndexOfFieldByName(fldName: string): number {\r\n    let depth: number = this.getTaskDepth(true);\r\n    let index: number = 0;\r\n    let fld: Field = this.getFieldByName(fldName);\r\n    let fldTab: FieldsTable;\r\n\r\n    if (fld == null)\r\n      return 0;\r\n\r\n    let treeRoute = new Array(depth);\r\n    this.pathToRoot(treeRoute, true);\r\n    for (let curr: number = depth - 1; curr >= 0; curr--) {\r\n      let currTask: Task = treeRoute[curr];\r\n      if (currTask === fld.getTask()) {\r\n        curr = fld.getId();\r\n        index += ++curr;         // start index in Magic from 1 and not from 0\r\n        break;                   // get out of the task tree - the index is found\r\n      }\r\n      fldTab = <FieldsTable>currTask.DataView.GetFieldsTab();\r\n      index += fldTab.getSize();\r\n    }\r\n    return index;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   calculate the path from this task to the root of the tasks tree\r\n  /// </summary>\r\n  /// <param name = \"path\">array of tasks, the route up. The 0 item is start point task</param>\r\n  /// <param name = \"byParentOrder\">if true, we travel the parents, otherwise we travel the triggering tasks</param>\r\n  pathToRoot(path: Task[], byParentOrder: boolean): void {\r\n    let task: Task = (byParentOrder ? this : <Task> this.GetContextTask());\r\n\r\n    for (let i: number = 0; i < path.length; i++) {\r\n      path[i] = task;\r\n      let ctlIdx: number = task.getCtlIdx();\r\n\r\n      let tmpTask: Task = byParentOrder ? null : task.getTriggeringTask();\r\n\r\n      if (tmpTask != null)\r\n        task = tmpTask;\r\n      else {\r\n        task = <Task>task.getParent();\r\n\r\n        if (task == null) {\r\n          // QCR 366748 if we are in a component global handler add it to the path\r\n          if (!byParentOrder && this.isMainProg() && this.getCtlIdx() !== ConstInterface.TOP_LEVEL_CONTAINER)\r\n            path[i + 1] = this;\r\n          break;\r\n        }\r\n\r\n        if (byParentOrder && ctlIdx !== task.getCtlIdx())\r\n          path[++i] = <Task>AccessHelper.mgDataTable.GetMainProgByCtlIdx(-1, ctlIdx);\r\n      }\r\n    }\r\n  }\r\n\r\n  /// <summary>\r\n  ///   check if this task should be refreshed - compare the \"refresh on\" fields of the current record to the\r\n  ///   previous record and if different values are found returns true\r\n  /// </summary>\r\n  private shouldBeRefreshed(): boolean {\r\n    let dataView: DataView = <DataView>this._parentTask.DataView;\r\n    let result: boolean = false;\r\n\r\n    // prevCurrRec is null only if it is the first time or after Cancel.\r\n    // After Cancel in the parent task Subform refresh must be done always\r\n    if (this._parentTask === null || dataView.isPrevCurrRecNull() ||\r\n      (this.RefreshOnVars !== null && !dataView.currEqualsPrev(this.RefreshOnVars)))\r\n      result = true;\r\n\r\n    return result;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   returns true if the subTasks (subforms) should be refreshed\r\n  /// </summary>\r\n  async CheckRefreshSubTasks(): Promise<boolean> {\r\n    let ret: boolean = false;\r\n\r\n    // do not refresh subforms before the first record prefix. The server sent us their dataview!\r\n    if (this._enteredRecLevel) {\r\n      let subformsToRefresh: List<Task> = await this.GetSubformsToRefresh();\r\n\r\n      if (subformsToRefresh.length > 0)\r\n        ret = true;\r\n    }\r\n    return ret;\r\n  }\r\n\r\n  /// <summary>\r\n  /// Gets a list of subtasks\r\n  /// </summary>\r\n  /// <returns>a list of subtasks</returns>\r\n  private GetSubTasks(): List<Task> {\r\n    let subTasks: List<Task> = new List<Task>();\r\n\r\n    if (this.hasSubTasks()) {\r\n      for (let i: number = 0; i < this.SubTasks.getSize(); i = i + 1)\r\n        subTasks.push(<Task>this.SubTasks.getTask(i));\r\n    }\r\n\r\n    return subTasks;\r\n  }\r\n\r\n  /// <summary>\r\n  /// Gets a list of those subforms that must be refreshed.\r\n  /// </summary>\r\n  /// <returns>list of subforms to refresh</returns>\r\n  async GetSubformsToRefresh(): Promise<List<Task>> {\r\n    let subTasks: List<Task> = this.GetSubTasks();\r\n    let subTasksToRefresh: List<Task> = new List<Task>();\r\n\r\n    for (let i: number = 0; i < subTasks.length; i++) {\r\n      let subTask: Task = subTasks.get_Item(i);\r\n      if (await this.ShouldRefreshSubformTask(subTask))\r\n        subTasksToRefresh.push(subTask)\r\n    }\r\n\r\n    return subTasksToRefresh;\r\n  }\r\n\r\n\r\n  /// <summary>\r\n  /// Check if the specific subform must be refreshed\r\n  /// </summary>\r\n  /// <param name=\"subTask\"></param>\r\n  /// <returns></returns>\r\n  async ShouldRefreshSubformTask(subTask: Task): Promise<boolean> {\r\n    let refresh: boolean = false;\r\n    let subformCtrl: MgControl = <MgControl>subTask.getForm().getSubFormCtrl();\r\n\r\n    subTask.DoSubformPrefixSuffix = false;\r\n    // Defect 76979. Subform can execute refresh only after it has TaskView.\r\n    if (subformCtrl != null && !subTask.InSelect && subTask.AfterFirstRecordPrefix) {\r\n      let parentMode: string = this.getMode();\r\n      let modeProperty: number = (parentMode === Constants.TASK_MODE_QUERY ? PropInterface.PROP_TYPE_ALLOW_QUERY\r\n        : parentMode === Constants.TASK_MODE_MODIFY\r\n                                    ? PropInterface.PROP_TYPE_ALLOW_MODIFY\r\n                                    : PropInterface.PROP_TYPE_ALLOW_CREATE);\r\n\r\n      // For a subform with 'AsParent' mode we also must refresh the subform\r\n      // after the parent record prefix. If the specific mode is not allowed\r\n      // the subform continues in the old mode.\r\n      if (subTask.ModeAsParent && parentMode !== subTask.getMode() &&\r\n        this.getLevel() === Constants.TASK_LEVEL_RECORD &&\r\n        await (subTask.getProp(PropInterface.PROP_TYPE_ALLOW_OPTION)).getValueBoolean() &&\r\n        await subTask.checkProp(modeProperty, true)) {\r\n        if (!subformCtrl.isVisible() &&\r\n          !await subformCtrl.checkProp(PropInterface.PROP_TYPE_REFRESH_WHEN_HIDDEN, false)) {\r\n          subformCtrl.RefreshOnVisible = true;\r\n          refresh = false;\r\n        }\r\n        else\r\n          refresh = true;\r\n\r\n        await subTask.SetModeAsParent(parentMode);\r\n      }\r\n      else {\r\n        refresh = await subformCtrl.checkProp(PropInterface.PROP_TYPE_AUTO_REFRESH, true) && subTask.shouldBeRefreshed();\r\n\r\n        if (refresh) {\r\n          if (!subformCtrl.isVisible() &&\r\n            !await subformCtrl.checkProp(PropInterface.PROP_TYPE_REFRESH_WHEN_HIDDEN, false)) {\r\n            subformCtrl.RefreshOnVisible = true;\r\n            refresh = false;\r\n          }\r\n        }\r\n      }\r\n\r\n      if (refresh)\r\n        subTask.DoSubformPrefixSuffix = true;\r\n    }\r\n    return refresh;\r\n  }\r\n\r\n  /// <summary>\r\n  /// Sets the task mode as parent mode\r\n  /// </summary>\r\n  /// <param name=\"parentMode\"></param>\r\n  async SetModeAsParent(parentMode: string): Promise<void> {\r\n    await this.enableModes();\r\n\r\n    if (parentMode === Constants.TASK_MODE_CREATE) {\r\n      let cmd: IClientCommand = CommandFactory.CreateEventCommand(this.getTaskTag(), InternalInterface.MG_ACT_RTO_CREATE);\r\n      await this.DataviewManager.Execute(cmd);\r\n    }\r\n    else if (this.getMode() === Constants.TASK_MODE_CREATE) {\r\n      this.setPreventRecordSuffix(true);\r\n      this.setPreventControlChange(true);\r\n      await AccessHelper.eventsManager.handleInternalEventWithTask(this, InternalInterface.MG_ACT_RT_REFRESH_VIEW);\r\n      this.setPreventRecordSuffix(false);\r\n      this.setPreventControlChange(false);\r\n      let subTaskDv: DataView = <DataView>this.DataView;\r\n      if (!subTaskDv.isEmpty() && (subTaskDv.getCurrRec()).getMode() !== DataModificationTypes.Insert)\r\n        this.setMode(parentMode);\r\n      else\r\n        this.setMode(Constants.TASK_MODE_CREATE);\r\n      await (<MgForm>this.getForm()).RefreshDisplay(Constants.TASK_REFRESH_CURR_REC);\r\n    }\r\n    else\r\n      this.setMode(parentMode);\r\n\r\n    this.setOriginalTaskMode(parentMode);\r\n    await this.setCreateDeleteActsEnableState();\r\n  }\r\n\r\n  // after compute do subform task record prefix & suffix\r\n  async doSubformRecPrefixSuffix(): Promise<void> {\r\n    let subTasks: List<Task> = this.GetSubTasks();\r\n\r\n\r\n    for (let i: number = 0; i < subTasks.length; i++) {\r\n      let subTask: Task = subTasks.get_Item(i);\r\n      if (subTask.DoSubformPrefixSuffix) {\r\n        await AccessHelper.eventsManager.handleInternalEventWithTaskAndSubformRefresh(subTask, InternalInterface.MG_ACT_REC_PREFIX, true);\r\n        if (!AccessHelper.eventsManager.GetStopExecutionFlag())\r\n          await AccessHelper.eventsManager.handleInternalEventWithTask(subTask, InternalInterface.MG_ACT_REC_SUFFIX);\r\n      }\r\n    }\r\n  }\r\n\r\n  /// <summary> Clean flag for Subform record cycle </summary>\r\n  CleanDoSubformPrefixSuffix(): void {\r\n    let subTasks: List<Task> = this.GetSubTasks();\r\n\r\n    for (let i: number = 0; i < subTasks.length; i++) {\r\n      let subTask: Task = subTasks.get_Item(i);\r\n      subTask.DoSubformPrefixSuffix = false;\r\n    }\r\n  }\r\n\r\n  /// <summary>\r\n  ///   returns true if the task must display confirmation window prior to deleting a record.\r\n  /// </summary>\r\n  mustConfirmInDeleteMode(): boolean {\r\n    let prop: Property = this.getProp(PropInterface.PROP_TYPE_CONFIRM_UPDATE);\r\n\r\n    // As strange as it sounds, if the property is an expression which evaluates to\r\n    // False, then no need to display confirmation...\r\n    return !prop.isExpression();\r\n  }\r\n\r\n  /// <summary>\r\n  ///   add a sub-task\r\n  /// </summary>\r\n  /// <param name = \"subTask\">the sub task to add</param>\r\n  addSubTask(subTask: Task): void {\r\n    if (this.SubTasks === null)\r\n      this.SubTasks = new TasksTable();\r\n    this.SubTasks.addTask(subTask);\r\n  }\r\n\r\n  /// <summary>\r\n  ///   remove one of this tasks sub-task\r\n  /// </summary>\r\n  /// <param name = \"subTask\">a reference to the sub-task to remove</param>\r\n  removeSubTask(subTask: Task): void {\r\n    if (this.SubTasks !== null)\r\n      this.SubTasks.removeTask(subTask);\r\n  }\r\n\r\n  /// <summary>\r\n  ///   sets the value of the dynamicDef.transaction failed flag\r\n  /// </summary>\r\n  /// <param name = \"val\">the new value of the flag</param>\r\n  setTransactionFailed(val: boolean): void {\r\n    this._transactionFailed = val;\r\n\r\n    if (!val)\r\n      this.TransactionErrorHandlingsRetry = null;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   returns the value of the \"dynamicDef.transaction failed\" flag\r\n  /// </summary>\r\n  /// <param name = \"level\">is the dynamicDef.transaction level we are interested in checking. TRANS_NONE --> check for any\r\n  ///   dynamicDef.transaction level failure TRANS_RECORD/TASK_PREFIX --> check for a failure in that specific\r\n  ///   level</param>\r\n  transactionFailed(level: string): boolean {\r\n    if (level === ConstInterface.TRANS_NONE ||\r\n      (this.Transaction != null && this.Transaction.getLevel() === level))\r\n      return this._transactionFailed;\r\n    else if (level === ConstInterface.TRANS_NONE ||\r\n      (this.TransactionErrorHandlingsRetry != null && this.TransactionErrorHandlingsRetry.getLevel() === level))\r\n      return this._transactionFailed;\r\n    return false;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   set the flag of a dynamicDef.transaction retry on the task's dynamicDef.transaction\r\n  /// </summary>\r\n  /// <param name = \"val\">value of flag</param>\r\n  setAfterRetry(val: string): void {\r\n    if (this.Transaction != null)\r\n      this.Transaction.setAfterRetry(val);\r\n    else if (this.TransactionErrorHandlingsRetry != null) {\r\n      if (val === ConstInterface.RECOVERY_NONE)\r\n        this.TransactionErrorHandlingsRetry = null;\r\n      else\r\n        this.TransactionErrorHandlingsRetry.setAfterRetry(val);\r\n    }\r\n  }\r\n\r\n  getAfterRetry(): boolean;\r\n  getAfterRetry(recovery: string): boolean;\r\n  getAfterRetry(recovery?: string): boolean {\r\n    if (arguments.length === 0) {\r\n      return this.getAfterRetry_0();\r\n    }\r\n    return this.getAfterRetry_1(recovery);\r\n  }\r\n\r\n  /// <returns> true if this task is part of a dynamicDef.transaction currently being retried</returns>\r\n  private getAfterRetry_0(): boolean {\r\n    if (this.Transaction != null)\r\n      return this.Transaction.getAfterRetry();\r\n    else if (this.TransactionErrorHandlingsRetry != null)\r\n      return this.TransactionErrorHandlingsRetry.getAfterRetry();\r\n    return false;\r\n  }\r\n\r\n  /// <returns> true if this task is part of a dynamicDef.transaction currently being retried with a specific recovery</returns>\r\n  private getAfterRetry_1(recovery: string): boolean {\r\n    if (this.Transaction != null)\r\n      return this.Transaction.getAfterRetry(recovery);\r\n    else if (this.TransactionErrorHandlingsRetry != null)\r\n      return this.TransactionErrorHandlingsRetry.getAfterRetry(recovery);\r\n    return false;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   get the ExecEndTask flag\r\n  /// </summary>\r\n  /// <returns> the _bExecEndTask value</returns>\r\n  getExecEndTask(): boolean {\r\n    return this._bExecEndTask;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   reset the \"execute end task\" flag\r\n  /// </summary>\r\n  resetExecEndTask(): void {\r\n    this._bExecEndTask = false;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   reset the \"execute end task\" flag\r\n  /// </summary>\r\n  setExecEndTask(): void {\r\n    this._bExecEndTask = true;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   Evaluate the end condition property\r\n  /// </summary>\r\n  /// <param name = \"mode\">the mode to compare to</param>\r\n  /// <returns> should we evaluate the end condition?</returns>\r\n  async evalEndCond(mode: string): Promise<boolean> {\r\n    let endTaskCondProp: Property;\r\n    let evalEndCondProp: Property = this.getProp(PropInterface.PROP_TYPE_EVAL_END_CONDITION);\r\n\r\n    // Dont evaluate end condition if we are already closing the task\r\n    if (this.InEndTask)\r\n      return false;\r\n\r\n    if (this._bExecEndTask)\r\n      return true;\r\n\r\n    if (evalEndCondProp != null && ( NString.Compare(await evalEndCondProp.getValue(), ConstInterface.END_COND_EVAL_IMMIDIATE,\r\n        true) === 0 || ((await evalEndCondProp.getValue()).toLowerCase() === mode.toLowerCase()))) {\r\n      // check the end condition\r\n      endTaskCondProp = this.getProp(PropInterface.PROP_TYPE_END_CONDITION);\r\n      if (endTaskCondProp == null)\r\n        return false;\r\n      let endTask: string = await endTaskCondProp.getValue();\r\n      // signal we need to perform an end task after we get out of the loop\r\n      if (DisplayConvertor.toBoolean(endTask)) {\r\n        this._bExecEndTask = true;\r\n        return true;\r\n      }\r\n      return false;\r\n    }\r\n    return false;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   set the \"trying to stop\" flag for the task and it's subTasks\r\n  /// </summary>\r\n  /// <param name = \"val\">the value to use for the flag</param>\r\n  setTryingToStop(val: boolean): void {\r\n    if (this.hasSubTasks()) {\r\n      for (let i: number = 0; i < this.SubTasks.getSize(); i = i + 1) {\r\n        let task: Task = <Task>this.SubTasks.getTask(i);\r\n        task.setTryingToStop(val);\r\n      }\r\n    }\r\n    this.IsTryingToStop = val;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   get the bInRecordSuffix\r\n  /// </summary\r\n  getInRecordSuffix(): boolean {\r\n    return this._inRecordSuffix;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   set the bInRecordSuffix\r\n  /// </summary>\r\n  setInRecordSuffix(bValue: boolean): boolean {\r\n    if (bValue !== this._inRecordSuffix) {\r\n      this._inRecordSuffix = bValue;\r\n      return true;\r\n    }\r\n    return false;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   set the bEvalOldValues flag\r\n  /// </summary>\r\n  /// <param name = \"bFlag\">true/false value</param>\r\n  /// <returns> true/flase - value updated</returns>\r\n  setEvalOldValues(bFlag: boolean): boolean {\r\n    if (bFlag !== this._evalOldValues) {\r\n      this._evalOldValues = bFlag;\r\n      return true;\r\n    }\r\n    return false;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   get the bEvalOldValues value\r\n  /// </summary>\r\n  /// <returns> true/false - look at old values when getting the field value</returns>\r\n  getEvalOldValues(): boolean {\r\n    return this._evalOldValues;\r\n  }\r\n\r\n   async endTask(reversibleExit: boolean, onlyDescs: boolean, dueToVerifyError: boolean, subformDestination?: boolean): Promise<boolean> {\r\n    if (isNullOrUndefined(subformDestination))\r\n      return await this.endTask_1(reversibleExit, onlyDescs, false, dueToVerifyError);\r\n    else\r\n      return await this.endTask_1(reversibleExit, onlyDescs, subformDestination, dueToVerifyError);\r\n  }\r\n\r\n  /// <summary>\r\n  ///   returns true if succeeded in ending the task and its sub tasks\r\n  /// </summary>\r\n  /// <param name = \"reversibleExit\">if true then the exit is reversible</param>\r\n  /// <param name = \"onlyDescs\">if true then end only the sub tasks and handle rec suffix for this task</param>\r\n  /// <param name = \"subformDestination\">if true then end only this task</param>\r\n  private async endTask_1(reversibleExit: boolean, onlyDescs: boolean, subformDestination: boolean, dueToVerifyError: boolean): Promise<boolean> {\r\n    let succeeded: boolean = true;\r\n    let closedSubForm: boolean = false;\r\n    let subTask: Task;\r\n    let mgdTab: IMGDataCollection = AccessHelper.mgDataTable;\r\n\r\n    if ((this.IsSubForm && !subformDestination) && !this._parentTask.InEndTask) {\r\n      // if this task is a subform and its parent is not trying to stop then\r\n      // start stopping the tasks sub tree from the parent form\r\n      succeeded = await this._parentTask.endTask(reversibleExit, onlyDescs, dueToVerifyError);\r\n    }\r\n    else if (!this.isAborting() && !this.InEndTask) {\r\n      try {\r\n        this.InEndTask = true;\r\n\r\n        // In case of error and browser close, intimate server about browser close\r\n        if((MGDataCollection.Instance.StartupMgData.getFirstTask().InEndTask && MGDataCollection.Instance.StartupMgData.getFirstTask().ClosingFormUI) && AccessHelper.eventsManager.GetStopExecutionFlag())\r\n        {\r\n          let cmd: IClientCommand = CommandFactory.CreateUnloadCommand();\r\n          MGDataCollection.Instance.getMGData(0).CmdsToServer.Add(cmd);\r\n          await CommandsProcessorManager.GetCommandsProcessor().Execute(CommandsProcessorBase_SendingInstruction.TASKS_AND_COMMANDS);\r\n          return;\r\n        }\r\n\r\n        if (!this.IsTryingToStop)\r\n          this.setTryingToStop(true);\r\n\r\n        // exit from subTasks in a prefix manner\r\n        let i: number;\r\n        if (reversibleExit) {\r\n          // exit from the sub tasks\r\n          if (this.hasSubTasks()) {\r\n\r\n            if (!RemoteCommandsProcessor.GetInstance().DelayCommandExecution) {\r\n              let pendingTransactions: boolean = true;\r\n              let clientOperExist: boolean = await this.CheckIfClientOperationExistsInSubformTasks(this,\r\n                InternalInterface.MG_ACT_TASK_SUFFIX);\r\n              if (!clientOperExist) {\r\n                clientOperExist = await this.CheckIfClientOperationExistsInSubformTasks(this,\r\n                  InternalInterface.MG_ACT_REC_SUFFIX);\r\n              if (!clientOperExist)\r\n                  pendingTransactions = this.CheckIfPendingTransactions(this);\r\n              }\r\n              if (!clientOperExist && !pendingTransactions) {\r\n                this.allowRemoteCmdExecution = false;\r\n                this.SetServerSideTaskSuffix(this);\r\n\r\n                RemoteCommandsProcessor.GetInstance().DelayCommandExecution = true;\r\n              }\r\n            }\r\n            else\r\n              this.SetServerSideTaskSuffix(this);\r\n            for (i = 0; i < this.SubTasks.getSize() && succeeded; i++) {\r\n              subTask = <Task>this.SubTasks.getTask(i);\r\n              closedSubForm = closedSubForm || subTask.IsSubForm;\r\n              await AccessHelper.eventsManager.handleInternalEventWithTask(subTask, InternalInterface.MG_ACT_EXIT);\r\n              succeeded = (!AccessHelper.eventsManager.GetStopExecutionFlag() || dueToVerifyError);\r\n            }\r\n          }\r\n          else\r\n          {\r\n            if (RemoteCommandsProcessor.GetInstance().DelayCommandExecution)\r\n              this.SetServerSideTaskSuffix(this);\r\n          }\r\n          // exit for the first task must end all tasks\r\n          if (this === mgdTab.StartupMgData.getFirstTask()) {\r\n            for (i = mgdTab.getSize() - 1; i > 0 && succeeded; i--) {\r\n              if (mgdTab.getMGData(i) != null) {\r\n                await AccessHelper.eventsManager.handleInternalEventWithTask(mgdTab.getMGData(i).getFirstTask(),\r\n                                                                       InternalInterface.MG_ACT_EXIT);\r\n                succeeded = (!AccessHelper.eventsManager.GetStopExecutionFlag() || dueToVerifyError);\r\n              }\r\n            }\r\n          }\r\n        }\r\n\r\n        if (succeeded) {\r\n          // if closing the sub tasks was successful then execute record suffix\r\n          if (reversibleExit && !dueToVerifyError) {\r\n            let forceSuffix: boolean = await this.checkProp(PropInterface.PROP_TYPE_FORCE_SUFFIX, false);\r\n            // for non interactive, turn off the force record suffix,\r\n            // otherwise an unwanted update might be sent when task ends.\r\n            if (!this.IsInteractive && forceSuffix === true && this.getMode() === Constants.TASK_MODE_CREATE)\r\n              this.setProp(PropInterface.PROP_TYPE_FORCE_SUFFIX, \"0\");\r\n\r\n            await AccessHelper.eventsManager.handleInternalEventWithTask(this, InternalInterface.MG_ACT_REC_SUFFIX);\r\n\r\n            // restore the force suffix, for just in case.\r\n            if (!this.IsInteractive && forceSuffix === true && this.getMode() === Constants.TASK_MODE_CREATE)\r\n              this.setProp(PropInterface.PROP_TYPE_FORCE_SUFFIX, \"1\");\r\n          }\r\n\r\n          succeeded = (!AccessHelper.eventsManager.GetStopExecutionFlag() || dueToVerifyError);\r\n\r\n          if (succeeded && !onlyDescs)\r\n            this.HandleTransactionInfo();\r\n\r\n          let preTskSuffix: boolean = succeeded;\r\n\r\n          // now perform task suffix\r\n          if (succeeded && !onlyDescs && reversibleExit && !dueToVerifyError &&\r\n            (!this.IsSubForm || subformDestination) &&\r\n            this.TaskPrefixExecuted && !this.TaskSuffixExecuted)\r\n            succeeded = await this.handleTaskSuffix(true);\r\n\r\n          // Don't forget to exit from any subTasks opened during the last rec-suffix or task suffix\r\n          if (reversibleExit && this.hasSubTasks())\r\n            for (i = 0; i < this.SubTasks.getSize(); i++) {\r\n\r\n              subTask = <Task>this.SubTasks.getTask(i);\r\n\r\n              if (!subTask.IsSubForm)\r\n                await AccessHelper.eventsManager.handleNonReversibleEvent(subTask, InternalInterface.MG_ACT_EXIT);\r\n            }\r\n\r\n          // dont continue with task exit if a data error occured during task suffix (e.g. rollback())\r\n          if (reversibleExit)\r\n            succeeded = (!AccessHelper.eventsManager.GetStopExecutionFlag() || dueToVerifyError);\r\n\r\n          // task suffix only stops execution for current task, which is being closed\r\n          if (preTskSuffix)\r\n            AccessHelper.eventsManager.setStopExecution(false);\r\n\r\n          this.setAfterRetry(ConstInterface.RECOVERY_NONE);\r\n\r\n          if (!this.isAborting() && succeeded && !onlyDescs) {\r\n            // Try closing any task level dynamicDef.transaction\r\n            if (reversibleExit) {\r\n              this.setTransactionFailed(false);\r\n              await this.TaskTransactionManager.checkAndCommit(false, ConstInterface.TRANS_TASK_PREFIX, false);\r\n              succeeded = (!AccessHelper.eventsManager.GetStopExecutionFlag() || dueToVerifyError) && !this.isAborting() && !this.transactionFailed(ConstInterface.TRANS_TASK_PREFIX);\r\n            }\r\n\r\n            this.setAfterRetry(ConstInterface.RECOVERY_NONE);\r\n\r\n            if (succeeded) {\r\n\r\n\r\n              if (!this.allowRemoteCmdExecution) {\r\n                this.allowRemoteCmdExecution = true;\r\n                RemoteCommandsProcessor.GetInstance().DelayCommandExecution = false;\r\n              }\r\n              else if (this.DelayCommandExecution){\r\n                this.DelayCommandExecution = false;\r\n                RemoteCommandsProcessor.GetInstance().DelayCommandExecution = true;\r\n              }\r\n\r\n              let baseMgd: MGData = AccessHelper.mgDataTable.StartupMgData;\r\n              // If we are closing the topmost task - dont loose any events, left in the queue\r\n              if (reversibleExit && baseMgd.getFirstTask().getTaskTag() === this.getTaskTag()) {\r\n                AccessHelper.eventsManager.setProcessingTopMostEndTask(true);\r\n                await AccessHelper.eventsManager.handleEvents(baseMgd, 0);\r\n                AccessHelper.eventsManager.setProcessingTopMostEndTask(false);\r\n\r\n                // var st = new SessionStatisticsForm();\r\n                // st.WriteToFlowMonitor((FlowMonitorQueue)_flowMonitor);\r\n\r\n                if (this.isAborting()) {\r\n                  //aborting task closure\r\n                  RemoteCommandsProcessor.GetInstance().DelayCommandExecution = false;\r\n                  this.DelayCommandExecution = false;\r\n                  this.allowRemoteCmdExecution = true;\r\n                  return true;\r\n                }\r\n              }\r\n\r\n              await TaskServiceBase.Exit(this, reversibleExit, subformDestination);\r\n\r\n              // When closing a task whose parent is a main program, check the main program's end\r\n              // condition\r\n              if (this._parentTask != null && this._parentTask.isMainProg()) {\r\n                let mgd: MGData = AccessHelper.mgDataTable.getMGData(0);\r\n                let mainPrgTask: Task = mgd.getMainProg(0);\r\n                let rootTask: Task = AccessHelper.mgDataTable.StartupMgData.getFirstTask();\r\n                let endMainPrg: boolean = await mainPrgTask.checkProp(PropInterface.PROP_TYPE_END_CONDITION, false);\r\n\r\n                // No need to end the root task if we are already doing it.\r\n                if (this !== rootTask && endMainPrg) {\r\n                  let rtEvt = new RunTimeEvent(rootTask);\r\n                  rtEvt.setInternal(InternalInterface.MG_ACT_CLOSE);\r\n                  rtEvt.setCtrl(null);\r\n                  rtEvt.setArgList(null);\r\n                  AccessHelper.eventsManager.addToTail(rtEvt);\r\n                }\r\n              }\r\n              MgForm.CreatedForms.remove(<MgForm>this.Form);\r\n            }\r\n          }\r\n        }\r\n      }\r\n\r\n      finally {\r\n        if (!this.IsSubForm || subformDestination)\r\n          this.handleFinallyEndTask(succeeded, reversibleExit);\r\n      }\r\n    }\r\n\r\n    // Qcr #914645 : return false in a recursive call.\r\n    // otherwise commonHandlerAfter(eventManager) will not be executed if the call is recursively made from handleEvent.\r\n    // for example : task cond fulfilled. handleInternalEvent(this, MG_ACT_REC_SUFFIX) is called.\r\n    // while in rec suf handler, endTask is called again..if we return true then the commonHandlerAfter is not executed.\r\n    // if the rec suffix handler did not exist, there will be no call to endTask and the commonHandlerAfter will be executed.\r\n    // The name 'succeeded' is a bit misleading..its more like 'executed'..but we decided to keep it.\r\n    else if (this.InEndTask)\r\n      succeeded = false;\r\n\r\n    // restore the flag.\r\n    AccessHelper.eventsManager.setProcessingTopMostEndTask(this._inProcessingTopMostEndTaskSaved);\r\n\r\n    return succeeded;\r\n  }\r\n\r\n  /// <summary>\r\n  /// SetServerSideTaskSuffix()\r\n  /// </summary>\r\n  /// <param name=\"task\"></param>\r\n  private SetServerSideTaskSuffix (task : Task) : void\r\n  {\r\n    var rtEvt = new RunTimeEvent(task);\r\n    rtEvt.setInternal(InternalInterface.MG_ACT_TASK_SUFFIX);\r\n\r\n    let  handler: EventHandler = null;\r\n    // find if MG_ACT_TASK_SUFFIX handler exists?\r\n    var evtHanPos = new EventHandlerPosition();\r\n    evtHanPos.init(rtEvt);\r\n    handler = evtHanPos.getNext();\r\n\r\n    if (handler != null)\r\n    {\r\n      for (let  i = 0; i < handler.getOperationTab().getSize(); i++)\r\n      {\r\n        let oper = handler.getOperationTab().getOperation(i);\r\n        oper.setExecOnServer(true);\r\n      }\r\n    }\r\n    if (task.hasSubTasks())   {\r\n      for (let i = 0; i < task.GetSubTasks().length; i++)\r\n      {\r\n        let subTask: Task = <Task>task.SubTasks.getTask(i);\r\n        this.SetServerSideTaskSuffix(subTask);\r\n      }\r\n    }\r\n\r\n  }\r\n\r\n  /// <summary>\r\n  /// CheckIfClientOperationExistsInSubformTasks()\r\n  /// </summary>\r\n  /// <param name=\"task\"></param>\r\n  private async CheckIfClientOperationExistsInSubformTasks (task: Task, eventCode: number): Promise <boolean> {\r\n    let clientOperationExist = false;\r\n    var rtEvt = new RunTimeEvent(task);\r\n    rtEvt.setInternal(eventCode);\r\n\r\n    let handler: EventHandler = null;\r\n    // find if MG_ACT_TASK_SUFFIX / MG_ACT_REC_SUFFIX handler exists?\r\n    var evtHanPos = new EventHandlerPosition();\r\n    evtHanPos.init(rtEvt);\r\n    handler = evtHanPos.getNext();\r\n\r\n    if (eventCode == InternalInterface.MG_ACT_REC_SUFFIX) {\r\n      let currRecord = (<DataView>task.DataView).getCurrRec();\r\n      if ((<DataView>task.DataView).modifiedRecordsNumber() > 0 || (currRecord != null && currRecord.Modified))\r\n        clientOperationExist = true;\r\n\r\n      if (!clientOperationExist) {\r\n        let forceSuffix: boolean = await task.checkProp(PropInterface.PROP_TYPE_FORCE_SUFFIX, false);\r\n        // for non interactive, create mode task.  force record suffix is cancelled\r\n\r\n        if (forceSuffix === true)\r\n        if (task.IsInteractive ||  task.getMode() !== Constants.TASK_MODE_CREATE)\r\n          clientOperationExist = true;\r\n\r\n      }\r\n    }\r\n\r\n    if (handler != null && !clientOperationExist) {\r\n        let cnt = handler.getOperationTab().getSize();\r\n\r\n        for (let i = 0; i < cnt; i++) {\r\n          let oper = handler.getOperationTab().getOperation(i);\r\n          if (oper.getExecOnClient()) {\r\n            clientOperationExist = true;\r\n            break;\r\n          }\r\n          else {\r\n            if (oper.getType() == ConstInterface.MG_OPER_RAISE_EVENT){\r\n              if (oper.GetRuntimeEvent().getType() == ConstInterface.EVENT_TYPE_INTERNAL &&\r\n              oper.GetRuntimeEvent().getInternalCode() === InternalInterface.MG_ACT_RT_REFRESH_VIEW) {\r\n                clientOperationExist = true;\r\n                break;\r\n              }\r\n            }\r\n          }\r\n        }\r\n      }\r\n\r\n      if (!clientOperationExist && task.hasSubTasks()) {\r\n        for (let i = 0; (!clientOperationExist && i < task.getSubTasks().getSize()); i++) {\r\n          let subTask = <Task>task.SubTasks.getTask(i);\r\n          clientOperationExist = await this.CheckIfClientOperationExistsInSubformTasks(subTask, eventCode);\r\n        }\r\n      }\r\n\r\n      return clientOperationExist;\r\n  }\r\n\r\n\r\n  /// <summary>\r\n  /// CheckIfPendingTransactions()\r\n  /// </summary>\r\n  /// <param name=\"task\"></param>\r\n  private CheckIfPendingTransactions(task : Task): boolean\r\n  {\r\n    let pendingTransactions = false;\r\n    let currRecord =  (<DataView>task.DataView).getCurrRec();\r\n    if ((<DataView>task.DataView).modifiedRecordsNumber() > 0 || (currRecord != null && currRecord.Modified))\r\n      pendingTransactions = true;\r\n\r\n    if (!pendingTransactions && task.hasSubTasks())\r\n    {\r\n      for (let i = 0; (!pendingTransactions && i < task.getSubTasks().getSize()); i++)\r\n      {\r\n        let subTask = <Task>task.SubTasks.getTask(i);\r\n        pendingTransactions = this.CheckIfPendingTransactions(subTask);\r\n      }\r\n    }\r\n\r\n    return pendingTransactions;\r\n  }\r\n\r\n  /// <summary>\r\n  ///\r\n  /// </summary>\r\n  /// <param name=\"onlyDescs\"></param>\r\n  /// <param name=\"succeeded\"></param>\r\n  private HandleTransactionInfo(): void {\r\n    // while remote task without local data, has subform that has local data : Remote transaction is set on the parent task and local Transaction is set on subform.\r\n    // The member task.Transaction is get the DataviewManager.CurrentDataviewManager.Transaction\r\n    // for subform :  the CurrentDataviewManager is the localDataview so the transaction is the local transaction that the subform is the owner but not the owner of the remote transaction\r\n    // The method setTransCleared() need to be called only for remote transaction that is the owner task . (_transCleared is send to the server )\r\n\r\n    // check the remote transaction\r\n    let transaction: Transaction = this.DataviewManager.RemoteDataviewManager.Transaction;\r\n    if (transaction !== null && transaction.isOwner(this) && transaction.getLevel() === 'P') {\r\n      this.DataviewManager.RemoteDataviewManager.Transaction = null;\r\n      (<DataView>this.DataView).setTransCleared();\r\n    }\r\n  }\r\n\r\n  /// <summary>\r\n  /// Creates exit command, adds it to commands for execution and execute it if it's needed\r\n  /// </summary>\r\n  /// <param name=\"reversibleExit\"></param>\r\n  /// <param name=\"subformDestination\"></param>\r\n  async Exit(reversibleExit: boolean, subformDestination: boolean): Promise<void> {\r\n    // if record suffix was successful and this task is not a sub form\r\n    // then end the task at the server side\r\n\r\n    let cmd: IClientCommand = reversibleExit ?\r\n                              <IClientCommand>CommandFactory.CreateBrowserEscEventCommand(this.getTaskTag(), subformDestination) :\r\n                              <IClientCommand>CommandFactory.CreateNonReversibleExitCommand(this.getTaskTag(), subformDestination);\r\n\r\n    this._mgData.CmdsToServer.Add(cmd);\r\n    if (!subformDestination) {\r\n      try {\r\n        // Execute the BrowerEscCommand immediately only if\r\n        // 1. If we are trying to close the browser and the topmost task is closing\r\n        // 2. If user explicitly closes the current task (like closing overlay)\r\n        // For all other Exit() commands, just add the BrowserEscCommand to CmdsToServer.\r\n        if(this.getTaskTag() == MGDataCollection.Instance.StartupMgData.getFirstTask().getTaskTag() ||\r\n           !(MGDataCollection.Instance.StartupMgData.getFirstTask().InEndTask && MGDataCollection.Instance.StartupMgData.getFirstTask().ClosingFormUI))\r\n          await Task.CommandsProcessor.Execute(CommandsProcessorBase_SendingInstruction.TASKS_AND_COMMANDS);\r\n      }\r\n      catch (err) {\r\n        // If the closing of Main Program didn't succeed on server, close it here --- ofcourse it\r\n        // includes the execution of TS as well.\r\n        if (this.isMainProg()) {\r\n          this._mgData.CmdsToServer.Add(cmd);\r\n        }\r\n        else\r\n          throw err;\r\n      }\r\n\r\n    }\r\n  }\r\n\r\n  /// <summary>\r\n  ///   Recursive function for finally operation of endTask function\r\n  /// </summary>\r\n  /// <param name = \"succeeded\"></param>\r\n  /// <param name = \"reversibleExit\">\r\n  /// </param>\r\n  private handleFinallyEndTask(succeeded: boolean, reversibleExit: boolean): void {\r\n    let subTask: Task;\r\n\r\n    if (this.hasSubTasks()) {\r\n      for (let i: number = 0; i < this.SubTasks.getSize(); i++) {\r\n        subTask = <Task>this.SubTasks.getTask(i);\r\n        subTask.handleFinallyEndTask(succeeded, reversibleExit);\r\n      }\r\n    }\r\n\r\n    this.InEndTask = false;\r\n\r\n    if (succeeded)\r\n      this._isStarted = false;\r\n\r\n    if (!succeeded && reversibleExit && this.IsTryingToStop)\r\n      this.setTryingToStop(false);\r\n  }\r\n\r\n  /// <summary>\r\n  ///   Recursive function for Task Prefix execution for all subforms\r\n  /// </summary>\r\n  /// <returns></returns>\r\n  async handleTaskSuffix(withSubTasks: boolean): Promise<boolean> {\r\n    let succeeded: boolean = true;\r\n    let subTask: Task;\r\n\r\n    if (withSubTasks) {\r\n      if (this.hasSubTasks()) {\r\n        for (let i: number = 0; i < this.SubTasks.getSize() && succeeded; i++) {\r\n          subTask = <Task>this.SubTasks.getTask(i);\r\n          succeeded = await subTask.handleTaskSuffix(withSubTasks);\r\n        }\r\n      }\r\n    }\r\n\r\n    if (succeeded)\r\n      await AccessHelper.eventsManager.handleInternalEventWithTask(this, InternalInterface.MG_ACT_TASK_SUFFIX);\r\n    succeeded = !AccessHelper.eventsManager.GetStopExecutionFlag();\r\n    this.TaskSuffixExecuted = true;\r\n    return succeeded;\r\n  }\r\n\r\n\r\n  /// <summary>\r\n  ///   set if the task into create line processing or not\r\n  /// </summary>\r\n  setInCreateLine(inCreateLine: boolean): void {\r\n    this._inCreateLine = inCreateLine;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   get if the task is into Create line processing\r\n  /// </summary>\r\n  getInCreateLine(): boolean {\r\n    return this._inCreateLine;\r\n  }\r\n\r\n\r\n  /// <summary>\r\n  ///   handle an internal event on this tasks slave tasks. Slave tasks are: (1) If this task is a dynamicDef.transaction\r\n  ///   owner - all tasks participating in the transactions are its slaves. (2) If this task is not an owner -\r\n  ///   all its subforms are considered slaves. if one of the sub tasks failed handling the event then a\r\n  ///   reference to that task is returned otherwise the returned value is null\r\n  /// </summary>\r\n  /// <param name = \"internalEvtCode\">the code of the internal event to handle</param>\r\n  async handleEventOnSlaveTasks(internalEvtCode: number): Promise<Task> {\r\n    let i: number;\r\n    let task: Task = null;\r\n    let failureTask: Task = null;\r\n    let mgdTab: IMGDataCollection = AccessHelper.mgDataTable;\r\n    let triggeredTasks: List<TaskBase> = mgdTab.getTriggeredTasks(this);\r\n    let orphans: List<Task> = null;\r\n    let sameTrans: boolean;\r\n    let hasSlaves: boolean = false;\r\n    let isOwner: boolean = this.Transaction != null && this.Transaction.isOwner(this);\r\n\r\n    // event on trans-owner should be propogated to all other tasks in the dynamicDef.transaction.\r\n    if (isOwner) {\r\n      AccessHelper.eventsManager.setEventScopeTrans();\r\n      orphans = new List<Task>();\r\n\r\n      // In case a change of trans-ownership previously took place, there might be tasks\r\n      // which belong to the current dynamicDef.transaction but their parent is gone. These are orphan tasks\r\n      // and we need to propogate the event to them too.\r\n      mgdTab.startTasksIteration();\r\n      while ((task = <Task>mgdTab.getNextTask()) != null) {\r\n        sameTrans = task.Transaction != null && this.Transaction.getTransId() === task.Transaction.getTransId();\r\n        if (task !== this && sameTrans && task.PreviouslyActiveTaskId != null && mgdTab.GetTaskByID(task.PreviouslyActiveTaskId) == null)\r\n          orphans.push(task);\r\n      }\r\n    }\r\n\r\n    let scopeTrans: boolean = AccessHelper.eventsManager.isEventScopeTrans();\r\n\r\n    // Propagate the event according to the scope, on all tasks triggered by me\r\n    for (i = 0; i < triggeredTasks.length && !AccessHelper.eventsManager.GetStopExecutionFlag(); i++) {\r\n      task = <Task>triggeredTasks.get_Item(i);\r\n      sameTrans = this.Transaction != null && task.Transaction != null && this.Transaction.getTransId() === task.Transaction.getTransId();\r\n\r\n      if (!task.IsSubForm && (scopeTrans && sameTrans) && task.isStarted()) {\r\n        // QCR 438530 Guarantee that before prefix compute will be executed\r\n        if (task.getForm().FormRefreshed && internalEvtCode === InternalInterface.MG_ACT_REC_PREFIX && task.getLevel() === Constants.TASK_LEVEL_TASK)\r\n          await (<DataView>task.DataView).currRecCompute(false);\r\n        await AccessHelper.eventsManager.handleInternalEventWithTask(task, internalEvtCode);\r\n        hasSlaves = true;\r\n      }\r\n    }\r\n\r\n    // Propagate the event on orphans too.\r\n    for (; isOwner && i < orphans.length && !AccessHelper.eventsManager.GetStopExecutionFlag(); i++) {\r\n      task = orphans.get_Item(i);\r\n\r\n      // QCR 438530 Guarantee that before prefix compute will be executed\r\n      if (task.getForm().FormRefreshed && internalEvtCode === InternalInterface.MG_ACT_REC_PREFIX && task.getLevel() === Constants.TASK_LEVEL_TASK)\r\n        await (<DataView>task.DataView).currRecCompute(false);\r\n      await AccessHelper.eventsManager.handleInternalEventWithTask(task, internalEvtCode);\r\n      hasSlaves = true;\r\n    }\r\n\r\n    if (hasSlaves && AccessHelper.eventsManager.GetStopExecutionFlag())\r\n      failureTask = task;\r\n\r\n    if (isOwner)\r\n      AccessHelper.eventsManager.clearEventScope();\r\n\r\n    return failureTask;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   enable-disable actions for a record\r\n  /// </summary>\r\n  async enableRecordActions(): Promise<void> {\r\n    let dataview: DataView = <DataView>this.DataView;\r\n\r\n    await this.setCreateDeleteActsEnableState();\r\n\r\n    if (dataview.IncludesFirst() || dataview.IsOneWayKey) {\r\n      if (dataview.isEmptyDataview() || dataview.getCurrRecIdx() === 0) {\r\n        this.ActionManager.enable(InternalInterface.MG_ACT_TBL_PRVLINE, false);\r\n        if (dataview.IsOneWayKey)\r\n          this.ActionManager.enable(InternalInterface.MG_ACT_TBL_BEGTBL, true);\r\n        else this.ActionManager.enable(InternalInterface.MG_ACT_TBL_BEGTBL, false);\r\n        if (this.Form.isScreenMode())\r\n          this.ActionManager.enable(InternalInterface.MG_ACT_TBL_PRVPAGE, false);\r\n      }\r\n      else {\r\n        this.ActionManager.enable(InternalInterface.MG_ACT_TBL_PRVLINE, true);\r\n        this.ActionManager.enable(InternalInterface.MG_ACT_TBL_BEGTBL, true);\r\n        if (this.Form.isScreenMode())\r\n          this.ActionManager.enable(InternalInterface.MG_ACT_TBL_PRVPAGE, true);\r\n      }\r\n      if (!this.Form.isScreenMode())\r\n        if (dataview.isEmptyDataview() || (dataview.getCurrRecIdx() === 0) || (dataview.getTopRecIdx() === 0))\r\n          this.ActionManager.enable(InternalInterface.MG_ACT_TBL_PRVPAGE, false);\r\n        else this.ActionManager.enable(InternalInterface.MG_ACT_TBL_PRVPAGE, true);\r\n    }\r\n    else {\r\n      this.ActionManager.enable(InternalInterface.MG_ACT_TBL_BEGTBL, true);\r\n      this.ActionManager.enable(InternalInterface.MG_ACT_TBL_PRVPAGE, true);\r\n      this.ActionManager.enable(InternalInterface.MG_ACT_TBL_PRVLINE, true);\r\n    }\r\n\r\n    if (dataview.IncludesLast()) {\r\n      if (((this.getMode() === Constants.TASK_MODE_QUERY) || dataview.isEmptyDataview() ||\r\n          ((this.getMode() === Constants.TASK_MODE_MODIFY) &&\r\n            (!Environment.Instance.allowCreateInModifyMode(this.getCompIdx()) ||\r\n              !await this.checkProp(PropInterface.PROP_TYPE_ALLOW_CREATE, true)))) && (dataview.getCurrRecIdx() + 1) === dataview.getSize()) {\r\n        this.ActionManager.enable(InternalInterface.MG_ACT_TBL_NXTLINE, false);\r\n        this.ActionManager.enable(InternalInterface.MG_ACT_TBL_ENDTBL, false);\r\n        if (this.Form.isScreenMode())\r\n          this.ActionManager.enable(InternalInterface.MG_ACT_TBL_NXTPAGE, false);\r\n      }\r\n      else {\r\n        this.ActionManager.enable(InternalInterface.MG_ACT_TBL_NXTLINE, true);\r\n        this.ActionManager.enable(InternalInterface.MG_ACT_TBL_ENDTBL, true);\r\n        if (this.Form.isScreenMode())\r\n          this.ActionManager.enable(InternalInterface.MG_ACT_TBL_NXTPAGE, true);\r\n      }\r\n\r\n      if (!this.Form.isScreenMode()) {\r\n        if (dataview.isEmptyDataview() || ((dataview.getSize() - dataview.getTopRecIdx()) <= this.Form.getRowsInPage()))\r\n          this.ActionManager.enable(InternalInterface.MG_ACT_TBL_NXTPAGE, false);\r\n        else this.ActionManager.enable(InternalInterface.MG_ACT_TBL_NXTPAGE, true);\r\n      }\r\n    }\r\n    else {\r\n      this.ActionManager.enable(InternalInterface.MG_ACT_TBL_NXTLINE, true);\r\n      this.ActionManager.enable(InternalInterface.MG_ACT_TBL_NXTPAGE, true);\r\n      this.ActionManager.enable(InternalInterface.MG_ACT_TBL_ENDTBL, true);\r\n    }\r\n\r\n    if (dataview.isEmptyDataview())\r\n      this.ActionManager.enable(InternalInterface.MG_ACT_CANCEL, false);\r\n    else\r\n      this.ActionManager.enable(InternalInterface.MG_ACT_CANCEL, true);\r\n\r\n    this.ActionManager.enable(InternalInterface.MG_ACT_ENTER_ROW_EDITING, true);\r\n\r\n    this.ActionManager.enable(InternalInterface.MG_ACT_NO_PROG_EXE_RIGHTS, true);\r\n  }\r\n\r\n  /// <summary>\r\n  ///   returns true if the task is started\r\n  /// </summary>\r\n  isStarted(): boolean {\r\n    return this._isStarted;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   returns the sub tasks table\r\n  /// </summary>\r\n  getSubTasks(): TasksTable {\r\n    return this.SubTasks;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   returns true if this tasks refreshes on a change of one of its parent fields with the given id\r\n  /// </summary>\r\n  /// <param name = \"fldId\">the id of the parent field</param>\r\n  refreshesOn(fldId: number): boolean {\r\n    let result: boolean = false;\r\n\r\n    for (let i: number = 0; !result && this.RefreshOnVars !== null && i < this.RefreshOnVars.length; i++) {\r\n      result = (this.RefreshOnVars[i] === fldId);\r\n    }\r\n\r\n    return result;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   clear this task from the active transactions account\r\n  /// </summary>\r\n  private AbortTransaction(): void {\r\n    this.DataviewManager.RemoteDataviewManager.Transaction = null;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   set value of preventRecordSuffix to val\r\n  /// </summary>\r\n  /// <param name = \"val\">true if we already performed record suffix</param>\r\n  setPreventRecordSuffix(val: boolean): void {\r\n    this._preventRecordSuffix = val;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   get value of preventRecordSuffix\r\n  /// </summary\r\n  getPreventRecordSuffix(): boolean {\r\n    return this._preventRecordSuffix;\r\n  }\r\n\r\n  setPreventControlChange(val: boolean): void {\r\n    this._preventControlChange = val;\r\n  }\r\n\r\n  getPreventControlChange(): boolean {\r\n    return this._preventControlChange;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   signal the server closed this task\r\n  /// </summary>\r\n  resetKnownToServer(): void {\r\n    this._knownToServer = false;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   returns the dvPos value\r\n  /// </summary>\r\n  /// <param name = \"-\">evaluates the dercriptor and return the non-have dvPos value</param>\r\n  evaluateDescriptor(): number {\r\n    let result: string = \"\";\r\n    let res: NUM_TYPE;\r\n    if (this.DvPosDescriptor == null)\r\n      return HashUtils.GetHashCode(result);\r\n\r\n    let first: boolean = true;\r\n\r\n    // go over the list of the descriptor\r\n    for (let i: number = 0; i < this.DvPosDescriptor.length; i++) {\r\n      if (!first)\r\n        result += \";\";\r\n\r\n      let currentCell: string[] = this.DvPosDescriptor.get_Item(i);\r\n\r\n      // parse the current task and field number\r\n      let currentTag: string = currentCell[0];\r\n      let currentVeeIdx: number = NNumber.Parse(currentCell[1]);\r\n      let currentTask = <Task>AccessHelper.mgDataTable.GetTaskByID(currentTag);\r\n      let currentField = <Field>currentTask.DataView.getField(currentVeeIdx);\r\n      let dispVal: string = currentField.getDispValue();\r\n\r\n      // QCR 978566\r\n      if (currentField.isNull())\r\n        dispVal = \"\";\r\n\r\n      // QCR 743290\r\n      let pic: PIC;\r\n      switch (currentField.getType()) {\r\n        case StorageAttribute.BOOLEAN:\r\n        // boolean is stored as \"o\" or \"1\" so we just add them as we\r\n        // do in the server\r\n        case StorageAttribute.ALPHA:\r\n        case StorageAttribute.UNICODE:\r\n        case StorageAttribute.BLOB:\r\n        case StorageAttribute.BLOB_VECTOR:\r\n          result += dispVal;\r\n          break;\r\n\r\n        case StorageAttribute.DATE:\r\n        case StorageAttribute.TIME:\r\n          // QCR 742966 date and time special treatment\r\n          if (dispVal !== \"\") {\r\n            pic = new PIC(currentField.getPicture(), currentField.getType(), 0);\r\n            let conv: DisplayConvertor = DisplayConvertor.Instance;\r\n            result += conv.mg2disp(dispVal, \"\", pic, false, this.getCompIdx(), false);\r\n          }\r\n          break;\r\n\r\n        case StorageAttribute.NUMERIC:\r\n          // QCR 543204 when there is an empty string (alpha)append nothing\r\n          if (dispVal !== \"\") {\r\n            res = new NUM_TYPE(dispVal);\r\n            pic = new PIC(currentField.getPicture(), currentField.getType(), 0);\r\n            result += res.to_a(pic);\r\n          }\r\n          break;\r\n      }\r\n\r\n      first = false;\r\n    }\r\n\r\n    let tmpStr2: string = StrUtil.stringToHexaDump(result, 4);\r\n\r\n    return HashUtils.GetHashCode(tmpStr2);\r\n  }\r\n\r\n  /// <summary>\r\n  ///   builds the dvPos descriptor vector each of the dvPosDescriptor vector elements is a String array of size\r\n  ///   2 in the first cell of each array we have the tag and in the second we have the vee iindex\r\n  /// </summary>\r\n  setDescriptor(newDesc: string): void {\r\n    if (!(newDesc.trim() === \"\")) {\r\n      let desc: string[] = StrUtil.tokenize(newDesc, \";\");\r\n      this.DvPosDescriptor = new List<string[]>();\r\n\r\n      for (let i: number = 0; i < desc.length; i = i + 1) {\r\n        let cell: string[] = new Array<string>(2);\r\n        let tagVeePair: string[] = StrUtil.tokenize(desc[i], \",\");\r\n        cell[0] = tagVeePair[0];\r\n        cell[1] = tagVeePair[1];\r\n\r\n        // put the cell value into the vector\r\n        this.DvPosDescriptor.push(cell);\r\n      }\r\n    }\r\n  }\r\n\r\n  /// <summary>\r\n  ///   returns the cache object of this task\r\n  /// </summary>\r\n  getTaskCache(): DvCache {\r\n    return this._dvCache;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   prepare all sub-form tree's to either go to server (after deleting relevant entries) or to take d.v from\r\n  ///   cache\r\n  /// </summary>\r\n  /// <returns> true if all subform can do need to go to the server because of updates</returns>\r\n  async prepareCache(ignoreCurr: boolean): Promise<boolean> {\r\n    let success: boolean = true;\r\n\r\n    // checking myself if i am a subform\r\n    if (!ignoreCurr) {\r\n      if (await this.isCached()) {\r\n        if ((<DataView>this.DataView).getChanged()) {\r\n          // is the current update dataview were previously taken from cache\r\n          this._dvCache.removeDvFromCache((<DataView>this.DataView).getDvPosValue(), true);\r\n          success = false;\r\n        }\r\n      }\r\n      else {\r\n        // checks that i am a sub form but i am not cached\r\n        if (this.IsSubForm && ! await this.isCached()) {\r\n          success = false;\r\n        }\r\n      }\r\n    }\r\n\r\n    let curretTask: Task;\r\n\r\n    // check all my sub forms\r\n    if (this.hasSubTasks()) {\r\n      // this loop must run to its end so all updated d.v will be deleted\r\n      for (let i: number = 0; i < this.SubTasks.getSize(); i = i + 1) {\r\n        curretTask = <Task>this.SubTasks.getTask(i);\r\n        // if one of my sub-forms needs to go to the server - so do i\r\n        if (! await curretTask.prepareCache(false)) {\r\n          success = false;\r\n        }\r\n      }\r\n    }\r\n    return success;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   checks if we can take the d.v of the task and all his sub-forms from cache is we can - take them and\r\n  ///   replace them with the current d.v of each task\r\n  /// </summary>\r\n  /// <returns> true if all d.v's were found and set</returns>\r\n  async testAndSet(ignoreCurr: boolean): Promise<boolean> {\r\n    // check current task\r\n    if (!ignoreCurr && await this.isCached()) {\r\n      let requestedDv: number = this.evaluateDescriptor();\r\n\r\n      // try to take from cache only if requested is not current\r\n      if (requestedDv !== (<DataView>this.DataView).getDvPosValue()) {\r\n        let fromCache: DataView = this._dvCache.getCachedDataView(requestedDv);\r\n        if (fromCache == null)\r\n          return false;\r\n        await this.changeDv(fromCache);     // changes the current d.v with the one taken from cache do not forget to\r\n                                      // check if the current needs to be inserted to the cache\r\n      }\r\n\r\n      // QCR #430045. Indicate that RP must be executed after get from the cache.\r\n      this.DoSubformPrefixSuffix = true;\r\n    }\r\n\r\n    // check all sub-forms tasksd\r\n    if (this.hasSubTasks()) {\r\n      // this loop does not need to reach its end\r\n      // the moment one that need to go to the server is discovered all need to go also\r\n      for (let i: number = 0; i < this.SubTasks.getSize(); i++) {\r\n        // does the i-th son need to go to the server\r\n        if (!await this.SubTasks.getTask(i).testAndSet(false))\r\n          return false;\r\n      }\r\n    }\r\n    return true;\r\n  }\r\n\r\n\r\n  /// <summary>\r\n  ///   changes the current d.v with one taken from cache in this method we do not have to worry about updates\r\n  ///   of the current dataview since the method is only called from testAndSet that in turn is only used after\r\n  ///   a Successful run prapreCache which is responsible for checking for updates in the current dataview of\r\n  ///   each related task. however to be on the safe side we check it anyway\r\n  /// </summary>\r\n  /// <param name = \"fromCache\">the new d.v</param>\r\n  private async changeDv(fromCache: DataView): Promise<void> {\r\n    let dataview: DataView = <DataView>this.DataView;\r\n    // the data view we receive is Certainly from the cache\r\n\r\n    if (!this.hasLocate) {\r\n      if (!dataview.getChanged() && dataview.IncludesFirst())\r\n        this._dvCache.putInCache(dataview.replicate());\r\n    }\r\n    else\r\n      this.locatePutInCache();\r\n\r\n    // set the data view from the cache as the current\r\n    await dataview.setSameAs(fromCache);\r\n    dataview.takeFldValsFromCurrRec();\r\n\r\n    this.Form.SetTableItemsCount(0, true);\r\n    (<MgForm>this.Form).setTableItemsCount(false);\r\n\r\n    await (<MgForm>this.Form).RefreshDisplay(Constants.TASK_REFRESH_FORM);\r\n\r\n    // QCR 9248094\r\n    this.setOriginalTaskMode(this.getMode());\r\n  }\r\n\r\n  setOriginalTaskMode(originalTaskMode: string): void {\r\n    this._originalTaskMode = originalTaskMode.charAt(0);\r\n  }\r\n\r\n\r\n  /// <summary>\r\n  ///   get mode of task\r\n  /// </summary>\r\n  getOriginalTaskMode(): string {\r\n    return this._originalTaskMode;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   returns the is Cache property value of the sub form control this task Correlates with this method\r\n  ///   actually combines two test first that the task is a sub form second that the sub that the sub form has\r\n  ///   the is cached property set to yes\r\n  /// </summary>\r\n  async isCached(): Promise<boolean> {\r\n    return this.IsSubForm && await (<MgControlBase>this.Form.getSubFormCtrl()).checkProp(PropInterface.PROP_TYPE_IS_CACHED, false);\r\n  }\r\n\r\n  /// <summary>\r\n  ///   does the insert in cache logic in case the task has locate expressions\r\n  /// </summary>\r\n  private locatePutInCache(): void {\r\n    let cached: DataView = this._dvCache.getCachedDataView((<DataView>this.DataView).getDvPosValue());\r\n\r\n    // if this data view has been inserted to the cache before\r\n    if (cached != null) {\r\n      if ((<DataView>this.DataView).checkFirst(cached.getLocateFirstRec()) && !(<DataView>this.DataView).getChanged()) {\r\n        (<DataView>this.DataView).setLocateFirstRec(cached.getLocateFirstRec());\r\n        this._dvCache.putInCache((<DataView>this.DataView).replicate());\r\n      }\r\n      else\r\n        this._dvCache.removeDvFromCache((<DataView>this.DataView).getDvPosValue(), true);\r\n    }\r\n    // put it in the cache if it is not updated\r\n    else {\r\n      if (!(<DataView>this.DataView).getChanged())\r\n        this._dvCache.putInCache((<DataView>this.DataView).replicate());\r\n    }\r\n  }\r\n\r\n  /// <summary>\r\n  ///   returns the hasLocate flag\r\n  /// </summary>\r\n  HasLoacte(): boolean {\r\n    return this.hasLocate;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   opens a new Transaction or set reference to the existing Transaction\r\n  /// </summary>\r\n  private setRemoteTransaction(transId: string): void {\r\n    let mgdTab: IMGDataCollection = AccessHelper.mgDataTable;\r\n    let transTask: Task;\r\n    let isFind: boolean = false;\r\n\r\n    mgdTab.startTasksIteration();\r\n    while ((transTask = <Task>mgdTab.getNextTask()) != null) {\r\n      // transaction might be null when task is aborting but not yet unloaded.\r\n      if (transTask.DataviewManager.RemoteDataviewManager.Transaction != null &&\r\n        transTask.DataviewManager.RemoteDataviewManager.Transaction.getTransId() === transId) {\r\n        isFind = true;\r\n        break;\r\n      }\r\n    }\r\n\r\n    this.DataviewManager.RemoteDataviewManager.Transaction = (isFind ?\r\n                                                              transTask.DataviewManager.RemoteDataviewManager.Transaction :\r\n                                                              new Transaction(this, transId));\r\n  }\r\n\r\n  /// <summary>\r\n  ///   sets the new Transaction Owner\r\n  /// </summary>\r\n  setTransOwnerTask(): void {\r\n    this.Transaction.setOwnerTask(this);\r\n    this.Transaction.setTransBegin('T')/*'T'*/;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   returns the value of the loop counter according to the topmost value in the stack and the status of the\r\n  ///   \"useLoopStack\" flag\r\n  /// </summary>\r\n  getLoopCounter(): number {\r\n    let result: number = 0;\r\n    if (this._useLoopStack && this._loopStack !== null && !(this._loopStack.count() === 0)) {\r\n      result = <number>this._loopStack.peek();\r\n    }\r\n    return result;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   pushes the value 0 on the top of the loop stack\r\n  /// </summary>\r\n  enterLoop(): void {\r\n    if (this._loopStack === null)\r\n      this._loopStack = new Stack();\r\n\r\n    this._loopStack.push(0);\r\n  }\r\n\r\n  /// <summary>\r\n  ///   pops the topmost entry from the loop stack\r\n  /// </summary>\r\n  leaveLoop(): void {\r\n    this.popLoopCounter();\r\n  }\r\n\r\n  /// <summary>\r\n  ///   pops the value of the loop counter from the stack and returns it\r\n  /// </summary>\r\n  popLoopCounter(): number {\r\n    let result: number = 0;\r\n\r\n    if (this._loopStack !== null && !(this._loopStack.count() === 0))\r\n      result = <number>this._loopStack.pop();\r\n\r\n    return result;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   increases the value at the top of the loop stack\r\n  /// </summary>\r\n  increaseLoopCounter(): void {\r\n    this._loopStack.push(this.popLoopCounter() + 1);\r\n  }\r\n\r\n  /// <summary>\r\n  ///   returns the number of entries in the loop stack\r\n  /// </summary>\r\n  getLoopStackSize(): number {\r\n    if (this._loopStack !== null)\r\n      return this._loopStack.count();\r\n\r\n    return 0;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   set the value of the \"use loop stack\" variable\r\n  /// </summary>\r\n  /// <param name = \"val\">the new value to set</param>\r\n  setUseLoopStack(val: boolean): void {\r\n    this._useLoopStack = val;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   return the links table\r\n  /// </summary>\r\n  getDataviewHeaders(): DataviewHeaders {\r\n    return this.DataviewHeadersTable;\r\n  }\r\n\r\n  isFirstRecordCycle(Value_?: boolean): any {\r\n    if (arguments.length === 0) {\r\n      return this.isFirstRecordCycle_0();\r\n    }\r\n    return this.isFirstRecordCycle_1(Value_);\r\n  }\r\n\r\n  private isFirstRecordCycle_0(): boolean {\r\n    return this._firstRecordCycle;\r\n  }\r\n\r\n  private isFirstRecordCycle_1(Value_: boolean): void {\r\n    this._firstRecordCycle = Value_;\r\n  }\r\n\r\n  ///<summary>get the internal name</summary>\r\n  getPublicName(): string {\r\n    return this.PublicName;\r\n  }\r\n\r\n  ///<summary>get the AllowEvents</summary>\r\n  async isAllowEvents(): Promise<boolean> {\r\n    let prop: Property = this.getProp(PropInterface.PROP_TYPE_TASK_PROPERTIES_ALLOW_EVENTS);\r\n    return await prop.getValueBoolean();\r\n  }\r\n\r\n  ///<summary>get the task id</summary>\r\n  getExternalTaskId(): string {\r\n    let taskId: string = \"\";\r\n    let prop: Property = this.getProp(PropInterface.PROP_TYPE_TASK_ID);\r\n\r\n    if (prop != null)\r\n      taskId = prop.GetComputedValue();\r\n\r\n    return taskId;\r\n  }\r\n\r\n\r\n  /// <summary>\r\n  ///   returns TRUE if this task owns a dynamicDef.transaction\r\n  /// </summary>\r\n  isTransactionOwner(): boolean {\r\n    let isTransOwner: boolean = false;\r\n\r\n    if (this.Transaction != null && this.Transaction.isOwner(this))\r\n      isTransOwner = true;\r\n\r\n    return isTransOwner;\r\n  }\r\n\r\n  isTransactionOnLevel(level: string): boolean {\r\n    return this.isTransactionOwner() && this.Transaction.getLevel() === level;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   get whether the task is the Program (i.e. not a subtask)\r\n  /// </summary>\r\n  isProgram(): boolean {\r\n    return this._isPrg;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   enable-disable actions for task modes\r\n  /// </summary>\r\n  async enableModes(): Promise<void> {\r\n    let enable: boolean = await this.checkProp(PropInterface.PROP_TYPE_ALLOW_MODIFY, true);\r\n    this.ActionManager.enable(InternalInterface.MG_ACT_RTO_MODIFY, enable);\r\n\r\n    enable = await this.checkProp(PropInterface.PROP_TYPE_ALLOW_CREATE, true);\r\n    this.ActionManager.enable(InternalInterface.MG_ACT_RTO_CREATE, enable);\r\n\r\n    enable = await this.checkProp(PropInterface.PROP_TYPE_ALLOW_QUERY, true);\r\n    this.ActionManager.enable(InternalInterface.MG_ACT_RTO_QUERY, enable);\r\n\r\n    enable = await this.checkProp(PropInterface.PROP_TYPE_ALLOW_RANGE, true);\r\n    this.ActionManager.enable(InternalInterface.MG_ACT_RTO_RANGE, enable);\r\n\r\n    enable = await this.checkProp(PropInterface.PROP_TYPE_ALLOW_LOCATE, true);\r\n    this.ActionManager.enable(InternalInterface.MG_ACT_RTO_LOCATE, enable);\r\n    this.ActionManager.enable(InternalInterface.MG_ACT_RTO_SEARCH, enable);\r\n\r\n    enable = await this.checkProp(PropInterface.PROP_TYPE_ALLOW_SORT, true);\r\n    this.ActionManager.enable(InternalInterface.MG_ACT_SORT_RECORDS, enable);\r\n\r\n    enable = await this.checkProp(PropInterface.PROP_TYPE_TASK_PROPERTIES_ALLOW_INDEX, true);\r\n    this.ActionManager.enable(InternalInterface.MG_ACT_VIEW_BY_KEY, enable);\r\n\r\n    this.ActionManager.enable(InternalInterface.MG_ACT_DUMP_ENVIRONMENT, true);\r\n  }\r\n\r\n  /// <summary>\r\n  ///   set hasZoomHandler to true\r\n  /// </summary>\r\n  setEnableZoomHandler(): void {\r\n    this._enableZoomHandler = true;\r\n  }\r\n\r\n\r\n  /// <returns> the hasZoomHandler\r\n  /// </returns>\r\n  getEnableZoomHandler(): boolean {\r\n    return this._enableZoomHandler;\r\n  }\r\n\r\n  /// <returns> is the task is a Destination Subform task</returns>\r\n  isDestinationSubform(): boolean {\r\n    return this._destinationSubform;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   set for Destination Subform task\r\n  /// </summary>\r\n  /// <param name = \"destinationSubform\"></param>\r\n  setDestinationSubform(destinationSubform: boolean): void {\r\n    this._destinationSubform = destinationSubform;\r\n  }\r\n\r\n  /// <returns> is the task is a Destination Subform task</returns>\r\n  getIsDestinationCall(): boolean {\r\n    return this._isDestinationCall;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   set for Destination Subform task\r\n  /// </summary>\r\n  /// <param name = \"isDestinationCall\"></param>\r\n  setIsDestinationCall(isDestinationCall: boolean): void {\r\n    this._isDestinationCall = isDestinationCall;\r\n  }\r\n\r\n\r\n  /// <param name = \"val\">\r\n  /// </param>\r\n  setCancelWasRaised(val: boolean): void {\r\n    this._cancelWasRaised = val;\r\n  }\r\n\r\n  /// <returns>\r\n  /// </returns>\r\n  cancelWasRaised(): boolean {\r\n    return this._cancelWasRaised;\r\n  }\r\n\r\n  enableCreateActs(val: boolean): void {\r\n    this.ActionManager.enable(InternalInterface.MG_ACT_CRELINE, val);\r\n\r\n    this.ActionManager.enable(InternalInterface.MG_ACT_CRELINE_ABOVE,  (this.getForm().HasTable() ) ? val : false);\r\n  }\r\n\r\n  /// <summary>\r\n  ///   sets enable/disable status of create and delete actions\r\n  /// </summary\r\n  async setCreateDeleteActsEnableState(): Promise<void> {\r\n    if (!(this.DataView).isEmptyDataview() && await this.checkProp(PropInterface.PROP_TYPE_ALLOW_DELETE, true) &&\r\n      this.getMode() === Constants.TASK_MODE_MODIFY && (<DataView>this.DataView).HasMainTable)\r\n      this.ActionManager.enable(InternalInterface.MG_ACT_DELLINE, true);\r\n    else\r\n      this.ActionManager.enable(InternalInterface.MG_ACT_DELLINE, false);\r\n\r\n    if ((await this.checkProp(PropInterface.PROP_TYPE_ALLOW_CREATE, true)) &&\r\n      ((<DataView>this.DataView).HasMainTable &&\r\n        (this.getMode() === Constants.TASK_MODE_MODIFY && Environment.Instance.allowCreateInModifyMode(this.getCompIdx())) ||\r\n        (this.getMode() === Constants.TASK_MODE_CREATE)))\r\n      this.enableCreateActs(true);\r\n    else\r\n      this.enableCreateActs(false);\r\n  }\r\n\r\n  /// <param name = \"emptyDataview\">the emptyDataview to set </param>\r\n  setEmptyDataview(emptyDataview: boolean): void {\r\n    this.DataView.setEmptyDataview(emptyDataview);\r\n  }\r\n\r\n  /// <returns> </returns>\r\n  getName(): string {\r\n    return this.Name;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   This function is executed when task starts its execution in Empty Dataview mode\r\n  /// </summary>\r\n  async emptyDataviewOpen(subformRefresh: boolean): Promise<void> {\r\n    // to prevent double prefix on the same record\r\n    if (this.getLevel() === Constants.TASK_LEVEL_TASK) {\r\n      this.ActionManager.enable(InternalInterface.MG_ACT_EMPTY_DATAVIEW, true);\r\n      // if the task is a subform and subform refresh is done, so execute the empty datatview handler,\r\n      // if the task is not a subform, put the empty dataview event on the queue\r\n      if (this.IsSubForm) {\r\n        let rtEvnt = AccessHelper.eventsManager.getLastRtEvent();\r\n        if ((rtEvnt != null && rtEvnt.getInternalCode() == InternalInterface.MG_ACT_RT_REFRESH_VIEW) || subformRefresh)\r\n        {\r\n          let rtEvt: RunTimeEvent = new RunTimeEvent(this);\r\n          rtEvt.setInternal(InternalInterface.MG_ACT_EMPTY_DATAVIEW);\r\n          rtEvt.SetEventSubType(EventSubType.Normal);\r\n          await AccessHelper.eventsManager.handleEvent(rtEvt, false);\r\n        }\r\n      }\r\n      else\r\n        AccessHelper.eventsManager.addInternalEventWithItaskAndCode(this, InternalInterface.MG_ACT_EMPTY_DATAVIEW);\r\n\r\n      this.setLevel(Constants.TASK_LEVEL_RECORD);\r\n\r\n      // for subform mode 'AsParent'. If the parent task that in 'Empty Dataview' state changes its mode\r\n      // the subform also must change mode.\r\n      // QCR #281862. If the subform task is opened in the first time do not refresh it's subforms,\r\n      // because they've received their dataviews already.\r\n      // We must refresh them when the subform task passes to empty DV.\r\n      if (this.SubformExecMode !== Task_SubformExecModeEnum.FIRST_TIME && subformRefresh && await this.CheckRefreshSubTasks()) {\r\n        await (<DataView>this.DataView).computeSubForms();\r\n        await this.doSubformRecPrefixSuffix();\r\n      }\r\n\r\n      await this.enableRecordActions();\r\n      this.ActionManager.enable(InternalInterface.MG_ACT_RT_REFRESH_RECORD, false);\r\n      this.ActionManager.enable(InternalInterface.MG_ACT_RT_REFRESH_SCREEN, false);\r\n    }\r\n  }\r\n\r\n  /// <summary>\r\n  ///   This function is executed when task ends its execution in Empty Dataview mode\r\n  /// </summary>\r\n  emptyDataviewClose(): void {\r\n    this.ActionManager.enable(InternalInterface.MG_ACT_EMPTY_DATAVIEW, false);\r\n    this.setLevel(Constants.TASK_LEVEL_TASK);\r\n\r\n    this.ActionManager.enable(InternalInterface.MG_ACT_RT_REFRESH_RECORD, true);\r\n    this.ActionManager.enable(InternalInterface.MG_ACT_RT_REFRESH_SCREEN, true);\r\n  }\r\n\r\n  /// <summary>\r\n  ///\r\n  /// </summary>\r\n  /// <param name=\"subformTask\"></param>\r\n  async SubformRefresh(subformTask: TaskBase, explicitSubformRefresh: boolean): Promise<void> {\r\n    let currTask: Task = LastFocusedManager.Instance.getLastFocusedTask();\r\n    let isInside: boolean = await (<Task>subformTask).ExecuteNestedRS(currTask);\r\n\r\n    if (AccessHelper.eventsManager.GetStopExecutionFlag())\r\n      return;\r\n\r\n    // QCR #434467. Execute RS of the current subform if it's the current (last focused) task.\r\n    if (subformTask.getLevel() !== Constants.TASK_LEVEL_TASK && !AccessHelper.eventsManager.GetStopExecutionFlag()) {\r\n      AccessHelper.eventsManager.pushNewExecStacks();\r\n      await AccessHelper.eventsManager.handleInternalEventWithTaskAndSubformRefresh(subformTask, InternalInterface.MG_ACT_REC_SUFFIX, true);\r\n      AccessHelper.eventsManager.popNewExecStacks();\r\n      isInside = true;\r\n\r\n      // Defect 77483. Do not continue if the record suffix execution is failed.\r\n      if (AccessHelper.eventsManager.GetStopExecutionFlag())\r\n        return;\r\n    }\r\n\r\n    // create command for the server\r\n    let cmd: IClientCommand = CommandFactory.CreateSubformRefreshCommand(this.getTaskTag(), subformTask.getTaskTag(), explicitSubformRefresh);\r\n    await subformTask.DataviewManager.Execute(cmd);\r\n    if (subformTask.isAborting())\r\n      return;\r\n\r\n    if (explicitSubformRefresh) {\r\n      // QCR #429112. Push execution stack before RP execution.\r\n      AccessHelper.eventsManager.pushNewExecStacks();\r\n\r\n      // Defect #77049. Do not execute parent RP. We need it only when click on subformwas done.\r\n      let performParentRecordPrefixOrg: boolean = (<Task>subformTask).PerformParentRecordPrefix;\r\n      (<Task>subformTask).PerformParentRecordPrefix = false;\r\n      await AccessHelper.eventsManager.handleInternalEventWithTaskAndSubformRefresh(subformTask, InternalInterface.MG_ACT_REC_PREFIX, true);\r\n      (<Task>subformTask).PerformParentRecordPrefix = performParentRecordPrefixOrg;\r\n      AccessHelper.eventsManager.popNewExecStacks();\r\n      if (AccessHelper.eventsManager.GetStopExecutionFlag())\r\n        return;\r\n    }\r\n\r\n    // if SubformRefresh event to itself so the cursor must be on the first control of the current record\r\n    // as for ViewRefresh event.\r\n    if (isInside) {\r\n      // Defect 115793. currTask can't be null.\r\n      // if (!AccessHelper.eventsManager.GetStopExecutionFlag() && !subformTask.getPreventControlChange() && currTask != null)\r\n      //   currTask.moveToFirstCtrl(false);\r\n      // TODO: Tabbing & Focusing: Handle this situation\r\n    }\r\n    else {\r\n      if (!AccessHelper.eventsManager.GetStopExecutionFlag()) {\r\n        if (explicitSubformRefresh) {\r\n          await AccessHelper.eventsManager.handleInternalEventWithTask(subformTask, InternalInterface.MG_ACT_REC_SUFFIX);\r\n          if (currTask != null)\r\n            (<DataView>currTask.DataView).setPrevCurrRec();\r\n          subformTask.DoSubformPrefixSuffix = false;\r\n        }\r\n      }\r\n    }\r\n  }\r\n\r\n  /// <summary>\r\n  /// Executes Record Suffixes of all nested subforms from bottom to top.\r\n  /// </summary>\r\n  /// <param name=\"subformTask\"></param>\r\n  /// <param name=\"currTask\"></param>\r\n  /// <returns></returns>\r\n  async ExecuteNestedRS(lastTask: Task): Promise<boolean> {\r\n    let isExecuteNestedRS: boolean = false;\r\n\r\n    // QCR #168342. A new task is set as focused task after the first CP.\r\n    // So if in CP Update operation is executed currTask is null. But we must refresh the subform.\r\n    if (lastTask == null)\r\n      return isExecuteNestedRS;\r\n\r\n    // Do not execute subform refresh when the focused task is not opened as a subform (it was opened from call operation),\r\n    // but the focused task is a child of the subform task. See for example QCR #431850.\r\n    if (this.getLevel() !== Constants.TASK_LEVEL_TASK && lastTask.getMgdID() !== this.getMgdID())\r\n      return isExecuteNestedRS;\r\n\r\n    for (let task: Task = lastTask; task !== this && task.pathContains(this) && task.getLevel() !== Constants.TASK_LEVEL_TASK; task = <Task>task.getParent()) {\r\n      AccessHelper.eventsManager.pushNewExecStacks();\r\n      await AccessHelper.eventsManager.handleInternalEventWithTask(task, InternalInterface.MG_ACT_REC_SUFFIX);\r\n      AccessHelper.eventsManager.popNewExecStacks();\r\n      isExecuteNestedRS = true;\r\n    }\r\n\r\n    return isExecuteNestedRS;\r\n  }\r\n\r\n\r\n  /// <summary>\r\n  ///   execute Rec suffix for all nested subforms untill subform task that contains these 2 subforms\r\n  /// </summary>\r\n  /// <param name = \"newTask\"></param>\r\n  /// <returns></returns>\r\n  async execSubformRecSuffix(newTask: Task): Promise<number> {\r\n    let subfTask: Task;\r\n    let i: number, idx = 0;\r\n    for (i = this._taskPath.length; i > 0; i--) {\r\n      subfTask = this._taskPath.get_Item(i - 1);\r\n      if (!newTask._taskPath.Contains(subfTask)) {\r\n        await AccessHelper.eventsManager.handleInternalEventWithTask(subfTask, InternalInterface.MG_ACT_REC_SUFFIX);\r\n        if (AccessHelper.eventsManager.GetStopExecutionFlag())\r\n          break;\r\n\r\n        // Change the Create mode to Modify if the current record is not a new record.\r\n        // So the mode is changed only for the first record that was not changed.\r\n        if (subfTask.getMode() === Constants.TASK_MODE_CREATE && !((<DataView>subfTask.DataView).getCurrRec()).isNewRec())\r\n          subfTask.setMode(Constants.TASK_MODE_MODIFY);\r\n      }\r\n      else {\r\n        idx = newTask._taskPath.indexOf(subfTask);\r\n        break;\r\n      }\r\n    }\r\n    Debug.Assert(i > 0);\r\n    return idx;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   get the counter of the task\r\n  /// </summary>\r\n  /// <returns>counter</returns>\r\n  getCounter(): number {\r\n    return this._counter;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   increase the tasks counter by 1.\r\n  /// </summary>\r\n  /// <returns>counter</returns>\r\n  increaseCounter(): void {\r\n    this._counter = this._counter + 1;\r\n  }\r\n\r\n  setCounter(cnt: number): void {\r\n    this._counter = cnt;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   !!\r\n  /// </summary>\r\n  /// <returns></returns>\r\n  isCurrentStartProgLevel(): boolean {\r\n    return this._currStartProgLevel === Task.StartProgLevel;\r\n  }\r\n\r\n\r\n  /// <summary>\r\n  ///   Check if reference to main program field\r\n  /// </summary>\r\n  /// <param name = \"fieldStr\">a reference to the field</param>\r\n  /// <returns></returns>\r\n  static isMainProgramField(fieldStr: string): boolean {\r\n    let Field: List<string> = XmlParser.getTokens(fieldStr, ',');\r\n    let mainProgField: boolean = false;\r\n\r\n    if (Field.length === 2) {\r\n      let parent: number = NNumber.Parse(Field.get_Item(0));\r\n      if (parent === TaskBase.MAIN_PRG_PARENT_ID)\r\n        mainProgField = true;\r\n    }\r\n\r\n    return mainProgField;\r\n  }\r\n\r\n  getTaskInfo(): string {\r\n    // Get the task name using the getProp() as name is only serialized for debug\r\n    let taskName: string = (this.getProp(PropInterface.PROP_TYPE_NAME)).GetComputedValue();\r\n    return NString.Format('{0} {1}',this.isProgram() ? 'Program': 'Subtask', taskName);\r\n  }\r\n\r\n  toString(): string {\r\n    return NString.Format(\"(task {0}-\\\"{1}\\\"{2})\", this._taskTag, this.Name, super.isMainProg() ? (\" ctl \" + this._ctlIdx) : \"\");\r\n  }\r\n\r\n\r\n  /// <summary>\r\n  ///\r\n  /// </summary>\r\n  /// <returns></returns>\r\n  ConstructMgForm(alreadySetParentForm: RefParam<boolean>): MgFormBase {\r\n    let form: MgForm = new MgForm();\r\n    let parentForm: MgFormBase = (this.ParentTask != null ? this.ParentTask.getForm() : null);\r\n\r\n    // ParentForm of any form should be a visible one. It might happen that the ParentTask\r\n    // is a non-interactive task with OpenWindow=No. In this case, the Parent of the non-interactive\r\n    // task, should be the parent of the current form.\r\n    while (parentForm != null && !parentForm.getTask().isOpenWin()) {\r\n      parentForm = parentForm.ParentForm;\r\n    }\r\n\r\n    form.ParentForm = parentForm;\r\n    alreadySetParentForm.value = true;\r\n    return form;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   returns the mgdata ID to which task belongs\r\n  /// </summary>\r\n  getMgdID(): number {\r\n    return this._mgData.GetId();\r\n  }\r\n\r\n  /// <summary>\r\n  ///   get reference to current MGData\r\n  /// </summary>\r\n  getMGData(): MGData {\r\n    return this._mgData;\r\n  }\r\n\r\n  /// <summary> refresh the display, paint the controls and their properties again </summary>\r\n  async RefreshDisplay(): Promise<void> {\r\n    if (this.Form !== null && !this.isAborting() && this.isStarted()) {\r\n      Logger.Instance.WriteDevToLog(\"Start task.RefreshDisplay()\");\r\n\r\n      // records from the DataView and refreshes the rows.\r\n      // Now, Task.RefreshDisplay() is called from 2 places:\r\n      // 1. while initing the form\r\n      // 2. when coming back from server\r\n      // In case #1, we do not need to refresh the table as it is done from firstTableRefresh().\r\n      // Check if this can be eliminated.\r\n      if (this._refreshType !== Constants.TASK_REFRESH_NONE) {\r\n        let form: MgForm = <MgForm>this.Form;\r\n        let wasRefreshed: boolean = await form.RefreshDisplay(Constants.TASK_REFRESH_FORM);\r\n        if (wasRefreshed) {\r\n          this._refreshType = Constants.TASK_REFRESH_NONE;\r\n        }\r\n      }\r\n      Logger.Instance.WriteDevToLog(\"End task.RefreshDisplay()\");\r\n    }\r\n  }\r\n\r\n  /// <summary> get the value of a field. </summary>\r\n  /// <param name=\"fieldDef\"></param>\r\n  /// <param name=\"value\"></param>\r\n  /// <param name=\"isNull\"></param>\r\n  // TODO sadhan remove unused\r\n  // async getFieldValue(fieldDef: FieldDef, value: RefParam<string>, isNull: RefParam<boolean>): Promise<void> {\r\n  //   value.value = await (<Field>fieldDef).getValue(false);\r\n  //   isNull.value = await (<Field>fieldDef).isNull();\r\n  // }\r\n\r\n  /// <summary> get the display value of a field. </summary>\r\n  /// <param name=\"fieldDef\"></param>\r\n  /// <param name=\"value\"></param>\r\n  /// <param name=\"isNull\"></param>\r\n  getFieldDisplayValue(fieldDef: FieldDef, value: RefParam<string>, isNull: RefParam<boolean>): void {\r\n    value.value = (<Field>fieldDef).getDispValue();\r\n    isNull.value = (<Field>fieldDef).isNull();\r\n  }\r\n\r\n  /// <summary> updates the field's value and starts recompute. </summary>\r\n  /// <param name=\"fieldDef\"></param>\r\n  /// <param name=\"value\"></param>\r\n  /// <param name=\"isNull\"></param>\r\n  async UpdateFieldValueAndStartRecompute(fieldDef: FieldDef, value: string, isNull: boolean): Promise<void> {\r\n    if (this.TaskPrefixExecuted) {\r\n      await (<Field>fieldDef).setValueAndStartRecompute(value, isNull, true, false, false);\r\n    }\r\n  }\r\n\r\n  /// <summary>\r\n  /// For a richclient tasks, check if Non-Interactive task child should be Modal.\r\n  /// </summary>\r\n  /// <returns>true</returns>\r\n  ShouldNonInteractiveChildBeModal(): boolean {\r\n    return this.ShouldChildBeModal();\r\n  }\r\n\r\n  /// <summary>\r\n  /// Check if a tasks child should be modal\r\n  ///\r\n  /// </summary>\r\n  /// <returns></returns>\r\n  private ShouldChildBeModal(): boolean {\r\n    let childShouldBehaveAsModal: boolean = false;\r\n\r\n    // window is opened and of modal type (doesn't matter if interactive or not)\r\n    if ((this.Form.ConcreteWindowType === WindowType.Overlay) && this.getForm().Opened)\r\n      childShouldBehaveAsModal = true;\r\n    else if (!this.IsInteractive) {\r\n        childShouldBehaveAsModal = true;\r\n    }\r\n    return childShouldBehaveAsModal;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   get the parent task of this task\r\n  /// </summary>\r\n  getParent(): TaskBase {\r\n    return this._parentTask;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   returns true if and only if this task is the checked task or a descendant of it\r\n  /// </summary>\r\n  isDescendentOf(chkTask: TaskBase): boolean {\r\n    if (chkTask === this)\r\n      return true;\r\n    else if (chkTask === null || this._parentTask === null)\r\n      return false;\r\n\r\n    return this._parentTask.isDescendentOf(chkTask);\r\n  }\r\n\r\n  /// <summary>\r\n  ///   returns subformCtrl which is Modal in current runtime tree if there is any?.\r\n  /// </summary>\r\n  public GetSubformModalParentTask(): MgControl {\r\n    let currTask: Task = this;\r\n    while (currTask._parentTask != null && currTask._parentTask.getIsDestinationCall()) {\r\n      let subformCtrl: MgControl = <MgControl>(currTask._parentTask.getForm().getSubFormCtrl());\r\n      if (subformCtrl.IsModal())\r\n      {\r\n        return subformCtrl;\r\n      }\r\n      currTask = currTask._parentTask;\r\n    }\r\n\r\n    return null;\r\n  }\r\n\r\n  /// <summary>\r\n  /// return true for remote task for expression that was computed once on server\r\n  /// </summary>\r\n  /// <returns></returns>\r\n  ShouldEvaluatePropertyLocally(propId: number): boolean {\r\n    return this.TaskService.ShouldEvaluatePropertyLocally(propId);\r\n  }\r\n\r\n  /// <summary>\r\n  /// This method runs actions after the 'form' tag is handled.\r\n  ///\r\n  /// </summary>\r\n  EnsureValidForm(): void {\r\n    // Default implementation of the method:\r\n    // If this task is the main program and _openWin evaluates to 'false', then\r\n    // prevent the display of the form, by setting it to 'null'.\r\n    if (this._isMainPrg && this.Form !== null) {\r\n      if (!this._openWin || !this.Form.isLegalForm) {   // This can be mdi frame\r\n        this.Form = null;\r\n      }\r\n    }\r\n  }\r\n\r\n  /// <summary>\r\n  /// compute the main display once\r\n  /// </summary>\r\n  /// <returns></returns>\r\n  async ComputeMainDisplay():Promise<void>  {\r\n    let propMainDisplay: Property = this.getProp(PropInterface.PROP_TYPE_MAIN_DISPLAY);\r\n    // get the value of main display\r\n    let mainDisplayIndex: number = await propMainDisplay.getValueInt();\r\n\r\n    mainDisplayIndex = this.GetRealMainDisplayIndexOnCurrentTask(mainDisplayIndex);\r\n\r\n    this._forms.InitFormFromXmlString(mainDisplayIndex);\r\n    this.EnsureValidForm();\r\n  }\r\n\r\n  /// <summary>\r\n  /// prepare task form\r\n  /// </summary>\r\n  async PrepareTaskForm(): Promise<ReturnResult> {\r\n    await TaskServiceBase.PreparePropOpenTaskWindow(this);\r\n    return await RemoteTaskService.PreparePropMainDisplay(this);\r\n  }\r\n\r\n  /// <summary>\r\n  /// return true if form is legal\r\n  /// we are not get to that method for main display that open window is false\r\n  /// </summary>\r\n  /// <returns></returns>\r\n  FormIsLegal(): boolean {\r\n    let isFormIsLegal: boolean = super.isMainProg();\r\n    return isFormIsLegal || super.getForm().isLegalForm;\r\n  }\r\n\r\n  /// <summary>\r\n  /// get the main display on studio depth\r\n  /// </summary>\r\n  /// <param name=\"mainDspIdx\"></param>\r\n  /// <returns></returns>\r\n  GetRealMainDisplayIndexOnDepth(mainDspIdx: number): number {\r\n    let task: Task = this.LogicalStudioParentTask;\r\n\r\n    while (task != null) {\r\n      mainDspIdx += task._forms.Count;\r\n      task = task.LogicalStudioParentTask;\r\n    }\r\n\r\n    return mainDspIdx;\r\n  }\r\n\r\n  /// <summary>\r\n  /// get the main display on studio depth\r\n  /// </summary>\r\n  /// <param name=\"mainDspIdx\"></param>\r\n  /// <returns></returns>\r\n  GetRealMainDisplayIndexOnCurrentTask(mainDspIdx: number): number {\r\n    if (mainDspIdx > 1) {\r\n\r\n      let task: Task = this.LogicalStudioParentTask;\r\n\r\n      while (task != null) {\r\n        mainDspIdx -= task._forms.Count;\r\n        task = task.LogicalStudioParentTask;\r\n      }\r\n    }\r\n\r\n    return mainDspIdx;\r\n  }\r\n\r\n  /// <summary>\r\n  /// get Ancestor task (on runtime tree) of the send task definition id\r\n  /// </summary>\r\n  /// <param name=\"findTaskDefinitionId\"></param>\r\n  /// <returns></returns>\r\n  GetAncestorTaskByTaskDefinitionId(findTaskDefinitionId: TaskDefinitionId): Task {\r\n    let currentTask: Task = this;\r\n\r\n    // Fixed bug #:172959\r\n    // if the findTaskDefinitionId is main program (can be of component) we will not found it in the _parentTask\r\n    // so we will take the task from the MGDataTable\r\n    if (findTaskDefinitionId.IsMainProgram())\r\n      return <Task>GuiDataCollection.MGDataTable.GetMainProgByCtlIdx(this.ContextID, findTaskDefinitionId.CtlIndex);\r\n\r\n    while (currentTask != null) {\r\n      if (currentTask.TaskDefinitionId.Equals(findTaskDefinitionId))\r\n        return currentTask;\r\n\r\n      currentTask = currentTask._parentTask;\r\n    }\r\n\r\n    return null;\r\n  }\r\n\r\n  SetDataControlValuesReference(controlId: number, dcValuesId: number): void {\r\n    let ctrl: MgControlBase = super.getForm().getCtrl(controlId);\r\n    ctrl.setDcValId(dcValuesId);\r\n  }\r\n\r\n  /// <summary>\r\n  /// display test on status bar\r\n  /// </summary>\r\n  /// <param name=\"task\"></param>\r\n  /// <param name=\"text\"></param>\r\n  DisplayMessageToStatusBar(text: string): void {\r\n    // Qcr #798311. if server side had MP doing verify to pane and MP has no form\r\n    // we will get an exception. so in case of no form, get it from last focused task.\r\n    let taskToVerifyOn: Task = <Task> this.GetContextTask();\r\n    if (taskToVerifyOn.getForm() == null)\r\n      taskToVerifyOn = LastFocusedManager.Instance.getLastFocusedTask();\r\n\r\n    taskToVerifyOn.WriteToMessagePane(text);\r\n  }\r\n\r\n\r\n  isTableWithAbsolutesScrollbar(): boolean {\r\n    let isTableWithAbsolutesScrollbar: boolean = false;\r\n\r\n    if (this.getForm() != null)\r\n      isTableWithAbsolutesScrollbar = (<MgForm>this.getForm()).isTableWithAbsoluteScrollbar();\r\n\r\n    return isTableWithAbsolutesScrollbar;\r\n  }\r\n\r\n  GetTaskDetails(): string {\r\n    let names =  (this.getProp(PropInterface.PROP_TYPE_NAME)).GetComputedValue();\r\n    let task: Task = this;\r\n    while (task.ParentTask !== null && !task.ParentTask.isMainProg()) {\r\n      task = <Task>task.ParentTask;\r\n      names =  (task.getProp(PropInterface.PROP_TYPE_NAME)).GetComputedValue() + \".\" + names;\r\n    }\r\n\r\n    return names;\r\n  }\r\n\r\n\r\n  /// <summary> parses the taskURL tag\r\n  /// every taskURL tag is replaced by the data of the xml island it refers to</summary>\r\n  static async ProcessTaskURL(): Promise<void> {\r\n    let xmlData: string = RuntimeContextBase.Instance.Parser.getXMLdata();\r\n    let endTaskUrlIdx: number = xmlData.indexOf(XMLConstants.TAG_CLOSE, RuntimeContextBase.Instance.Parser.getCurrIndex());\r\n    Debug.Assert(endTaskUrlIdx !== -1 && endTaskUrlIdx < xmlData.length);\r\n\r\n    // extract the task url and the ref list\r\n    let tag: string = RuntimeContextBase.Instance.Parser.getXMLsubstring(endTaskUrlIdx);\r\n    RuntimeContextBase.Instance.Parser.add2CurrIndex(tag.indexOf(ConstInterface.MG_TAG_TASKURL) + ConstInterface.MG_TAG_TASKURL.length);\r\n\r\n    let tokensVector: List<string> = XmlParser.getTokens(RuntimeContextBase.Instance.Parser.getXMLsubstring(endTaskUrlIdx), XMLConstants.XML_ATTR_DELIM);\r\n    let taskCacheURL: string = tokensVector.get_Item(1);\r\n    let refListStr: string = tokensVector.get_Item(3);\r\n\r\n    let taskContentOriginal: string = \"\"; // data of the task read from taskCacheURL\r\n\r\n    if(taskCacheURL.trim() != \"\") {\r\n      // bring the data\r\n\r\n      if(taskCacheURL.startsWith(\"./\"))\r\n       taskCacheURL= NString.Replace(taskCacheURL, './', ClientManager.GetAssetsURL() + '/cache/');\r\n\r\n      taskContentOriginal = await Task.CommandsProcessor.GetContent(taskCacheURL, true);\r\n    }\r\n\r\n    // prefix the original data till the start of the current <taskURL>\r\n    let taskContentFinal: StringBuilder = new StringBuilder(xmlData.substr(0, RuntimeContextBase.Instance.Parser.getCurrIndex() - (ConstInterface.MG_TAG_TASKURL.length + 1)), taskContentOriginal.length);\r\n    // the number of tokens in refList and the number of location in the xml to be replaced (i.e. the places with [:) should be equal\r\n    let reflist: List<string> = this.getReflist(refListStr, ';', true, -1);\r\n    let refListIdx = 0;\r\n\r\n    let currIdx: number = taskContentOriginal.indexOf(\"[:\");\r\n    let prevIdx: number = 0;\r\n    while (currIdx !== -1) {\r\n      taskContentFinal.Append(taskContentOriginal.substr(prevIdx, currIdx - prevIdx));\r\n      taskContentFinal.Append(reflist.get_Item(refListIdx++));\r\n      currIdx += 2;\r\n      prevIdx = currIdx;\r\n      currIdx = taskContentOriginal.indexOf(\"[:\", prevIdx);\r\n    }\r\n    taskContentFinal.Append(taskContentOriginal.substr(prevIdx));\r\n\r\n    // suffix the rest of the original xml from the end of the current </taskURL>\r\n    taskContentFinal.Append(xmlData.substr(xmlData.indexOf(XMLConstants.TAG_CLOSE, endTaskUrlIdx + 1) + 1));\r\n    xmlData = taskContentFinal.ToString();\r\n\r\n    Logger.Instance.WriteDevToLog(NString.Format(\"{0} -------> {1}\", taskCacheURL, xmlData));\r\n\r\n    RuntimeContextBase.Instance.Parser.setXMLdata(xmlData);\r\n    RuntimeContextBase.Instance.Parser.setCurrIndex(RuntimeContextBase.Instance.Parser.getCurrIndex() - (ConstInterface.MG_TAG_TASKURL.length + 1));\r\n  }\r\n\r\n  /// <summary> parses the data acording to the delimeter and the reflist delimeters logic</summary>\r\n  /// <param name=\"delim\"></param>\r\n  /// <param name=\"trunc\">if true trucate first '\\\\' (in use for island data parsing</param>\r\n  /// <param name=\"maxTokens\">if -1 all tokens avialable else the number of tokens to search</param>\r\n  /// <param name=\"data\"></param>\r\n  private static getReflist(data: string, delim: string, trunc: boolean, maxTokens: number): List<string> {\r\n    let currStr: StringBuilder = new StringBuilder();\r\n    let list: List<string> = new List<string>();\r\n    let tokensCnt: number = 0;\r\n\r\n    // since the first character is always ';' we start from 1\r\n    for (let i: number = 1; i < data.length; i++) {\r\n      let curr: string = data.charAt(i);\r\n\r\n      if (curr !== '\\\\' && curr !== delim)\r\n        currStr.Append(curr);\r\n      else if (curr === delim) {\r\n        list.push(currStr.ToString());\r\n        currStr = new StringBuilder();\r\n        tokensCnt++;\r\n\r\n        if (tokensCnt === maxTokens)\r\n          break;\r\n      }\r\n      else if (curr === '\\\\') {\r\n        // the format '\\\\delimiter' is always truncated\r\n        if (!trunc && data.charAt(i + 1) !== delim)\r\n          currStr.Append(data.charAt(i));\r\n\r\n        i++;\r\n        currStr.Append(data.charAt(i));\r\n      }\r\n    }\r\n\r\n    // append the last element in the ref list\r\n    list.push(currStr.ToString());\r\n\r\n    return list;\r\n  }\r\n\r\n  /// <summary>\r\n  /// start the execution of the program and set focus to the first control.\r\n  /// </summary>\r\n  static async StartProgram(callByDestSubForm: boolean, moveToFirstControl: boolean): Promise<Task> {\r\n    let orgStopExecution: boolean = AccessHelper.eventsManager.GetStopExecutionFlag();\r\n    let nonInteractiveTaskAlreadyExecuted: Task = null;\r\n    let allowEvents: EventsAllowedType = AccessHelper.eventsManager.getAllowEvents();\r\n    AccessHelper.eventsManager.setAllowEvents(EventsAllowedType.ALL);\r\n\r\n    Logger.Instance.WriteDevToLog(\"Start \\\"startProg\\\"\");\r\n    Task.StartProgLevel++;\r\n    AccessHelper.eventsManager.setStopExecution(false); // QCR #769734 - nothing can stop a task from starting up.\r\n\r\n    // Fixed bug #283647 execute components main programs -  in the server we execute the same see ini.cpp method execute_main_progs()\r\n    nonInteractiveTaskAlreadyExecuted = await this.ExecuteComponentMainPrograms(callByDestSubForm, moveToFirstControl);\r\n\r\n    // execute internal main programs\r\n    let nonInteractiveTaskAlreadyExecutedRef: RefParam<Task> = new RefParam(nonInteractiveTaskAlreadyExecuted);\r\n    let currentNonInteractiveTaskRef: RefParam<Task> = new RefParam(null);\r\n    await Task.ExecuteMainProgram(0, callByDestSubForm, moveToFirstControl, nonInteractiveTaskAlreadyExecutedRef, currentNonInteractiveTaskRef, AccessHelper.mgDataTable);\r\n    nonInteractiveTaskAlreadyExecuted = nonInteractiveTaskAlreadyExecutedRef.value;\r\n\r\n    if (!Task._idleTimerStarted) {\r\n      GUIManager.Instance.startTimer(AccessHelper.mgDataTable.getMGData(0), Environment.Instance.getIdleTime(0), true);\r\n      Task._idleTimerStarted = true;\r\n    }\r\n\r\n    await this.OpenForms(callByDestSubForm);\r\n    await this.DoFirstRecordCycle();\r\n    await this.MoveToFirstControls(callByDestSubForm);\r\n\r\n\r\n    // Handle the events only when all the tasks and their forms are opened.\r\n    if (Task.StartProgLevel === 1) {\r\n      let resetAllowEvents: boolean = false;\r\n      let canExecuteEvents: boolean = true;\r\n\r\n      // set the within non interactive since the handleEvents might try to execute an event\r\n      // that was raised in the 1st rec pref (added in moveToFirstcontrols).\r\n      if (nonInteractiveTaskAlreadyExecuted !== null && nonInteractiveTaskAlreadyExecuted.isStarted()) {\r\n        resetAllowEvents = true;\r\n        AccessHelper.eventsManager.setNonInteractiveAllowEvents(await nonInteractiveTaskAlreadyExecuted.isAllowEvents());\r\n\r\n        // non interactive task with allow events = NO is about to run.\r\n        // don't try to execute the events before it starts because they will be lost. (#138493)\r\n        canExecuteEvents = await  nonInteractiveTaskAlreadyExecuted.isAllowEvents();\r\n      }\r\n\r\n      // if the it is a subform with visibility expression evaluated to TRUE,\r\n      // so after return from the server do not execute events from the queue.\r\n      // These events will be executed from the 'startProg' of the parent task.\r\n      if (LastFocusedManager.Instance.getLastFocusedTask() !== null && canExecuteEvents) {\r\n        AccessHelper.eventsManager.pushNewExecStacks();\r\n        await AccessHelper.eventsManager.handleEvents(AccessHelper.mgDataTable.getCurrMGData(), 0);\r\n        AccessHelper.eventsManager.popNewExecStacks();\r\n      }\r\n\r\n      // restore. just to be on the safe side. it will be set again once in the correct eventsLoop.\r\n      if (resetAllowEvents)\r\n        AccessHelper.eventsManager.setAllowEvents(allowEvents);\r\n    }\r\n\r\n    Task.StartProgLevel--;\r\n\r\n    Logger.Instance.WriteDevToLog(\"End \\\"startProg\\\"\");\r\n\r\n    // If originally we were instructed to stop events execution, then restore this\r\n    if (orgStopExecution && !AccessHelper.eventsManager.GetStopExecutionFlag())\r\n      if (orgStopExecution && !AccessHelper.eventsManager.GetStopExecutionFlag())\r\n        AccessHelper.eventsManager.setStopExecution(orgStopExecution);\r\n\r\n    return nonInteractiveTaskAlreadyExecuted;\r\n  }\r\n\r\n\r\n  /// <summary>\r\n  /// execute component's main program\r\n  /// </summary>\r\n  /// <param name=\"callByDestSubForm\"></param>\r\n  /// <param name=\"moveToFirstControl\"></param>\r\n  /// <returns>the non interactive task if any that executed</returns>\r\n  static async ExecuteComponentMainPrograms(callByDestSubForm: boolean, moveToFirstControl: boolean): Promise<Task> { // go with StartProgram\r\n    let currentNonInteractiveTask: RefParam<Task> = new RefParam(null);\r\n    let nonInteractiveTaskAlreadyExecuted: RefParam<Task> = new RefParam(null);\r\n\r\n    let maxCtlIdx: number = AccessHelper.mgDataTable.getMGData(0).getMaxCtlIdx();\r\n\r\n    for (let i: number = 1; i <= maxCtlIdx; i = i + 1) {\r\n      let componentMainProgram: Task = <Task>AccessHelper.mgDataTable.GetMainProgByCtlIdx(-1, i);\r\n\r\n      if (componentMainProgram !== null)\r\n        await Task.ExecuteMainProgram(i, callByDestSubForm, moveToFirstControl, currentNonInteractiveTask, nonInteractiveTaskAlreadyExecuted, AccessHelper.mgDataTable);\r\n    }\r\n\r\n    return nonInteractiveTaskAlreadyExecuted.value;\r\n  }\r\n\r\n\r\n  /// <summary>\r\n  /// execute main program of CtlIndex\r\n  /// </summary>\r\n  /// <param name=\"CtlIndex\"></param>\r\n  /// <param name=\"callByDestSubForm\"></param>\r\n  /// <param name=\"moveToFirstControl\"></param>\r\n  /// <param name=\"currentNonInteractiveTask\"></param>\r\n  /// <param name=\"nonInteractiveTaskAlreadyExecuted\"></param>\r\n  private static async ExecuteMainProgram(CtlIndex: number, callByDestSubForm: boolean, moveToFirstControl: boolean, currentNonInteractiveTask: RefParam<Task>, nonInteractiveTaskAlreadyExecuted: RefParam<Task>, mgDataTable: IMGDataCollection): Promise<void> {\r\n    let mainProgramTask: Task = <Task>mgDataTable.GetMainProgByCtlIdx(-1, CtlIndex);\r\n\r\n    Logger.Instance.WriteDevToLog(NString.Format(\"  ClientManager.startProg: ctlIdx={0}, task={1}\", CtlIndex, mainProgramTask));\r\n\r\n    currentNonInteractiveTask.value =  <Task>(await mainProgramTask.Start(moveToFirstControl, callByDestSubForm));\r\n    if (nonInteractiveTaskAlreadyExecuted.value === null)\r\n      nonInteractiveTaskAlreadyExecuted.value = currentNonInteractiveTask.value;\r\n    else if (currentNonInteractiveTask.value !== null) {\r\n      Debug.Assert(false, \"more than 1 non interactive tasks in startProg\");\r\n    }\r\n  }\r\n\r\n  /// <summary> Open all the form that are pending in CreatedForms vector. </summary>\r\n  static async OpenForms(callByDestSubForm: boolean): Promise<void> {\r\n    let createdForms: CreatedFormVector = MgForm.CreatedForms;\r\n\r\n    if (createdForms.Count() > 0) {\r\n      let i: number = 0;\r\n      while (i < createdForms.Count()) {\r\n        let mgForm: MgForm = createdForms.get(i);\r\n        let canOpen: boolean = false;\r\n\r\n        // Open a subform only if its container form is Opened.\r\n        // isCurrentStartProgLevel() doesn't go well for subforms (QCR #919119).\r\n        if (mgForm.isSubForm()) {\r\n          let opened: boolean = (<MgFormBase>mgForm.getSubFormCtrl().getForm()).Opened;\r\n          if (opened) {\r\n            canOpen = true;\r\n          }\r\n        }\r\n        else {\r\n          if ((<Task>mgForm.getTask()).isCurrentStartProgLevel()) {\r\n            canOpen = true;\r\n          }\r\n        }\r\n\r\n        if (canOpen) {\r\n          Manager.OpenForm(mgForm);\r\n          await Manager.DoFirstRefreshTable(mgForm);\r\n        }\r\n\r\n        if (mgForm.Opened) {\r\n\r\n          createdForms.remove(mgForm);\r\n        }\r\n        else\r\n          i++;\r\n      }\r\n    }\r\n  }\r\n\r\n  /// <summary> Goes over forms is createdFormVec and performs move to first record cycle control</summary>\r\n  static async DoFirstRecordCycle(): Promise<void> {\r\n\r\n    for (let i: number = 0; i < AccessHelper.mgDataTable.getSize(); i++) {\r\n      let mgd: MGData = AccessHelper.mgDataTable.getMGData(i);\r\n      if (mgd === null || mgd.IsAborting)\r\n        continue;\r\n\r\n      for (let j: number = 0; j < mgd.getTasksCount(); j++) {\r\n        let task: Task = mgd.getTask(j);\r\n\r\n        if (task !== null) {\r\n          let mgForm: MgForm = <MgForm>task.getForm();\r\n\r\n          if (mgForm !== null && task.isCurrentStartProgLevel() && !mgForm.IgnoreFirstRecordCycle) {\r\n            mgForm.IgnoreFirstRecordCycle = true;\r\n            await task.doFirstRecordCycle();\r\n          }\r\n        }\r\n      }\r\n    }\r\n  }\r\n\r\n  /// <summary>\r\n  /// For every mgdata perform move to first control to the form\r\n  /// that we marked before with MoveToFirstControl flag\r\n  /// </summary>\r\n  private static async MoveToFirstControls(callByDestSubForm: boolean): Promise<void> {\r\n\r\n    for (let i: number = 0; i < AccessHelper.mgDataTable.getSize(); i++) {\r\n      let mgd: MGData = AccessHelper.mgDataTable.getMGData(i);\r\n\r\n      if (mgd === null || mgd.IsAborting)\r\n        continue;\r\n\r\n      let tasksCount: number = mgd.getTasksCount();\r\n      for (let j: number = 0; j < tasksCount; j++) {\r\n        let task: Task = mgd.getTask(j);\r\n        let mgForm: MgForm = <MgForm>task.getForm();\r\n\r\n        if (task.isCurrentStartProgLevel() && mgForm !== null && mgForm.MovedToFirstControl) {\r\n          mgForm.MovedToFirstControl = false;\r\n          AccessHelper.eventsManager.pushNewExecStacks();\r\n          await mgForm.moveToFirstParkabelControl(callByDestSubForm);\r\n          AccessHelper.eventsManager.popNewExecStacks();\r\n        }\r\n      }\r\n    }\r\n  }\r\n}\r\n\r\n\r\n\r\n"]}