VCATSample/vcat/main.js.map

{"version":3,"file":"main.js","mappings":"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","sources":["webpack://vcat/webpack/universalModuleDefinition","webpack://vcat/./i18n/error.csv","webpack://vcat/./i18n/message.csv","webpack://vcat/./i18n/ui.csv","webpack://vcat/./node_modules/moo/moo.js","webpack://vcat/./node_modules/@babel/runtime/helpers/regeneratorRuntime.js","webpack://vcat/./node_modules/@babel/runtime/helpers/typeof.js","webpack://vcat/./node_modules/@babel/runtime/regenerator/index.js","webpack://vcat/webpack/bootstrap","webpack://vcat/webpack/runtime/compat get default export","webpack://vcat/webpack/runtime/define property getters","webpack://vcat/webpack/runtime/hasOwnProperty shorthand","webpack://vcat/webpack/runtime/make namespace object","webpack://vcat/./node_modules/@babel/runtime/helpers/esm/asyncToGenerator.js","webpack://vcat/./node_modules/@babel/runtime/helpers/esm/classCallCheck.js","webpack://vcat/./node_modules/@babel/runtime/helpers/esm/typeof.js","webpack://vcat/./node_modules/@babel/runtime/helpers/esm/toPropertyKey.js","webpack://vcat/./node_modules/@babel/runtime/helpers/esm/toPrimitive.js","webpack://vcat/./node_modules/@babel/runtime/helpers/esm/createClass.js","webpack://vcat/./node_modules/@babel/runtime/helpers/esm/setPrototypeOf.js","webpack://vcat/./node_modules/@babel/runtime/helpers/esm/inherits.js","webpack://vcat/./node_modules/@babel/runtime/helpers/esm/assertThisInitialized.js","webpack://vcat/./node_modules/@babel/runtime/helpers/esm/possibleConstructorReturn.js","webpack://vcat/./node_modules/@babel/runtime/helpers/esm/getPrototypeOf.js","webpack://vcat/./node_modules/@babel/runtime/helpers/esm/arrayLikeToArray.js","webpack://vcat/./node_modules/@babel/runtime/helpers/esm/unsupportedIterableToArray.js","webpack://vcat/./node_modules/@babel/runtime/helpers/esm/slicedToArray.js","webpack://vcat/./node_modules/@babel/runtime/helpers/esm/arrayWithHoles.js","webpack://vcat/./node_modules/@babel/runtime/helpers/esm/iterableToArrayLimit.js","webpack://vcat/./node_modules/@babel/runtime/helpers/esm/nonIterableRest.js","webpack://vcat/./node_modules/@babel/runtime/helpers/esm/taggedTemplateLiteral.js","webpack://vcat/./grammar/helper.ts","webpack://vcat/./grammar/lexer.ts","webpack://vcat/./grammar/pt/ivprog.ts","webpack://vcat/./grammar/en/ivprog.ts","webpack://vcat/./grammar/index.ts","webpack://vcat/./node_modules/line-i18n/dist/LanguageService.js","webpack://vcat/./node_modules/line-i18n/dist/StringTypes.js","webpack://vcat/./node_modules/line-i18n/dist/LocalizedStrings.js","webpack://vcat/./node_modules/line-i18n/dist/index.js","webpack://vcat/./node_modules/line-i18n/dist/LanguageServiceNoLS.js","webpack://vcat/./node_modules/@babel/runtime/helpers/esm/defineProperty.js","webpack://vcat/./src/util/config.ts","webpack://vcat/./src/services/languageService.ts","webpack://vcat/./i18n/index.ts","webpack://vcat/./src/ast/commands/command.js","webpack://vcat/./src/ast/commands/break.js","webpack://vcat/./src/ast/commands/return.js","webpack://vcat/./src/ast/commands/assign.js","webpack://vcat/./src/ast/commands/arrayAssign.js","webpack://vcat/./src/ast/commands/declaration.js","webpack://vcat/./src/ast/commands/arrayDeclaration.js","webpack://vcat/./src/ast/commands/while.js","webpack://vcat/./src/ast/commands/for.js","webpack://vcat/./src/typeSystem/type.ts","webpack://vcat/./src/typeSystem/multiType.ts","webpack://vcat/./src/typeSystem/types.ts","webpack://vcat/./src/ast/commands/function.js","webpack://vcat/./src/ast/commands/ifThenElse.js","webpack://vcat/./src/ast/commands/commandBlock.js","webpack://vcat/./src/ast/commands/repeatUntil.js","webpack://vcat/./src/ast/commands/switch.js","webpack://vcat/./src/ast/commands/case.js","webpack://vcat/./src/ast/commands/sysCall.js","webpack://vcat/./src/ast/commands/formalParameter.js","webpack://vcat/./src/ast/expressions/expression.js","webpack://vcat/./src/ast/expressions/functionCall.js","webpack://vcat/./node_modules/decimal.js/decimal.mjs","webpack://vcat/./src/processor/modes.ts","webpack://vcat/./src/typeSystem/parsers.js","webpack://vcat/./node_modules/@babel/runtime/helpers/esm/isNativeReflectConstruct.js","webpack://vcat/./node_modules/@babel/runtime/helpers/esm/construct.js","webpack://vcat/./node_modules/@babel/runtime/helpers/esm/wrapNativeSuper.js","webpack://vcat/./node_modules/@babel/runtime/helpers/esm/isNativeFunction.js","webpack://vcat/./src/processor/error/runtimeError.js","webpack://vcat/./src/processor/error/semanticError.js","webpack://vcat/./src/processor/error/processorErrorFactory.js","webpack://vcat/./src/processor/store/value/store_value.ts","webpack://vcat/./src/typeSystem/array_type.ts","webpack://vcat/./src/ast/expressions/arrayAccess.js","webpack://vcat/./src/ast/expressions/literal.js","webpack://vcat/./src/ast/expressions/intLiteral.js","webpack://vcat/./src/ast/expressions/realLiteral.js","webpack://vcat/./src/ast/expressions/boolLiteral.js","webpack://vcat/./src/ast/expressions/charLiteral.js","webpack://vcat/./src/ast/expressions/stringLiteral.js","webpack://vcat/./src/ast/expressions/arrayLiteral.js","webpack://vcat/./src/ast/expressions/variableLiteral.js","webpack://vcat/./src/ast/expressions/infixApp.js","webpack://vcat/./src/ast/expressions/unaryApp.js","webpack://vcat/./src/ast/sourceInfo.js","webpack://vcat/./src/ast/operators.ts","webpack://vcat/./src/ast/error/syntaxError.js","webpack://vcat/./src/ast/error/syntaxErrorFactory.js","webpack://vcat/./src/ast/ivprogParser.js","webpack://vcat/./node_modules/@babel/runtime/helpers/esm/toConsumableArray.js","webpack://vcat/./node_modules/@babel/runtime/helpers/esm/arrayWithoutHoles.js","webpack://vcat/./node_modules/@babel/runtime/helpers/esm/iterableToArray.js","webpack://vcat/./node_modules/@babel/runtime/helpers/esm/nonIterableSpread.js","webpack://vcat/./src/processor/lib/math.js","webpack://vcat/./src/processor/definedFunctions.js","webpack://vcat/./src/processor/lib/io.js","webpack://vcat/./src/processor/lib/strings.js","webpack://vcat/./src/processor/lib/arrays.js","webpack://vcat/./src/processor/lib/lang.js","webpack://vcat/./src/services/localizedStringsService.js","webpack://vcat/./src/util/utils.js","webpack://vcat/./src/util/dataProcess.js","webpack://vcat/./src/util/parseFromVisual.js","webpack://vcat/./src/processor/compatibilityTable.ts","webpack://vcat/./src/memory/address.ts","webpack://vcat/./src/memory/location.ts","webpack://vcat/./src/processor/store/storeObject.ts","webpack://vcat/./src/processor/store/storeObjectRef.ts","webpack://vcat/./src/processor/store/value/store_value_address.ts","webpack://vcat/./src/processor/store/value/array_store_value.ts","webpack://vcat/./node_modules/@babel/runtime/helpers/esm/superPropBase.js","webpack://vcat/./node_modules/@babel/runtime/helpers/esm/get.js","webpack://vcat/./src/processor/store/storeObjectArray.ts","webpack://vcat/./src/processor/store/value/store_value_ref.ts","webpack://vcat/./src/processor/store/value/array_store_value_ref.ts","webpack://vcat/./src/processor/store/store_object_array_ref.ts","webpack://vcat/./src/processor/store/store.ts","webpack://vcat/./src/processor/semantic/semanticAnalyser.js","webpack://vcat/./src/processor/context.ts","webpack://vcat/./src/processor/ivprogProcessor.js","webpack://vcat/./src/util/inputTest.js","webpack://vcat/./src/io/input.js","webpack://vcat/./src/util/outputTest.js","webpack://vcat/./src/io/output.js","webpack://vcat/./src/util/auto_gen_output.js","webpack://vcat/./src/services/i18nHelper.js","webpack://vcat/./main.js"],"sourcesContent":["(function webpackUniversalModuleDefinition(root, factory) {\n\tif(typeof exports === 'object' && typeof module === 'object')\n\t\tmodule.exports = factory();\n\telse if(typeof define === 'function' && define.amd)\n\t\tdefine([], factory);\n\telse if(typeof exports === 'object')\n\t\texports[\"vcat\"] = factory();\n\telse\n\t\troot[\"vcat\"] = factory();\n})(this, () => {\nreturn ","module.exports = {\"pt\":{\"token_missing_one\":\"Erro de sintaxe: Espera-se $0, mas encontrou-se $1 na linha:$2, coluna:$3\",\"token_missing_two\":\"Erro de sintaxe: Esperava-se $0 ou $1 mas encontrou-se $2 na liha:$3, coluna: $4\",\"eos_missing\":\"Falta uma nova linha ou ; na linha: $0, coluna: $1\",\"invalid_type\":\"$0 na linha: $1, coluna: $2 é um tipo inválido. Os tipos válidos são: $3\",\"invalid_array_dimension\":\"A dimensão inválida na linha: $0, coluna: $1. Insira um $2 ou identificador válido do mesmo tipo.\",\"invalid_array_size\":\"O tamnho do vetor/matriz excede o máximo de 2 na linha $0\",\"extra_lines\":\"Nenhum texto é permitido após '}' em 'programa {...}'\",\"invalid_main_return\":\"A função $0 declarada na linha $2 deve retornar $1.\",\"invalid_var_declaration\":\"Erro na linha $0: variáveis só podem ser declaradas no corpo principal da função e nas primeiras linhas, antes de qualquer comando.\",\"invalid_break_command\":\"Erro na linha $0. O comando $1 não pode ser usado fora de uma estrutura de repetição ou 'escolha...caso'\",\"invalid_terminal\":\"Não é possível utilizar $0 na expressão da linha: $1, coluna: $2. Tente um valor númerico, variável ou chamada de função.\",\"const_not_init\":\"Erro na linha: $0, coluna: $1. Uma variável declarada como const deve ser inicializada\",\"id_missing\":\"Esperava-se um identificador, mas encontrou-se $0 na linha: $1, coluna: $2\",\"invalid_id_format\":\"$0 na linha: $1, coluna: $2 não é um identificador válido. O símbolo '.' não é permitido neste contexto.\",\"main_missing\":\"A função principal não foi encontrada\",\"invalid_global_var\":\"Erro crítico: Chamada inválida da função initGlobal fora do contexto BASE\",\"not_implemented\":\"Erro interno crítico: A função definida pelo sistema $0 não foi implementada.\",\"function_missing\":\"A função $0 não foi encontrada\",\"function_missing_full\":\"A função $0 na linha: $1, coluna: $2 não foi encontrada\",\"invalid_parameters_size_full\":\"Erro na linha $0: a quantidade de parâmetros fornecidos à função $1 está incorreta. Esperava-se $2, encontrou-se $3.\",\"invalid_parameters_size\":\"A quantidade de parâmetros fornecidos à função $0 está incorreta. Esperava-se $1, encontrou-se $2\",\"invalid_ref_full\":\"A expressão $0 fornecida como parâmetro para a função $1 na linha $2 não é válida para esta função. Use uma variável ou posição de vetor.\",\"invalid_ref\":\"A expressão $0 fornecida como parâmetro para a função $1 não é válida para esta função. Use uma variável ou posição de vetor.\",\"invalid_parameter_type_full\":\"A expressão $0 fornecida como parâmetro para a função $1 na linha $2 não é compatível com o tipo esperado.\",\"invalid_parameter_type\":\"A expressão $0 fornecida como parâmetro para a função $1 não é compatível com o tipo esperado.\",\"unknown_command_full\":\"Erro interno crítico: comando desconhecido encontrado na linha $0\",\"unknown_command\":\"Erro interno crítico: comando desconhecido encontrado!\",\"loop_condition_type_full\":\"Erro na linha: $0, coluna $1: a condição $2 do laço de repetição deve ser do tipo lógico\",\"loop_condition_type\":\"A condição $0 do laço de repetição deve ser do tipo lógico\",\"endless_loop_full\":\"Possível laço infinito detectado no seu código. Verifique a linha $0\",\"endless_loop\":\"Possível laço infinito detectado no seu código.\",\"for_condition_type_full\":\"Erro na linha: $0, coluna $1: a condição de parada $2 do comando para(...) deve ser do tipo lógico\",\"for_condition_type\":\"A condição de parada $0 do comando para(...) deve ser do tipo lógico\",\"if_condition_type_full\":\"Erro na linha: $0, coluna $1: a condição $2 do comando se...senao deve ser do tipo lógico\",\"if_condition_type\":\"A condição $0 do comando se...senao deve ser do tipo lógico\",\"invalid_return_type_full\":\"Erro na linha $0: a expressão não produz um tipo compatível com a função $1. Tipo esperado: $2.\",\"invalid_return_type\":\"A expressão não produz um tipo compatível com a função $0. Tipo esperado: $1.\",\"invalid_void_return_full\":\"Erro na linha $0: a função $1 não pode retornar uma expressão vazia, use uma espressão do tipo $2\",\"invalid_void_return\":\"A função $0 não pode retornar uma expressão vazia, use uma espressão do tipo $1\",\"unexpected_break_command_full\":\"Erro interno crítico: comando pare encontrado fora do contexto de um laço/escolha..caso na linha $0\",\"unexpected_break_command\":\"Erro interno crítico: comando pare encontrado fora do contexto de um laço/escolha..caso\",\"invalid_dimension\":\"As dimensões de um vetor/matriz devem ser do tipo inteiro\",\"void_in_expression_full\":\"Erro na linha: $0, coluna: $1: a função $2 não pode ser utilizada em uma expressão pois seu tipo de retorno é vazio\",\"void_in_expression\":\"A função $0 não pode ser utilizada em uma expressão pois seu tipo de retorno é vazio\",\"invalid_array_access_full\":\"Identificador $0 na linha: $1, coluna: $2 não se refere a um vetor/matriz válido\",\"invalid_array_access\":\"Identificador $0 não se refere a um vetor/matriz válido\",\"invalid_matrix_access_full\":\"Identificador $0 na linha: $1, coluna: $2 não se refere a uma matriz válida\",\"invalid_matrix_access\":\"Identificador $0 não se refere a uma matriz válida\",\"matrix_column_outbounds_full\":\"Erro na linha $0: número de colunas $1 é inválido para a matriz $2 que possui $3 colunas\",\"matrix_column_outbounds\":\"Número de colunas $0 é inválido para a matriz $1 que possui $2 colunas\",\"matrix_line_outbounds_full\":\"Erro na linha $0: número de linhas $1 é inválido para a matriz $2 que possui $3 linhas\",\"matrix_line_outbounds\":\"Número de linhas $0 é inválido para a matriz $1 que possui $2 linhas\",\"vector_line_outbounds_full\":\"Erro na linha $0: O número de elementos $1 é inválido para a vetor $2 que possui $3 elementos.\",\"vector_line_outbounds\":\"O número de elementos $1 é inválido para a vetor $2 que possui $3 elementos.\",\"vector_not_matrix_full\":\"Erro na linha $0: $1 não é uma matriz\",\"vector_not_matrix\":\"$0 não é uma matriz\",\"invalid_infix_op_full\":\"Erro na linha $0: a expressão $1 é inválida, pois o operador $2 não pode ser aplicado aos tipos $3 e $4\",\"invalid_infix_op\":\"A expressão $0 é inválida, pois o operador $1 não pode ser aplicado aos tipos $2 e $3\",\"invalid_unary_op_full\":\"Erro na linha $0: a expressão $1 é inválida, pois o operador $2 não pode ser aplicado ao tipo $3\",\"invalid_unary_op\":\"A expressão $0 é inválida, pois o operador $1 não pode ser aplicado ao tipo $2\",\"unknown_op\":\"Erro interno crítico: Operação $0 desconhecida\",\"duplicate_function\":\"A função $0 na linha: $1, coluna: $2 já foi definida anteriormente.\",\"duplicate_variable\":\"A variável $0 na linha: $1, coluna: $2 já foi declarada anteriormente.\",\"main_parameters\":\"A função inicio não pode ter parâmetros.\",\"symbol_not_found_full\":\"A variável $0 na linha: $1, coluna: $2 não foi declarada\",\"symbol_not_found\":\"A variável $0 não foi declarada\",\"array_dimension_not_int_full\":\"As dimensões do arranjo (vetor ou matriz) na linha $0 devem ser do tipo inteiro.\",\"array_dimension_not_int\":\"As dimensões de um arranjo (vetor ou matriz) devem ser do tipo inteiro.\",\"array_dimension_not_positive_full\":\"As dimensões do arranjo (vetor ou matriz) na linha $0 devem ser valores positivos.\",\"array_dimension_not_positive\":\"As dimensões de um arranjo (vetor ou matriz) devem ser valores positivos.\",\"incompatible_types_full\":\"Era esperado um $0 mas a expressão $1 na linha $2 resulta em $3.\",\"incompatible_types\":\"Era esperado um $0 mas a expressão $1 resulta em $2.\",\"incompatible_types_array_full\":\"A expressão $0 na linha $2 é incompatível com o tipo $1.\",\"incompatible_types_array\":\"A expressão $0 é incompatível com o tipo $1.\",\"invalid_case_type_full\":\"O caso $0 na linha $1 é incompatível com o tipo $2.\",\"invalid_case_type\":\"O caso $0 é incompatível com o tipo $1.\",\"function_no_return\":\"A função $0 não possui um comando de devolução acessível. Toda função deve ter ao menos um comando 'devolva' no seu corpo principal.\",\"invalid_array_literal_type_full\":\"Erro na linha $0: a expressão $1 não resulta em um tipo compatível.\",\"invalid_array_literal_type\":\"A expressão $0 não resulta em um tipo compatível.\",\"invalid_array_literal_line_full\":\"Erro na linha $0: esperava-se $1 linhas mas encontrou $2.\",\"invalid_array_literal_line\":\"Esperava-se $0 linhas mas encontrou $1.\",\"invalid_array_literal_column_full\":\"Erro na linha $0: esperava-se $1 colunas mas encontrou $2.\",\"invalid_array_literal_column\":\"Esperava-se $0 colunas mas encontrou $1.\",\"exceeded_input_request\":\"A quantidade de leituras requisitadas execedeu a quantidade de entradas disponíveis.\",\"test_case_few_reads\":\"Caso de teste $0 falhou: ainda restam entradas!\",\"test_case_failed\":\"<div class='assessment-div-detail' onClick='ivprogCore.openAssessmentDetail(event)' data-page=\\\"$1\\\"> <span>Caso de teste $0 não executou com sucesso.</span></div>\",\"test_case_failed_exception\":\"<div class='assessment-div-detail' onClick='ivprogCore.openAssessmentDetail(event)' data-page=\\\"$2\\\"> <span>Caso de teste $0 falhou</span>: $1\",\"test_case_exception\":\"Ocorreu uma exceção no caso de teste $0: $1\",\"invalid_type_conversion\":\"O valor $0 não pode ser convertido para o tipo $1\",\"invalid_read_type\":\"Erro na linha $0: A entrada \\\"$1\\\" não é do tipo $2, que é o tipo da variável <span class='ivprog-error-varname'>$3</span>.\",\"invalid_read_type_array\":\"Erro na linha $0: A entrada \\\"$1\\\" não é do tipo $2, que é o tipo aceito pela variável <span class='ivprog-error-varname'>$3</span> que é um $4.\",\"inform_valid_identifier\":\"Informe um nome válido! O nome não pode ser uma palavra reservadas e deve começar com letras ou _ e conter apenas letras, números e _.\",\"inform_valid_global_duplicated\":\"Já existe uma variável global com o nome <span class='ivprog-error-varname'>$0</span>, você precisa de nomes distintos.\",\"inform_valid_variable_duplicated\":\"Já existe uma variável com o nome <span class='ivprog-error-varname'>$0</span> na função <span class='ivprog-error-varname'>$1</span>, você precisa de nomes distintos.\",\"inform_valid_function_duplicated\":\"Já existe uma função com o nome <span class='ivprog-error-varname'>$0</span>, você precisa de nomes distintos.\",\"inform_valid_param_duplicated\":\"Já existe um parâmetro com o nome <span class='ivprog-error-varname'>$0</span> na função <span class='ivprog-error-varname'>$1</span>, você precisa de nomes distintos.\",\"invalid_character\":\"O caractere $0 na linha $1 não pode ser utilizado neste contexto.\",\"invalid_syntax\":\"O iVProg não reconhece o texto $0 na linha $1. Certifique-se que não há erro de digitação ou caractere inválido.\",\"annonymous_array_literal\":\"Erro na linha $0: a notação de vetor/matriz só permitida durante a inicialização de uma variável desse tipo. Ex: inteiro vec[3] ← {1,2,3}.\",\"invalid_matrix_literal_line\":\"A expressão $0 na linha $1 não possui um número de elementos igual a linha anterior. Todas as linhas de uma matriz devem ter a mesma quantidade de elementos.\",\"cannot_infer_matrix_line\":\"Não é possível inferir o número de linhas da matriz $0 na linha $1. É necessário que ela seja inicializada ou que o valor seja informado de forma explícita.\",\"cannot_infer_matrix_column\":\"Não é possível inferir o número de colunas da matriz $0 na linha $1. É necessário que ela seja inicializada ou que o valor seja informado de forma explícita.\",\"cannot_infer_vector_size\":\"Não é possível inferir o número de elementos do vetor $0 na linha $1. É necessário que ele seja inicializado ou que o valor seja informado de forma explícita\",\"matrix_to_vector_literal_attr\":\"Erro na linha $0: A expressão $1 representa uma matriz e não pode ser atribuída ao vetor $2.\",\"vector_to_matrix_literal_attr\":\"Erro na linha $0: A expressão $1 representa um vetor e não pode ser atribuído a matriz $2.\",\"invalid_const_ref_full\":\"A variável $0 fornecida como parâmetro para a função $1 na linha $2 é uma constante e não pode ser usada neste contexto. Use uma variável ou posição de vetor.\",\"invalid_const_ref\":\"A variável $0 fornecida como parâmetro para a função $1 é uma constante e não pode ser usada neste contexto. Use uma variável ou posição de vetor.\",\"invalid_const_assignment_full\":\"Erro na linha $0: $1 é uma constante e portanto não pode ter seu valor alterado\",\"invalid_const_assignment\":\"$0 é uma constante e portanto não pode ter seu valor alterado\",\"array_init_not_literal\":\"Erro na linha $0: Vetor/Matriz só pode ser inicializado por literal. Ex: real vetor[] <- {1,2,3}\",\"array_exceeds_2d\":\"Erro na linha $0: O número máximo de dimensões que um arranjo pode ter é 2. Elemento de 3 ou mais dimensões encontrado!\",\"invalid_matrix_id_dimension\":\"Erro na linha $0: Você deve definir todas as dimensões da matriz quando uma delas é definida por uma variável! Ex: real mat1[var][5], mat2[5][var]\",\"invalid_vector_init\":\"Erro na linha $0: Não se pode inicializar um vetor que teve seu tamanho declarado utilizando uma variável! Utilize uma atribuição de vetores ou use um laço de repetição.\",\"invalid_matrix_init\":\"Erro na linha $0: Não se pode inicializar uma matrix que teve ao menos uma das suas dimensões declaradas utilizando uma variável! Utilize uma atribuição de matrizes ou use um laço de repetição.\",\"invalid_vector_assignment_full\":\"Erro na linha $0: Só se pode atribuir um vetor a outro desde que eles comportem o mesmo número de elementos. $1 comporta $2 e $3 comporta $4!\",\"invalid_vector_assignment\":\"Só se pode atribuir um vetor a outro desde que eles comportem o mesmo número de elementos. $0 comporta $1 e $2 comporta $3!\",\"invalid_matrix_assignment_full\":\"Erro na linha $0: Só se pode atribuir uma matriz a outra desde que ambas possuam dimensões de mesmo tamanho. $1 tem $2 linhas e $3 colunas, enquanto $4 possui $5 linhas e $6 colunas!\",\"invalid_matrix_assignment\":\"Só se pode atribuir uma matriz a outra desde que ambas possuam dimensões de mesmo tamanho. $0 tem $1 linhas e $2 colunas, enquanto $3 possui $4 linhas e $5 colunas!\",\"matrix_to_vector_attr\":\"Erro na linha $0: $1 representa uma matriz e não pode ser atribuída ao vetor $2.\",\"vector_to_matrix_attr\":\"Erro na linha $0: $1 representa um vetor e não pode ser atribuído a matriz $2.\",\"invalid_matrix_index_assign_full\":\"Erro na linha $0: A posição $1 da matriz $2 aceita apenas vetores de tamanho $3, mas $4 tem tamanho $5\",\"invalid_matrix_index_assign\":\"A linha $0 da matriz $1 aceita apenas vetores de tamanho $2, mas $3 tem tamanho $4\",\"invalid_number_elements_vector\":\"Esperava-se por $0 elementos na linha $1 mas a expressão $2 possui $3 elementos.\",\"invalid_number_lines_matrix\":\"Esperava-se por uma matriz com $0 linhas na linha $1 mas a expressão $2 possui $3 linhas\",\"divsion_by_zero_full\":\"Erro na linha $0: A expressão $1 resulta em uma divisão por 0.\",\"divsion_by_zero\":\"A expressão $0 resulta em uma divisão por 0.\",\"undefined_tanget_value\":\"Erro na linha $0: A tangente de $1° não é indefinida.\",\"negative_log_value\":\"Erro na linha $0: Não se pode calcular o log de um valor negativo.\",\"invalid_string_index\":\"Erro na linha $0 durante a execução da função $1: $2 é um índice inválido para a cadeia de texto $3. Os valores válidos vão de 0 à $4\",\"negative_sqrt_value\":\"Erro na linha $0: Não é permitido calcular a raiz quadrada de um número negativo.\",\"exceeded_recursive_calls\":\"Erro na execução da linha $0: Número de chamadas recursivas execedeu o limite máximo definido!\",\"invalid_for_variable\":\"Erro na linha $0: A variavel $1 utilizada no comando repita_para deve ser do tipo inteiro.\",\"invalid_for_from\":\"Erro na linha $0: O valor $1 passado para o parâmetro 'de' do comando repita_para deve ser do tipo inteiro.\",\"invalid_for_to\":\"Erro na linha $0: O valor $1 passado para o parâmetro 'para' do comando repita_para deve ser do tipo inteiro.\",\"invalid_for_pass\":\"Erro na linha $0: O valor $1 passado para o parâmetro 'passo' do comando repita_para deve ser do tipo inteiro.\",\"exceed_max_instructions\":\"Número de instruções excedeu o limite definido. Certifique-se que seu código não possui laços infinitos ou muitas chamadas de funções recursivas.\"},\"en\":{\"token_missing_one\":\"Syntax error: Expected $0 but found $1 at line:$2, column:$3\",\"token_missing_two\":\"Syntax error: Expected $0 or $1 but found $2 at line:$3, column: $4\",\"eos_missing\":\"A new line or a ‘;’ is missing at line: $0, column: $1\",\"invalid_type\":\"$0 at line: $1, column: $2 is a invalid type. The valid types are: $3\",\"invalid_array_dimension\":\"Invalid dimension at line: $0, column: $1. Insert a $2 or a valid identifier of the same type.\",\"invalid_array_size\":\"The array at line $0 exceeds the maximum size of 2.\",\"extra_lines\":\"No text is allowed after '}' in 'program { … }'\",\"invalid_main_return\":\"The function $0 declared at line $2 must return $1.\",\"invalid_var_declaration\":\"Error at line $0: Variables can only be declared in the main body of a function and at the first lines, before any command.\",\"invalid_break_command\":\"Error at line $0. The command $1 cannot be used outside a loop command or ‘switch ...case’ structure.\",\"invalid_terminal\":\"It is not possible to use $0 in the expression at line: $1, column: $2. Try a numeric value, variable or function call.\",\"const_not_init\":\"Error at line: $0, column: $1. A variable declared as const must be initialized.\",\"id_missing\":\"Expected an identifier but found $0 at line: $1, column: $2.\",\"invalid_id_format\":\"$0 at line: $1, column: $2 is not a valid identifier. The symbol '.' is not permitted in this context.\",\"main_missing\":\"The main function was not found. You need to declare a function of return type void named main.\",\"invalid_global_var\":\"Critical Error: Invalid call of the function IVProgProcessor.initGlobal outside the BASE context.\",\"not_implemented\":\"Critial internal error: The system defined function $0 was not found.\",\"function_missing\":\"The function $0 was not found.\",\"function_missing_full\":\"The function $0 at line: $1, column: $2 was not found.\",\"invalid_parameters_size_full\":\"Error at line $0: The number of parameters provided to the function $1 is incorrect. It expected $2 but found $3.\",\"invalid_parameters_size\":\"The number of parameters provided to the function $0 is incorrect. It expected $1 but found $2.\",\"invalid_ref_full\":\"The expression $0 provided as a parameter to the function $1 at line $2 is not valid in this context. Use a variable or a position of a vector.\",\"invalid_ref\":\"The expression $0 provided as a parameter to the function $1 is not valid in this context. Use a variable or a position of a vector.\",\"invalid_parameter_type_full\":\"The expression $0 provided as a parameter to the function $1 at line $2 is not of the expected type.\",\"invalid_parameter_type\":\"The expression $0 provided as a parameter to the function $1 is not of the expected type.\",\"unknown_command_full\":\"Internal error: an unknown command found at line $0.\",\"unknown_command\":\"Internal error: an unknown command found.\",\"loop_condition_type_full\":\"Error at line: $0, column $1: the condition $2 of the loop must be of type bool (true or false).\",\"loop_condition_type\":\"The condition $0 of the loop must be of type bool (true or false).\",\"endless_loop_full\":\"Possible infinite loop detected in your code. Check line $0.\",\"endless_loop\":\"Possible infinite loop detected in your code.\",\"for_condition_type_full\":\"Erro na linha: $0, coluna $1: a condição de parada $2 do comando para(...) deve ser do tipo lógico\",\"for_condition_type\":\"A condição de parada $0 do comando para(...) deve ser do tipo lógico\",\"if_condition_type_full\":\"Error at line: $0, column $1: the condition $2 in the if … else command must result in a bool (true or false).\",\"if_condition_type\":\"The condition $0 in the if … else command must result in a bool (true or false).\",\"invalid_return_type_full\":\"Error at line $0: The expression doest not result in a type compatible with the function $1.  Expected type: $2.\",\"invalid_return_type\":\"The expression doest not result in a type compatible with the function $0.  Expected type: $1.\",\"invalid_void_return_full\":\"Error at line $0: The function $1 cannot return an empty expression, use an expression that results in a $2\",\"invalid_void_return\":\"The function $0 cannot return an empty expression, use an expression that results in a $1\",\"unexpected_break_command_full\":\"Critical error at line $0:  a break command was found outside a valid context: loop or switch … case structure.\",\"unexpected_break_command\":\"Critical error:  a break command was found outside a valid context: loop or switch … case structure.\",\"invalid_dimension\":\"Array (vector or matrix) dimensions must be of type int.\",\"void_in_expression_full\":\"Error at line: $0, column: $1: The function $2 cannot be used inside an expression since its return type is void.\",\"void_in_expression\":\"The function $0 cannot be used inside an expression since its return type is void.\",\"invalid_array_access_full\":\"Identifier $0 at line: $1, column: $2 does not identify a valid vector or matrix.\",\"invalid_array_access\":\"Identifier $0 does not identify a valid vector or matrix.\",\"invalid_matrix_access_full\":\"Identifier $0 at line: $1, column: $2 does not identify a valid matrix.\",\"invalid_matrix_access\":\"Identifier $0 does not identify a valid matrix.\",\"matrix_column_outbounds_full\":\"Error at line $0: The number of columns $1 is invalid for the matrix $2 which has $3 columns.\",\"matrix_column_outbounds\":\"The number of columns $0 is invalid for the matrix $1 which has $2 columns.\",\"matrix_line_outbounds_full\":\"Error at line $0: The number of lines $1 is invalid for matrix $2 which has $3 lines.\",\"matrix_line_outbounds\":\"The number of lines $0 is invalid for matrix $1 which has $2 lines.\",\"vector_line_outbounds_full\":\"Error at line $0: The number of elements $1 is invalid for vector $2 which has $3 elements.\",\"vector_line_outbounds\":\"Error at line $0: The number of elements $1 is invalid for vector $2 which has $3 elements.\",\"vector_not_matrix_full\":\"Error at line $0: $1 is not a matrix.\",\"vector_not_matrix\":\"$0 is not a matrix.\",\"invalid_infix_op_full\":\"Error at line $0:  The expression $1 is not valid because the operator $2 cannot be applied to the types $3 and $4.\",\"invalid_infix_op\":\"The expression $0 is not valid because the operator $1 cannot be applied to the types $2 and $3.\",\"invalid_unary_op_full\":\"Error at line $0:  The expression $1 is not valid because the operator $2 cannot be applied to the type $3.\",\"invalid_unary_op\":\"The expression $0 is not valid because the operator $1 cannot be applied to the type $2.\",\"unknown_op\":\"Critical error: Unknown operator $0.\",\"duplicate_function\":\"The function $0 at line: $1, column: $2 has already been declared.\",\"duplicate_variable\":\"The variable $0 at line: $1, column: $2 has already been declared.\",\"main_parameters\":\"The main function cannot have parameters.\",\"symbol_not_found_full\":\"The variable $0 at line: $1, column: $2 has not been declared.\",\"symbol_not_found\":\"The variable $0 has not been declared.\",\"array_dimension_not_int_full\":\"The array (vector or matrix) dimensions at line $0 must be of type int.\",\"array_dimension_not_int\":\"An array (vector or matrix) dimensions must be of type int.\",\"array_dimension_not_positive_full\":\"The array (vector or matrix) dimensions at line $0 must be positive.\",\"array_dimension_not_positive\":\"An array (vector or matrix) dimensions must be positive.\",\"incompatible_types_full\":\"It expected $0 but the expression $1 at line $2 results in $3.\",\"incompatible_types\":\"It expected $0 but the expression $1 results in $2.\",\"incompatible_types_array_full\":\"The expression $0 at line $2 is not compatible with type $1.\",\"incompatible_types_array\":\"The expression $0 is not compatible with type $1.\",\"invalid_case_type_full\":\"The case expression $0 at line $1 is not compatible with type $2.\",\"invalid_case_type\":\"The case expression $0 is not compatible with type $1.\",\"function_no_return\":\"The function $0 does not have a reacheable return command. Every function must have at least one return command in its main body.\",\"invalid_array_literal_type_full\":\"Error at line $0: the expression $1 does not result in a compatible type.\",\"invalid_array_literal_type\":\"The expression $0 does not result in a compatible type.\",\"invalid_array_literal_line_full\":\"Error at line $0: it expected $1 lines but found $2.\",\"invalid_array_literal_line\":\"It expected $0 lines but found $1.\",\"invalid_array_literal_column_full\":\"Error at line $0: it expected $1 column but found $2.\",\"invalid_array_literal_column\":\"It expected $0 column but found $1.\",\"exceeded_input_request\":\"The amount of reads requested exceeded the amount of inputs available.\",\"test_case_few_reads\":\"Teste case $0 failed: there are available inputs remaining.\",\"test_case_failed\":\"<div class='assessment-div-detail' onClick='ivprogCore.openAssessmentDetail(event)' data-page=\\\"$1\\\"> <span>Test case $0 did not executed successfully.</span></div>\",\"test_case_failed_exception\":\"<div class='assessment-div-detail' onClick='ivprogCore.openAssessmentDetail(event)' data-page=\\\"$2\\\"> <span>Test case $0 failed</span>: $1\",\"test_case_exception\":\"An exception has ocurred during the execution of test case $0: $1\",\"invalid_type_conversion\":\"The value $0 cannot be converted to type $1.\",\"invalid_read_type\":\"Error at line $0: The input \\\"$1\\\" is not of type $2 which is the type of the variable <span class='ivprog-error-varname'>$3</span>.\",\"invalid_read_type_array\":\"Error at line $0: The input \\\"$1\\\" is not of type $2 which is the type  accepted by the variable <span class='ivprog-error-varname'>$3</span> of type $4.\",\"inform_valid_identifier\":\"Enter a valid identifier! The identifier cannot be a reserved word and it must begin with a letter or _, followed by numbers, letters and _ only.\",\"inform_valid_global_duplicated\":\"A global variable named <span class='ivprog-error-varname'>$0</span> already exists, you need distinct names for each gloval variable.\",\"inform_valid_variable_duplicated\":\"A variable named <span class='ivprog-error-varname'>$0</span> already exists, you need distinct names for each variable.\",\"inform_valid_function_duplicated\":\"A function named <span class='ivprog-error-varname'>$0</span> already exists, you need distinct names for each function.\",\"inform_valid_param_duplicated\":\"A parameter named <span class='ivprog-error-varname'>$0</span> already exists in function <span class='ivprog-error-varname'>$1</span>, you need distinc names for each parameter.\",\"invalid_character\":\"The character $0 at line $1 cannot be used in this context.\",\"invalid_syntax\":\"iVProg does not recognize the text $0 at line $1. Check for typos or invalid character.\",\"annonymous_array_literal\":\"Error at line $0: the array notation is only permitted during initialization of an array variable. i. e.: int vec[3] ← {1, 2, 3}.\",\"invalid_matrix_literal_line\":\"The expression $0 at line $1 does not have the same number of elements as the last line. All lines of a matrix must have the same number of elements.\",\"cannot_infer_matrix_line\":\"It is not possible to infer the number of lines of matrix $0 at line $1. It must be initialized or have its lines explicitly declared.\",\"cannot_infer_matrix_column\":\"It is not possible to infer the number of columns of matrix $0 at line $1. It must be initialized or have its columns explicitly declared.\",\"cannot_infer_vector_size\":\"It is not possible to infer the number of elements of vector $0 at line $1. It must be initialized or have its size explicitly declard.\",\"matrix_to_vector_literal_attr\":\"Error at line $0: The expression $1 represents a matrix and cannot be assigned to the vector $2.\",\"vector_to_matrix_literal_attr\":\"Error at line $0: The expression $1 represents a vector and cannot be assigned to the matrix $2.\",\"invalid_const_ref_full\":\"The variable $0 provided as a parameter to the function $1 at line $2 is a constant and cannot be used in this context. Use a non-constant variable or vector position.\",\"invalid_const_ref\":\"The variable $0 provided as a parameter to the function $1 is a constant and cannot be used in this context. Use a non-constant variable or vector position.\",\"invalid_const_assignment_full\":\"Error at line $0: $1 is a constant e therefore cannot have its value changed.\",\"invalid_const_assignment\":\"$0 is a constant e therefore cannot have its value changed.\",\"array_init_not_literal\":\"Error at line $0: An array (vector or matrix) can only be initialized by an array literal. i.e : real vector[] <- {1,2,3}\",\"array_exceeds_2d\":\"Error at line $0: The maximum number of dimensions an array can have is 2. An element of 3 or dimensions was found.\",\"invalid_matrix_id_dimension\":\"Error at line $0: You must define all dimensions of the matrix when one of them is defined by a variable! i.e: real mat1[var][5], mat2[5][var]\",\"invalid_vector_init\":\"Error at line $0: You cannot initialize a vector when its size is defined by a variable. Use a vector assignment or loop command.\",\"invalid_matrix_init\":\"Error at line $0: You cannot initialize a matrix when one of its dimensions is defined by a variable. Use a matrix assignment or loop command.\",\"invalid_vector_assignment_full\":\"Error at line $0: You can only assign a vector to another when both have the same number of elements. $1 has $2 and $3 has $4 elements!\",\"invalid_vector_assignment\":\"You can only assign a vector to another when both have the same number of elements. $0 has $1 and $2 has $3 elements!\",\"invalid_matrix_assignment_full\":\"Error at line $0: You can only assign a matrix to another when both have dimensions of the same size. $1 has $2 lines e $3 columns while $4 has $5 lines and $6 columns!\",\"invalid_matrix_assignment\":\"You can only assign a matrix to another when both have dimensions of the same size. $0 has $1 lines e $2 columns while $3 has $4 lines and $5 columns!\",\"matrix_to_vector_attr\":\"Error at line $0: $1 represents a matrix and cannot be assigned to the vector $2.\",\"vector_to_matrix_attr\":\"Error at line $0: $1 represents a vector and cannot be assigned to the matrix $2.\",\"invalid_matrix_index_assign_full\":\"Error at line $0: The position $1 of the matrix $2 only accepts vectors of size $3 but $4 has size $5.\",\"invalid_matrix_index_assign\":\"The position $0 of the matrix $1 only accepts vectors of size $2 but $3 has size $4.\",\"invalid_number_elements_vector\":\"It expected $0 elements at line $1 but the expression $2 has $3 elements.\",\"invalid_number_lines_matrix\":\"It expected a matrix with $0 lines at line $1 but the expression $2 has $3 lines.\",\"divsion_by_zero_full\":\"Error at line $0: The expression $1 resuts in a division by zero.\",\"divsion_by_zero\":\"The expression $0 resuts in a division by zero.\",\"undefined_tanget_value\":\"Error at line $0: The tangent of $1° is undefined.\",\"negative_log_value\":\"Error at line $0: You cannot calculate the logarithm of a negative value.\",\"invalid_string_index\":\"Error at line $0 during the execution of the function $1: $2 is an invalid index for the text string $3. The valid indexes go from 0 to $4.\",\"negative_sqrt_value\":\"Error at line $0: It is not allowd to calculate the square root of a negative number.\",\"exceeded_recursive_calls\":\"Error during the execution of line $0: The number of recursive calls exceeded the allowed number of calls.\",\"invalid_for_variable\":\"Error at line $0: The variable $1 used in the repeat_for command must be of type int.\",\"invalid_for_from\":\"Error at line $0: The value $1 passed to the parameter 'from' of the repeat_for command must be of type int.\",\"invalid_for_to\":\"Error at line $0: The value $1 passed to the parameter 'to' of the repeat_for command must be of type int.\",\"invalid_for_pass\":\"Error at line $0: The value $1 passed to the parameter 'pass' of the repeat_for command must be of type int.\",\"exceed_max_instructions\":\"The number of instructions executed by your program exceed the defined limit. Check your code for infinite loops or excessive recursive functions calls.\"},\"es\":{\"token_missing_one\":\"Syntax error: Expected $0 but found $1 at line:$2, column:$3\",\"token_missing_two\":\"Syntax error: Expected $0 or $1 but found $2 at line:$3, column: $4\",\"eos_missing\":\"A new line or a ‘;’ is missing at line: $0, column: $1\",\"invalid_type\":\"$0 at line: $1, column: $2 is a invalid type. The valid types are: $3\",\"invalid_array_dimension\":\"Invalid dimension at line: $0, column: $1. Insert a $2 or a valid identifier of the same type.\",\"invalid_array_size\":\"The array at line $0 exceeds the maximum size of 2.\",\"extra_lines\":\"No text is allowed after '}' in 'program { … }'\",\"invalid_main_return\":\"The function $0 declared at line $2 must return $1.\",\"invalid_var_declaration\":\"Error at line $0: Variables can only be declared in the main body of a function and at the first lines, before any command.\",\"invalid_break_command\":\"Error at line $0. The command $1 cannot be used outside a loop command or ‘switch ...case’ structure.\",\"invalid_terminal\":\"It is not possible to use $0 in the expression at line: $1, column: $2. Try a numeric value, variable or function call.\",\"const_not_init\":\"Error at line: $0, column: $1. A variable declared as const must be initialized.\",\"id_missing\":\"Expected an identifier but found $0 at line: $1, column: $2.\",\"invalid_id_format\":\"$0 at line: $1, column: $2 is not a valid identifier. The symbol '.' is not permitted in this context.\",\"main_missing\":\"The main function was not found. You need to declare a function of return type void named main.\",\"invalid_global_var\":\"Critical Error: Invalid call of the function IVProgProcessor.initGlobal outside the BASE context.\",\"not_implemented\":\"Critial internal error: The system defined function $0 was not found.\",\"function_missing\":\"The function $0 was not found.\",\"function_missing_full\":\"The function $0 at line: $1, column: $2 was not found.\",\"invalid_parameters_size_full\":\"Error at line $0: The number of parameters provided to the function $1 is incorrect. It expected $2 but found $3.\",\"invalid_parameters_size\":\"The number of parameters provided to the function $0 is incorrect. It expected $1 but found $2.\",\"invalid_ref_full\":\"The expression $0 provided as a parameter to the function $1 at line $2 is not valid in this context. Use a variable or a position of a vector.\",\"invalid_ref\":\"The expression $0 provided as a parameter to the function $1 is not valid in this context. Use a variable or a position of a vector.\",\"invalid_parameter_type_full\":\"The expression $0 provided as a parameter to the function $1 at line $2 is not of the expected type.\",\"invalid_parameter_type\":\"The expression $0 provided as a parameter to the function $1 is not of the expected type.\",\"unknown_command_full\":\"Internal error: an unknown command found at line $0.\",\"unknown_command\":\"Internal error: an unknown command found.\",\"loop_condition_type_full\":\"Error at line: $0, column $1: the condition $2 of the loop must be of type bool (true or false).\",\"loop_condition_type\":\"The condition $0 of the loop must be of type bool (true or false).\",\"endless_loop_full\":\"Possible infinite loop detected in your code. Check line $0.\",\"endless_loop\":\"Possible infinite loop detected in your code.\",\"for_condition_type_full\":\"Erro na linha: $0, coluna $1: a condição de parada $2 do comando para(...) deve ser do tipo lógico\",\"for_condition_type\":\"A condição de parada $0 do comando para(...) deve ser do tipo lógico\",\"if_condition_type_full\":\"Error at line: $0, column $1: the condition $2 in the if … else command must result in a bool (true or false).\",\"if_condition_type\":\"The condition $0 in the if … else command must result in a bool (true or false).\",\"invalid_return_type_full\":\"Error at line $0: The expression doest not result in a type compatible with the function $1.  Expected type: $2.\",\"invalid_return_type\":\"The expression doest not result in a type compatible with the function $0.  Expected type: $1.\",\"invalid_void_return_full\":\"Error at line $0: The function $1 cannot return an empty expression, use an expression that results in a $2\",\"invalid_void_return\":\"The function $0 cannot return an empty expression, use an expression that results in a $1\",\"unexpected_break_command_full\":\"Critical error at line $0:  a break command was found outside a valid context: loop or switch … case structure.\",\"unexpected_break_command\":\"Critical error:  a break command was found outside a valid context: loop or switch … case structure.\",\"invalid_dimension\":\"Array (vector or matrix) dimensions must be of type int.\",\"void_in_expression_full\":\"Error at line: $0, column: $1: The function $2 cannot be used inside an expression since its return type is void.\",\"void_in_expression\":\"The function $0 cannot be used inside an expression since its return type is void.\",\"invalid_array_access_full\":\"Identifier $0 at line: $1, column: $2 does not identify a valid vector or matrix.\",\"invalid_array_access\":\"Identifier $0 does not identify a valid vector or matrix.\",\"invalid_matrix_access_full\":\"Identifier $0 at line: $1, column: $2 does not identify a valid matrix.\",\"invalid_matrix_access\":\"Identifier $0 does not identify a valid matrix.\",\"matrix_column_outbounds_full\":\"Error at line $0: The number of columns $1 is invalid for the matrix $2 which has $3 columns.\",\"matrix_column_outbounds\":\"The number of columns $0 is invalid for the matrix $1 which has $2 columns.\",\"matrix_line_outbounds_full\":\"Error at line $0: The number of lines $1 is invalid for matrix $2 which has $3 lines.\",\"matrix_line_outbounds\":\"The number of lines $0 is invalid for matrix $1 which has $2 lines.\",\"vector_line_outbounds_full\":\"Error at line $0: The number of elements $1 is invalid for vector $2 which has $3 elements.\",\"vector_line_outbounds\":\"Error at line $0: The number of elements $1 is invalid for vector $2 which has $3 elements.\",\"vector_not_matrix_full\":\"Error at line $0: $1 is not a matrix.\",\"vector_not_matrix\":\"$0 is not a matrix.\",\"invalid_infix_op_full\":\"Error at line $0:  The expression $1 is not valid because the operator $2 cannot be applied to the types $3 and $4.\",\"invalid_infix_op\":\"The expression $0 is not valid because the operator $1 cannot be applied to the types $2 and $3.\",\"invalid_unary_op_full\":\"Error at line $0:  The expression $1 is not valid because the operator $2 cannot be applied to the type $3.\",\"invalid_unary_op\":\"The expression $0 is not valid because the operator $1 cannot be applied to the type $2.\",\"unknown_op\":\"Critical error: Unknown operator $0.\",\"duplicate_function\":\"The function $0 at line: $1, column: $2 has already been declared.\",\"duplicate_variable\":\"The variable $0 at line: $1, column: $2 has already been declared.\",\"main_parameters\":\"The main function cannot have parameters.\",\"symbol_not_found_full\":\"The variable $0 at line: $1, column: $2 has not been declared.\",\"symbol_not_found\":\"The variable $0 has not been declared.\",\"array_dimension_not_int_full\":\"The array (vector or matrix) dimensions at line $0 must be of type int.\",\"array_dimension_not_int\":\"An array (vector or matrix) dimensions must be of type int.\",\"array_dimension_not_positive_full\":\"The array (vector or matrix) dimensions at line $0 must be positive.\",\"array_dimension_not_positive\":\"An array (vector or matrix) dimensions must be positive.\",\"incompatible_types_full\":\"It expected $0 but the expression $1 at line $2 results in $3.\",\"incompatible_types\":\"It expected $0 but the expression $1 results in $2.\",\"incompatible_types_array_full\":\"The expression $0 at line $2 is not compatible with type $1.\",\"incompatible_types_array\":\"The expression $0 is not compatible with type $1.\",\"invalid_case_type_full\":\"The case expression $0 at line $1 is not compatible with type $2.\",\"invalid_case_type\":\"The case expression $0 is not compatible with type $1.\",\"function_no_return\":\"The function $0 does not have a reacheable return command. Every function must have at least one return command in its main body.\",\"invalid_array_literal_type_full\":\"Error at line $0: the expression $1 does not result in a compatible type.\",\"invalid_array_literal_type\":\"The expression $0 does not result in a compatible type.\",\"invalid_array_literal_line_full\":\"Error at line $0: it expected $1 lines but found $2.\",\"invalid_array_literal_line\":\"It expected $0 lines but found $1.\",\"invalid_array_literal_column_full\":\"Error at line $0: it expected $1 column but found $2.\",\"invalid_array_literal_column\":\"It expected $0 column but found $1.\",\"exceeded_input_request\":\"The amount of reads requested exceeded the amount of inputs available.\",\"test_case_few_reads\":\"Teste case $0 failed: there are available inputs remaining.\",\"test_case_failed\":\"<div class='assessment-div-detail' onClick='ivprogCore.openAssessmentDetail(event)' data-page=\\\"$1\\\"> <span>Test case $0 did not executed successfully.</span></div>\",\"test_case_failed_exception\":\"<div class='assessment-div-detail' onClick='ivprogCore.openAssessmentDetail(event)' data-page=\\\"$2\\\"> <span>Test case $0 failed</span>: $1\",\"test_case_exception\":\"An exception has ocurred during the execution of test case $0: $1\",\"invalid_type_conversion\":\"The value $0 cannot be converted to type $1.\",\"invalid_read_type\":\"Error at line $0: The input \\\"$1\\\" is not of type $2 which is the type of the variable <span class='ivprog-error-varname'>$3</span>.\",\"invalid_read_type_array\":\"Error at line $0: The input \\\"$1\\\" is not of type $2 which is the type  accepted by the variable <span class='ivprog-error-varname'>$3</span> of type $4.\",\"inform_valid_identifier\":\"Enter a valid identifier! The identifier cannot be a reserved word and it must begin with a letter or _, followed by numbers, letters and _ only.\",\"inform_valid_global_duplicated\":\"A global variable named <span class='ivprog-error-varname'>$0</span> already exists, you need distinct names for each gloval variable.\",\"inform_valid_variable_duplicated\":\"A variable named <span class='ivprog-error-varname'>$0</span> already exists, you need distinct names for each variable.\",\"inform_valid_function_duplicated\":\"A function named <span class='ivprog-error-varname'>$0</span> already exists, you need distinct names for each function.\",\"inform_valid_param_duplicated\":\"A parameter named <span class='ivprog-error-varname'>$0</span> already exists in function <span class='ivprog-error-varname'>$1</span>, you need distinc names for each parameter.\",\"invalid_character\":\"The character $0 at line $1 cannot be used in this context.\",\"invalid_syntax\":\"iVProg does not recognize the text $0 at line $1. Check for typos or invalid character.\",\"annonymous_array_literal\":\"Error at line $0: the array notation is only permitted during initialization of an array variable. i. e.: int vec[3] ← {1, 2, 3}.\",\"invalid_matrix_literal_line\":\"The expression $0 at line $1 does not have the same number of elements as the last line. All lines of a matrix must have the same number of elements.\",\"cannot_infer_matrix_line\":\"It is not possible to infer the number of lines of matrix $0 at line $1. It must be initialized or have its lines explicitly declared.\",\"cannot_infer_matrix_column\":\"It is not possible to infer the number of columns of matrix $0 at line $1. It must be initialized or have its columns explicitly declared.\",\"cannot_infer_vector_size\":\"It is not possible to infer the number of elements of vector $0 at line $1. It must be initialized or have its size explicitly declard.\",\"matrix_to_vector_literal_attr\":\"Error at line $0: The expression $1 represents a matrix and cannot be assigned to the vector $2.\",\"vector_to_matrix_literal_attr\":\"Error at line $0: The expression $1 represents a vector and cannot be assigned to the matrix $2.\",\"invalid_const_ref_full\":\"The variable $0 provided as a parameter to the function $1 at line $2 is a constant and cannot be used in this context. Use a non-constant variable or vector position.\",\"invalid_const_ref\":\"The variable $0 provided as a parameter to the function $1 is a constant and cannot be used in this context. Use a non-constant variable or vector position.\",\"invalid_const_assignment_full\":\"Error at line $0: $1 is a constant e therefore cannot have its value changed.\",\"invalid_const_assignment\":\"$0 is a constant e therefore cannot have its value changed.\",\"array_init_not_literal\":\"Error at line $0: An array (vector or matrix) can only be initialized by an array literal. i.e : real vector[] <- {1,2,3}\",\"array_exceeds_2d\":\"Error at line $0: The maximum number of dimensions an array can have is 2. An element of 3 or dimensions was found.\",\"invalid_matrix_id_dimension\":\"Error at line $0: You must define all dimensions of the matrix when one of them is defined by a variable! i.e: real mat1[var][5], mat2[5][var]\",\"invalid_vector_init\":\"Error at line $0: You cannot initialize a vector when its size is defined by a variable. Use a vector assignment or loop command.\",\"invalid_matrix_init\":\"Error at line $0: You cannot initialize a matrix when one of its dimensions is defined by a variable. Use a matrix assignment or loop command.\",\"invalid_vector_assignment_full\":\"Error at line $0: You can only assign a vector to another when both have the same number of elements. $1 has $2 and $3 has $4 elements!\",\"invalid_vector_assignment\":\"You can only assign a vector to another when both have the same number of elements. $0 has $1 and $2 has $3 elements!\",\"invalid_matrix_assignment_full\":\"Error at line $0: You can only assign a matrix to another when both have dimensions of the same size. $1 has $2 lines e $3 columns while $4 has $5 lines and $6 columns!\",\"invalid_matrix_assignment\":\"You can only assign a matrix to another when both have dimensions of the same size. $0 has $1 lines e $2 columns while $3 has $4 lines and $5 columns!\",\"matrix_to_vector_attr\":\"Error at line $0: $1 represents a matrix and cannot be assigned to the vector $2.\",\"vector_to_matrix_attr\":\"Error at line $0: $1 represents a vector and cannot be assigned to the matrix $2.\",\"invalid_matrix_index_assign_full\":\"Error at line $0: The position $1 of the matrix $2 only accepts vectors of size $3 but $4 has size $5.\",\"invalid_matrix_index_assign\":\"The position $0 of the matrix $1 only accepts vectors of size $2 but $3 has size $4.\",\"invalid_number_elements_vector\":\"It expected $0 elements at line $1 but the expression $2 has $3 elements.\",\"invalid_number_lines_matrix\":\"It expected a matrix with $0 lines at line $1 but the expression $2 has $3 lines.\",\"divsion_by_zero_full\":\"Error at line $0: The expression $1 resuts in a division by zero.\",\"divsion_by_zero\":\"The expression $0 resuts in a division by zero.\",\"undefined_tanget_value\":\"Error at line $0: The tangent of $1° is undefined.\",\"negative_log_value\":\"Error at line $0: You cannot calculate the logarithm of a negative value.\",\"invalid_string_index\":\"Error at line $0 during the execution of the function $1: $2 is an invalid index for the text string $3. The valid indexes go from 0 to $4.\",\"negative_sqrt_value\":\"Error at line $0: It is not allowd to calculate the square root of a negative number.\",\"exceeded_recursive_calls\":\"Error during the execution of line $0: The number of recursive calls exceeded the allowed number of calls.\",\"invalid_for_variable\":\"Error at line $0: The variable $1 used in the repeat_for command must be of type int.\",\"invalid_for_from\":\"Error at line $0: The value $1 passed to the parameter 'from' of the repeat_for command must be of type int.\",\"invalid_for_to\":\"Error at line $0: The value $1 passed to the parameter 'to' of the repeat_for command must be of type int.\",\"invalid_for_pass\":\"Error at line $0: The value $1 passed to the parameter 'pass' of the repeat_for command must be of type int.\",\"exceed_max_instructions\":\"The number of instructions executed by your program exceed the defined limit. Check your code for infinite loops or excessive recursive functions calls.\"}}","module.exports = {\"pt\":{\"test_case_success\":\"<div class='assessment-div-detail' onClick='ivprogCore.openAssessmentDetail(event)' data-page=\\\"$1\\\"><span>Caso de teste $0</span>: OK</div>\",\"test_case_duration\":\"Levou $0ms\",\"test_suite_grade\":\"A sua solução alcançou $0% da nota.\",\"awaiting_input_message\":\"O seu programa está em execução e aguardando uma entrada! Digite algo e pressione ENTER...\",\"assessment-empty-expected-tooltip\":\"A saída gerada foi além do esperado\",\"assessment-empty-generated-tooltip\":\"O programa não gerou saídas suficientes\",\"testcase_autogen_unused_input\":\"A solução submetida não lê todas entradas disponíveis no caso de teste 1\",\"testcase_autogen_empty\":\"Sua solução não gerou qualquer saída para o caso de teste $0.\",\"success_execution\":\"Execução do programa finalizada!\",\"aborted_execution\":\"A execução do programa foi interrompida!\",\"unexpected_execution_error\":\"Erro inesperado durante a execução do programa.\"},\"en\":{\"test_case_success\":\"<div class='assessment-div-detail' onClick='ivprogCore.openAssessmentDetail(event)' data-page=\\\"$1\\\"><span>Test case $0</span>: OK</div>\",\"test_case_duration\":\"Took $0ms\",\"test_suite_grade\":\"Your solution scored $0% of the grade.\",\"awaiting_input_message\":\"Your program is running and awaiting for an input. Type something and press ENTER…\",\"assessment-empty-expected-tooltip\":\"The generated output was beyond the amount expected\",\"assessment-empty-generated-tooltip\":\"The program did not generate enough outputs\",\"testcase_autogen_unused_input\":\"The submitted solution does not read all inputs available in the test case $0\",\"testcase_autogen_empty\":\"Your solution did not generate any output for test case $0.\",\"success_execution\":\"Program execution finished!\",\"aborted_execution\":\"Program execution was aborted!\",\"unexpected_execution_error\":\"Unexpected error during program execution.\"},\"es\":{\"test_case_success\":\"<div class='assessment-div-detail' onClick='ivprogCore.openAssessmentDetail(event)' data-page=\\\"$1\\\"><span>Test case $0</span>: OK</div>\",\"test_case_duration\":\"Tardó $0ms\",\"test_suite_grade\":\"Su solución obtuvo $0% de la calificación.\",\"awaiting_input_message\":\"Su programa se está ejecutando y esperando una entrada. Escriba algo y presione ENTER ...\",\"assessment-empty-expected-tooltip\":\"The generated output was beyond the amount expected\",\"assessment-empty-generated-tooltip\":\"El programa no generó suficientes resultados.\",\"testcase_autogen_unused_input\":\"La solución presentada no lee todas las entradas disponibles en el caso de prueba 1\",\"testcase_autogen_empty\":\"Su solución no generó ningún resultado para el caso de prueba de $ 0.\",\"success_execution\":\"¡Ejecución del programa terminada!\",\"aborted_execution\":\"¡La ejecución del programa fue abortada!\",\"unexpected_execution_error\":\"Error inesperado durante la ejecución del programa.\"}}","module.exports = {\"pt\":{\"function\":\"funcao\",\"btn_clear\":\"Limpar\",\"btn_function\":\"Função\",\"btn_arithmetic_plus\":\"Adição\",\"btn_arithmetic_minus\":\"Subtração\",\"btn_arithmetic_multiplication\":\"Multiplicação\",\"btn_arithmetic_division\":\"Divisão\",\"btn_arithmetic_module\":\"Módulo\",\"btn_break\":\"Pare\",\"btn_case\":\"Caso\",\"btn_add_var\":\"Adicionar variável\",\"btn_drag_and_drop_function\":\"Mover função\",\"btn_delete_function\":\"Excluir função\",\"expression_invalid\":\"Expressão inválida. Verifique a sintáxe antes de continuar.\",\"expression_undelcared_variable\":\"Variáveis não declaradas:\",\"expression_undeclared_function\":\"Funções não definidas:\",\"start\":\"inicio\",\"type_void\":\"vazio\",\"type_integer\":\"inteiro\",\"logic_operator_and\":\"E\",\"logic_operator_or\":\"OU\",\"logic_operator_not\":\"nao\",\"type_real\":\"real\",\"program\":\"programa\",\"type_text\":\"cadeia\",\"textvar_default_value\":\"texto\",\"type_boolean\":\"logico\",\"logic_value_true\":\"verdadeiro\",\"logic_value_false\":\"falso\",\"variable\":\"Variável\",\"command\":\"Comando\",\"new_parameter\":\"parametro\",\"new_variable\":\"variavel\",\"new_global\":\"global\",\"new_function\":\"nova_funcao\",\"matrix\":\"matriz\",\"vector\":\"vetor\",\"text_lock_expression\":\"Bloquear expressão\",\"text_unlock_expression\":\"Desbloquear expressão\",\"text_edit_expression\":\"Editar expressão manualmente\",\"text_edit_expression_confirm\":\"Confirmar edição\",\"text_edit_expression_cancel\":\"Cancelar edição\",\"text_add_function\":\"Adicionar uma nova função ao programa\",\"text_move_command\":\"Mover comando\",\"text_add_parameters\":\"Adicionar um novo parâmetro\",\"text_parameter_reference\":\"Definir parâmetro como passagem por referência\",\"text_parameter_copy\":\"Definir parâmetro como passagem por cópia\",\"text_comment_start\":\"Comentário inicial da função...\",\"text_comment_main\":\"Esta é a função principal...\",\"text_read_var\":\"Entrada/Leitura de dados\",\"text_write_var\":\"Saída/Escrita de dados\",\"text_command_read\":\"leia\",\"text_command_write\":\"escreva\",\"text_return\":\"devolva\",\"text_btn_return\":\"Devolver\",\"text_comment\":\"Comentário\",\"string_join_or\":\"ou\",\"matrix_info_string\":\"matriz de $0\",\"vector_info_string\":\"vetor de $0\",\"text_attribution\":\"Atribuição\",\"text_if\":\"se\",\"text_break\":\"pare\",\"text_else\":\"senao\",\"text_for\":\"repita_para\",\"text_code_while\":\"repita_enquanto\",\"text_code_do\":\"repita\",\"text_code_do_until\":\"ate_que\",\"text_command_do\":\"repita\",\"text_command_while\":\"repita enquanto\",\"text_command_do_until\":\"até que\",\"text_code_switch\":\"escolha\",\"text_code_case\":\"caso\",\"text_config_programming\":\"Programação\",\"text_config_programming_both\":\"Visual e textual\",\"text_config_programming_textual\":\"Textual\",\"text_config_programming_visual\":\"Visual\",\"text_logic_expression\":\"Lógicos\",\"text_arithmetic_expression\":\"Aritméticos\",\"text_iftrue\":\"Se condição senão\",\"text_message_error_activity_file\":\"Aconteceu um erro ao processar a atividade. <br> Recarregue a página para tentar novamente.\",\"text_message_error_upload_file\":\"Não foi possível carregar o arquivo.<br>Verifique o conteúdo do arquivo e tente novamente.\",\"text_message_error_upload_close\":\"Fechar\",\"text_message_error_activity_reload\":\"Recarregar\",\"text_repeatNtimes\":\"Repita N vezes\",\"text_receives\":\"recebe\",\"text_whiletrue\":\"Enquanto verdadeiro\",\"text_dowhiletrue\":\"Repita até que verdadeiro\",\"text_switch\":\"Escolha\",\"text_functioncall\":\"Chamada de função\",\"text_value\":\"Valor\",\"text_operator\":\"Operador\",\"text_parentheses\":\"Parênteses\",\"text_change\":\"Alterar\",\"text_teacher_algorithm\":\"Algoritmo\",\"text_teacher_algorithm_include\":\"Incluir o algoritmo abaixo no exercício\",\"text_teacher_test_case\":\"Casos de teste\",\"text_teacher_config\":\"Configurações\",\"text_teacher_data_types\":\"Tipos de dados\",\"text_teacher_commands\":\"Comandos\",\"text_teacher_functions\":\"Funções\",\"text_teacher_create_functions\":\"Criar novas funções\",\"text_teacher_create_movement_functions\":\"Movimentar funções\",\"text_teacher_test_case_input\":\"Entrada\",\"text_teacher_test_case_output\":\"Saída\",\"text_teacher_test_case_actions\":\"Ações\",\"text_teacher_test_case_add\":\"Adicionar caso de teste\",\"text_header_ivprog_functions\":\"Funções do iVProg\",\"text_menu_functions_math\":\"Matemática\",\"text_menu_functions_text\":\"Texto\",\"text_menu_functions_array\":\"Arranjo\",\"text_menu_functions_conversion\":\"Conversão\",\"text_no_variable\":\"Nenhuma variável declarada\",\"text_no_variable_instruction\":\"Antes de utilizar uma variável, é necessário criá-la\",\"text_ivprog_description\":\"Programação Visual interativa na Internet\",\"tooltip_visual\":\"Programação visual\",\"tooltip_textual\":\"Programação textual\",\"tooltip_upload\":\"Upload de código fonte\",\"tooltip_download\":\"Download do código fonte\",\"tooltip_undo\":\"Desfazer\",\"tooltip_redo\":\"Refazer\",\"tooltip_run\":\"Executar o programa\",\"tooltip_evaluate\":\"Avaliar o programa\",\"tooltip_help\":\"Ajuda\",\"tooltip_add_global\":\"Adicionar variável global\",\"tooltip_hide_function\":\"Ocultar os elementos da função\",\"var_menu_select_var\":\"Selecione uma variável\",\"var_menu_select_all\":\"Selecione\",\"var_menu_select_function\":\"Selecione uma função\",\"expression_menu_select\":\"Construir uma expressão lógica\",\"inform_valid_content\":\"Informe o conteúdo!\",\"inform_valid_expression\":\"Construa uma expressão lógica!\",\"tooltip_terminal_clear\":\"Limpa o terminal removendo todos os textos já escritos e os pendentes.\",\"tooltip_terminal_show\":\"Exibe o terminal caso esteja escondido\",\"tooltip_terminal_hide\":\"Esconde o terminal caso não esteja escondido\",\"tooltip_menu_read\":\"Comando para receber dados pelo teclado\",\"tooltip_menu_write\":\"Comando para apresentar conteúdo ao usuário\",\"tooltip_menu_comments\":\"Bloco para comentários internos do programador\",\"tooltip_menu_attribution\":\"Comando para atribuir uma expressão a uma variável\",\"tooltip_menu_call_function\":\"Comando para realizar a chamada de uma função\",\"tooltip_menu_if_else\":\"Estrutura para que os comandos só sejam executados de acordo com as condições estabelecidas\",\"tooltip_menu_repeat_n_times\":\"Estrutura para executar um bloco de comandos repetidamente\",\"tooltip_menu_repeat_whiletrue\":\"Estrutura para repetir um bloco de comandos enquanto a condição for verdadeira\",\"tooltip_menu_repeat_dowhiletrue\":\"Estrutura que executa um bloco e o repete enquanto a condição for verdadeira\",\"tooltip_menu_repeat_switch\":\"Estrutura de escolha do bloco a ser executado\",\"tooltip_menu_repeat_return\":\"Comando para devolver o resultado e finalizar a função\",\"tooltip_move_var\":\"Mover variável\",\"tooltip_remove_var\":\"Excluir variável\",\"text_ivprog_version\":\"Versão\",\"text_teacher_filter\":\"Filtro\",\"text_teacher_filter_active\":\"Ativado\",\"text_teacher_filter_help\":\"Ao ativar o filtro, as modificações do iVProg estarão bloqueadas.\",\"text_join_assessment_outputs\":\" ; \",\"assessment-detail-time-label\":\"Duração\",\"assessment-detail-grade-label\":\"Nota\",\"assessment-detail-input-label\":\"Entradas\",\"assessment-detail-output-label\":\"Saídas\",\"assessment-detail-expected-label\":\"Esperava\",\"assessment-detail-generated-label\":\"Gerou\",\"assessment-detail-result-label\":\"Correção\",\"assessment-detail-title\":\"Caso de Teste $0\",\"text_teacher_generate_outputs\":\"Gerar saídas\",\"text_teacher_generate_outputs_algorithm\":\"Antes de gerar as saídas, elabore um algoritmo!\",\"text_code_for_from\":\"de\",\"text_code_for_to\":\"ate\",\"text_code_for_pass\":\"passo\",\"text_for_from\":\"de\",\"text_for_to\":\"até\",\"text_for_pass\":\"passo\",\"text_relational_expression\":\"Relacionais\",\"write_command_newline_on\":\"Quebra de linha ativada\",\"write_command_newline_off\":\" Quebra de linha desativada\",\"write_seprator_menu_text\":\"Espaço\",\"initial_program_code\":\"programa {\\\\n\\\\n\\\\t\\\\tfuncao vazio inicio () {\\\\n\\\\t\\\\t\\\\t// Inicie seu codigo aqui!\\\\n\\\\t\\\\t}\\\\n}\",\"type_char\":\"caractere\",\"charvar_default_value\":\"A\",\"write_seprator_menu_tooltip\":\"Separador para imprimir mais valores/variáveis\"},\"en\":{\"function\":\"function\",\"btn_clear\":\"Clean\",\"btn_function\":\"Function\",\"btn_arithmetic_plus\":\"Addition\",\"btn_arithmetic_minus\":\"Subtraction\",\"btn_arithmetic_multiplication\":\"Multiplication\",\"btn_arithmetic_division\":\"Division\",\"btn_arithmetic_module\":\"Remainder\",\"btn_break\":\"break\",\"btn_case\":\"Case\",\"btn_add_var\":\"Add a variable\",\"btn_drag_and_drop_function\":\"Move function\",\"btn_delete_function\":\"Delete function\",\"expression_invalid\":\"Invalid expression. Check the syntax before proceeding.\",\"expression_undelcared_variable\":\"Undeclared variables:\",\"expression_undeclared_function\":\"Undefined functions:\",\"start\":\"main\",\"type_void\":\"void\",\"type_integer\":\"int\",\"logic_operator_and\":\"AND\",\"logic_operator_or\":\"OR\",\"logic_operator_not\":\"not\",\"type_real\":\"real\",\"program\":\"program\",\"type_text\":\"string\",\"textvar_default_value\":\"text\",\"type_boolean\":\"bool\",\"logic_value_true\":\"true\",\"logic_value_false\":\"false\",\"variable\":\"Variable\",\"command\":\"Command\",\"new_parameter\":\"parameter\",\"new_variable\":\"variable\",\"new_global\":\"global\",\"new_function\":\"new_function\",\"matrix\":\"matrix\",\"vector\":\"vector\",\"text_lock_expression\":\"Block expression\",\"text_unlock_expression\":\"Unlock expression\",\"text_edit_expression\":\"Edit expression manually\",\"text_edit_expression_confirm\":\"Confirm edition\",\"text_edit_expression_cancel\":\"Cancel edition\",\"text_add_function\":\"Add a new function to the program\",\"text_move_command\":\"Move command\",\"text_add_parameters\":\"Add a new parameter\",\"text_parameter_reference\":\"Define parameter passed by reference\",\"text_parameter_copy\":\"Define parameter passed by copy\",\"text_comment_start\":\"Function initial comment\",\"text_comment_main\":\"This is the main funcion\",\"text_read_var\":\"Input/Read data\",\"text_write_var\":\"Output/Write data\",\"text_command_read\":\"read\",\"text_command_write\":\"write\",\"text_return\":\"return\",\"text_btn_return\":\"Return\",\"text_comment\":\"Comment\",\"string_join_or\":\"or\",\"matrix_info_string\":\"matrix of $0\",\"vector_info_string\":\"vector of $0\",\"text_attribution\":\"Assignment\",\"text_if\":\"if\",\"text_break\":\"break\",\"text_else\":\"else\",\"text_for\":\"repeat_for\",\"text_code_while\":\"repeat_while\",\"text_code_do\":\"repeat\",\"text_code_do_until\":\"until\",\"text_command_do\":\"repeat\",\"text_command_while\":\"repeat while\",\"text_command_do_until\":\"until\",\"text_code_switch\":\"switch\",\"text_code_case\":\"case\",\"text_config_programming\":\"Programming\",\"text_config_programming_both\":\"Visual & Textual\",\"text_config_programming_textual\":\"Textual\",\"text_config_programming_visual\":\"Visual\",\"text_logic_expression\":\"Logic\",\"text_arithmetic_expression\":\"Arithmetics\",\"text_iftrue\":\"If condition else\",\"text_message_error_activity_file\":\"There was an error processing the activity.<br> Reload the page to try again.\",\"text_message_error_upload_file\":\"It was not possible upload the file.<br>Verify the file's content and try again.\",\"text_message_error_upload_close\":\"Close\",\"text_message_error_activity_reload\":\"Reload\",\"text_repeatNtimes\":\"Repeat N times\",\"text_receives\":\"receives\",\"text_whiletrue\":\"While true\",\"text_dowhiletrue\":\"Repeat until true\",\"text_switch\":\"Switch\",\"text_functioncall\":\"Function call\",\"text_value\":\"Value\",\"text_operator\":\"Operator\",\"text_parentheses\":\"Parentheses\",\"text_change\":\"Modify\",\"text_teacher_algorithm\":\"Algorithm\",\"text_teacher_algorithm_include\":\"Include the algorithm below in the activity\",\"text_teacher_test_case\":\"Test cases\",\"text_teacher_config\":\"Configurations\",\"text_teacher_data_types\":\"Data types\",\"text_teacher_commands\":\"Commands\",\"text_teacher_functions\":\"Functions\",\"text_teacher_create_functions\":\"Create new functions\",\"text_teacher_create_movement_functions\":\"Move functions\",\"text_teacher_test_case_input\":\"Input\",\"text_teacher_test_case_output\":\"Output\",\"text_teacher_test_case_actions\":\"Actions\",\"text_teacher_test_case_add\":\"Add test case\",\"text_header_ivprog_functions\":\"iVProg Functions\",\"text_menu_functions_math\":\"Math\",\"text_menu_functions_text\":\"Text\",\"text_menu_functions_array\":\"Array\",\"text_menu_functions_conversion\":\"Conversion\",\"text_no_variable\":\"No variable declared\",\"text_no_variable_instruction\":\"Before using a variable, you need to create it\",\"text_ivprog_description\":\"Interactive and Visual Programming on the Internet\",\"tooltip_visual\":\"Visual programming\",\"tooltip_textual\":\"Textual programming\",\"tooltip_upload\":\"Upload source code\",\"tooltip_download\":\"Download source code\",\"tooltip_undo\":\"Undo\",\"tooltip_redo\":\"Redo\",\"tooltip_run\":\"Run the program\",\"tooltip_evaluate\":\"Evaluate the program\",\"tooltip_help\":\"Help\",\"tooltip_add_global\":\"Add a global variable\",\"tooltip_hide_function\":\"Hide function elements\",\"var_menu_select_var\":\"Select a variable\",\"var_menu_select_all\":\"Select\",\"var_menu_select_function\":\"Select a function\",\"expression_menu_select\":\"Construct a logic expression\",\"inform_valid_content\":\"Provide some data\",\"inform_valid_expression\":\"Construct a logic expression\",\"tooltip_terminal_clear\":\"Clears the terminal by removing all wrriten and pending text.\",\"tooltip_terminal_show\":\"Shows the terminal if it is hidden\",\"tooltip_terminal_hide\":\"Hides the terminal if it is not on display\",\"tooltip_menu_read\":\"Command to input data from keyboard\",\"tooltip_menu_write\":\"Command to present content to user\",\"tooltip_menu_comments\":\"Block to comments from developer\",\"tooltip_menu_attribution\":\"Command to assign an expression to a variable\",\"tooltip_menu_call_function\":\"Command to execute a function call\",\"tooltip_menu_if_else\":\"Structure in which command only run when the conditions are satisfied\",\"tooltip_menu_repeat_n_times\":\"Structure to execute a block of commands repeatedly\",\"tooltip_menu_repeat_whiletrue\":\"Structure to execute a block repeatdly while condition is true\",\"tooltip_menu_repeat_dowhiletrue\":\"Structure that executes a block and repeat while the condition is true\",\"tooltip_menu_repeat_switch\":\"Structure that choices the block to be executed\",\"tooltip_menu_repeat_return\":\"Command to return the result and finish the function\",\"tooltip_move_var\":\"Move variable\",\"tooltip_remove_var\":\"Delete variable\",\"text_ivprog_version\":\"Version\",\"text_teacher_filter\":\"Filter\",\"text_teacher_filter_active\":\"Activated\",\"text_teacher_filter_help\":\"By activating the filter modifications in iVProg will be blocked\",\"text_join_assessment_outputs\":\" ; \",\"assessment-detail-time-label\":\"Duration\",\"assessment-detail-grade-label\":\"Grade\",\"assessment-detail-input-label\":\"Inputs\",\"assessment-detail-output-label\":\"Outputs\",\"assessment-detail-expected-label\":\"Expected\",\"assessment-detail-generated-label\":\"Generated\",\"assessment-detail-result-label\":\"Correction\",\"assessment-detail-title\":\"Test Case $0\",\"text_teacher_generate_outputs\":\"Generate outputs\",\"text_teacher_generate_outputs_algorithm\":\"Before generating the outputs you need to create an algorithm\",\"text_code_for_from\":\"from\",\"text_code_for_to\":\"to\",\"text_code_for_pass\":\"pass\",\"text_for_from\":\"from\",\"text_for_to\":\"to\",\"text_for_pass\":\"pass\",\"text_relational_expression\":\"Relational\",\"write_command_newline_on\":\" Line break is on\",\"write_command_newline_off\":\" Line break is off\",\"write_seprator_menu_text\":\"Spacer\",\"initial_program_code\":\"program {\\\\n\\\\n\\\\t\\\\tfunction void main () {\\\\n\\\\t\\\\t\\\\t// Start your code here!\\\\n\\\\t\\\\t}\\\\n}\",\"type_char\":\"char\",\"charvar_default_value\":\"A\",\"write_seprator_menu_tooltip\":\"Separator used to print more values/variables\"},\"es\":{\"function\":\"function\",\"btn_clear\":\"Limpiar\",\"btn_function\":\"Funcíon\",\"btn_arithmetic_plus\":\"Adición\",\"btn_arithmetic_minus\":\"Sustracción\",\"btn_arithmetic_multiplication\":\"Multiplicación\",\"btn_arithmetic_division\":\"División\",\"btn_arithmetic_module\":\"Resto\",\"btn_break\":\"break\",\"btn_case\":\"Caso\",\"btn_add_var\":\"Add a variable\",\"btn_drag_and_drop_function\":\"Mover función\",\"btn_delete_function\":\"Borrar función\",\"expression_invalid\":\"Expresión no válida. Verifique la sintaxis antes de continuar.\",\"expression_undelcared_variable\":\"Variables no declaradas:\",\"expression_undeclared_function\":\"Funcíon no declaradas:\",\"start\":\"main\",\"type_void\":\"void\",\"type_integer\":\"int\",\"logic_operator_and\":\"AND\",\"logic_operator_or\":\"OR\",\"logic_operator_not\":\"not\",\"type_real\":\"real\",\"program\":\"program\",\"type_text\":\"string\",\"textvar_default_value\":\"texto\",\"type_boolean\":\"bool\",\"logic_value_true\":\"true\",\"logic_value_false\":\"false\",\"variable\":\"Variable\",\"command\":\"Comando\",\"new_parameter\":\"parametro\",\"new_variable\":\"variable\",\"new_global\":\"global\",\"new_function\":\"nueva_función\",\"matrix\":\"matriz\",\"vector\":\"vector\",\"text_lock_expression\":\"Expresión de bloque\",\"text_unlock_expression\":\"Desbloquear expresión\",\"text_edit_expression\":\"Editar expresión manualmente\",\"text_edit_expression_confirm\":\"Confirmar edición\",\"text_edit_expression_cancel\":\"Cancelar edición\",\"text_add_function\":\"Agregar una nueva función al programa\",\"text_move_command\":\"Mover comando\",\"text_add_parameters\":\"Agregar un nuevo parámetro\",\"text_parameter_reference\":\"Define parameter passed by reference\",\"text_parameter_copy\":\"Define parameter passed by copy\",\"text_comment_start\":\"Comentario inicial de la función\",\"text_comment_main\":\"Esta es la función principal\",\"text_read_var\":\"Entrada/Lectura de dados\",\"text_write_var\":\"Salida/Escribir datos\",\"text_command_read\":\"read\",\"text_command_write\":\"write\",\"text_return\":\"return\",\"text_btn_return\":\"Devolución\",\"text_comment\":\"Comentario\",\"string_join_or\":\"or\",\"matrix_info_string\":\"matriz de $0\",\"vector_info_string\":\"vector de $0\",\"text_attribution\":\"Asignación\",\"text_if\":\"if\",\"text_break\":\"break\",\"text_else\":\"else\",\"text_for\":\"repeat_for\",\"text_code_while\":\"repeat_while\",\"text_code_do\":\"repeat\",\"text_code_do_until\":\"until\",\"text_command_do\":\"repeat\",\"text_command_while\":\"repeat while\",\"text_command_do_until\":\"until\",\"text_code_switch\":\"switch\",\"text_code_case\":\"case\",\"text_config_programming\":\"Programación\",\"text_config_programming_both\":\"Visual & Textual\",\"text_config_programming_textual\":\"Textual\",\"text_config_programming_visual\":\"Visual\",\"text_logic_expression\":\"Lógicos\",\"text_arithmetic_expression\":\"Aritmética\",\"text_iftrue\":\"Si condicion sino\",\"text_message_error_activity_file\":\"Se produjo un error al procesar la actividad.<br> Recargar la página para volver a intentarlo.\",\"text_message_error_upload_file\":\"text_message_error_upload_file\",\"text_message_error_upload_close\":\"Close\",\"text_message_error_activity_reload\":\"Recargar\",\"text_repeatNtimes\":\"Repetir N veces\",\"text_receives\":\"receives\",\"text_whiletrue\":\"Mientras verdad\",\"text_dowhiletrue\":\"Repita hasta verdad\",\"text_switch\":\"Switch\",\"text_functioncall\":\"Llamada de función\",\"text_value\":\"Valor\",\"text_operator\":\"Operador\",\"text_parentheses\":\"Paréntesis\",\"text_change\":\"Modify\",\"text_teacher_algorithm\":\"Algorithm\",\"text_teacher_algorithm_include\":\"Incluir el algoritmo en la actividad.\",\"text_teacher_test_case\":\"Test cases\",\"text_teacher_config\":\"Configuraciones\",\"text_teacher_data_types\":\"Data types\",\"text_teacher_commands\":\"Commands\",\"text_teacher_functions\":\"Funciones\",\"text_teacher_create_functions\":\"Create new functions\",\"text_teacher_create_movement_functions\":\"Move functions\",\"text_teacher_test_case_input\":\"Input\",\"text_teacher_test_case_output\":\"Output\",\"text_teacher_test_case_actions\":\"Actions\",\"text_teacher_test_case_add\":\"Add test case\",\"text_header_ivprog_functions\":\"iVProg Functions\",\"text_menu_functions_math\":\"Math\",\"text_menu_functions_text\":\"Text\",\"text_menu_functions_array\":\"Array\",\"text_menu_functions_conversion\":\"Conversion\",\"text_no_variable\":\"No variable declared\",\"text_no_variable_instruction\":\"Antes de usar una variable, debe crearla\",\"text_ivprog_description\":\"Interactive and Visual Programming on the Internet\",\"tooltip_visual\":\"Visual programming\",\"tooltip_textual\":\"Textual programming\",\"tooltip_upload\":\"Upload source code\",\"tooltip_download\":\"Download source code\",\"tooltip_undo\":\"Undo\",\"tooltip_redo\":\"Redo\",\"tooltip_run\":\"Run the program\",\"tooltip_evaluate\":\"Evaluate the program\",\"tooltip_help\":\"Help\",\"tooltip_add_global\":\"Add a global variable\",\"tooltip_hide_function\":\"Hide function elements\",\"var_menu_select_var\":\"Select a variable\",\"var_menu_select_all\":\"Select\",\"var_menu_select_function\":\"Select a function\",\"expression_menu_select\":\"Construct a logic expression\",\"inform_valid_content\":\"Proporcionar algunos datos\",\"inform_valid_expression\":\"Construct a logic expression\",\"tooltip_terminal_clear\":\"Borra el terminal eliminando todo el texto escrito y pendiente.\",\"tooltip_terminal_show\":\"Muestra el terminal si está oculto.\",\"tooltip_terminal_hide\":\"Oculta el terminal si no está en exhibición\",\"tooltip_menu_read\":\"Command to input data from keyboard\",\"tooltip_menu_write\":\"Command to present content to user\",\"tooltip_menu_comments\":\"Block to comments from developer\",\"tooltip_menu_attribution\":\"Command to assign an expression to a variable\",\"tooltip_menu_call_function\":\"Command to execute a function call\",\"tooltip_menu_if_else\":\"Structure in which command only run when the conditions are satisfied\",\"tooltip_menu_repeat_n_times\":\"Structure to execute a block of commands repeatedly\",\"tooltip_menu_repeat_whiletrue\":\"Structure to execute a block repeatdly while condition is true\",\"tooltip_menu_repeat_dowhiletrue\":\"Structure that executes a block and repeat while the condition is true\",\"tooltip_menu_repeat_switch\":\"Structure that choices the block to be executed\",\"tooltip_menu_repeat_return\":\"Command to return the result and finish the function\",\"tooltip_move_var\":\"Move variable\",\"tooltip_remove_var\":\"Delete variable\",\"text_ivprog_version\":\"Version\",\"text_teacher_filter\":\"Filter\",\"text_teacher_filter_active\":\"Activated\",\"text_teacher_filter_help\":\"Al activar el filtro, las modificaciones en iVProg serán bloqueadas\",\"text_join_assessment_outputs\":\" ;\",\"assessment-detail-time-label\":\"Duration\",\"assessment-detail-grade-label\":\"Grade\",\"assessment-detail-input-label\":\"Inputs\",\"assessment-detail-output-label\":\"Outputs\",\"assessment-detail-expected-label\":\"Expected\",\"assessment-detail-generated-label\":\"Generated\",\"assessment-detail-result-label\":\"Correction\",\"assessment-detail-title\":\"Test Case $0\",\"text_teacher_generate_outputs\":\"Generate outputs\",\"text_teacher_generate_outputs_algorithm\":\"Antes de generar las salidas necesita crear un algoritmo\",\"text_code_for_from\":\"from\",\"text_code_for_to\":\"to\",\"text_code_for_pass\":\"pass\",\"text_for_from\":\"from\",\"text_for_to\":\"to\",\"text_for_pass\":\"pass\",\"text_relational_expression\":\"Relational\",\"write_command_newline_on\":\"El salto de línea está activado\",\"write_command_newline_off\":\"El salto de línea está desactivado\",\"write_seprator_menu_text\":\"Spacer\",\"initial_program_code\":\"program {\\\\n\\\\n\\\\t\\\\tfunction void main () {\\\\n\\\\t\\\\t\\\\t// Start your code here!\\\\n\\\\t\\\\t}\\\\n}\",\"type_char\":\"char\",\"charvar_default_value\":\"A\",\"write_seprator_menu_tooltip\":\"Separator used to print more values/variables\"}}","(function(root, factory) {\n  if (typeof define === 'function' && define.amd) {\n    define([], factory) /* global define */\n  } else if (typeof module === 'object' && module.exports) {\n    module.exports = factory()\n  } else {\n    root.moo = factory()\n  }\n}(this, function() {\n  'use strict';\n\n  var hasOwnProperty = Object.prototype.hasOwnProperty\n  var toString = Object.prototype.toString\n  var hasSticky = typeof new RegExp().sticky === 'boolean'\n\n  /***************************************************************************/\n\n  function isRegExp(o) { return o && toString.call(o) === '[object RegExp]' }\n  function isObject(o) { return o && typeof o === 'object' && !isRegExp(o) && !Array.isArray(o) }\n\n  function reEscape(s) {\n    return s.replace(/[-\\/\\\\^$*+?.()|[\\]{}]/g, '\\\\$&')\n  }\n  function reGroups(s) {\n    var re = new RegExp('|' + s)\n    return re.exec('').length - 1\n  }\n  function reCapture(s) {\n    return '(' + s + ')'\n  }\n  function reUnion(regexps) {\n    if (!regexps.length) return '(?!)'\n    var source =  regexps.map(function(s) {\n      return \"(?:\" + s + \")\"\n    }).join('|')\n    return \"(?:\" + source + \")\"\n  }\n\n  function regexpOrLiteral(obj) {\n    if (typeof obj === 'string') {\n      return '(?:' + reEscape(obj) + ')'\n\n    } else if (isRegExp(obj)) {\n      // TODO: consider /u support\n      if (obj.ignoreCase) throw new Error('RegExp /i flag not allowed')\n      if (obj.global) throw new Error('RegExp /g flag is implied')\n      if (obj.sticky) throw new Error('RegExp /y flag is implied')\n      if (obj.multiline) throw new Error('RegExp /m flag is implied')\n      return obj.source\n\n    } else {\n      throw new Error('Not a pattern: ' + obj)\n    }\n  }\n\n  function pad(s, length) {\n    if (s.length > length) {\n      return s\n    }\n    return Array(length - s.length + 1).join(\" \") + s\n  }\n\n  function lastNLines(string, numLines) {\n    var position = string.length\n    var lineBreaks = 0;\n    while (true) {\n      var idx = string.lastIndexOf(\"\\n\", position - 1)\n      if (idx === -1) {\n        break;\n      } else {\n        lineBreaks++\n      }\n      position = idx\n      if (lineBreaks === numLines) {\n        break;\n      }\n      if (position === 0) {\n        break;\n      }\n    }\n    var startPosition = \n      lineBreaks < numLines ?\n      0 : \n      position + 1\n    return string.substring(startPosition).split(\"\\n\")\n  }\n\n  function objectToRules(object) {\n    var keys = Object.getOwnPropertyNames(object)\n    var result = []\n    for (var i = 0; i < keys.length; i++) {\n      var key = keys[i]\n      var thing = object[key]\n      var rules = [].concat(thing)\n      if (key === 'include') {\n        for (var j = 0; j < rules.length; j++) {\n          result.push({include: rules[j]})\n        }\n        continue\n      }\n      var match = []\n      rules.forEach(function(rule) {\n        if (isObject(rule)) {\n          if (match.length) result.push(ruleOptions(key, match))\n          result.push(ruleOptions(key, rule))\n          match = []\n        } else {\n          match.push(rule)\n        }\n      })\n      if (match.length) result.push(ruleOptions(key, match))\n    }\n    return result\n  }\n\n  function arrayToRules(array) {\n    var result = []\n    for (var i = 0; i < array.length; i++) {\n      var obj = array[i]\n      if (obj.include) {\n        var include = [].concat(obj.include)\n        for (var j = 0; j < include.length; j++) {\n          result.push({include: include[j]})\n        }\n        continue\n      }\n      if (!obj.type) {\n        throw new Error('Rule has no type: ' + JSON.stringify(obj))\n      }\n      result.push(ruleOptions(obj.type, obj))\n    }\n    return result\n  }\n\n  function ruleOptions(type, obj) {\n    if (!isObject(obj)) {\n      obj = { match: obj }\n    }\n    if (obj.include) {\n      throw new Error('Matching rules cannot also include states')\n    }\n\n    // nb. error and fallback imply lineBreaks\n    var options = {\n      defaultType: type,\n      lineBreaks: !!obj.error || !!obj.fallback,\n      pop: false,\n      next: null,\n      push: null,\n      error: false,\n      fallback: false,\n      value: null,\n      type: null,\n      shouldThrow: false,\n    }\n\n    // Avoid Object.assign(), so we support IE9+\n    for (var key in obj) {\n      if (hasOwnProperty.call(obj, key)) {\n        options[key] = obj[key]\n      }\n    }\n\n    // type transform cannot be a string\n    if (typeof options.type === 'string' && type !== options.type) {\n      throw new Error(\"Type transform cannot be a string (type '\" + options.type + \"' for token '\" + type + \"')\")\n    }\n\n    // convert to array\n    var match = options.match\n    options.match = Array.isArray(match) ? match : match ? [match] : []\n    options.match.sort(function(a, b) {\n      return isRegExp(a) && isRegExp(b) ? 0\n           : isRegExp(b) ? -1 : isRegExp(a) ? +1 : b.length - a.length\n    })\n    return options\n  }\n\n  function toRules(spec) {\n    return Array.isArray(spec) ? arrayToRules(spec) : objectToRules(spec)\n  }\n\n  var defaultErrorRule = ruleOptions('error', {lineBreaks: true, shouldThrow: true})\n  function compileRules(rules, hasStates) {\n    var errorRule = null\n    var fast = Object.create(null)\n    var fastAllowed = true\n    var unicodeFlag = null\n    var groups = []\n    var parts = []\n\n    // If there is a fallback rule, then disable fast matching\n    for (var i = 0; i < rules.length; i++) {\n      if (rules[i].fallback) {\n        fastAllowed = false\n      }\n    }\n\n    for (var i = 0; i < rules.length; i++) {\n      var options = rules[i]\n\n      if (options.include) {\n        // all valid inclusions are removed by states() preprocessor\n        throw new Error('Inheritance is not allowed in stateless lexers')\n      }\n\n      if (options.error || options.fallback) {\n        // errorRule can only be set once\n        if (errorRule) {\n          if (!options.fallback === !errorRule.fallback) {\n            throw new Error(\"Multiple \" + (options.fallback ? \"fallback\" : \"error\") + \" rules not allowed (for token '\" + options.defaultType + \"')\")\n          } else {\n            throw new Error(\"fallback and error are mutually exclusive (for token '\" + options.defaultType + \"')\")\n          }\n        }\n        errorRule = options\n      }\n\n      var match = options.match.slice()\n      if (fastAllowed) {\n        while (match.length && typeof match[0] === 'string' && match[0].length === 1) {\n          var word = match.shift()\n          fast[word.charCodeAt(0)] = options\n        }\n      }\n\n      // Warn about inappropriate state-switching options\n      if (options.pop || options.push || options.next) {\n        if (!hasStates) {\n          throw new Error(\"State-switching options are not allowed in stateless lexers (for token '\" + options.defaultType + \"')\")\n        }\n        if (options.fallback) {\n          throw new Error(\"State-switching options are not allowed on fallback tokens (for token '\" + options.defaultType + \"')\")\n        }\n      }\n\n      // Only rules with a .match are included in the RegExp\n      if (match.length === 0) {\n        continue\n      }\n      fastAllowed = false\n\n      groups.push(options)\n\n      // Check unicode flag is used everywhere or nowhere\n      for (var j = 0; j < match.length; j++) {\n        var obj = match[j]\n        if (!isRegExp(obj)) {\n          continue\n        }\n\n        if (unicodeFlag === null) {\n          unicodeFlag = obj.unicode\n        } else if (unicodeFlag !== obj.unicode && options.fallback === false) {\n          throw new Error('If one rule is /u then all must be')\n        }\n      }\n\n      // convert to RegExp\n      var pat = reUnion(match.map(regexpOrLiteral))\n\n      // validate\n      var regexp = new RegExp(pat)\n      if (regexp.test(\"\")) {\n        throw new Error(\"RegExp matches empty string: \" + regexp)\n      }\n      var groupCount = reGroups(pat)\n      if (groupCount > 0) {\n        throw new Error(\"RegExp has capture groups: \" + regexp + \"\\nUse (?: … ) instead\")\n      }\n\n      // try and detect rules matching newlines\n      if (!options.lineBreaks && regexp.test('\\n')) {\n        throw new Error('Rule should declare lineBreaks: ' + regexp)\n      }\n\n      // store regex\n      parts.push(reCapture(pat))\n    }\n\n\n    // If there's no fallback rule, use the sticky flag so we only look for\n    // matches at the current index.\n    //\n    // If we don't support the sticky flag, then fake it using an irrefutable\n    // match (i.e. an empty pattern).\n    var fallbackRule = errorRule && errorRule.fallback\n    var flags = hasSticky && !fallbackRule ? 'ym' : 'gm'\n    var suffix = hasSticky || fallbackRule ? '' : '|'\n\n    if (unicodeFlag === true) flags += \"u\"\n    var combined = new RegExp(reUnion(parts) + suffix, flags)\n    return {regexp: combined, groups: groups, fast: fast, error: errorRule || defaultErrorRule}\n  }\n\n  function compile(rules) {\n    var result = compileRules(toRules(rules))\n    return new Lexer({start: result}, 'start')\n  }\n\n  function checkStateGroup(g, name, map) {\n    var state = g && (g.push || g.next)\n    if (state && !map[state]) {\n      throw new Error(\"Missing state '\" + state + \"' (in token '\" + g.defaultType + \"' of state '\" + name + \"')\")\n    }\n    if (g && g.pop && +g.pop !== 1) {\n      throw new Error(\"pop must be 1 (in token '\" + g.defaultType + \"' of state '\" + name + \"')\")\n    }\n  }\n  function compileStates(states, start) {\n    var all = states.$all ? toRules(states.$all) : []\n    delete states.$all\n\n    var keys = Object.getOwnPropertyNames(states)\n    if (!start) start = keys[0]\n\n    var ruleMap = Object.create(null)\n    for (var i = 0; i < keys.length; i++) {\n      var key = keys[i]\n      ruleMap[key] = toRules(states[key]).concat(all)\n    }\n    for (var i = 0; i < keys.length; i++) {\n      var key = keys[i]\n      var rules = ruleMap[key]\n      var included = Object.create(null)\n      for (var j = 0; j < rules.length; j++) {\n        var rule = rules[j]\n        if (!rule.include) continue\n        var splice = [j, 1]\n        if (rule.include !== key && !included[rule.include]) {\n          included[rule.include] = true\n          var newRules = ruleMap[rule.include]\n          if (!newRules) {\n            throw new Error(\"Cannot include nonexistent state '\" + rule.include + \"' (in state '\" + key + \"')\")\n          }\n          for (var k = 0; k < newRules.length; k++) {\n            var newRule = newRules[k]\n            if (rules.indexOf(newRule) !== -1) continue\n            splice.push(newRule)\n          }\n        }\n        rules.splice.apply(rules, splice)\n        j--\n      }\n    }\n\n    var map = Object.create(null)\n    for (var i = 0; i < keys.length; i++) {\n      var key = keys[i]\n      map[key] = compileRules(ruleMap[key], true)\n    }\n\n    for (var i = 0; i < keys.length; i++) {\n      var name = keys[i]\n      var state = map[name]\n      var groups = state.groups\n      for (var j = 0; j < groups.length; j++) {\n        checkStateGroup(groups[j], name, map)\n      }\n      var fastKeys = Object.getOwnPropertyNames(state.fast)\n      for (var j = 0; j < fastKeys.length; j++) {\n        checkStateGroup(state.fast[fastKeys[j]], name, map)\n      }\n    }\n\n    return new Lexer(map, start)\n  }\n\n  function keywordTransform(map) {\n\n    // Use a JavaScript Map to map keywords to their corresponding token type\n    // unless Map is unsupported, then fall back to using an Object:\n    var isMap = typeof Map !== 'undefined'\n    var reverseMap = isMap ? new Map : Object.create(null)\n\n    var types = Object.getOwnPropertyNames(map)\n    for (var i = 0; i < types.length; i++) {\n      var tokenType = types[i]\n      var item = map[tokenType]\n      var keywordList = Array.isArray(item) ? item : [item]\n      keywordList.forEach(function(keyword) {\n        if (typeof keyword !== 'string') {\n          throw new Error(\"keyword must be string (in keyword '\" + tokenType + \"')\")\n        }\n        if (isMap) {\n          reverseMap.set(keyword, tokenType)\n        } else {\n          reverseMap[keyword] = tokenType\n        }\n      })\n    }\n    return function(k) {\n      return isMap ? reverseMap.get(k) : reverseMap[k]\n    }\n  }\n\n  /***************************************************************************/\n\n  var Lexer = function(states, state) {\n    this.startState = state\n    this.states = states\n    this.buffer = ''\n    this.stack = []\n    this.reset()\n  }\n\n  Lexer.prototype.reset = function(data, info) {\n    this.buffer = data || ''\n    this.index = 0\n    this.line = info ? info.line : 1\n    this.col = info ? info.col : 1\n    this.queuedToken = info ? info.queuedToken : null\n    this.queuedText = info ? info.queuedText: \"\";\n    this.queuedThrow = info ? info.queuedThrow : null\n    this.setState(info ? info.state : this.startState)\n    this.stack = info && info.stack ? info.stack.slice() : []\n    return this\n  }\n\n  Lexer.prototype.save = function() {\n    return {\n      line: this.line,\n      col: this.col,\n      state: this.state,\n      stack: this.stack.slice(),\n      queuedToken: this.queuedToken,\n      queuedText: this.queuedText,\n      queuedThrow: this.queuedThrow,\n    }\n  }\n\n  Lexer.prototype.setState = function(state) {\n    if (!state || this.state === state) return\n    this.state = state\n    var info = this.states[state]\n    this.groups = info.groups\n    this.error = info.error\n    this.re = info.regexp\n    this.fast = info.fast\n  }\n\n  Lexer.prototype.popState = function() {\n    this.setState(this.stack.pop())\n  }\n\n  Lexer.prototype.pushState = function(state) {\n    this.stack.push(this.state)\n    this.setState(state)\n  }\n\n  var eat = hasSticky ? function(re, buffer) { // assume re is /y\n    return re.exec(buffer)\n  } : function(re, buffer) { // assume re is /g\n    var match = re.exec(buffer)\n    // will always match, since we used the |(?:) trick\n    if (match[0].length === 0) {\n      return null\n    }\n    return match\n  }\n\n  Lexer.prototype._getGroup = function(match) {\n    var groupCount = this.groups.length\n    for (var i = 0; i < groupCount; i++) {\n      if (match[i + 1] !== undefined) {\n        return this.groups[i]\n      }\n    }\n    throw new Error('Cannot find token type for matched text')\n  }\n\n  function tokenToString() {\n    return this.value\n  }\n\n  Lexer.prototype.next = function() {\n    var index = this.index\n\n    // If a fallback token matched, we don't need to re-run the RegExp\n    if (this.queuedGroup) {\n      var token = this._token(this.queuedGroup, this.queuedText, index)\n      this.queuedGroup = null\n      this.queuedText = \"\"\n      return token\n    }\n\n    var buffer = this.buffer\n    if (index === buffer.length) {\n      return // EOF\n    }\n\n    // Fast matching for single characters\n    var group = this.fast[buffer.charCodeAt(index)]\n    if (group) {\n      return this._token(group, buffer.charAt(index), index)\n    }\n\n    // Execute RegExp\n    var re = this.re\n    re.lastIndex = index\n    var match = eat(re, buffer)\n\n    // Error tokens match the remaining buffer\n    var error = this.error\n    if (match == null) {\n      return this._token(error, buffer.slice(index, buffer.length), index)\n    }\n\n    var group = this._getGroup(match)\n    var text = match[0]\n\n    if (error.fallback && match.index !== index) {\n      this.queuedGroup = group\n      this.queuedText = text\n\n      // Fallback tokens contain the unmatched portion of the buffer\n      return this._token(error, buffer.slice(index, match.index), index)\n    }\n\n    return this._token(group, text, index)\n  }\n\n  Lexer.prototype._token = function(group, text, offset) {\n    // count line breaks\n    var lineBreaks = 0\n    if (group.lineBreaks) {\n      var matchNL = /\\n/g\n      var nl = 1\n      if (text === '\\n') {\n        lineBreaks = 1\n      } else {\n        while (matchNL.exec(text)) { lineBreaks++; nl = matchNL.lastIndex }\n      }\n    }\n\n    var token = {\n      type: (typeof group.type === 'function' && group.type(text)) || group.defaultType,\n      value: typeof group.value === 'function' ? group.value(text) : text,\n      text: text,\n      toString: tokenToString,\n      offset: offset,\n      lineBreaks: lineBreaks,\n      line: this.line,\n      col: this.col,\n    }\n    // nb. adding more props to token object will make V8 sad!\n\n    var size = text.length\n    this.index += size\n    this.line += lineBreaks\n    if (lineBreaks !== 0) {\n      this.col = size - nl + 1\n    } else {\n      this.col += size\n    }\n\n    // throw, if no rule with {error: true}\n    if (group.shouldThrow) {\n      var err = new Error(this.formatError(token, \"invalid syntax\"))\n      throw err;\n    }\n\n    if (group.pop) this.popState()\n    else if (group.push) this.pushState(group.push)\n    else if (group.next) this.setState(group.next)\n\n    return token\n  }\n\n  if (typeof Symbol !== 'undefined' && Symbol.iterator) {\n    var LexerIterator = function(lexer) {\n      this.lexer = lexer\n    }\n\n    LexerIterator.prototype.next = function() {\n      var token = this.lexer.next()\n      return {value: token, done: !token}\n    }\n\n    LexerIterator.prototype[Symbol.iterator] = function() {\n      return this\n    }\n\n    Lexer.prototype[Symbol.iterator] = function() {\n      return new LexerIterator(this)\n    }\n  }\n\n  Lexer.prototype.formatError = function(token, message) {\n    if (token == null) {\n      // An undefined token indicates EOF\n      var text = this.buffer.slice(this.index)\n      var token = {\n        text: text,\n        offset: this.index,\n        lineBreaks: text.indexOf('\\n') === -1 ? 0 : 1,\n        line: this.line,\n        col: this.col,\n      }\n    }\n    \n    var numLinesAround = 2\n    var firstDisplayedLine = Math.max(token.line - numLinesAround, 1)\n    var lastDisplayedLine = token.line + numLinesAround\n    var lastLineDigits = String(lastDisplayedLine).length\n    var displayedLines = lastNLines(\n        this.buffer, \n        (this.line - token.line) + numLinesAround + 1\n      )\n      .slice(0, 5)\n    var errorLines = []\n    errorLines.push(message + \" at line \" + token.line + \" col \" + token.col + \":\")\n    errorLines.push(\"\")\n    for (var i = 0; i < displayedLines.length; i++) {\n      var line = displayedLines[i]\n      var lineNo = firstDisplayedLine + i\n      errorLines.push(pad(String(lineNo), lastLineDigits) + \"  \" + line);\n      if (lineNo === token.line) {\n        errorLines.push(pad(\"\", lastLineDigits + token.col + 1) + \"^\")\n      }\n    }\n    return errorLines.join(\"\\n\")\n  }\n\n  Lexer.prototype.clone = function() {\n    return new Lexer(this.states, this.state)\n  }\n\n  Lexer.prototype.has = function(tokenType) {\n    return true\n  }\n\n\n  return {\n    compile: compile,\n    states: compileStates,\n    error: Object.freeze({error: true}),\n    fallback: Object.freeze({fallback: true}),\n    keywords: keywordTransform,\n  }\n\n}));\n","var _typeof = require(\"./typeof.js\")[\"default\"];\nfunction _regeneratorRuntime() {\n  \"use strict\"; /*! regenerator-runtime -- Copyright (c) 2014-present, Facebook, Inc. -- license (MIT): https://github.com/facebook/regenerator/blob/main/LICENSE */\n  module.exports = _regeneratorRuntime = function _regeneratorRuntime() {\n    return exports;\n  }, module.exports.__esModule = true, module.exports[\"default\"] = module.exports;\n  var exports = {},\n    Op = Object.prototype,\n    hasOwn = Op.hasOwnProperty,\n    defineProperty = Object.defineProperty || function (obj, key, desc) {\n      obj[key] = desc.value;\n    },\n    $Symbol = \"function\" == typeof Symbol ? Symbol : {},\n    iteratorSymbol = $Symbol.iterator || \"@@iterator\",\n    asyncIteratorSymbol = $Symbol.asyncIterator || \"@@asyncIterator\",\n    toStringTagSymbol = $Symbol.toStringTag || \"@@toStringTag\";\n  function define(obj, key, value) {\n    return Object.defineProperty(obj, key, {\n      value: value,\n      enumerable: !0,\n      configurable: !0,\n      writable: !0\n    }), obj[key];\n  }\n  try {\n    define({}, \"\");\n  } catch (err) {\n    define = function define(obj, key, value) {\n      return obj[key] = value;\n    };\n  }\n  function wrap(innerFn, outerFn, self, tryLocsList) {\n    var protoGenerator = outerFn && outerFn.prototype instanceof Generator ? outerFn : Generator,\n      generator = Object.create(protoGenerator.prototype),\n      context = new Context(tryLocsList || []);\n    return defineProperty(generator, \"_invoke\", {\n      value: makeInvokeMethod(innerFn, self, context)\n    }), generator;\n  }\n  function tryCatch(fn, obj, arg) {\n    try {\n      return {\n        type: \"normal\",\n        arg: fn.call(obj, arg)\n      };\n    } catch (err) {\n      return {\n        type: \"throw\",\n        arg: err\n      };\n    }\n  }\n  exports.wrap = wrap;\n  var ContinueSentinel = {};\n  function Generator() {}\n  function GeneratorFunction() {}\n  function GeneratorFunctionPrototype() {}\n  var IteratorPrototype = {};\n  define(IteratorPrototype, iteratorSymbol, function () {\n    return this;\n  });\n  var getProto = Object.getPrototypeOf,\n    NativeIteratorPrototype = getProto && getProto(getProto(values([])));\n  NativeIteratorPrototype && NativeIteratorPrototype !== Op && hasOwn.call(NativeIteratorPrototype, iteratorSymbol) && (IteratorPrototype = NativeIteratorPrototype);\n  var Gp = GeneratorFunctionPrototype.prototype = Generator.prototype = Object.create(IteratorPrototype);\n  function defineIteratorMethods(prototype) {\n    [\"next\", \"throw\", \"return\"].forEach(function (method) {\n      define(prototype, method, function (arg) {\n        return this._invoke(method, arg);\n      });\n    });\n  }\n  function AsyncIterator(generator, PromiseImpl) {\n    function invoke(method, arg, resolve, reject) {\n      var record = tryCatch(generator[method], generator, arg);\n      if (\"throw\" !== record.type) {\n        var result = record.arg,\n          value = result.value;\n        return value && \"object\" == _typeof(value) && hasOwn.call(value, \"__await\") ? PromiseImpl.resolve(value.__await).then(function (value) {\n          invoke(\"next\", value, resolve, reject);\n        }, function (err) {\n          invoke(\"throw\", err, resolve, reject);\n        }) : PromiseImpl.resolve(value).then(function (unwrapped) {\n          result.value = unwrapped, resolve(result);\n        }, function (error) {\n          return invoke(\"throw\", error, resolve, reject);\n        });\n      }\n      reject(record.arg);\n    }\n    var previousPromise;\n    defineProperty(this, \"_invoke\", {\n      value: function value(method, arg) {\n        function callInvokeWithMethodAndArg() {\n          return new PromiseImpl(function (resolve, reject) {\n            invoke(method, arg, resolve, reject);\n          });\n        }\n        return previousPromise = previousPromise ? previousPromise.then(callInvokeWithMethodAndArg, callInvokeWithMethodAndArg) : callInvokeWithMethodAndArg();\n      }\n    });\n  }\n  function makeInvokeMethod(innerFn, self, context) {\n    var state = \"suspendedStart\";\n    return function (method, arg) {\n      if (\"executing\" === state) throw new Error(\"Generator is already running\");\n      if (\"completed\" === state) {\n        if (\"throw\" === method) throw arg;\n        return doneResult();\n      }\n      for (context.method = method, context.arg = arg;;) {\n        var delegate = context.delegate;\n        if (delegate) {\n          var delegateResult = maybeInvokeDelegate(delegate, context);\n          if (delegateResult) {\n            if (delegateResult === ContinueSentinel) continue;\n            return delegateResult;\n          }\n        }\n        if (\"next\" === context.method) context.sent = context._sent = context.arg;else if (\"throw\" === context.method) {\n          if (\"suspendedStart\" === state) throw state = \"completed\", context.arg;\n          context.dispatchException(context.arg);\n        } else \"return\" === context.method && context.abrupt(\"return\", context.arg);\n        state = \"executing\";\n        var record = tryCatch(innerFn, self, context);\n        if (\"normal\" === record.type) {\n          if (state = context.done ? \"completed\" : \"suspendedYield\", record.arg === ContinueSentinel) continue;\n          return {\n            value: record.arg,\n            done: context.done\n          };\n        }\n        \"throw\" === record.type && (state = \"completed\", context.method = \"throw\", context.arg = record.arg);\n      }\n    };\n  }\n  function maybeInvokeDelegate(delegate, context) {\n    var methodName = context.method,\n      method = delegate.iterator[methodName];\n    if (undefined === method) return context.delegate = null, \"throw\" === methodName && delegate.iterator[\"return\"] && (context.method = \"return\", context.arg = undefined, maybeInvokeDelegate(delegate, context), \"throw\" === context.method) || \"return\" !== methodName && (context.method = \"throw\", context.arg = new TypeError(\"The iterator does not provide a '\" + methodName + \"' method\")), ContinueSentinel;\n    var record = tryCatch(method, delegate.iterator, context.arg);\n    if (\"throw\" === record.type) return context.method = \"throw\", context.arg = record.arg, context.delegate = null, ContinueSentinel;\n    var info = record.arg;\n    return info ? info.done ? (context[delegate.resultName] = info.value, context.next = delegate.nextLoc, \"return\" !== context.method && (context.method = \"next\", context.arg = undefined), context.delegate = null, ContinueSentinel) : info : (context.method = \"throw\", context.arg = new TypeError(\"iterator result is not an object\"), context.delegate = null, ContinueSentinel);\n  }\n  function pushTryEntry(locs) {\n    var entry = {\n      tryLoc: locs[0]\n    };\n    1 in locs && (entry.catchLoc = locs[1]), 2 in locs && (entry.finallyLoc = locs[2], entry.afterLoc = locs[3]), this.tryEntries.push(entry);\n  }\n  function resetTryEntry(entry) {\n    var record = entry.completion || {};\n    record.type = \"normal\", delete record.arg, entry.completion = record;\n  }\n  function Context(tryLocsList) {\n    this.tryEntries = [{\n      tryLoc: \"root\"\n    }], tryLocsList.forEach(pushTryEntry, this), this.reset(!0);\n  }\n  function values(iterable) {\n    if (iterable) {\n      var iteratorMethod = iterable[iteratorSymbol];\n      if (iteratorMethod) return iteratorMethod.call(iterable);\n      if (\"function\" == typeof iterable.next) return iterable;\n      if (!isNaN(iterable.length)) {\n        var i = -1,\n          next = function next() {\n            for (; ++i < iterable.length;) if (hasOwn.call(iterable, i)) return next.value = iterable[i], next.done = !1, next;\n            return next.value = undefined, next.done = !0, next;\n          };\n        return next.next = next;\n      }\n    }\n    return {\n      next: doneResult\n    };\n  }\n  function doneResult() {\n    return {\n      value: undefined,\n      done: !0\n    };\n  }\n  return GeneratorFunction.prototype = GeneratorFunctionPrototype, defineProperty(Gp, \"constructor\", {\n    value: GeneratorFunctionPrototype,\n    configurable: !0\n  }), defineProperty(GeneratorFunctionPrototype, \"constructor\", {\n    value: GeneratorFunction,\n    configurable: !0\n  }), GeneratorFunction.displayName = define(GeneratorFunctionPrototype, toStringTagSymbol, \"GeneratorFunction\"), exports.isGeneratorFunction = function (genFun) {\n    var ctor = \"function\" == typeof genFun && genFun.constructor;\n    return !!ctor && (ctor === GeneratorFunction || \"GeneratorFunction\" === (ctor.displayName || ctor.name));\n  }, exports.mark = function (genFun) {\n    return Object.setPrototypeOf ? Object.setPrototypeOf(genFun, GeneratorFunctionPrototype) : (genFun.__proto__ = GeneratorFunctionPrototype, define(genFun, toStringTagSymbol, \"GeneratorFunction\")), genFun.prototype = Object.create(Gp), genFun;\n  }, exports.awrap = function (arg) {\n    return {\n      __await: arg\n    };\n  }, defineIteratorMethods(AsyncIterator.prototype), define(AsyncIterator.prototype, asyncIteratorSymbol, function () {\n    return this;\n  }), exports.AsyncIterator = AsyncIterator, exports.async = function (innerFn, outerFn, self, tryLocsList, PromiseImpl) {\n    void 0 === PromiseImpl && (PromiseImpl = Promise);\n    var iter = new AsyncIterator(wrap(innerFn, outerFn, self, tryLocsList), PromiseImpl);\n    return exports.isGeneratorFunction(outerFn) ? iter : iter.next().then(function (result) {\n      return result.done ? result.value : iter.next();\n    });\n  }, defineIteratorMethods(Gp), define(Gp, toStringTagSymbol, \"Generator\"), define(Gp, iteratorSymbol, function () {\n    return this;\n  }), define(Gp, \"toString\", function () {\n    return \"[object Generator]\";\n  }), exports.keys = function (val) {\n    var object = Object(val),\n      keys = [];\n    for (var key in object) keys.push(key);\n    return keys.reverse(), function next() {\n      for (; keys.length;) {\n        var key = keys.pop();\n        if (key in object) return next.value = key, next.done = !1, next;\n      }\n      return next.done = !0, next;\n    };\n  }, exports.values = values, Context.prototype = {\n    constructor: Context,\n    reset: function reset(skipTempReset) {\n      if (this.prev = 0, this.next = 0, this.sent = this._sent = undefined, this.done = !1, this.delegate = null, this.method = \"next\", this.arg = undefined, this.tryEntries.forEach(resetTryEntry), !skipTempReset) for (var name in this) \"t\" === name.charAt(0) && hasOwn.call(this, name) && !isNaN(+name.slice(1)) && (this[name] = undefined);\n    },\n    stop: function stop() {\n      this.done = !0;\n      var rootRecord = this.tryEntries[0].completion;\n      if (\"throw\" === rootRecord.type) throw rootRecord.arg;\n      return this.rval;\n    },\n    dispatchException: function dispatchException(exception) {\n      if (this.done) throw exception;\n      var context = this;\n      function handle(loc, caught) {\n        return record.type = \"throw\", record.arg = exception, context.next = loc, caught && (context.method = \"next\", context.arg = undefined), !!caught;\n      }\n      for (var i = this.tryEntries.length - 1; i >= 0; --i) {\n        var entry = this.tryEntries[i],\n          record = entry.completion;\n        if (\"root\" === entry.tryLoc) return handle(\"end\");\n        if (entry.tryLoc <= this.prev) {\n          var hasCatch = hasOwn.call(entry, \"catchLoc\"),\n            hasFinally = hasOwn.call(entry, \"finallyLoc\");\n          if (hasCatch && hasFinally) {\n            if (this.prev < entry.catchLoc) return handle(entry.catchLoc, !0);\n            if (this.prev < entry.finallyLoc) return handle(entry.finallyLoc);\n          } else if (hasCatch) {\n            if (this.prev < entry.catchLoc) return handle(entry.catchLoc, !0);\n          } else {\n            if (!hasFinally) throw new Error(\"try statement without catch or finally\");\n            if (this.prev < entry.finallyLoc) return handle(entry.finallyLoc);\n          }\n        }\n      }\n    },\n    abrupt: function abrupt(type, arg) {\n      for (var i = this.tryEntries.length - 1; i >= 0; --i) {\n        var entry = this.tryEntries[i];\n        if (entry.tryLoc <= this.prev && hasOwn.call(entry, \"finallyLoc\") && this.prev < entry.finallyLoc) {\n          var finallyEntry = entry;\n          break;\n        }\n      }\n      finallyEntry && (\"break\" === type || \"continue\" === type) && finallyEntry.tryLoc <= arg && arg <= finallyEntry.finallyLoc && (finallyEntry = null);\n      var record = finallyEntry ? finallyEntry.completion : {};\n      return record.type = type, record.arg = arg, finallyEntry ? (this.method = \"next\", this.next = finallyEntry.finallyLoc, ContinueSentinel) : this.complete(record);\n    },\n    complete: function complete(record, afterLoc) {\n      if (\"throw\" === record.type) throw record.arg;\n      return \"break\" === record.type || \"continue\" === record.type ? this.next = record.arg : \"return\" === record.type ? (this.rval = this.arg = record.arg, this.method = \"return\", this.next = \"end\") : \"normal\" === record.type && afterLoc && (this.next = afterLoc), ContinueSentinel;\n    },\n    finish: function finish(finallyLoc) {\n      for (var i = this.tryEntries.length - 1; i >= 0; --i) {\n        var entry = this.tryEntries[i];\n        if (entry.finallyLoc === finallyLoc) return this.complete(entry.completion, entry.afterLoc), resetTryEntry(entry), ContinueSentinel;\n      }\n    },\n    \"catch\": function _catch(tryLoc) {\n      for (var i = this.tryEntries.length - 1; i >= 0; --i) {\n        var entry = this.tryEntries[i];\n        if (entry.tryLoc === tryLoc) {\n          var record = entry.completion;\n          if (\"throw\" === record.type) {\n            var thrown = record.arg;\n            resetTryEntry(entry);\n          }\n          return thrown;\n        }\n      }\n      throw new Error(\"illegal catch attempt\");\n    },\n    delegateYield: function delegateYield(iterable, resultName, nextLoc) {\n      return this.delegate = {\n        iterator: values(iterable),\n        resultName: resultName,\n        nextLoc: nextLoc\n      }, \"next\" === this.method && (this.arg = undefined), ContinueSentinel;\n    }\n  }, exports;\n}\nmodule.exports = _regeneratorRuntime, module.exports.__esModule = true, module.exports[\"default\"] = module.exports;","function _typeof(obj) {\n  \"@babel/helpers - typeof\";\n\n  return (module.exports = _typeof = \"function\" == typeof Symbol && \"symbol\" == typeof Symbol.iterator ? function (obj) {\n    return typeof obj;\n  } : function (obj) {\n    return obj && \"function\" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? \"symbol\" : typeof obj;\n  }, module.exports.__esModule = true, module.exports[\"default\"] = module.exports), _typeof(obj);\n}\nmodule.exports = _typeof, module.exports.__esModule = true, module.exports[\"default\"] = module.exports;","// TODO(Babel 8): Remove this file.\n\nvar runtime = require(\"../helpers/regeneratorRuntime\")();\nmodule.exports = runtime;\n\n// Copied from https://github.com/facebook/regenerator/blob/main/packages/runtime/runtime.js#L736=\ntry {\n  regeneratorRuntime = runtime;\n} catch (accidentalStrictMode) {\n  if (typeof globalThis === \"object\") {\n    globalThis.regeneratorRuntime = runtime;\n  } else {\n    Function(\"r\", \"regeneratorRuntime = r\")(runtime);\n  }\n}\n","// The module cache\nvar __webpack_module_cache__ = {};\n\n// The require function\nfunction __webpack_require__(moduleId) {\n\t// Check if module is in cache\n\tvar cachedModule = __webpack_module_cache__[moduleId];\n\tif (cachedModule !== undefined) {\n\t\treturn cachedModule.exports;\n\t}\n\t// Create a new module (and put it into the cache)\n\tvar module = __webpack_module_cache__[moduleId] = {\n\t\t// no module.id needed\n\t\t// no module.loaded needed\n\t\texports: {}\n\t};\n\n\t// Execute the module function\n\t__webpack_modules__[moduleId].call(module.exports, module, module.exports, __webpack_require__);\n\n\t// Return the exports of the module\n\treturn module.exports;\n}\n\n","// getDefaultExport function for compatibility with non-harmony modules\n__webpack_require__.n = (module) => {\n\tvar getter = module && module.__esModule ?\n\t\t() => (module['default']) :\n\t\t() => (module);\n\t__webpack_require__.d(getter, { a: getter });\n\treturn getter;\n};","// define getter functions for harmony exports\n__webpack_require__.d = (exports, definition) => {\n\tfor(var key in definition) {\n\t\tif(__webpack_require__.o(definition, key) && !__webpack_require__.o(exports, key)) {\n\t\t\tObject.defineProperty(exports, key, { enumerable: true, get: definition[key] });\n\t\t}\n\t}\n};","__webpack_require__.o = (obj, prop) => (Object.prototype.hasOwnProperty.call(obj, prop))","// define __esModule on exports\n__webpack_require__.r = (exports) => {\n\tif(typeof Symbol !== 'undefined' && Symbol.toStringTag) {\n\t\tObject.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });\n\t}\n\tObject.defineProperty(exports, '__esModule', { value: true });\n};","function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {\n  try {\n    var info = gen[key](arg);\n    var value = info.value;\n  } catch (error) {\n    reject(error);\n    return;\n  }\n  if (info.done) {\n    resolve(value);\n  } else {\n    Promise.resolve(value).then(_next, _throw);\n  }\n}\nexport default function _asyncToGenerator(fn) {\n  return function () {\n    var self = this,\n      args = arguments;\n    return new Promise(function (resolve, reject) {\n      var gen = fn.apply(self, args);\n      function _next(value) {\n        asyncGeneratorStep(gen, resolve, reject, _next, _throw, \"next\", value);\n      }\n      function _throw(err) {\n        asyncGeneratorStep(gen, resolve, reject, _next, _throw, \"throw\", err);\n      }\n      _next(undefined);\n    });\n  };\n}","export default function _classCallCheck(instance, Constructor) {\n  if (!(instance instanceof Constructor)) {\n    throw new TypeError(\"Cannot call a class as a function\");\n  }\n}","export default function _typeof(obj) {\n  \"@babel/helpers - typeof\";\n\n  return _typeof = \"function\" == typeof Symbol && \"symbol\" == typeof Symbol.iterator ? function (obj) {\n    return typeof obj;\n  } : function (obj) {\n    return obj && \"function\" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? \"symbol\" : typeof obj;\n  }, _typeof(obj);\n}","import _typeof from \"./typeof.js\";\nimport toPrimitive from \"./toPrimitive.js\";\nexport default function _toPropertyKey(arg) {\n  var key = toPrimitive(arg, \"string\");\n  return _typeof(key) === \"symbol\" ? key : String(key);\n}","import _typeof from \"./typeof.js\";\nexport default function _toPrimitive(input, hint) {\n  if (_typeof(input) !== \"object\" || input === null) return input;\n  var prim = input[Symbol.toPrimitive];\n  if (prim !== undefined) {\n    var res = prim.call(input, hint || \"default\");\n    if (_typeof(res) !== \"object\") return res;\n    throw new TypeError(\"@@toPrimitive must return a primitive value.\");\n  }\n  return (hint === \"string\" ? String : Number)(input);\n}","import toPropertyKey from \"./toPropertyKey.js\";\nfunction _defineProperties(target, props) {\n  for (var i = 0; i < props.length; i++) {\n    var descriptor = props[i];\n    descriptor.enumerable = descriptor.enumerable || false;\n    descriptor.configurable = true;\n    if (\"value\" in descriptor) descriptor.writable = true;\n    Object.defineProperty(target, toPropertyKey(descriptor.key), descriptor);\n  }\n}\nexport default function _createClass(Constructor, protoProps, staticProps) {\n  if (protoProps) _defineProperties(Constructor.prototype, protoProps);\n  if (staticProps) _defineProperties(Constructor, staticProps);\n  Object.defineProperty(Constructor, \"prototype\", {\n    writable: false\n  });\n  return Constructor;\n}","export default function _setPrototypeOf(o, p) {\n  _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) {\n    o.__proto__ = p;\n    return o;\n  };\n  return _setPrototypeOf(o, p);\n}","import setPrototypeOf from \"./setPrototypeOf.js\";\nexport default function _inherits(subClass, superClass) {\n  if (typeof superClass !== \"function\" && superClass !== null) {\n    throw new TypeError(\"Super expression must either be null or a function\");\n  }\n  subClass.prototype = Object.create(superClass && superClass.prototype, {\n    constructor: {\n      value: subClass,\n      writable: true,\n      configurable: true\n    }\n  });\n  Object.defineProperty(subClass, \"prototype\", {\n    writable: false\n  });\n  if (superClass) setPrototypeOf(subClass, superClass);\n}","export default function _assertThisInitialized(self) {\n  if (self === void 0) {\n    throw new ReferenceError(\"this hasn't been initialised - super() hasn't been called\");\n  }\n  return self;\n}","import _typeof from \"./typeof.js\";\nimport assertThisInitialized from \"./assertThisInitialized.js\";\nexport default function _possibleConstructorReturn(self, call) {\n  if (call && (_typeof(call) === \"object\" || typeof call === \"function\")) {\n    return call;\n  } else if (call !== void 0) {\n    throw new TypeError(\"Derived constructors may only return object or undefined\");\n  }\n  return assertThisInitialized(self);\n}","export default function _getPrototypeOf(o) {\n  _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function _getPrototypeOf(o) {\n    return o.__proto__ || Object.getPrototypeOf(o);\n  };\n  return _getPrototypeOf(o);\n}","export default function _arrayLikeToArray(arr, len) {\n  if (len == null || len > arr.length) len = arr.length;\n  for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i];\n  return arr2;\n}","import arrayLikeToArray from \"./arrayLikeToArray.js\";\nexport default function _unsupportedIterableToArray(o, minLen) {\n  if (!o) return;\n  if (typeof o === \"string\") return arrayLikeToArray(o, minLen);\n  var n = Object.prototype.toString.call(o).slice(8, -1);\n  if (n === \"Object\" && o.constructor) n = o.constructor.name;\n  if (n === \"Map\" || n === \"Set\") return Array.from(o);\n  if (n === \"Arguments\" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return arrayLikeToArray(o, minLen);\n}","import arrayWithHoles from \"./arrayWithHoles.js\";\nimport iterableToArrayLimit from \"./iterableToArrayLimit.js\";\nimport unsupportedIterableToArray from \"./unsupportedIterableToArray.js\";\nimport nonIterableRest from \"./nonIterableRest.js\";\nexport default function _slicedToArray(arr, i) {\n  return arrayWithHoles(arr) || iterableToArrayLimit(arr, i) || unsupportedIterableToArray(arr, i) || nonIterableRest();\n}","export default function _arrayWithHoles(arr) {\n  if (Array.isArray(arr)) return arr;\n}","export default function _iterableToArrayLimit(arr, i) {\n  var _i = null == arr ? null : \"undefined\" != typeof Symbol && arr[Symbol.iterator] || arr[\"@@iterator\"];\n  if (null != _i) {\n    var _s,\n      _e,\n      _x,\n      _r,\n      _arr = [],\n      _n = !0,\n      _d = !1;\n    try {\n      if (_x = (_i = _i.call(arr)).next, 0 === i) {\n        if (Object(_i) !== _i) return;\n        _n = !1;\n      } else for (; !(_n = (_s = _x.call(_i)).done) && (_arr.push(_s.value), _arr.length !== i); _n = !0);\n    } catch (err) {\n      _d = !0, _e = err;\n    } finally {\n      try {\n        if (!_n && null != _i[\"return\"] && (_r = _i[\"return\"](), Object(_r) !== _r)) return;\n      } finally {\n        if (_d) throw _e;\n      }\n    }\n    return _arr;\n  }\n}","export default function _nonIterableRest() {\n  throw new TypeError(\"Invalid attempt to destructure non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.\");\n}","export default function _taggedTemplateLiteral(strings, raw) {\n  if (!raw) {\n    raw = strings.slice(0);\n  }\n  return Object.freeze(Object.defineProperties(strings, {\n    raw: {\n      value: Object.freeze(raw)\n    }\n  }));\n}","export function combineRegex(strings: TemplateStringsArray, ...pieces: any[]) {\n  return new RegExp(\n    strings.raw\n      .map(\n        (r, i) =>\n          r + (pieces[i] === undefined ? \"\" : \"(?:\" + pieces[i].source + \")\")\n      )\n      .join(\"\")\n  );\n}\n","import * as moo from \"moo\";\nimport { combineRegex } from \"./helper\";\n\nexport interface I18N_LEXER_TYPES {\n  RK_INTEGER: string;\n  RK_REAL: string;\n  RK_CHARACTER: string;\n  RK_STRING: string;\n  RK_BOOLEAN: string;\n}\n\nexport interface I18N_LEXER_BOOLVAL {\n  RK_FALSE: string;\n  RK_TRUE: string;\n}\n\nexport interface I18N_LEXER_LOGICOP {\n  RK_LOGICAL_NOT: string;\n  RK_LOGICAL_AND: string;\n  RK_LOGICAL_OR: string;\n}\n\nexport interface I18N_LEXER_COMMANDS {\n  RK_PROGRAM: string;\n  RK_VOID: string;\n  RK_SWITCH: string;\n  RK_CASE: string;\n  RK_DEFAULT: string;\n  RK_CONST: string;\n  RK_FUNCTION: string;\n  RK_RETURN: string;\n  RK_FOR: string;\n  RK_FOR_ALT: string;\n  RK_FOR_FROM: string;\n  RK_FOR_TO: string;\n  RK_FOR_PASS: string;\n  RK_BREAK: string;\n  RK_DO: string;\n  RK_DO_UNTIL: string;\n  RK_WHILE: string;\n  RK_WHILE_ALT: string;\n  RK_IF: string;\n  RK_ELSE: string;\n  RK_REFERENCE: string;\n}\n\nexport interface I18N_LANG_LIBS {\n  $ioLib: string;\n  $strLib: string;\n  $mathLib: string;\n  $langLib: string;\n  $arrayLib: string;\n}\n\nexport interface I18N_LANG_FUNCS {\n  main_function: string;\n  $read: string;\n  $write: string;\n  $numElements: string;\n  $matrixLines: string;\n  $matrixColumns: string;\n  $substring: string;\n  $length: string;\n  $uppercase: string;\n  $lowercase: string;\n  $charAt: string;\n  $isReal: string;\n  $isInt: string;\n  $isBool: string;\n  $castReal: string;\n  $castInt: string;\n  $castBool: string;\n  $castString: string;\n  $castChar: string;\n  $sin: string;\n  $cos: string;\n  $tan: string;\n  $sqrt: string;\n  $pow: string;\n  $log: string;\n  $abs: string;\n  $negate: string;\n  $invert: string;\n  $max: string;\n  $min: string;\n  $rand: string;\n}\n\nexport interface I18nLexer {\n  commands: I18N_LEXER_COMMANDS;\n  logicOp: I18N_LEXER_LOGICOP;\n  boolVal: I18N_LEXER_BOOLVAL;\n  types: I18N_LEXER_TYPES;\n  langLibs: I18N_LANG_LIBS;\n  langFuncs: I18N_LANG_FUNCS;\n}\n\nexport class IVProgLexer {\n  constructor (\n    private RKs: Record<string, string>,\n    public lexer: moo.Lexer,\n    private rules: I18N_LEXER_RULES,\n    private i18nLexer: I18nLexer\n  ) {}\n\n  getReservedKeys (): Record<string, string> {\n    return this.RKs;\n  }\n\n  getRules (): I18N_LEXER_RULES {\n    return this.rules;\n  }\n\n  getTypeKeys (): I18N_LEXER_TYPES {\n    return this.i18nLexer.types;\n  }\n\n  getLangLibs (): I18N_LANG_LIBS {\n    return this.i18nLexer.langLibs;\n  }\n\n  getLangFuncs (): I18N_LANG_FUNCS {\n    return this.i18nLexer.langFuncs;\n  }\n}\n\nexport interface I18N_LEXER_RULES\n  extends I18N_LEXER_TYPES,\n    I18N_LEXER_COMMANDS,\n    I18N_LEXER_BOOLVAL,\n    I18N_LEXER_LOGICOP {\n  OPEN_BRACE: string;\n  CLOSE_BRACE: string;\n  OPEN_PARENTHESIS: string;\n  CLOSE_PARENTHESIS: string;\n  OPEN_CURLY: string;\n  CLOSE_CURLY: string;\n  COMMA: string;\n  ASSIGNMENT: string;\n  REAL: string;\n  INTEGER: string;\n  SUM_OP: string;\n  MULTI_OP: string;\n  RELATIONAL_OPERATOR: string;\n  COLON: string;\n  STRING: string;\n  CHARACTER: string;\n  EOS: string;\n  WHITESPACE: string;\n  COMMENTS: string;\n  RK_REFERENCE: string;\n  ID: string;\n  DOT: string;\n  ERROR: string;\n}\n\n// General Regex Rules\nconst ID = \"[a-zA-Z_][a-zA-Z0-9_]*\";\nconst HEX_DIGIT = \"[0-9a-fA-F]\";\nconst OCTAL_DIGIT = \"[0-7]\";\nconst ESC_OCTAL = RegExp(\n  `\\\\\\\\[0-3]${OCTAL_DIGIT}${OCTAL_DIGIT}|\\\\\\\\${OCTAL_DIGIT}${OCTAL_DIGIT}|\\\\\\\\${OCTAL_DIGIT}`\n);\nconst ESC_UNICODE = RegExp(\n  `\\\\\\\\u${HEX_DIGIT}${HEX_DIGIT}${HEX_DIGIT}${HEX_DIGIT}`\n);\nconst ESC_SEQ_BASE = /\\\\[b,t,n,f,r,\",',\\\\]|/;\nconst ESC_SEQ = combineRegex`${ESC_SEQ_BASE}|${ESC_UNICODE}|${ESC_OCTAL}`;\nconst STRING_CHARACTER = combineRegex`${ESC_SEQ}|[^\"\\\\\\\\]`;\n\nexport function makeLexer (lexer: I18nLexer): IVProgLexer {\n  const RKs: Record<string, string> = {};\n  const rules: Record<string, string> = {};\n  Object.entries(lexer.types).forEach(([key, value]) => {\n    RKs[key] = value;\n    rules[key] = key;\n  });\n  Object.entries(lexer.boolVal).forEach(([key, value]) => {\n    RKs[key] = value;\n    rules[key] = key;\n  });\n  Object.entries(lexer.commands).forEach(([key, value]) => {\n    RKs[key] = value;\n    rules[key] = key;\n  });\n  RKs[\"RK_LOGICAL_AND\"] = lexer.logicOp.RK_LOGICAL_AND;\n  RKs[\"RK_LOGICAL_OR\"] = lexer.logicOp.RK_LOGICAL_OR;\n  RKs[\"RK_LOGICAL_NOT\"] = lexer.logicOp.RK_LOGICAL_NOT;\n\n  rules[\"RK_LOGICAL_AND\"] = \"RK_LOGICAL_AND\";\n  rules[\"RK_LOGICAL_OR\"] = \"RK_LOGICAL_OR\";\n  rules[\"RK_LOGICAL_NOT\"] = \"RK_LOGICAL_NOT\";\n\n  const RESERVED_KEYS = moo.keywords(RKs);\n\n  const lexerRules: moo.Rules = {\n    COMMENTS: { match: /\\/\\/[^$]*?$|\\/\\*[^$]*?\\*\\//, lineBreaks: true },\n    OPEN_BRACE: /\\[/,\n    CLOSE_BRACE: /\\]/,\n    OPEN_PARENTHESIS: /\\(/,\n    CLOSE_PARENTHESIS: /\\)/,\n    OPEN_CURLY: /\\{/,\n    CLOSE_CURLY: /\\}/,\n    COMMA: /,/,\n    ASSIGNMENT: /<-|←/,\n    REAL: /[0-9]+\\.[0-9]*[eE][+-]?[0-9]+|[0-9]+\\.[0-9]+/,\n    INTEGER: RegExp(`(?:0x|0X)${HEX_DIGIT}+|(?:0b|0B)[0-1]+|[0-9]+`),\n    SUM_OP: /[+-]/,\n    MULTI_OP: /[*/%]/,\n    RELATIONAL_OPERATOR: />=|==|<=|>|<|!=/,\n    COLON: /:/,\n    STRING: combineRegex`\"(?:${STRING_CHARACTER})*?\"`,\n    CHARACTER: combineRegex`'(?:${ESC_SEQ}|[^'\\\\\\\\])'`,\n    EOS: { match: /;\\r?\\n?|[\\r\\n]+/, lineBreaks: true },\n    WHITESPACE: /(?: |\\t)+/,\n    RK_REFERENCE: RegExp(lexer.commands.RK_REFERENCE),\n    ID: { match: RegExp(ID), type: RESERVED_KEYS },\n    DOT: /\\./,\n    ERROR: { match: /[\\$?`]/, error: true },\n  };\n  Object.entries(lexerRules).forEach(([key, _]) => (rules[key] = key));\n  const moolexer = moo.compile(lexerRules);\n  return new IVProgLexer(RKs, moolexer, rules as unknown as I18N_LEXER_RULES, lexer);\n}\n","import {\n  I18N_LEXER_TYPES,\n  I18N_LEXER_COMMANDS,\n  I18N_LEXER_BOOLVAL,\n  I18N_LEXER_LOGICOP,\n  makeLexer,\n  I18N_LANG_LIBS,\n  I18N_LANG_FUNCS,\n} from \"../lexer\";\n\n// i18n lexer strings for the language.\nconst types: I18N_LEXER_TYPES = {\n  // types\n  RK_REAL: \"real\",\n  RK_INTEGER: \"inteiro\",\n  RK_BOOLEAN: \"logico\",\n  RK_CHARACTER: \"caractere\",\n  RK_STRING: \"cadeia\",\n};\nconst commands: I18N_LEXER_COMMANDS = {\n  // RK_VOID is not formally part of Types since it doesn't have a valid value/instance\n  RK_VOID: \"vazio\",\n  // commands\n  RK_PROGRAM: \"programa\",\n  RK_SWITCH: \"escolha\",\n  RK_CASE: \"caso\",\n  RK_DEFAULT: \"contrario\",\n  RK_CONST: \"const\",\n  RK_FUNCTION: \"funcao\",\n  RK_RETURN: \"devolva\",\n  RK_FOR: \"para\",\n  RK_FOR_ALT: \"repita_para\",\n  RK_FOR_FROM: \"de\",\n  RK_FOR_TO: \"ate\",\n  RK_FOR_PASS: \"passo\",\n  RK_BREAK: \"pare\",\n  RK_DO: \"repita\",\n  RK_DO_UNTIL: \"ate_que\",\n  RK_WHILE: \"enquanto\",\n  RK_WHILE_ALT: \"repita_enquanto\",\n  RK_IF: \"se\",\n  RK_ELSE: \"senao\",\n  RK_REFERENCE: \"&\",\n};\nconst boolVal: I18N_LEXER_BOOLVAL = {\n  RK_FALSE: \"falso\",\n  RK_TRUE: \"verdadeiro\",\n};\n\nconst logicOp: I18N_LEXER_LOGICOP = {\n  RK_LOGICAL_NOT: \"nao\",\n  RK_LOGICAL_AND: \"E\",\n  RK_LOGICAL_OR: \"OU\",\n};\n\nconst langLibs: I18N_LANG_LIBS = {\n  $mathLib: \"Matematica\",\n  $ioLib: \"ES\",\n  $strLib: \"Texto\",\n  $arrayLib: \"Arranjo\",\n  $langLib: \"Conversao\",\n};\n\nconst langFuncs: I18N_LANG_FUNCS = {\n  main_function: \"inicio\",\n  $read: \"leia\",\n  $write: \"escreva\",\n  $numElements: \"total_de_elementos\",\n  $matrixLines: \"total_de_linhas\",\n  $matrixColumns: \"total_de_colunas\",\n  $substring: \"subcadeia\",\n  $length: \"comprimento\",\n  $uppercase: \"caixa_alta\",\n  $lowercase: \"caixa_baixa\",\n  $charAt: \"caractere_na_posicao\",\n  $isReal: \"e_real\",\n  $isInt: \"e_inteiro\",\n  $isBool: \"e_logico\",\n  $castReal: \"como_real\",\n  $castInt: \"como_inteiro\",\n  $castBool: \"como_logico\",\n  $castString: \"como_cadeia\",\n  $castChar: \"como_caractere\",\n  $sin: \"seno\",\n  $cos: \"cosseno\",\n  $tan: \"tangente\",\n  $sqrt: \"raiz_quadrada\",\n  $pow: \"potencia\",\n  $log: \"logaritmo\",\n  $abs: \"modulo\",\n  $negate: \"trocar_sinal\",\n  $invert: \"inverter_valor\",\n  $max: \"maximo\",\n  $min: \"minimo\",\n  $rand: \"numero_aleatorio\",\n};\n// END i18n lexer strings\nexport const ptLexer = makeLexer({\n  commands,\n  boolVal,\n  logicOp,\n  types,\n  langLibs,\n  langFuncs,\n});\n","import {\n  I18N_LEXER_TYPES,\n  I18N_LEXER_COMMANDS,\n  I18N_LEXER_BOOLVAL,\n  I18N_LEXER_LOGICOP,\n  makeLexer,\n  I18N_LANG_LIBS,\n  I18N_LANG_FUNCS,\n} from \"../lexer\";\n\n// i18n lexer strings for the language.\nconst types: I18N_LEXER_TYPES = {\n  // types\n  RK_REAL: \"real\",\n  RK_INTEGER: \"int\",\n  RK_BOOLEAN: \"bool\",\n  RK_CHARACTER: \"char\",\n  RK_STRING: \"string\",\n};\nconst commands: I18N_LEXER_COMMANDS = {\n  // RK_VOID is not formally part of Types since it doesn't have a valid value/instance\n  RK_VOID: \"void\",\n  // commands\n  RK_PROGRAM: \"program\",\n  RK_SWITCH: \"switch\",\n  RK_CASE: \"case\",\n  RK_DEFAULT: \"otherwise\",\n  RK_CONST: \"const\",\n  RK_FUNCTION: \"function\",\n  RK_RETURN: \"return\",\n  RK_FOR: \"for\",\n  RK_FOR_ALT: \"repeat_for\",\n  RK_FOR_FROM: \"from\",\n  RK_FOR_TO: \"to\",\n  RK_FOR_PASS: \"pass\",\n  RK_BREAK: \"break\",\n  RK_DO: \"repeat\",\n  RK_DO_UNTIL: \"until\",\n  RK_WHILE: \"while\",\n  RK_WHILE_ALT: \"repeat_while\",\n  RK_IF: \"if\",\n  RK_ELSE: \"else\",\n  RK_REFERENCE: \"&\",\n};\nconst boolVal: I18N_LEXER_BOOLVAL = {\n  RK_FALSE: \"false\",\n  RK_TRUE: \"true\",\n};\n\nconst logicOp: I18N_LEXER_LOGICOP = {\n  RK_LOGICAL_NOT: \"not\",\n  RK_LOGICAL_AND: \"AND\",\n  RK_LOGICAL_OR: \"OR\",\n};\n\nconst langLibs: I18N_LANG_LIBS = {\n  $mathLib: \"Mathematics\",\n  $ioLib: \"IO\",\n  $strLib: \"Text\",\n  $arrayLib: \"Array\",\n  $langLib: \"Conversion\",\n};\n\nconst langFuncs: I18N_LANG_FUNCS = {\n  main_function: \"main\",\n  $read: \"read\",\n  $write: \"write\",\n  $numElements: \"total_of_elements\",\n  $matrixLines: \"total_of_lines\",\n  $matrixColumns: \"total_of_columns\",\n  $substring: \"substring\",\n  $length: \"length\",\n  $uppercase: \"uppercase\",\n  $lowercase: \"lowercase\",\n  $charAt: \"char_at\",\n  $isReal: \"is_real\",\n  $isInt: \"is_integer\",\n  $isBool: \"is_logic\",\n  $castReal: \"to_real\",\n  $castInt: \"to_integer\",\n  $castBool: \"to_logic\",\n  $castString: \"to_string\",\n  $castChar: \"to_char\",\n  $sin: \"sin\",\n  $cos: \"cos\",\n  $tan: \"tan\",\n  $sqrt: \"sqrt\",\n  $pow: \"pow\",\n  $log: \"log\",\n  $abs: \"abs\",\n  $negate: \"negate\",\n  $invert: \"invert\",\n  $max: \"maximum\",\n  $min: \"minimum\",\n  $rand: \"random\",\n};\n// END i18n lexer strings\nexport const enLexer = makeLexer({\n  commands,\n  boolVal,\n  logicOp,\n  types,\n  langLibs,\n  langFuncs,\n});\n","import { ptLexer as pt } from \"./pt/ivprog\";\nimport { enLexer as en } from \"./en/ivprog\";\nimport { IVProgLexer } from \"./lexer\";\n/*import * as ES from \"./es/ivprog.g4\";\nimport ESFuncs from \"./es/langFunctions\";\nimport ESLibs from \"./es/langLibs\";*/\nconst lexers: Record<string, IVProgLexer> = {};\nlexers[\"pt\"] = pt;\nlexers[\"en\"] = en;\n\nexport default lexers;\n","var LanguageService = /** @class */ (function () {\n    function LanguageService(lsKey, defaultLang) {\n        if (defaultLang === void 0) { defaultLang = 'pt'; }\n        this.lsKey = lsKey;\n        this.defaultLang = defaultLang;\n        this.listeners = [];\n        this.document = document;\n        this.setupListener();\n    }\n    LanguageService.prototype.setupListener = function () {\n        var _this = this;\n        if (this.document !== null) {\n            this.document.addEventListener(\"storage\", (function (event) {\n                var e = event;\n                if (e.key === _this.lsKey) {\n                    _this.listeners.forEach(function (l) { return l(); });\n                }\n            }));\n        }\n    };\n    LanguageService.prototype.getLang = function () {\n        var lang = localStorage.getItem(this.lsKey);\n        if (lang === null || lang === undefined) {\n            console.warn(\"Internal Error: User language information has not been set. Returning default...\");\n            return this.getDefaultLang();\n        }\n        return lang;\n    };\n    LanguageService.prototype.getDefaultLang = function () {\n        return this.defaultLang;\n    };\n    LanguageService.prototype.registerLanguageChangeListener = function (listener) {\n        this.listeners.push(listener);\n    };\n    return LanguageService;\n}());\nexport { LanguageService };\n","export var StringTypes;\n(function (StringTypes) {\n    StringTypes[\"ERROR\"] = \"error\";\n    StringTypes[\"MESSAGE\"] = \"message\";\n    StringTypes[\"UI\"] = \"ui\";\n})(StringTypes || (StringTypes = {}));\n","import { StringTypes } from \"./StringTypes\";\nvar LocalizedStrings = /** @class */ (function () {\n    function LocalizedStrings(service, i18nData, listenToChange) {\n        var _this = this;\n        if (listenToChange === void 0) { listenToChange = false; }\n        this.service = service;\n        this.i18nData = i18nData;\n        this.listenToChange = listenToChange;\n        this.document = document;\n        if (this.listenToChange) {\n            service.registerLanguageChangeListener(function () {\n                _this.updateTagText();\n            });\n        }\n    }\n    LocalizedStrings.prototype.getString = function (id, type) {\n        var i18nObj = this.i18nData[this.service.getLang()];\n        if (!i18nObj) {\n            console.warn(\"Internal Error. The language set at ivprog.lang is not valid: \" + this.service.getLang());\n            return this.getDefaultString(id, type);\n        }\n        if (!i18nObj[type]) {\n            return this.getDefaultString(id, type);\n        }\n        else if (!i18nObj[type][id]) {\n            return this.getDefaultString(id, type);\n        }\n        else {\n            return i18nObj[type][id];\n        }\n    };\n    LocalizedStrings.prototype.getDefaultString = function (id, type) {\n        var i18nObj = this.i18nData[this.service.getDefaultLang()];\n        if (!i18nObj[type]) {\n            return \"{MISSING_I18N_TYPE_IDENTIFIER: \" + type + \"}\";\n        }\n        else if (!i18nObj[type][id]) {\n            return \"{MISSING_I18N_IDENTIFIER: \" + id + \"}\";\n        }\n        else {\n            return i18nObj[type][id];\n        }\n    };\n    LocalizedStrings.prototype.getOR = function () {\n        return this.getUI(\"string_join_or\");\n    };\n    LocalizedStrings.prototype.getError = function (id, context) {\n        if (context === void 0) { context = []; }\n        var text = this.getString(id, StringTypes.ERROR);\n        return this.processString(text, context);\n    };\n    LocalizedStrings.prototype.getMessage = function (id, context) {\n        if (context === void 0) { context = []; }\n        var text = this.getString(id, StringTypes.MESSAGE);\n        return this.processString(text, context);\n    };\n    LocalizedStrings.prototype.getUI = function (id, context) {\n        if (context === void 0) { context = []; }\n        var text = this.getString(id, StringTypes.UI);\n        return this.processString(text, context);\n    };\n    LocalizedStrings.prototype.processString = function (text, context) {\n        for (var i = 0; i < context.length; i++) {\n            var v = context[i];\n            text = text.replace(\"$\" + i, v);\n        }\n        return text;\n    };\n    LocalizedStrings.prototype.updateTagText = function (func) {\n        var _this = this;\n        if (func === void 0) { func = null; }\n        if (this.document !== null) {\n            var list = this.document.querySelectorAll(\"data.i18n\");\n            list.forEach(function (node) {\n                if (func === null) {\n                    node.innerHTML = _this.processTagTex(node.getAttribute(\"value\"));\n                }\n                else {\n                    node.innerHTML = func(node.getAttribute(\"value\"));\n                }\n            });\n        }\n    };\n    LocalizedStrings.prototype.processTagTex = function (text) {\n        if (text === null) {\n            return \"<Invalid i18n identifier>\";\n        }\n        var opts = text.split(\":\");\n        var type = opts[0].toLowerCase();\n        var id = opts[1];\n        if (StringTypes.ERROR === type) {\n            return this.getError(id);\n        }\n        else if (StringTypes.MESSAGE === type) {\n            return this.getMessage(id);\n        }\n        else if (StringTypes.UI === type) {\n            return this.getUI(id);\n        }\n        else {\n            console.warn(\" A string has been passed to the i18n helper function that was not in the form type:id -> \" +\n                text);\n            return this.getString(id, type);\n        }\n    };\n    return LocalizedStrings;\n}());\nexport { LocalizedStrings };\n","import { LanguageService } from \"./LanguageService\";\nimport { LocalizedStrings } from \"./LocalizedStrings\";\nimport { StringTypes } from \"./StringTypes\";\nimport { LanguageServiceNoLS } from \"./LanguageServiceNoLS\";\nexport default {\n    LanguageService: LanguageService,\n    LanguageServiceNoLS: LanguageServiceNoLS,\n    LocalizedStrings: LocalizedStrings,\n    StringTypes: StringTypes\n};\n","var LanguageServiceNoLS = /** @class */ (function () {\n    function LanguageServiceNoLS(lang) {\n        this.lang = lang;\n        this.listeners = [];\n    }\n    LanguageServiceNoLS.prototype.setupListener = function () { };\n    LanguageServiceNoLS.prototype.notifyChange = function () {\n        this.listeners.forEach(function (l) { return l(); });\n    };\n    LanguageServiceNoLS.prototype.setLang = function (lang) {\n        this.lang = lang;\n        this.notifyChange();\n    };\n    LanguageServiceNoLS.prototype.getLang = function () {\n        return this.lang;\n    };\n    LanguageServiceNoLS.prototype.getDefaultLang = function () {\n        return this.lang;\n    };\n    LanguageServiceNoLS.prototype.registerLanguageChangeListener = function (listener) {\n        this.listeners.push(listener);\n    };\n    return LanguageServiceNoLS;\n}());\nexport { LanguageServiceNoLS };\n","import toPropertyKey from \"./toPropertyKey.js\";\nexport default function _defineProperty(obj, key, value) {\n  key = toPropertyKey(key);\n  if (key in obj) {\n    Object.defineProperty(obj, key, {\n      value: value,\n      enumerable: true,\n      configurable: true,\n      writable: true\n    });\n  } else {\n    obj[key] = value;\n  }\n  return obj;\n}","interface ConfigInterface {\n  [id: string]: unknown;\n}\n\nclass ConfigObject implements ConfigInterface {\n  public decimalPlaces: number;\n  public intConvertRoundMode: number;\n  public default_lang: string;\n  public enable_type_casting: boolean;\n  public idle_input_interval: number;\n  public suspend_threshold: number;\n  public max_instruction_count: number;\n  public activity_programming_type: Map<string, string>;\n  public activity_functions: Map<string, boolean>;\n  public activity_datatypes: Map<string, boolean>;\n  public activity_commands: Map<string, boolean>;\n  public activity_filter: Map<string, boolean>;\n  [id: string]: unknown;\n\n  constructor () {\n    this.decimalPlaces = 8;\n    this.intConvertRoundMode = 2;\n    this.default_lang = \"pt\";\n    this.enable_type_casting = true;\n    this.idle_input_interval = 5000;\n    this.suspend_threshold = 1000;\n    // this.max_instruction_count = 350250; - automated evaluation limit\n    this.max_instruction_count = Number.MAX_SAFE_INTEGER;\n    this.activity_programming_type = new Map<string, string>();\n    this.activity_functions = new Map<string, boolean>();\n    this.activity_datatypes = new Map<string, boolean>();\n    this.activity_commands = new Map<string, boolean>();\n    this.activity_filter = new Map<string, boolean>();\n  }\n\n  setConfig (opts: object): void {\n    const otherConfig = opts as ConfigInterface;\n    for (const key in otherConfig) {\n      if (Object.prototype.hasOwnProperty.call(this, key)) {\n        this[key] = otherConfig[key];\n      }\n    }\n  }\n}\n\nconst config = new ConfigObject();\nexport const Config = config;\n","declare const iLMparameters: any; // Tell Typescript iLMparameters is a global\n\nimport Lexers from \"./../../grammar/\";\nimport line_i18n from \"line-i18n\";\nimport { Config } from \"./../util/config\";\nimport {\n  IVProgLexer,\n  I18N_LANG_FUNCS,\n  I18N_LANG_LIBS,\n} from \"../../grammar/lexer\";\n\nclass LanguageServiceExtended extends line_i18n.LanguageServiceNoLS {\n  constructor () {\n    super(\n      typeof iLMparameters === \"undefined\"\n        ? Config.default_lang\n        : iLMparameters.lang\n    );\n  }\n\n  getDefaultLang (): string {\n    return \"en\";\n  }\n\n  getCurrentLexer (): IVProgLexer {\n    const langLexer = Lexers[this.getLang()];\n    if (langLexer === null || langLexer === undefined) {\n      return Lexers[this.getDefaultLang()];\n    } else {\n      return langLexer;\n    }\n  }\n\n  getCurrentLangFuncs (): I18N_LANG_FUNCS {\n    const langInfo = Lexers[this.getLang()];\n    if (langInfo === null || langInfo === undefined) {\n      return Lexers[this.getDefaultLang()].getLangFuncs();\n    } else {\n      return langInfo.getLangFuncs();\n    }\n  }\n\n  getCurrentLangLibs (): I18N_LANG_LIBS {\n    const langInfo = Lexers[this.getLang()];\n    if (langInfo === null || langInfo === undefined) {\n      return Lexers[this.getDefaultLang()].getLangLibs();\n    }\n    return langInfo.getLangLibs();\n  }\n}\n\nexport const LanguageService = new LanguageServiceExtended();\n","import * as Messages from './message.csv';\nimport * as UI from './ui.csv';\nimport * as Errors from './error.csv';\n\ntype Dict =  {[id: string]: unknown};\n\nconst MessagesObj = Messages as Dict;\nconst UIObj = UI as Dict;\nconst ErrorsObj = Errors as Dict;\nconst i18n_data = {} as Dict;\n\nfor (const key in UIObj) {\n  const data = {} as Dict;\n  data['error'] = ErrorsObj[key];\n  data['message'] = MessagesObj[key];\n  data['ui'] = UIObj[key];\n  i18n_data[key] = data;\n}\n\nexport default i18n_data;\n","export class Command {\n\n  constructor () {\n    this._sourceInfo = null;\n  }\n\n  set sourceInfo (sourceInfo) {\n    this._sourceInfo = sourceInfo;\n  }\n\n  get sourceInfo () {\n    return this._sourceInfo;\n  }\n}\n","import { Command } from './command';\n\nexport class Break extends Command {\n\n  constructor () {\n    super();\n  }\n}\n","import { Command } from './command';\n\nexport class Return extends Command {\n\n  constructor(expression) {\n    super();\n    this.expression = expression;\n  }\n  \n}","import { Command } from './command';\n\nexport class Assign extends Command {\n  \n  constructor (id, expression) {\n    super();\n    this.id = id;\n    this.expression = expression;\n  }\n}","import { Assign } from './assign';\n\nexport class ArrayIndexAssign extends Assign {\n\n  constructor (id, lineExpression, columnExpression, expression) {\n    super(id, expression);\n    this.line = lineExpression;\n    this.column = columnExpression;\n  }\n}\n","import { Command } from './command';\n\nexport class Declaration extends Command {\n  \n  constructor (id, type, initial, isConst) {\n    super();\n    this.id = id;\n    this.type = type;\n    this.initial = initial;\n    this.isConst = isConst;\n  }\n}\n","import { Declaration } from './declaration';\n\nexport class ArrayDeclaration extends Declaration {\n\n  constructor (id, type, lines, columns, initial, isConst)   {\n    super(id, type, initial, isConst);\n    this.lines = lines;\n    this.columns = columns;\n  }\n\n  get isVector () {\n    return this.columns == null;\n  }\n}","import { Command } from './command';\n\nexport class While extends Command {\n\n  constructor (expression, commandBlock) {\n    super();\n    this.expression = expression;\n    this.commandBlock = commandBlock;\n  }\n\n  get commands () {\n    return this.commandBlock.commands;\n  }\n\n  get testFirst () {\n  \treturn true;\n  }\n}","import { Command } from './command';\n\nexport class For extends Command {\n\n  constructor (for_id, for_from, for_to, for_pass, commandBlock) {\n    super();\n    this.for_id = for_id;\n    this.for_from = for_from;\n    this.for_to = for_to;\n    this.for_pass = for_pass;\n    this.commandBlock = commandBlock;\n  }\n\n  get commands () {\n    return this.commandBlock.commands;\n  }\n}","import { IType } from \"./itype\";\n\nexport class Type implements IType {\n  public value: string;\n  public ord: number;\n\n  constructor (value: string, ord: number) {\n    this.value = value;\n    this.ord = ord;\n  }\n\n  stringInfo (): object[] {\n    return [{ type: this.value, dim: 0 }];\n  }\n\n  isCompatible (another: IType): boolean {\n    return this.value === another.value && this.ord === another.ord;\n  }\n}\n","import { Type } from \"./type\";\nimport { IType } from \"./itype\";\n\nexport class MultiType implements IType {\n\n  constructor (public types: Type[]) {\n  }\n\n  get value (): undefined {\n    return undefined;\n  }\n\n  get ord (): undefined {\n    return undefined;\n  }\n\n  stringInfo (): object[] {\n    let list: object[] = [];\n    for (let i = 0; i < this.types.length; i++) {\n      const t = this.types[i];\n      list = list.concat(t.stringInfo());\n    }\n    return list;\n  }\n\n  isCompatible (another: Type): boolean {\n    for (let i = 0; i < this.types.length; i++) {\n      const t = this.types[i];\n      if (another.isCompatible(t)) {\n        return true;\n      }\n    }\n    return false;\n  }\n}\n","import { Type } from \"./type\";\nimport { MultiType } from \"./multiType\";\nimport { IType } from \"./itype\";\nimport { Maybe } from \"../util/maybe\";\n\nconst INTEGER = new Type(\"integer\", 0);\nconst REAL = new Type(\"real\", 1);\nconst STRING = new Type(\"text\", 2);\nconst BOOLEAN = new Type(\"boolean\", 3);\nconst CHAR = new Type(\"char\", 4);\nconst VOID = new Type(\"void\", 5);\nconst UNDEFINED = new Type(\"undefined\", 6);\nconst ALL = new MultiType([INTEGER, REAL, STRING, CHAR, BOOLEAN]);\n\ninterface TypeMap {\n  [key: string]: IType;\n}\n\nexport const Types = Object.freeze({\n  INTEGER: INTEGER,\n  REAL: REAL,\n  STRING: STRING,\n  CHAR: CHAR,\n  BOOLEAN: BOOLEAN,\n  VOID: VOID,\n  UNDEFINED: UNDEFINED,\n  ALL: ALL\n});\n\nexport function fromOrdToType (ord: number): Maybe<IType> {\n  const typeMap = Types as TypeMap;\n  for (const t in typeMap) {\n    if (typeMap[t].ord && typeMap[t].ord === ord){\n      return Maybe.some<IType>(typeMap[t]);\n    }\n  }\n  return Maybe.none<IType>();\n}\n","import { Types } from './../../typeSystem/types';\n\nexport class Function {\n\n  /**\n   * \n   * @param {string} name \n   * @param {import('./../../typeSystem/itype').IType} returnType \n   * @param {import('./formalParameter').FormalParameter[]} formalParameters \n   * @param {import('./commandBlock').CommandBlock} commandBlock \n   */\n  constructor (name, returnType, formalParameters, commandBlock) {\n    this.name = name;\n    this.returnType = returnType;\n    this.formalParameters = formalParameters;\n    this.commandBlock = commandBlock;\n    this._sourceInfo = null;\n  }\n\n  get isMain () {\n    return this.name === null && this.returnType.isCompatible(Types.VOID);\n  }\n\n  get commands () {\n    return this.commandBlock.commands;\n  }\n\n  get variablesDeclarations () {\n    return this.commandBlock.variables;\n  }\n\n  set sourceInfo (sourceInfo) {\n\t\tthis._sourceInfo = sourceInfo;\n\t}\n\n\tget sourceInfo () {\n\t\treturn this._sourceInfo;\n  }\n  \n  hasVariadic () {\n    return this.formalParameters.some( p => p.variadic);\n  }\n}","import { Command } from './command';\n\nexport class IfThenElse extends Command {\n\n  constructor (condition, ifTrue, ifFalse) {\n    super();\n    this.condition = condition;\n    this.ifTrue = ifTrue;\n    this.ifFalse = ifFalse;\n  }\n}","export class CommandBlock {\n\t\n\tconstructor(variables, commands) {\n\t\tthis.variables = variables;\n\t\tthis.commands = commands;\n\t\tthis._sourceInfo = null;\n\t}\n\n\tset sourceInfo (sourceInfo) {\n\t\tthis._sourceInfo = sourceInfo;\n\t}\n\n\tget sourceInfo () {\n\t\treturn this._sourceInfo;\n\t}\n}","import { While } from './while';\n\nexport class RepeatUntil extends While {\n\n  constructor(condition, commandBlock) {\n    super(condition, commandBlock);\n  }\n\n  get testFirst () {\n    return false;\n  }\n  \n}","import { Command } from './command';\n// eslint-disable-next-line @typescript-eslint/no-unused-vars\nimport { Expression } from '../expressions/expression';\n// eslint-disable-next-line @typescript-eslint/no-unused-vars\nimport { Case } from '.';\n\nexport class Switch extends Command {\n  \n  /**\n   * \n   * @param {Expression} expression \n   * @param {Case[]} cases \n   */\n  constructor (expression, cases) {\n    super();\n    this.expression = expression;\n    this.cases = cases;\n  }\n}","import { Command } from './command';\n\nexport class Case extends Command {\n\n  constructor (expression) {\n    super();\n    this.expression = expression;\n    /**\n     * @type {Command[]}\n     */\n    this.commands = [];\n  }\n\n  /**\n   * \n   * @param {Command[]} commands \n   */\n  setCommands (commands) {\n    this.commands = commands;\n  }\n\n  get isDefault () {\n    return this.expression === null;\n  }\n}","/**\n * This class represents all the language defined functions.\n * The language processor uses the id provided here to properly execute the desired function.\n * The function is actually implemented inside the language processor.\n * All the functions can be found at: js/processor/definedFunctions.js\n */\nexport class SysCall {\n\n  constructor (langFunc) {\n    this.langFunc = langFunc;\n  }\n}","export class FormalParameter {\n\n  constructor (type, id, byRef = false, variadic = false) {\n    this.type = type;\n    this.id = id;\n    this.byRef = byRef;\n    this.variadic = variadic;\n    this._sourceInfo = null;\n  }\n\n  set sourceInfo (sourceInfo) {\n\t\tthis._sourceInfo = sourceInfo;\n\t}\n\n\tget sourceInfo () {\n\t\treturn this._sourceInfo;\n\t}\n}","export class Expression {\n\n  constructor () {\n\t\tthis._sourceInfo = null;\n\t\tthis._parenthesis = false;\n  }\n\n  set sourceInfo (sourceInfo) {\n\t\tthis._sourceInfo = sourceInfo;\n\t}\n\n\tget sourceInfo () {\n\t\treturn this._sourceInfo;\n\t}\n\n\tset parenthesis (flag) {\n\t\tthis._parenthesis = flag;\n\t}\n\n\tget parenthesis () {\n\t\treturn this._parenthesis;\n\t}\n}","import { Expression } from './expression';\nimport { LanguageDefinedFunction } from '../../processor/definedFunctions';\n\nexport class FunctionCall extends Expression {\n\n\t/**\n\t * \n\t * @param {string} id \n\t * @param {Expression[]} actualParameters \n\t */\n\tconstructor (id, actualParameters) {\n\t\tsuper();\n\t\tthis.id = id;\n\t\tthis.actualParameters = actualParameters;\n\t}\n\n\tget isMainCall () {\n\t\treturn this.id === null;\n\t}\n\n\tget parametersSize () {\n\t\treturn this.actualParameters.length;\n\t}\n\n\ttoString () {\n\t\tlet name = null;\n\t\tif(this.isMainCall) {\n\t\t\tname = LanguageDefinedFunction.getMainFunctionName();\n\t\t} else {\n\t\t\tname = LanguageDefinedFunction.getLocalName(this.id);\n\t\t}\n\t\tlet params = null;\n\t\tif(this.actualParameters.length == 0) {\n\t\t\tparams = \"()\";\n\t\t} else {\n\t\t\tconst strParams = this.actualParameters.map(v => v.toString());\n\t\t\tparams = \"(\" + strParams.join(\",\") + \")\";\n\t\t}\n\t\tif(this.parenthesis) {\n\t\t\treturn `(${name + params})`;\n\t\t} else {\n\t\t\treturn name + params;\n\t\t}\n\t}\n}","/*!\r\n *  decimal.js v10.4.3\r\n *  An arbitrary-precision Decimal type for JavaScript.\r\n *  https://github.com/MikeMcl/decimal.js\r\n *  Copyright (c) 2022 Michael Mclaughlin <M8ch88l@gmail.com>\r\n *  MIT Licence\r\n */\r\n\r\n\r\n// -----------------------------------  EDITABLE DEFAULTS  ------------------------------------ //\r\n\r\n\r\n  // The maximum exponent magnitude.\r\n  // The limit on the value of `toExpNeg`, `toExpPos`, `minE` and `maxE`.\r\nvar EXP_LIMIT = 9e15,                      // 0 to 9e15\r\n\r\n  // The limit on the value of `precision`, and on the value of the first argument to\r\n  // `toDecimalPlaces`, `toExponential`, `toFixed`, `toPrecision` and `toSignificantDigits`.\r\n  MAX_DIGITS = 1e9,                        // 0 to 1e9\r\n\r\n  // Base conversion alphabet.\r\n  NUMERALS = '0123456789abcdef',\r\n\r\n  // The natural logarithm of 10 (1025 digits).\r\n  LN10 = '2.3025850929940456840179914546843642076011014886287729760333279009675726096773524802359972050895982983419677840422862486334095254650828067566662873690987816894829072083255546808437998948262331985283935053089653777326288461633662222876982198867465436674744042432743651550489343149393914796194044002221051017141748003688084012647080685567743216228355220114804663715659121373450747856947683463616792101806445070648000277502684916746550586856935673420670581136429224554405758925724208241314695689016758940256776311356919292033376587141660230105703089634572075440370847469940168269282808481184289314848524948644871927809676271275775397027668605952496716674183485704422507197965004714951050492214776567636938662976979522110718264549734772662425709429322582798502585509785265383207606726317164309505995087807523710333101197857547331541421808427543863591778117054309827482385045648019095610299291824318237525357709750539565187697510374970888692180205189339507238539205144634197265287286965110862571492198849978748873771345686209167058',\r\n\r\n  // Pi (1025 digits).\r\n  PI = '3.1415926535897932384626433832795028841971693993751058209749445923078164062862089986280348253421170679821480865132823066470938446095505822317253594081284811174502841027019385211055596446229489549303819644288109756659334461284756482337867831652712019091456485669234603486104543266482133936072602491412737245870066063155881748815209209628292540917153643678925903600113305305488204665213841469519415116094330572703657595919530921861173819326117931051185480744623799627495673518857527248912279381830119491298336733624406566430860213949463952247371907021798609437027705392171762931767523846748184676694051320005681271452635608277857713427577896091736371787214684409012249534301465495853710507922796892589235420199561121290219608640344181598136297747713099605187072113499999983729780499510597317328160963185950244594553469083026425223082533446850352619311881710100031378387528865875332083814206171776691473035982534904287554687311595628638823537875937519577818577805321712268066130019278766111959092164201989380952572010654858632789',\r\n\r\n\r\n  // The initial configuration properties of the Decimal constructor.\r\n  DEFAULTS = {\r\n\r\n    // These values must be integers within the stated ranges (inclusive).\r\n    // Most of these values can be changed at run-time using the `Decimal.config` method.\r\n\r\n    // The maximum number of significant digits of the result of a calculation or base conversion.\r\n    // E.g. `Decimal.config({ precision: 20 });`\r\n    precision: 20,                         // 1 to MAX_DIGITS\r\n\r\n    // The rounding mode used when rounding to `precision`.\r\n    //\r\n    // ROUND_UP         0 Away from zero.\r\n    // ROUND_DOWN       1 Towards zero.\r\n    // ROUND_CEIL       2 Towards +Infinity.\r\n    // ROUND_FLOOR      3 Towards -Infinity.\r\n    // ROUND_HALF_UP    4 Towards nearest neighbour. If equidistant, up.\r\n    // ROUND_HALF_DOWN  5 Towards nearest neighbour. If equidistant, down.\r\n    // ROUND_HALF_EVEN  6 Towards nearest neighbour. If equidistant, towards even neighbour.\r\n    // ROUND_HALF_CEIL  7 Towards nearest neighbour. If equidistant, towards +Infinity.\r\n    // ROUND_HALF_FLOOR 8 Towards nearest neighbour. If equidistant, towards -Infinity.\r\n    //\r\n    // E.g.\r\n    // `Decimal.rounding = 4;`\r\n    // `Decimal.rounding = Decimal.ROUND_HALF_UP;`\r\n    rounding: 4,                           // 0 to 8\r\n\r\n    // The modulo mode used when calculating the modulus: a mod n.\r\n    // The quotient (q = a / n) is calculated according to the corresponding rounding mode.\r\n    // The remainder (r) is calculated as: r = a - n * q.\r\n    //\r\n    // UP         0 The remainder is positive if the dividend is negative, else is negative.\r\n    // DOWN       1 The remainder has the same sign as the dividend (JavaScript %).\r\n    // FLOOR      3 The remainder has the same sign as the divisor (Python %).\r\n    // HALF_EVEN  6 The IEEE 754 remainder function.\r\n    // EUCLID     9 Euclidian division. q = sign(n) * floor(a / abs(n)). Always positive.\r\n    //\r\n    // Truncated division (1), floored division (3), the IEEE 754 remainder (6), and Euclidian\r\n    // division (9) are commonly used for the modulus operation. The other rounding modes can also\r\n    // be used, but they may not give useful results.\r\n    modulo: 1,                             // 0 to 9\r\n\r\n    // The exponent value at and beneath which `toString` returns exponential notation.\r\n    // JavaScript numbers: -7\r\n    toExpNeg: -7,                          // 0 to -EXP_LIMIT\r\n\r\n    // The exponent value at and above which `toString` returns exponential notation.\r\n    // JavaScript numbers: 21\r\n    toExpPos:  21,                         // 0 to EXP_LIMIT\r\n\r\n    // The minimum exponent value, beneath which underflow to zero occurs.\r\n    // JavaScript numbers: -324  (5e-324)\r\n    minE: -EXP_LIMIT,                      // -1 to -EXP_LIMIT\r\n\r\n    // The maximum exponent value, above which overflow to Infinity occurs.\r\n    // JavaScript numbers: 308  (1.7976931348623157e+308)\r\n    maxE: EXP_LIMIT,                       // 1 to EXP_LIMIT\r\n\r\n    // Whether to use cryptographically-secure random number generation, if available.\r\n    crypto: false                          // true/false\r\n  },\r\n\r\n\r\n// ----------------------------------- END OF EDITABLE DEFAULTS ------------------------------- //\r\n\r\n\r\n  inexact, quadrant,\r\n  external = true,\r\n\r\n  decimalError = '[DecimalError] ',\r\n  invalidArgument = decimalError + 'Invalid argument: ',\r\n  precisionLimitExceeded = decimalError + 'Precision limit exceeded',\r\n  cryptoUnavailable = decimalError + 'crypto unavailable',\r\n  tag = '[object Decimal]',\r\n\r\n  mathfloor = Math.floor,\r\n  mathpow = Math.pow,\r\n\r\n  isBinary = /^0b([01]+(\\.[01]*)?|\\.[01]+)(p[+-]?\\d+)?$/i,\r\n  isHex = /^0x([0-9a-f]+(\\.[0-9a-f]*)?|\\.[0-9a-f]+)(p[+-]?\\d+)?$/i,\r\n  isOctal = /^0o([0-7]+(\\.[0-7]*)?|\\.[0-7]+)(p[+-]?\\d+)?$/i,\r\n  isDecimal = /^(\\d+(\\.\\d*)?|\\.\\d+)(e[+-]?\\d+)?$/i,\r\n\r\n  BASE = 1e7,\r\n  LOG_BASE = 7,\r\n  MAX_SAFE_INTEGER = 9007199254740991,\r\n\r\n  LN10_PRECISION = LN10.length - 1,\r\n  PI_PRECISION = PI.length - 1,\r\n\r\n  // Decimal.prototype object\r\n  P = { toStringTag: tag };\r\n\r\n\r\n// Decimal prototype methods\r\n\r\n\r\n/*\r\n *  absoluteValue             abs\r\n *  ceil\r\n *  clampedTo                 clamp\r\n *  comparedTo                cmp\r\n *  cosine                    cos\r\n *  cubeRoot                  cbrt\r\n *  decimalPlaces             dp\r\n *  dividedBy                 div\r\n *  dividedToIntegerBy        divToInt\r\n *  equals                    eq\r\n *  floor\r\n *  greaterThan               gt\r\n *  greaterThanOrEqualTo      gte\r\n *  hyperbolicCosine          cosh\r\n *  hyperbolicSine            sinh\r\n *  hyperbolicTangent         tanh\r\n *  inverseCosine             acos\r\n *  inverseHyperbolicCosine   acosh\r\n *  inverseHyperbolicSine     asinh\r\n *  inverseHyperbolicTangent  atanh\r\n *  inverseSine               asin\r\n *  inverseTangent            atan\r\n *  isFinite\r\n *  isInteger                 isInt\r\n *  isNaN\r\n *  isNegative                isNeg\r\n *  isPositive                isPos\r\n *  isZero\r\n *  lessThan                  lt\r\n *  lessThanOrEqualTo         lte\r\n *  logarithm                 log\r\n *  [maximum]                 [max]\r\n *  [minimum]                 [min]\r\n *  minus                     sub\r\n *  modulo                    mod\r\n *  naturalExponential        exp\r\n *  naturalLogarithm          ln\r\n *  negated                   neg\r\n *  plus                      add\r\n *  precision                 sd\r\n *  round\r\n *  sine                      sin\r\n *  squareRoot                sqrt\r\n *  tangent                   tan\r\n *  times                     mul\r\n *  toBinary\r\n *  toDecimalPlaces           toDP\r\n *  toExponential\r\n *  toFixed\r\n *  toFraction\r\n *  toHexadecimal             toHex\r\n *  toNearest\r\n *  toNumber\r\n *  toOctal\r\n *  toPower                   pow\r\n *  toPrecision\r\n *  toSignificantDigits       toSD\r\n *  toString\r\n *  truncated                 trunc\r\n *  valueOf                   toJSON\r\n */\r\n\r\n\r\n/*\r\n * Return a new Decimal whose value is the absolute value of this Decimal.\r\n *\r\n */\r\nP.absoluteValue = P.abs = function () {\r\n  var x = new this.constructor(this);\r\n  if (x.s < 0) x.s = 1;\r\n  return finalise(x);\r\n};\r\n\r\n\r\n/*\r\n * Return a new Decimal whose value is the value of this Decimal rounded to a whole number in the\r\n * direction of positive Infinity.\r\n *\r\n */\r\nP.ceil = function () {\r\n  return finalise(new this.constructor(this), this.e + 1, 2);\r\n};\r\n\r\n\r\n/*\r\n * Return a new Decimal whose value is the value of this Decimal clamped to the range\r\n * delineated by `min` and `max`.\r\n *\r\n * min {number|string|Decimal}\r\n * max {number|string|Decimal}\r\n *\r\n */\r\nP.clampedTo = P.clamp = function (min, max) {\r\n  var k,\r\n    x = this,\r\n    Ctor = x.constructor;\r\n  min = new Ctor(min);\r\n  max = new Ctor(max);\r\n  if (!min.s || !max.s) return new Ctor(NaN);\r\n  if (min.gt(max)) throw Error(invalidArgument + max);\r\n  k = x.cmp(min);\r\n  return k < 0 ? min : x.cmp(max) > 0 ? max : new Ctor(x);\r\n};\r\n\r\n\r\n/*\r\n * Return\r\n *   1    if the value of this Decimal is greater than the value of `y`,\r\n *  -1    if the value of this Decimal is less than the value of `y`,\r\n *   0    if they have the same value,\r\n *   NaN  if the value of either Decimal is NaN.\r\n *\r\n */\r\nP.comparedTo = P.cmp = function (y) {\r\n  var i, j, xdL, ydL,\r\n    x = this,\r\n    xd = x.d,\r\n    yd = (y = new x.constructor(y)).d,\r\n    xs = x.s,\r\n    ys = y.s;\r\n\r\n  // Either NaN or ±Infinity?\r\n  if (!xd || !yd) {\r\n    return !xs || !ys ? NaN : xs !== ys ? xs : xd === yd ? 0 : !xd ^ xs < 0 ? 1 : -1;\r\n  }\r\n\r\n  // Either zero?\r\n  if (!xd[0] || !yd[0]) return xd[0] ? xs : yd[0] ? -ys : 0;\r\n\r\n  // Signs differ?\r\n  if (xs !== ys) return xs;\r\n\r\n  // Compare exponents.\r\n  if (x.e !== y.e) return x.e > y.e ^ xs < 0 ? 1 : -1;\r\n\r\n  xdL = xd.length;\r\n  ydL = yd.length;\r\n\r\n  // Compare digit by digit.\r\n  for (i = 0, j = xdL < ydL ? xdL : ydL; i < j; ++i) {\r\n    if (xd[i] !== yd[i]) return xd[i] > yd[i] ^ xs < 0 ? 1 : -1;\r\n  }\r\n\r\n  // Compare lengths.\r\n  return xdL === ydL ? 0 : xdL > ydL ^ xs < 0 ? 1 : -1;\r\n};\r\n\r\n\r\n/*\r\n * Return a new Decimal whose value is the cosine of the value in radians of this Decimal.\r\n *\r\n * Domain: [-Infinity, Infinity]\r\n * Range: [-1, 1]\r\n *\r\n * cos(0)         = 1\r\n * cos(-0)        = 1\r\n * cos(Infinity)  = NaN\r\n * cos(-Infinity) = NaN\r\n * cos(NaN)       = NaN\r\n *\r\n */\r\nP.cosine = P.cos = function () {\r\n  var pr, rm,\r\n    x = this,\r\n    Ctor = x.constructor;\r\n\r\n  if (!x.d) return new Ctor(NaN);\r\n\r\n  // cos(0) = cos(-0) = 1\r\n  if (!x.d[0]) return new Ctor(1);\r\n\r\n  pr = Ctor.precision;\r\n  rm = Ctor.rounding;\r\n  Ctor.precision = pr + Math.max(x.e, x.sd()) + LOG_BASE;\r\n  Ctor.rounding = 1;\r\n\r\n  x = cosine(Ctor, toLessThanHalfPi(Ctor, x));\r\n\r\n  Ctor.precision = pr;\r\n  Ctor.rounding = rm;\r\n\r\n  return finalise(quadrant == 2 || quadrant == 3 ? x.neg() : x, pr, rm, true);\r\n};\r\n\r\n\r\n/*\r\n *\r\n * Return a new Decimal whose value is the cube root of the value of this Decimal, rounded to\r\n * `precision` significant digits using rounding mode `rounding`.\r\n *\r\n *  cbrt(0)  =  0\r\n *  cbrt(-0) = -0\r\n *  cbrt(1)  =  1\r\n *  cbrt(-1) = -1\r\n *  cbrt(N)  =  N\r\n *  cbrt(-I) = -I\r\n *  cbrt(I)  =  I\r\n *\r\n * Math.cbrt(x) = (x < 0 ? -Math.pow(-x, 1/3) : Math.pow(x, 1/3))\r\n *\r\n */\r\nP.cubeRoot = P.cbrt = function () {\r\n  var e, m, n, r, rep, s, sd, t, t3, t3plusx,\r\n    x = this,\r\n    Ctor = x.constructor;\r\n\r\n  if (!x.isFinite() || x.isZero()) return new Ctor(x);\r\n  external = false;\r\n\r\n  // Initial estimate.\r\n  s = x.s * mathpow(x.s * x, 1 / 3);\r\n\r\n   // Math.cbrt underflow/overflow?\r\n   // Pass x to Math.pow as integer, then adjust the exponent of the result.\r\n  if (!s || Math.abs(s) == 1 / 0) {\r\n    n = digitsToString(x.d);\r\n    e = x.e;\r\n\r\n    // Adjust n exponent so it is a multiple of 3 away from x exponent.\r\n    if (s = (e - n.length + 1) % 3) n += (s == 1 || s == -2 ? '0' : '00');\r\n    s = mathpow(n, 1 / 3);\r\n\r\n    // Rarely, e may be one less than the result exponent value.\r\n    e = mathfloor((e + 1) / 3) - (e % 3 == (e < 0 ? -1 : 2));\r\n\r\n    if (s == 1 / 0) {\r\n      n = '5e' + e;\r\n    } else {\r\n      n = s.toExponential();\r\n      n = n.slice(0, n.indexOf('e') + 1) + e;\r\n    }\r\n\r\n    r = new Ctor(n);\r\n    r.s = x.s;\r\n  } else {\r\n    r = new Ctor(s.toString());\r\n  }\r\n\r\n  sd = (e = Ctor.precision) + 3;\r\n\r\n  // Halley's method.\r\n  // TODO? Compare Newton's method.\r\n  for (;;) {\r\n    t = r;\r\n    t3 = t.times(t).times(t);\r\n    t3plusx = t3.plus(x);\r\n    r = divide(t3plusx.plus(x).times(t), t3plusx.plus(t3), sd + 2, 1);\r\n\r\n    // TODO? Replace with for-loop and checkRoundingDigits.\r\n    if (digitsToString(t.d).slice(0, sd) === (n = digitsToString(r.d)).slice(0, sd)) {\r\n      n = n.slice(sd - 3, sd + 1);\r\n\r\n      // The 4th rounding digit may be in error by -1 so if the 4 rounding digits are 9999 or 4999\r\n      // , i.e. approaching a rounding boundary, continue the iteration.\r\n      if (n == '9999' || !rep && n == '4999') {\r\n\r\n        // On the first iteration only, check to see if rounding up gives the exact result as the\r\n        // nines may infinitely repeat.\r\n        if (!rep) {\r\n          finalise(t, e + 1, 0);\r\n\r\n          if (t.times(t).times(t).eq(x)) {\r\n            r = t;\r\n            break;\r\n          }\r\n        }\r\n\r\n        sd += 4;\r\n        rep = 1;\r\n      } else {\r\n\r\n        // If the rounding digits are null, 0{0,4} or 50{0,3}, check for an exact result.\r\n        // If not, then there are further digits and m will be truthy.\r\n        if (!+n || !+n.slice(1) && n.charAt(0) == '5') {\r\n\r\n          // Truncate to the first rounding digit.\r\n          finalise(r, e + 1, 1);\r\n          m = !r.times(r).times(r).eq(x);\r\n        }\r\n\r\n        break;\r\n      }\r\n    }\r\n  }\r\n\r\n  external = true;\r\n\r\n  return finalise(r, e, Ctor.rounding, m);\r\n};\r\n\r\n\r\n/*\r\n * Return the number of decimal places of the value of this Decimal.\r\n *\r\n */\r\nP.decimalPlaces = P.dp = function () {\r\n  var w,\r\n    d = this.d,\r\n    n = NaN;\r\n\r\n  if (d) {\r\n    w = d.length - 1;\r\n    n = (w - mathfloor(this.e / LOG_BASE)) * LOG_BASE;\r\n\r\n    // Subtract the number of trailing zeros of the last word.\r\n    w = d[w];\r\n    if (w) for (; w % 10 == 0; w /= 10) n--;\r\n    if (n < 0) n = 0;\r\n  }\r\n\r\n  return n;\r\n};\r\n\r\n\r\n/*\r\n *  n / 0 = I\r\n *  n / N = N\r\n *  n / I = 0\r\n *  0 / n = 0\r\n *  0 / 0 = N\r\n *  0 / N = N\r\n *  0 / I = 0\r\n *  N / n = N\r\n *  N / 0 = N\r\n *  N / N = N\r\n *  N / I = N\r\n *  I / n = I\r\n *  I / 0 = I\r\n *  I / N = N\r\n *  I / I = N\r\n *\r\n * Return a new Decimal whose value is the value of this Decimal divided by `y`, rounded to\r\n * `precision` significant digits using rounding mode `rounding`.\r\n *\r\n */\r\nP.dividedBy = P.div = function (y) {\r\n  return divide(this, new this.constructor(y));\r\n};\r\n\r\n\r\n/*\r\n * Return a new Decimal whose value is the integer part of dividing the value of this Decimal\r\n * by the value of `y`, rounded to `precision` significant digits using rounding mode `rounding`.\r\n *\r\n */\r\nP.dividedToIntegerBy = P.divToInt = function (y) {\r\n  var x = this,\r\n    Ctor = x.constructor;\r\n  return finalise(divide(x, new Ctor(y), 0, 1, 1), Ctor.precision, Ctor.rounding);\r\n};\r\n\r\n\r\n/*\r\n * Return true if the value of this Decimal is equal to the value of `y`, otherwise return false.\r\n *\r\n */\r\nP.equals = P.eq = function (y) {\r\n  return this.cmp(y) === 0;\r\n};\r\n\r\n\r\n/*\r\n * Return a new Decimal whose value is the value of this Decimal rounded to a whole number in the\r\n * direction of negative Infinity.\r\n *\r\n */\r\nP.floor = function () {\r\n  return finalise(new this.constructor(this), this.e + 1, 3);\r\n};\r\n\r\n\r\n/*\r\n * Return true if the value of this Decimal is greater than the value of `y`, otherwise return\r\n * false.\r\n *\r\n */\r\nP.greaterThan = P.gt = function (y) {\r\n  return this.cmp(y) > 0;\r\n};\r\n\r\n\r\n/*\r\n * Return true if the value of this Decimal is greater than or equal to the value of `y`,\r\n * otherwise return false.\r\n *\r\n */\r\nP.greaterThanOrEqualTo = P.gte = function (y) {\r\n  var k = this.cmp(y);\r\n  return k == 1 || k === 0;\r\n};\r\n\r\n\r\n/*\r\n * Return a new Decimal whose value is the hyperbolic cosine of the value in radians of this\r\n * Decimal.\r\n *\r\n * Domain: [-Infinity, Infinity]\r\n * Range: [1, Infinity]\r\n *\r\n * cosh(x) = 1 + x^2/2! + x^4/4! + x^6/6! + ...\r\n *\r\n * cosh(0)         = 1\r\n * cosh(-0)        = 1\r\n * cosh(Infinity)  = Infinity\r\n * cosh(-Infinity) = Infinity\r\n * cosh(NaN)       = NaN\r\n *\r\n *  x        time taken (ms)   result\r\n * 1000      9                 9.8503555700852349694e+433\r\n * 10000     25                4.4034091128314607936e+4342\r\n * 100000    171               1.4033316802130615897e+43429\r\n * 1000000   3817              1.5166076984010437725e+434294\r\n * 10000000  abandoned after 2 minute wait\r\n *\r\n * TODO? Compare performance of cosh(x) = 0.5 * (exp(x) + exp(-x))\r\n *\r\n */\r\nP.hyperbolicCosine = P.cosh = function () {\r\n  var k, n, pr, rm, len,\r\n    x = this,\r\n    Ctor = x.constructor,\r\n    one = new Ctor(1);\r\n\r\n  if (!x.isFinite()) return new Ctor(x.s ? 1 / 0 : NaN);\r\n  if (x.isZero()) return one;\r\n\r\n  pr = Ctor.precision;\r\n  rm = Ctor.rounding;\r\n  Ctor.precision = pr + Math.max(x.e, x.sd()) + 4;\r\n  Ctor.rounding = 1;\r\n  len = x.d.length;\r\n\r\n  // Argument reduction: cos(4x) = 1 - 8cos^2(x) + 8cos^4(x) + 1\r\n  // i.e. cos(x) = 1 - cos^2(x/4)(8 - 8cos^2(x/4))\r\n\r\n  // Estimate the optimum number of times to use the argument reduction.\r\n  // TODO? Estimation reused from cosine() and may not be optimal here.\r\n  if (len < 32) {\r\n    k = Math.ceil(len / 3);\r\n    n = (1 / tinyPow(4, k)).toString();\r\n  } else {\r\n    k = 16;\r\n    n = '2.3283064365386962890625e-10';\r\n  }\r\n\r\n  x = taylorSeries(Ctor, 1, x.times(n), new Ctor(1), true);\r\n\r\n  // Reverse argument reduction\r\n  var cosh2_x,\r\n    i = k,\r\n    d8 = new Ctor(8);\r\n  for (; i--;) {\r\n    cosh2_x = x.times(x);\r\n    x = one.minus(cosh2_x.times(d8.minus(cosh2_x.times(d8))));\r\n  }\r\n\r\n  return finalise(x, Ctor.precision = pr, Ctor.rounding = rm, true);\r\n};\r\n\r\n\r\n/*\r\n * Return a new Decimal whose value is the hyperbolic sine of the value in radians of this\r\n * Decimal.\r\n *\r\n * Domain: [-Infinity, Infinity]\r\n * Range: [-Infinity, Infinity]\r\n *\r\n * sinh(x) = x + x^3/3! + x^5/5! + x^7/7! + ...\r\n *\r\n * sinh(0)         = 0\r\n * sinh(-0)        = -0\r\n * sinh(Infinity)  = Infinity\r\n * sinh(-Infinity) = -Infinity\r\n * sinh(NaN)       = NaN\r\n *\r\n * x        time taken (ms)\r\n * 10       2 ms\r\n * 100      5 ms\r\n * 1000     14 ms\r\n * 10000    82 ms\r\n * 100000   886 ms            1.4033316802130615897e+43429\r\n * 200000   2613 ms\r\n * 300000   5407 ms\r\n * 400000   8824 ms\r\n * 500000   13026 ms          8.7080643612718084129e+217146\r\n * 1000000  48543 ms\r\n *\r\n * TODO? Compare performance of sinh(x) = 0.5 * (exp(x) - exp(-x))\r\n *\r\n */\r\nP.hyperbolicSine = P.sinh = function () {\r\n  var k, pr, rm, len,\r\n    x = this,\r\n    Ctor = x.constructor;\r\n\r\n  if (!x.isFinite() || x.isZero()) return new Ctor(x);\r\n\r\n  pr = Ctor.precision;\r\n  rm = Ctor.rounding;\r\n  Ctor.precision = pr + Math.max(x.e, x.sd()) + 4;\r\n  Ctor.rounding = 1;\r\n  len = x.d.length;\r\n\r\n  if (len < 3) {\r\n    x = taylorSeries(Ctor, 2, x, x, true);\r\n  } else {\r\n\r\n    // Alternative argument reduction: sinh(3x) = sinh(x)(3 + 4sinh^2(x))\r\n    // i.e. sinh(x) = sinh(x/3)(3 + 4sinh^2(x/3))\r\n    // 3 multiplications and 1 addition\r\n\r\n    // Argument reduction: sinh(5x) = sinh(x)(5 + sinh^2(x)(20 + 16sinh^2(x)))\r\n    // i.e. sinh(x) = sinh(x/5)(5 + sinh^2(x/5)(20 + 16sinh^2(x/5)))\r\n    // 4 multiplications and 2 additions\r\n\r\n    // Estimate the optimum number of times to use the argument reduction.\r\n    k = 1.4 * Math.sqrt(len);\r\n    k = k > 16 ? 16 : k | 0;\r\n\r\n    x = x.times(1 / tinyPow(5, k));\r\n    x = taylorSeries(Ctor, 2, x, x, true);\r\n\r\n    // Reverse argument reduction\r\n    var sinh2_x,\r\n      d5 = new Ctor(5),\r\n      d16 = new Ctor(16),\r\n      d20 = new Ctor(20);\r\n    for (; k--;) {\r\n      sinh2_x = x.times(x);\r\n      x = x.times(d5.plus(sinh2_x.times(d16.times(sinh2_x).plus(d20))));\r\n    }\r\n  }\r\n\r\n  Ctor.precision = pr;\r\n  Ctor.rounding = rm;\r\n\r\n  return finalise(x, pr, rm, true);\r\n};\r\n\r\n\r\n/*\r\n * Return a new Decimal whose value is the hyperbolic tangent of the value in radians of this\r\n * Decimal.\r\n *\r\n * Domain: [-Infinity, Infinity]\r\n * Range: [-1, 1]\r\n *\r\n * tanh(x) = sinh(x) / cosh(x)\r\n *\r\n * tanh(0)         = 0\r\n * tanh(-0)        = -0\r\n * tanh(Infinity)  = 1\r\n * tanh(-Infinity) = -1\r\n * tanh(NaN)       = NaN\r\n *\r\n */\r\nP.hyperbolicTangent = P.tanh = function () {\r\n  var pr, rm,\r\n    x = this,\r\n    Ctor = x.constructor;\r\n\r\n  if (!x.isFinite()) return new Ctor(x.s);\r\n  if (x.isZero()) return new Ctor(x);\r\n\r\n  pr = Ctor.precision;\r\n  rm = Ctor.rounding;\r\n  Ctor.precision = pr + 7;\r\n  Ctor.rounding = 1;\r\n\r\n  return divide(x.sinh(), x.cosh(), Ctor.precision = pr, Ctor.rounding = rm);\r\n};\r\n\r\n\r\n/*\r\n * Return a new Decimal whose value is the arccosine (inverse cosine) in radians of the value of\r\n * this Decimal.\r\n *\r\n * Domain: [-1, 1]\r\n * Range: [0, pi]\r\n *\r\n * acos(x) = pi/2 - asin(x)\r\n *\r\n * acos(0)       = pi/2\r\n * acos(-0)      = pi/2\r\n * acos(1)       = 0\r\n * acos(-1)      = pi\r\n * acos(1/2)     = pi/3\r\n * acos(-1/2)    = 2*pi/3\r\n * acos(|x| > 1) = NaN\r\n * acos(NaN)     = NaN\r\n *\r\n */\r\nP.inverseCosine = P.acos = function () {\r\n  var halfPi,\r\n    x = this,\r\n    Ctor = x.constructor,\r\n    k = x.abs().cmp(1),\r\n    pr = Ctor.precision,\r\n    rm = Ctor.rounding;\r\n\r\n  if (k !== -1) {\r\n    return k === 0\r\n      // |x| is 1\r\n      ? x.isNeg() ? getPi(Ctor, pr, rm) : new Ctor(0)\r\n      // |x| > 1 or x is NaN\r\n      : new Ctor(NaN);\r\n  }\r\n\r\n  if (x.isZero()) return getPi(Ctor, pr + 4, rm).times(0.5);\r\n\r\n  // TODO? Special case acos(0.5) = pi/3 and acos(-0.5) = 2*pi/3\r\n\r\n  Ctor.precision = pr + 6;\r\n  Ctor.rounding = 1;\r\n\r\n  x = x.asin();\r\n  halfPi = getPi(Ctor, pr + 4, rm).times(0.5);\r\n\r\n  Ctor.precision = pr;\r\n  Ctor.rounding = rm;\r\n\r\n  return halfPi.minus(x);\r\n};\r\n\r\n\r\n/*\r\n * Return a new Decimal whose value is the inverse of the hyperbolic cosine in radians of the\r\n * value of this Decimal.\r\n *\r\n * Domain: [1, Infinity]\r\n * Range: [0, Infinity]\r\n *\r\n * acosh(x) = ln(x + sqrt(x^2 - 1))\r\n *\r\n * acosh(x < 1)     = NaN\r\n * acosh(NaN)       = NaN\r\n * acosh(Infinity)  = Infinity\r\n * acosh(-Infinity) = NaN\r\n * acosh(0)         = NaN\r\n * acosh(-0)        = NaN\r\n * acosh(1)         = 0\r\n * acosh(-1)        = NaN\r\n *\r\n */\r\nP.inverseHyperbolicCosine = P.acosh = function () {\r\n  var pr, rm,\r\n    x = this,\r\n    Ctor = x.constructor;\r\n\r\n  if (x.lte(1)) return new Ctor(x.eq(1) ? 0 : NaN);\r\n  if (!x.isFinite()) return new Ctor(x);\r\n\r\n  pr = Ctor.precision;\r\n  rm = Ctor.rounding;\r\n  Ctor.precision = pr + Math.max(Math.abs(x.e), x.sd()) + 4;\r\n  Ctor.rounding = 1;\r\n  external = false;\r\n\r\n  x = x.times(x).minus(1).sqrt().plus(x);\r\n\r\n  external = true;\r\n  Ctor.precision = pr;\r\n  Ctor.rounding = rm;\r\n\r\n  return x.ln();\r\n};\r\n\r\n\r\n/*\r\n * Return a new Decimal whose value is the inverse of the hyperbolic sine in radians of the value\r\n * of this Decimal.\r\n *\r\n * Domain: [-Infinity, Infinity]\r\n * Range: [-Infinity, Infinity]\r\n *\r\n * asinh(x) = ln(x + sqrt(x^2 + 1))\r\n *\r\n * asinh(NaN)       = NaN\r\n * asinh(Infinity)  = Infinity\r\n * asinh(-Infinity) = -Infinity\r\n * asinh(0)         = 0\r\n * asinh(-0)        = -0\r\n *\r\n */\r\nP.inverseHyperbolicSine = P.asinh = function () {\r\n  var pr, rm,\r\n    x = this,\r\n    Ctor = x.constructor;\r\n\r\n  if (!x.isFinite() || x.isZero()) return new Ctor(x);\r\n\r\n  pr = Ctor.precision;\r\n  rm = Ctor.rounding;\r\n  Ctor.precision = pr + 2 * Math.max(Math.abs(x.e), x.sd()) + 6;\r\n  Ctor.rounding = 1;\r\n  external = false;\r\n\r\n  x = x.times(x).plus(1).sqrt().plus(x);\r\n\r\n  external = true;\r\n  Ctor.precision = pr;\r\n  Ctor.rounding = rm;\r\n\r\n  return x.ln();\r\n};\r\n\r\n\r\n/*\r\n * Return a new Decimal whose value is the inverse of the hyperbolic tangent in radians of the\r\n * value of this Decimal.\r\n *\r\n * Domain: [-1, 1]\r\n * Range: [-Infinity, Infinity]\r\n *\r\n * atanh(x) = 0.5 * ln((1 + x) / (1 - x))\r\n *\r\n * atanh(|x| > 1)   = NaN\r\n * atanh(NaN)       = NaN\r\n * atanh(Infinity)  = NaN\r\n * atanh(-Infinity) = NaN\r\n * atanh(0)         = 0\r\n * atanh(-0)        = -0\r\n * atanh(1)         = Infinity\r\n * atanh(-1)        = -Infinity\r\n *\r\n */\r\nP.inverseHyperbolicTangent = P.atanh = function () {\r\n  var pr, rm, wpr, xsd,\r\n    x = this,\r\n    Ctor = x.constructor;\r\n\r\n  if (!x.isFinite()) return new Ctor(NaN);\r\n  if (x.e >= 0) return new Ctor(x.abs().eq(1) ? x.s / 0 : x.isZero() ? x : NaN);\r\n\r\n  pr = Ctor.precision;\r\n  rm = Ctor.rounding;\r\n  xsd = x.sd();\r\n\r\n  if (Math.max(xsd, pr) < 2 * -x.e - 1) return finalise(new Ctor(x), pr, rm, true);\r\n\r\n  Ctor.precision = wpr = xsd - x.e;\r\n\r\n  x = divide(x.plus(1), new Ctor(1).minus(x), wpr + pr, 1);\r\n\r\n  Ctor.precision = pr + 4;\r\n  Ctor.rounding = 1;\r\n\r\n  x = x.ln();\r\n\r\n  Ctor.precision = pr;\r\n  Ctor.rounding = rm;\r\n\r\n  return x.times(0.5);\r\n};\r\n\r\n\r\n/*\r\n * Return a new Decimal whose value is the arcsine (inverse sine) in radians of the value of this\r\n * Decimal.\r\n *\r\n * Domain: [-Infinity, Infinity]\r\n * Range: [-pi/2, pi/2]\r\n *\r\n * asin(x) = 2*atan(x/(1 + sqrt(1 - x^2)))\r\n *\r\n * asin(0)       = 0\r\n * asin(-0)      = -0\r\n * asin(1/2)     = pi/6\r\n * asin(-1/2)    = -pi/6\r\n * asin(1)       = pi/2\r\n * asin(-1)      = -pi/2\r\n * asin(|x| > 1) = NaN\r\n * asin(NaN)     = NaN\r\n *\r\n * TODO? Compare performance of Taylor series.\r\n *\r\n */\r\nP.inverseSine = P.asin = function () {\r\n  var halfPi, k,\r\n    pr, rm,\r\n    x = this,\r\n    Ctor = x.constructor;\r\n\r\n  if (x.isZero()) return new Ctor(x);\r\n\r\n  k = x.abs().cmp(1);\r\n  pr = Ctor.precision;\r\n  rm = Ctor.rounding;\r\n\r\n  if (k !== -1) {\r\n\r\n    // |x| is 1\r\n    if (k === 0) {\r\n      halfPi = getPi(Ctor, pr + 4, rm).times(0.5);\r\n      halfPi.s = x.s;\r\n      return halfPi;\r\n    }\r\n\r\n    // |x| > 1 or x is NaN\r\n    return new Ctor(NaN);\r\n  }\r\n\r\n  // TODO? Special case asin(1/2) = pi/6 and asin(-1/2) = -pi/6\r\n\r\n  Ctor.precision = pr + 6;\r\n  Ctor.rounding = 1;\r\n\r\n  x = x.div(new Ctor(1).minus(x.times(x)).sqrt().plus(1)).atan();\r\n\r\n  Ctor.precision = pr;\r\n  Ctor.rounding = rm;\r\n\r\n  return x.times(2);\r\n};\r\n\r\n\r\n/*\r\n * Return a new Decimal whose value is the arctangent (inverse tangent) in radians of the value\r\n * of this Decimal.\r\n *\r\n * Domain: [-Infinity, Infinity]\r\n * Range: [-pi/2, pi/2]\r\n *\r\n * atan(x) = x - x^3/3 + x^5/5 - x^7/7 + ...\r\n *\r\n * atan(0)         = 0\r\n * atan(-0)        = -0\r\n * atan(1)         = pi/4\r\n * atan(-1)        = -pi/4\r\n * atan(Infinity)  = pi/2\r\n * atan(-Infinity) = -pi/2\r\n * atan(NaN)       = NaN\r\n *\r\n */\r\nP.inverseTangent = P.atan = function () {\r\n  var i, j, k, n, px, t, r, wpr, x2,\r\n    x = this,\r\n    Ctor = x.constructor,\r\n    pr = Ctor.precision,\r\n    rm = Ctor.rounding;\r\n\r\n  if (!x.isFinite()) {\r\n    if (!x.s) return new Ctor(NaN);\r\n    if (pr + 4 <= PI_PRECISION) {\r\n      r = getPi(Ctor, pr + 4, rm).times(0.5);\r\n      r.s = x.s;\r\n      return r;\r\n    }\r\n  } else if (x.isZero()) {\r\n    return new Ctor(x);\r\n  } else if (x.abs().eq(1) && pr + 4 <= PI_PRECISION) {\r\n    r = getPi(Ctor, pr + 4, rm).times(0.25);\r\n    r.s = x.s;\r\n    return r;\r\n  }\r\n\r\n  Ctor.precision = wpr = pr + 10;\r\n  Ctor.rounding = 1;\r\n\r\n  // TODO? if (x >= 1 && pr <= PI_PRECISION) atan(x) = halfPi * x.s - atan(1 / x);\r\n\r\n  // Argument reduction\r\n  // Ensure |x| < 0.42\r\n  // atan(x) = 2 * atan(x / (1 + sqrt(1 + x^2)))\r\n\r\n  k = Math.min(28, wpr / LOG_BASE + 2 | 0);\r\n\r\n  for (i = k; i; --i) x = x.div(x.times(x).plus(1).sqrt().plus(1));\r\n\r\n  external = false;\r\n\r\n  j = Math.ceil(wpr / LOG_BASE);\r\n  n = 1;\r\n  x2 = x.times(x);\r\n  r = new Ctor(x);\r\n  px = x;\r\n\r\n  // atan(x) = x - x^3/3 + x^5/5 - x^7/7 + ...\r\n  for (; i !== -1;) {\r\n    px = px.times(x2);\r\n    t = r.minus(px.div(n += 2));\r\n\r\n    px = px.times(x2);\r\n    r = t.plus(px.div(n += 2));\r\n\r\n    if (r.d[j] !== void 0) for (i = j; r.d[i] === t.d[i] && i--;);\r\n  }\r\n\r\n  if (k) r = r.times(2 << (k - 1));\r\n\r\n  external = true;\r\n\r\n  return finalise(r, Ctor.precision = pr, Ctor.rounding = rm, true);\r\n};\r\n\r\n\r\n/*\r\n * Return true if the value of this Decimal is a finite number, otherwise return false.\r\n *\r\n */\r\nP.isFinite = function () {\r\n  return !!this.d;\r\n};\r\n\r\n\r\n/*\r\n * Return true if the value of this Decimal is an integer, otherwise return false.\r\n *\r\n */\r\nP.isInteger = P.isInt = function () {\r\n  return !!this.d && mathfloor(this.e / LOG_BASE) > this.d.length - 2;\r\n};\r\n\r\n\r\n/*\r\n * Return true if the value of this Decimal is NaN, otherwise return false.\r\n *\r\n */\r\nP.isNaN = function () {\r\n  return !this.s;\r\n};\r\n\r\n\r\n/*\r\n * Return true if the value of this Decimal is negative, otherwise return false.\r\n *\r\n */\r\nP.isNegative = P.isNeg = function () {\r\n  return this.s < 0;\r\n};\r\n\r\n\r\n/*\r\n * Return true if the value of this Decimal is positive, otherwise return false.\r\n *\r\n */\r\nP.isPositive = P.isPos = function () {\r\n  return this.s > 0;\r\n};\r\n\r\n\r\n/*\r\n * Return true if the value of this Decimal is 0 or -0, otherwise return false.\r\n *\r\n */\r\nP.isZero = function () {\r\n  return !!this.d && this.d[0] === 0;\r\n};\r\n\r\n\r\n/*\r\n * Return true if the value of this Decimal is less than `y`, otherwise return false.\r\n *\r\n */\r\nP.lessThan = P.lt = function (y) {\r\n  return this.cmp(y) < 0;\r\n};\r\n\r\n\r\n/*\r\n * Return true if the value of this Decimal is less than or equal to `y`, otherwise return false.\r\n *\r\n */\r\nP.lessThanOrEqualTo = P.lte = function (y) {\r\n  return this.cmp(y) < 1;\r\n};\r\n\r\n\r\n/*\r\n * Return the logarithm of the value of this Decimal to the specified base, rounded to `precision`\r\n * significant digits using rounding mode `rounding`.\r\n *\r\n * If no base is specified, return log[10](arg).\r\n *\r\n * log[base](arg) = ln(arg) / ln(base)\r\n *\r\n * The result will always be correctly rounded if the base of the log is 10, and 'almost always'\r\n * otherwise:\r\n *\r\n * Depending on the rounding mode, the result may be incorrectly rounded if the first fifteen\r\n * rounding digits are [49]99999999999999 or [50]00000000000000. In that case, the maximum error\r\n * between the result and the correctly rounded result will be one ulp (unit in the last place).\r\n *\r\n * log[-b](a)       = NaN\r\n * log[0](a)        = NaN\r\n * log[1](a)        = NaN\r\n * log[NaN](a)      = NaN\r\n * log[Infinity](a) = NaN\r\n * log[b](0)        = -Infinity\r\n * log[b](-0)       = -Infinity\r\n * log[b](-a)       = NaN\r\n * log[b](1)        = 0\r\n * log[b](Infinity) = Infinity\r\n * log[b](NaN)      = NaN\r\n *\r\n * [base] {number|string|Decimal} The base of the logarithm.\r\n *\r\n */\r\nP.logarithm = P.log = function (base) {\r\n  var isBase10, d, denominator, k, inf, num, sd, r,\r\n    arg = this,\r\n    Ctor = arg.constructor,\r\n    pr = Ctor.precision,\r\n    rm = Ctor.rounding,\r\n    guard = 5;\r\n\r\n  // Default base is 10.\r\n  if (base == null) {\r\n    base = new Ctor(10);\r\n    isBase10 = true;\r\n  } else {\r\n    base = new Ctor(base);\r\n    d = base.d;\r\n\r\n    // Return NaN if base is negative, or non-finite, or is 0 or 1.\r\n    if (base.s < 0 || !d || !d[0] || base.eq(1)) return new Ctor(NaN);\r\n\r\n    isBase10 = base.eq(10);\r\n  }\r\n\r\n  d = arg.d;\r\n\r\n  // Is arg negative, non-finite, 0 or 1?\r\n  if (arg.s < 0 || !d || !d[0] || arg.eq(1)) {\r\n    return new Ctor(d && !d[0] ? -1 / 0 : arg.s != 1 ? NaN : d ? 0 : 1 / 0);\r\n  }\r\n\r\n  // The result will have a non-terminating decimal expansion if base is 10 and arg is not an\r\n  // integer power of 10.\r\n  if (isBase10) {\r\n    if (d.length > 1) {\r\n      inf = true;\r\n    } else {\r\n      for (k = d[0]; k % 10 === 0;) k /= 10;\r\n      inf = k !== 1;\r\n    }\r\n  }\r\n\r\n  external = false;\r\n  sd = pr + guard;\r\n  num = naturalLogarithm(arg, sd);\r\n  denominator = isBase10 ? getLn10(Ctor, sd + 10) : naturalLogarithm(base, sd);\r\n\r\n  // The result will have 5 rounding digits.\r\n  r = divide(num, denominator, sd, 1);\r\n\r\n  // If at a rounding boundary, i.e. the result's rounding digits are [49]9999 or [50]0000,\r\n  // calculate 10 further digits.\r\n  //\r\n  // If the result is known to have an infinite decimal expansion, repeat this until it is clear\r\n  // that the result is above or below the boundary. Otherwise, if after calculating the 10\r\n  // further digits, the last 14 are nines, round up and assume the result is exact.\r\n  // Also assume the result is exact if the last 14 are zero.\r\n  //\r\n  // Example of a result that will be incorrectly rounded:\r\n  // log[1048576](4503599627370502) = 2.60000000000000009610279511444746...\r\n  // The above result correctly rounded using ROUND_CEIL to 1 decimal place should be 2.7, but it\r\n  // will be given as 2.6 as there are 15 zeros immediately after the requested decimal place, so\r\n  // the exact result would be assumed to be 2.6, which rounded using ROUND_CEIL to 1 decimal\r\n  // place is still 2.6.\r\n  if (checkRoundingDigits(r.d, k = pr, rm)) {\r\n\r\n    do {\r\n      sd += 10;\r\n      num = naturalLogarithm(arg, sd);\r\n      denominator = isBase10 ? getLn10(Ctor, sd + 10) : naturalLogarithm(base, sd);\r\n      r = divide(num, denominator, sd, 1);\r\n\r\n      if (!inf) {\r\n\r\n        // Check for 14 nines from the 2nd rounding digit, as the first may be 4.\r\n        if (+digitsToString(r.d).slice(k + 1, k + 15) + 1 == 1e14) {\r\n          r = finalise(r, pr + 1, 0);\r\n        }\r\n\r\n        break;\r\n      }\r\n    } while (checkRoundingDigits(r.d, k += 10, rm));\r\n  }\r\n\r\n  external = true;\r\n\r\n  return finalise(r, pr, rm);\r\n};\r\n\r\n\r\n/*\r\n * Return a new Decimal whose value is the maximum of the arguments and the value of this Decimal.\r\n *\r\n * arguments {number|string|Decimal}\r\n *\r\nP.max = function () {\r\n  Array.prototype.push.call(arguments, this);\r\n  return maxOrMin(this.constructor, arguments, 'lt');\r\n};\r\n */\r\n\r\n\r\n/*\r\n * Return a new Decimal whose value is the minimum of the arguments and the value of this Decimal.\r\n *\r\n * arguments {number|string|Decimal}\r\n *\r\nP.min = function () {\r\n  Array.prototype.push.call(arguments, this);\r\n  return maxOrMin(this.constructor, arguments, 'gt');\r\n};\r\n */\r\n\r\n\r\n/*\r\n *  n - 0 = n\r\n *  n - N = N\r\n *  n - I = -I\r\n *  0 - n = -n\r\n *  0 - 0 = 0\r\n *  0 - N = N\r\n *  0 - I = -I\r\n *  N - n = N\r\n *  N - 0 = N\r\n *  N - N = N\r\n *  N - I = N\r\n *  I - n = I\r\n *  I - 0 = I\r\n *  I - N = N\r\n *  I - I = N\r\n *\r\n * Return a new Decimal whose value is the value of this Decimal minus `y`, rounded to `precision`\r\n * significant digits using rounding mode `rounding`.\r\n *\r\n */\r\nP.minus = P.sub = function (y) {\r\n  var d, e, i, j, k, len, pr, rm, xd, xe, xLTy, yd,\r\n    x = this,\r\n    Ctor = x.constructor;\r\n\r\n  y = new Ctor(y);\r\n\r\n  // If either is not finite...\r\n  if (!x.d || !y.d) {\r\n\r\n    // Return NaN if either is NaN.\r\n    if (!x.s || !y.s) y = new Ctor(NaN);\r\n\r\n    // Return y negated if x is finite and y is ±Infinity.\r\n    else if (x.d) y.s = -y.s;\r\n\r\n    // Return x if y is finite and x is ±Infinity.\r\n    // Return x if both are ±Infinity with different signs.\r\n    // Return NaN if both are ±Infinity with the same sign.\r\n    else y = new Ctor(y.d || x.s !== y.s ? x : NaN);\r\n\r\n    return y;\r\n  }\r\n\r\n  // If signs differ...\r\n  if (x.s != y.s) {\r\n    y.s = -y.s;\r\n    return x.plus(y);\r\n  }\r\n\r\n  xd = x.d;\r\n  yd = y.d;\r\n  pr = Ctor.precision;\r\n  rm = Ctor.rounding;\r\n\r\n  // If either is zero...\r\n  if (!xd[0] || !yd[0]) {\r\n\r\n    // Return y negated if x is zero and y is non-zero.\r\n    if (yd[0]) y.s = -y.s;\r\n\r\n    // Return x if y is zero and x is non-zero.\r\n    else if (xd[0]) y = new Ctor(x);\r\n\r\n    // Return zero if both are zero.\r\n    // From IEEE 754 (2008) 6.3: 0 - 0 = -0 - -0 = -0 when rounding to -Infinity.\r\n    else return new Ctor(rm === 3 ? -0 : 0);\r\n\r\n    return external ? finalise(y, pr, rm) : y;\r\n  }\r\n\r\n  // x and y are finite, non-zero numbers with the same sign.\r\n\r\n  // Calculate base 1e7 exponents.\r\n  e = mathfloor(y.e / LOG_BASE);\r\n  xe = mathfloor(x.e / LOG_BASE);\r\n\r\n  xd = xd.slice();\r\n  k = xe - e;\r\n\r\n  // If base 1e7 exponents differ...\r\n  if (k) {\r\n    xLTy = k < 0;\r\n\r\n    if (xLTy) {\r\n      d = xd;\r\n      k = -k;\r\n      len = yd.length;\r\n    } else {\r\n      d = yd;\r\n      e = xe;\r\n      len = xd.length;\r\n    }\r\n\r\n    // Numbers with massively different exponents would result in a very high number of\r\n    // zeros needing to be prepended, but this can be avoided while still ensuring correct\r\n    // rounding by limiting the number of zeros to `Math.ceil(pr / LOG_BASE) + 2`.\r\n    i = Math.max(Math.ceil(pr / LOG_BASE), len) + 2;\r\n\r\n    if (k > i) {\r\n      k = i;\r\n      d.length = 1;\r\n    }\r\n\r\n    // Prepend zeros to equalise exponents.\r\n    d.reverse();\r\n    for (i = k; i--;) d.push(0);\r\n    d.reverse();\r\n\r\n  // Base 1e7 exponents equal.\r\n  } else {\r\n\r\n    // Check digits to determine which is the bigger number.\r\n\r\n    i = xd.length;\r\n    len = yd.length;\r\n    xLTy = i < len;\r\n    if (xLTy) len = i;\r\n\r\n    for (i = 0; i < len; i++) {\r\n      if (xd[i] != yd[i]) {\r\n        xLTy = xd[i] < yd[i];\r\n        break;\r\n      }\r\n    }\r\n\r\n    k = 0;\r\n  }\r\n\r\n  if (xLTy) {\r\n    d = xd;\r\n    xd = yd;\r\n    yd = d;\r\n    y.s = -y.s;\r\n  }\r\n\r\n  len = xd.length;\r\n\r\n  // Append zeros to `xd` if shorter.\r\n  // Don't add zeros to `yd` if shorter as subtraction only needs to start at `yd` length.\r\n  for (i = yd.length - len; i > 0; --i) xd[len++] = 0;\r\n\r\n  // Subtract yd from xd.\r\n  for (i = yd.length; i > k;) {\r\n\r\n    if (xd[--i] < yd[i]) {\r\n      for (j = i; j && xd[--j] === 0;) xd[j] = BASE - 1;\r\n      --xd[j];\r\n      xd[i] += BASE;\r\n    }\r\n\r\n    xd[i] -= yd[i];\r\n  }\r\n\r\n  // Remove trailing zeros.\r\n  for (; xd[--len] === 0;) xd.pop();\r\n\r\n  // Remove leading zeros and adjust exponent accordingly.\r\n  for (; xd[0] === 0; xd.shift()) --e;\r\n\r\n  // Zero?\r\n  if (!xd[0]) return new Ctor(rm === 3 ? -0 : 0);\r\n\r\n  y.d = xd;\r\n  y.e = getBase10Exponent(xd, e);\r\n\r\n  return external ? finalise(y, pr, rm) : y;\r\n};\r\n\r\n\r\n/*\r\n *   n % 0 =  N\r\n *   n % N =  N\r\n *   n % I =  n\r\n *   0 % n =  0\r\n *  -0 % n = -0\r\n *   0 % 0 =  N\r\n *   0 % N =  N\r\n *   0 % I =  0\r\n *   N % n =  N\r\n *   N % 0 =  N\r\n *   N % N =  N\r\n *   N % I =  N\r\n *   I % n =  N\r\n *   I % 0 =  N\r\n *   I % N =  N\r\n *   I % I =  N\r\n *\r\n * Return a new Decimal whose value is the value of this Decimal modulo `y`, rounded to\r\n * `precision` significant digits using rounding mode `rounding`.\r\n *\r\n * The result depends on the modulo mode.\r\n *\r\n */\r\nP.modulo = P.mod = function (y) {\r\n  var q,\r\n    x = this,\r\n    Ctor = x.constructor;\r\n\r\n  y = new Ctor(y);\r\n\r\n  // Return NaN if x is ±Infinity or NaN, or y is NaN or ±0.\r\n  if (!x.d || !y.s || y.d && !y.d[0]) return new Ctor(NaN);\r\n\r\n  // Return x if y is ±Infinity or x is ±0.\r\n  if (!y.d || x.d && !x.d[0]) {\r\n    return finalise(new Ctor(x), Ctor.precision, Ctor.rounding);\r\n  }\r\n\r\n  // Prevent rounding of intermediate calculations.\r\n  external = false;\r\n\r\n  if (Ctor.modulo == 9) {\r\n\r\n    // Euclidian division: q = sign(y) * floor(x / abs(y))\r\n    // result = x - q * y    where  0 <= result < abs(y)\r\n    q = divide(x, y.abs(), 0, 3, 1);\r\n    q.s *= y.s;\r\n  } else {\r\n    q = divide(x, y, 0, Ctor.modulo, 1);\r\n  }\r\n\r\n  q = q.times(y);\r\n\r\n  external = true;\r\n\r\n  return x.minus(q);\r\n};\r\n\r\n\r\n/*\r\n * Return a new Decimal whose value is the natural exponential of the value of this Decimal,\r\n * i.e. the base e raised to the power the value of this Decimal, rounded to `precision`\r\n * significant digits using rounding mode `rounding`.\r\n *\r\n */\r\nP.naturalExponential = P.exp = function () {\r\n  return naturalExponential(this);\r\n};\r\n\r\n\r\n/*\r\n * Return a new Decimal whose value is the natural logarithm of the value of this Decimal,\r\n * rounded to `precision` significant digits using rounding mode `rounding`.\r\n *\r\n */\r\nP.naturalLogarithm = P.ln = function () {\r\n  return naturalLogarithm(this);\r\n};\r\n\r\n\r\n/*\r\n * Return a new Decimal whose value is the value of this Decimal negated, i.e. as if multiplied by\r\n * -1.\r\n *\r\n */\r\nP.negated = P.neg = function () {\r\n  var x = new this.constructor(this);\r\n  x.s = -x.s;\r\n  return finalise(x);\r\n};\r\n\r\n\r\n/*\r\n *  n + 0 = n\r\n *  n + N = N\r\n *  n + I = I\r\n *  0 + n = n\r\n *  0 + 0 = 0\r\n *  0 + N = N\r\n *  0 + I = I\r\n *  N + n = N\r\n *  N + 0 = N\r\n *  N + N = N\r\n *  N + I = N\r\n *  I + n = I\r\n *  I + 0 = I\r\n *  I + N = N\r\n *  I + I = I\r\n *\r\n * Return a new Decimal whose value is the value of this Decimal plus `y`, rounded to `precision`\r\n * significant digits using rounding mode `rounding`.\r\n *\r\n */\r\nP.plus = P.add = function (y) {\r\n  var carry, d, e, i, k, len, pr, rm, xd, yd,\r\n    x = this,\r\n    Ctor = x.constructor;\r\n\r\n  y = new Ctor(y);\r\n\r\n  // If either is not finite...\r\n  if (!x.d || !y.d) {\r\n\r\n    // Return NaN if either is NaN.\r\n    if (!x.s || !y.s) y = new Ctor(NaN);\r\n\r\n    // Return x if y is finite and x is ±Infinity.\r\n    // Return x if both are ±Infinity with the same sign.\r\n    // Return NaN if both are ±Infinity with different signs.\r\n    // Return y if x is finite and y is ±Infinity.\r\n    else if (!x.d) y = new Ctor(y.d || x.s === y.s ? x : NaN);\r\n\r\n    return y;\r\n  }\r\n\r\n   // If signs differ...\r\n  if (x.s != y.s) {\r\n    y.s = -y.s;\r\n    return x.minus(y);\r\n  }\r\n\r\n  xd = x.d;\r\n  yd = y.d;\r\n  pr = Ctor.precision;\r\n  rm = Ctor.rounding;\r\n\r\n  // If either is zero...\r\n  if (!xd[0] || !yd[0]) {\r\n\r\n    // Return x if y is zero.\r\n    // Return y if y is non-zero.\r\n    if (!yd[0]) y = new Ctor(x);\r\n\r\n    return external ? finalise(y, pr, rm) : y;\r\n  }\r\n\r\n  // x and y are finite, non-zero numbers with the same sign.\r\n\r\n  // Calculate base 1e7 exponents.\r\n  k = mathfloor(x.e / LOG_BASE);\r\n  e = mathfloor(y.e / LOG_BASE);\r\n\r\n  xd = xd.slice();\r\n  i = k - e;\r\n\r\n  // If base 1e7 exponents differ...\r\n  if (i) {\r\n\r\n    if (i < 0) {\r\n      d = xd;\r\n      i = -i;\r\n      len = yd.length;\r\n    } else {\r\n      d = yd;\r\n      e = k;\r\n      len = xd.length;\r\n    }\r\n\r\n    // Limit number of zeros prepended to max(ceil(pr / LOG_BASE), len) + 1.\r\n    k = Math.ceil(pr / LOG_BASE);\r\n    len = k > len ? k + 1 : len + 1;\r\n\r\n    if (i > len) {\r\n      i = len;\r\n      d.length = 1;\r\n    }\r\n\r\n    // Prepend zeros to equalise exponents. Note: Faster to use reverse then do unshifts.\r\n    d.reverse();\r\n    for (; i--;) d.push(0);\r\n    d.reverse();\r\n  }\r\n\r\n  len = xd.length;\r\n  i = yd.length;\r\n\r\n  // If yd is longer than xd, swap xd and yd so xd points to the longer array.\r\n  if (len - i < 0) {\r\n    i = len;\r\n    d = yd;\r\n    yd = xd;\r\n    xd = d;\r\n  }\r\n\r\n  // Only start adding at yd.length - 1 as the further digits of xd can be left as they are.\r\n  for (carry = 0; i;) {\r\n    carry = (xd[--i] = xd[i] + yd[i] + carry) / BASE | 0;\r\n    xd[i] %= BASE;\r\n  }\r\n\r\n  if (carry) {\r\n    xd.unshift(carry);\r\n    ++e;\r\n  }\r\n\r\n  // Remove trailing zeros.\r\n  // No need to check for zero, as +x + +y != 0 && -x + -y != 0\r\n  for (len = xd.length; xd[--len] == 0;) xd.pop();\r\n\r\n  y.d = xd;\r\n  y.e = getBase10Exponent(xd, e);\r\n\r\n  return external ? finalise(y, pr, rm) : y;\r\n};\r\n\r\n\r\n/*\r\n * Return the number of significant digits of the value of this Decimal.\r\n *\r\n * [z] {boolean|number} Whether to count integer-part trailing zeros: true, false, 1 or 0.\r\n *\r\n */\r\nP.precision = P.sd = function (z) {\r\n  var k,\r\n    x = this;\r\n\r\n  if (z !== void 0 && z !== !!z && z !== 1 && z !== 0) throw Error(invalidArgument + z);\r\n\r\n  if (x.d) {\r\n    k = getPrecision(x.d);\r\n    if (z && x.e + 1 > k) k = x.e + 1;\r\n  } else {\r\n    k = NaN;\r\n  }\r\n\r\n  return k;\r\n};\r\n\r\n\r\n/*\r\n * Return a new Decimal whose value is the value of this Decimal rounded to a whole number using\r\n * rounding mode `rounding`.\r\n *\r\n */\r\nP.round = function () {\r\n  var x = this,\r\n    Ctor = x.constructor;\r\n\r\n  return finalise(new Ctor(x), x.e + 1, Ctor.rounding);\r\n};\r\n\r\n\r\n/*\r\n * Return a new Decimal whose value is the sine of the value in radians of this Decimal.\r\n *\r\n * Domain: [-Infinity, Infinity]\r\n * Range: [-1, 1]\r\n *\r\n * sin(x) = x - x^3/3! + x^5/5! - ...\r\n *\r\n * sin(0)         = 0\r\n * sin(-0)        = -0\r\n * sin(Infinity)  = NaN\r\n * sin(-Infinity) = NaN\r\n * sin(NaN)       = NaN\r\n *\r\n */\r\nP.sine = P.sin = function () {\r\n  var pr, rm,\r\n    x = this,\r\n    Ctor = x.constructor;\r\n\r\n  if (!x.isFinite()) return new Ctor(NaN);\r\n  if (x.isZero()) return new Ctor(x);\r\n\r\n  pr = Ctor.precision;\r\n  rm = Ctor.rounding;\r\n  Ctor.precision = pr + Math.max(x.e, x.sd()) + LOG_BASE;\r\n  Ctor.rounding = 1;\r\n\r\n  x = sine(Ctor, toLessThanHalfPi(Ctor, x));\r\n\r\n  Ctor.precision = pr;\r\n  Ctor.rounding = rm;\r\n\r\n  return finalise(quadrant > 2 ? x.neg() : x, pr, rm, true);\r\n};\r\n\r\n\r\n/*\r\n * Return a new Decimal whose value is the square root of this Decimal, rounded to `precision`\r\n * significant digits using rounding mode `rounding`.\r\n *\r\n *  sqrt(-n) =  N\r\n *  sqrt(N)  =  N\r\n *  sqrt(-I) =  N\r\n *  sqrt(I)  =  I\r\n *  sqrt(0)  =  0\r\n *  sqrt(-0) = -0\r\n *\r\n */\r\nP.squareRoot = P.sqrt = function () {\r\n  var m, n, sd, r, rep, t,\r\n    x = this,\r\n    d = x.d,\r\n    e = x.e,\r\n    s = x.s,\r\n    Ctor = x.constructor;\r\n\r\n  // Negative/NaN/Infinity/zero?\r\n  if (s !== 1 || !d || !d[0]) {\r\n    return new Ctor(!s || s < 0 && (!d || d[0]) ? NaN : d ? x : 1 / 0);\r\n  }\r\n\r\n  external = false;\r\n\r\n  // Initial estimate.\r\n  s = Math.sqrt(+x);\r\n\r\n  // Math.sqrt underflow/overflow?\r\n  // Pass x to Math.sqrt as integer, then adjust the exponent of the result.\r\n  if (s == 0 || s == 1 / 0) {\r\n    n = digitsToString(d);\r\n\r\n    if ((n.length + e) % 2 == 0) n += '0';\r\n    s = Math.sqrt(n);\r\n    e = mathfloor((e + 1) / 2) - (e < 0 || e % 2);\r\n\r\n    if (s == 1 / 0) {\r\n      n = '5e' + e;\r\n    } else {\r\n      n = s.toExponential();\r\n      n = n.slice(0, n.indexOf('e') + 1) + e;\r\n    }\r\n\r\n    r = new Ctor(n);\r\n  } else {\r\n    r = new Ctor(s.toString());\r\n  }\r\n\r\n  sd = (e = Ctor.precision) + 3;\r\n\r\n  // Newton-Raphson iteration.\r\n  for (;;) {\r\n    t = r;\r\n    r = t.plus(divide(x, t, sd + 2, 1)).times(0.5);\r\n\r\n    // TODO? Replace with for-loop and checkRoundingDigits.\r\n    if (digitsToString(t.d).slice(0, sd) === (n = digitsToString(r.d)).slice(0, sd)) {\r\n      n = n.slice(sd - 3, sd + 1);\r\n\r\n      // The 4th rounding digit may be in error by -1 so if the 4 rounding digits are 9999 or\r\n      // 4999, i.e. approaching a rounding boundary, continue the iteration.\r\n      if (n == '9999' || !rep && n == '4999') {\r\n\r\n        // On the first iteration only, check to see if rounding up gives the exact result as the\r\n        // nines may infinitely repeat.\r\n        if (!rep) {\r\n          finalise(t, e + 1, 0);\r\n\r\n          if (t.times(t).eq(x)) {\r\n            r = t;\r\n            break;\r\n          }\r\n        }\r\n\r\n        sd += 4;\r\n        rep = 1;\r\n      } else {\r\n\r\n        // If the rounding digits are null, 0{0,4} or 50{0,3}, check for an exact result.\r\n        // If not, then there are further digits and m will be truthy.\r\n        if (!+n || !+n.slice(1) && n.charAt(0) == '5') {\r\n\r\n          // Truncate to the first rounding digit.\r\n          finalise(r, e + 1, 1);\r\n          m = !r.times(r).eq(x);\r\n        }\r\n\r\n        break;\r\n      }\r\n    }\r\n  }\r\n\r\n  external = true;\r\n\r\n  return finalise(r, e, Ctor.rounding, m);\r\n};\r\n\r\n\r\n/*\r\n * Return a new Decimal whose value is the tangent of the value in radians of this Decimal.\r\n *\r\n * Domain: [-Infinity, Infinity]\r\n * Range: [-Infinity, Infinity]\r\n *\r\n * tan(0)         = 0\r\n * tan(-0)        = -0\r\n * tan(Infinity)  = NaN\r\n * tan(-Infinity) = NaN\r\n * tan(NaN)       = NaN\r\n *\r\n */\r\nP.tangent = P.tan = function () {\r\n  var pr, rm,\r\n    x = this,\r\n    Ctor = x.constructor;\r\n\r\n  if (!x.isFinite()) return new Ctor(NaN);\r\n  if (x.isZero()) return new Ctor(x);\r\n\r\n  pr = Ctor.precision;\r\n  rm = Ctor.rounding;\r\n  Ctor.precision = pr + 10;\r\n  Ctor.rounding = 1;\r\n\r\n  x = x.sin();\r\n  x.s = 1;\r\n  x = divide(x, new Ctor(1).minus(x.times(x)).sqrt(), pr + 10, 0);\r\n\r\n  Ctor.precision = pr;\r\n  Ctor.rounding = rm;\r\n\r\n  return finalise(quadrant == 2 || quadrant == 4 ? x.neg() : x, pr, rm, true);\r\n};\r\n\r\n\r\n/*\r\n *  n * 0 = 0\r\n *  n * N = N\r\n *  n * I = I\r\n *  0 * n = 0\r\n *  0 * 0 = 0\r\n *  0 * N = N\r\n *  0 * I = N\r\n *  N * n = N\r\n *  N * 0 = N\r\n *  N * N = N\r\n *  N * I = N\r\n *  I * n = I\r\n *  I * 0 = N\r\n *  I * N = N\r\n *  I * I = I\r\n *\r\n * Return a new Decimal whose value is this Decimal times `y`, rounded to `precision` significant\r\n * digits using rounding mode `rounding`.\r\n *\r\n */\r\nP.times = P.mul = function (y) {\r\n  var carry, e, i, k, r, rL, t, xdL, ydL,\r\n    x = this,\r\n    Ctor = x.constructor,\r\n    xd = x.d,\r\n    yd = (y = new Ctor(y)).d;\r\n\r\n  y.s *= x.s;\r\n\r\n   // If either is NaN, ±Infinity or ±0...\r\n  if (!xd || !xd[0] || !yd || !yd[0]) {\r\n\r\n    return new Ctor(!y.s || xd && !xd[0] && !yd || yd && !yd[0] && !xd\r\n\r\n      // Return NaN if either is NaN.\r\n      // Return NaN if x is ±0 and y is ±Infinity, or y is ±0 and x is ±Infinity.\r\n      ? NaN\r\n\r\n      // Return ±Infinity if either is ±Infinity.\r\n      // Return ±0 if either is ±0.\r\n      : !xd || !yd ? y.s / 0 : y.s * 0);\r\n  }\r\n\r\n  e = mathfloor(x.e / LOG_BASE) + mathfloor(y.e / LOG_BASE);\r\n  xdL = xd.length;\r\n  ydL = yd.length;\r\n\r\n  // Ensure xd points to the longer array.\r\n  if (xdL < ydL) {\r\n    r = xd;\r\n    xd = yd;\r\n    yd = r;\r\n    rL = xdL;\r\n    xdL = ydL;\r\n    ydL = rL;\r\n  }\r\n\r\n  // Initialise the result array with zeros.\r\n  r = [];\r\n  rL = xdL + ydL;\r\n  for (i = rL; i--;) r.push(0);\r\n\r\n  // Multiply!\r\n  for (i = ydL; --i >= 0;) {\r\n    carry = 0;\r\n    for (k = xdL + i; k > i;) {\r\n      t = r[k] + yd[i] * xd[k - i - 1] + carry;\r\n      r[k--] = t % BASE | 0;\r\n      carry = t / BASE | 0;\r\n    }\r\n\r\n    r[k] = (r[k] + carry) % BASE | 0;\r\n  }\r\n\r\n  // Remove trailing zeros.\r\n  for (; !r[--rL];) r.pop();\r\n\r\n  if (carry) ++e;\r\n  else r.shift();\r\n\r\n  y.d = r;\r\n  y.e = getBase10Exponent(r, e);\r\n\r\n  return external ? finalise(y, Ctor.precision, Ctor.rounding) : y;\r\n};\r\n\r\n\r\n/*\r\n * Return a string representing the value of this Decimal in base 2, round to `sd` significant\r\n * digits using rounding mode `rm`.\r\n *\r\n * If the optional `sd` argument is present then return binary exponential notation.\r\n *\r\n * [sd] {number} Significant digits. Integer, 1 to MAX_DIGITS inclusive.\r\n * [rm] {number} Rounding mode. Integer, 0 to 8 inclusive.\r\n *\r\n */\r\nP.toBinary = function (sd, rm) {\r\n  return toStringBinary(this, 2, sd, rm);\r\n};\r\n\r\n\r\n/*\r\n * Return a new Decimal whose value is the value of this Decimal rounded to a maximum of `dp`\r\n * decimal places using rounding mode `rm` or `rounding` if `rm` is omitted.\r\n *\r\n * If `dp` is omitted, return a new Decimal whose value is the value of this Decimal.\r\n *\r\n * [dp] {number} Decimal places. Integer, 0 to MAX_DIGITS inclusive.\r\n * [rm] {number} Rounding mode. Integer, 0 to 8 inclusive.\r\n *\r\n */\r\nP.toDecimalPlaces = P.toDP = function (dp, rm) {\r\n  var x = this,\r\n    Ctor = x.constructor;\r\n\r\n  x = new Ctor(x);\r\n  if (dp === void 0) return x;\r\n\r\n  checkInt32(dp, 0, MAX_DIGITS);\r\n\r\n  if (rm === void 0) rm = Ctor.rounding;\r\n  else checkInt32(rm, 0, 8);\r\n\r\n  return finalise(x, dp + x.e + 1, rm);\r\n};\r\n\r\n\r\n/*\r\n * Return a string representing the value of this Decimal in exponential notation rounded to\r\n * `dp` fixed decimal places using rounding mode `rounding`.\r\n *\r\n * [dp] {number} Decimal places. Integer, 0 to MAX_DIGITS inclusive.\r\n * [rm] {number} Rounding mode. Integer, 0 to 8 inclusive.\r\n *\r\n */\r\nP.toExponential = function (dp, rm) {\r\n  var str,\r\n    x = this,\r\n    Ctor = x.constructor;\r\n\r\n  if (dp === void 0) {\r\n    str = finiteToString(x, true);\r\n  } else {\r\n    checkInt32(dp, 0, MAX_DIGITS);\r\n\r\n    if (rm === void 0) rm = Ctor.rounding;\r\n    else checkInt32(rm, 0, 8);\r\n\r\n    x = finalise(new Ctor(x), dp + 1, rm);\r\n    str = finiteToString(x, true, dp + 1);\r\n  }\r\n\r\n  return x.isNeg() && !x.isZero() ? '-' + str : str;\r\n};\r\n\r\n\r\n/*\r\n * Return a string representing the value of this Decimal in normal (fixed-point) notation to\r\n * `dp` fixed decimal places and rounded using rounding mode `rm` or `rounding` if `rm` is\r\n * omitted.\r\n *\r\n * As with JavaScript numbers, (-0).toFixed(0) is '0', but e.g. (-0.00001).toFixed(0) is '-0'.\r\n *\r\n * [dp] {number} Decimal places. Integer, 0 to MAX_DIGITS inclusive.\r\n * [rm] {number} Rounding mode. Integer, 0 to 8 inclusive.\r\n *\r\n * (-0).toFixed(0) is '0', but (-0.1).toFixed(0) is '-0'.\r\n * (-0).toFixed(1) is '0.0', but (-0.01).toFixed(1) is '-0.0'.\r\n * (-0).toFixed(3) is '0.000'.\r\n * (-0.5).toFixed(0) is '-0'.\r\n *\r\n */\r\nP.toFixed = function (dp, rm) {\r\n  var str, y,\r\n    x = this,\r\n    Ctor = x.constructor;\r\n\r\n  if (dp === void 0) {\r\n    str = finiteToString(x);\r\n  } else {\r\n    checkInt32(dp, 0, MAX_DIGITS);\r\n\r\n    if (rm === void 0) rm = Ctor.rounding;\r\n    else checkInt32(rm, 0, 8);\r\n\r\n    y = finalise(new Ctor(x), dp + x.e + 1, rm);\r\n    str = finiteToString(y, false, dp + y.e + 1);\r\n  }\r\n\r\n  // To determine whether to add the minus sign look at the value before it was rounded,\r\n  // i.e. look at `x` rather than `y`.\r\n  return x.isNeg() && !x.isZero() ? '-' + str : str;\r\n};\r\n\r\n\r\n/*\r\n * Return an array representing the value of this Decimal as a simple fraction with an integer\r\n * numerator and an integer denominator.\r\n *\r\n * The denominator will be a positive non-zero value less than or equal to the specified maximum\r\n * denominator. If a maximum denominator is not specified, the denominator will be the lowest\r\n * value necessary to represent the number exactly.\r\n *\r\n * [maxD] {number|string|Decimal} Maximum denominator. Integer >= 1 and < Infinity.\r\n *\r\n */\r\nP.toFraction = function (maxD) {\r\n  var d, d0, d1, d2, e, k, n, n0, n1, pr, q, r,\r\n    x = this,\r\n    xd = x.d,\r\n    Ctor = x.constructor;\r\n\r\n  if (!xd) return new Ctor(x);\r\n\r\n  n1 = d0 = new Ctor(1);\r\n  d1 = n0 = new Ctor(0);\r\n\r\n  d = new Ctor(d1);\r\n  e = d.e = getPrecision(xd) - x.e - 1;\r\n  k = e % LOG_BASE;\r\n  d.d[0] = mathpow(10, k < 0 ? LOG_BASE + k : k);\r\n\r\n  if (maxD == null) {\r\n\r\n    // d is 10**e, the minimum max-denominator needed.\r\n    maxD = e > 0 ? d : n1;\r\n  } else {\r\n    n = new Ctor(maxD);\r\n    if (!n.isInt() || n.lt(n1)) throw Error(invalidArgument + n);\r\n    maxD = n.gt(d) ? (e > 0 ? d : n1) : n;\r\n  }\r\n\r\n  external = false;\r\n  n = new Ctor(digitsToString(xd));\r\n  pr = Ctor.precision;\r\n  Ctor.precision = e = xd.length * LOG_BASE * 2;\r\n\r\n  for (;;)  {\r\n    q = divide(n, d, 0, 1, 1);\r\n    d2 = d0.plus(q.times(d1));\r\n    if (d2.cmp(maxD) == 1) break;\r\n    d0 = d1;\r\n    d1 = d2;\r\n    d2 = n1;\r\n    n1 = n0.plus(q.times(d2));\r\n    n0 = d2;\r\n    d2 = d;\r\n    d = n.minus(q.times(d2));\r\n    n = d2;\r\n  }\r\n\r\n  d2 = divide(maxD.minus(d0), d1, 0, 1, 1);\r\n  n0 = n0.plus(d2.times(n1));\r\n  d0 = d0.plus(d2.times(d1));\r\n  n0.s = n1.s = x.s;\r\n\r\n  // Determine which fraction is closer to x, n0/d0 or n1/d1?\r\n  r = divide(n1, d1, e, 1).minus(x).abs().cmp(divide(n0, d0, e, 1).minus(x).abs()) < 1\r\n      ? [n1, d1] : [n0, d0];\r\n\r\n  Ctor.precision = pr;\r\n  external = true;\r\n\r\n  return r;\r\n};\r\n\r\n\r\n/*\r\n * Return a string representing the value of this Decimal in base 16, round to `sd` significant\r\n * digits using rounding mode `rm`.\r\n *\r\n * If the optional `sd` argument is present then return binary exponential notation.\r\n *\r\n * [sd] {number} Significant digits. Integer, 1 to MAX_DIGITS inclusive.\r\n * [rm] {number} Rounding mode. Integer, 0 to 8 inclusive.\r\n *\r\n */\r\nP.toHexadecimal = P.toHex = function (sd, rm) {\r\n  return toStringBinary(this, 16, sd, rm);\r\n};\r\n\r\n\r\n/*\r\n * Returns a new Decimal whose value is the nearest multiple of `y` in the direction of rounding\r\n * mode `rm`, or `Decimal.rounding` if `rm` is omitted, to the value of this Decimal.\r\n *\r\n * The return value will always have the same sign as this Decimal, unless either this Decimal\r\n * or `y` is NaN, in which case the return value will be also be NaN.\r\n *\r\n * The return value is not affected by the value of `precision`.\r\n *\r\n * y {number|string|Decimal} The magnitude to round to a multiple of.\r\n * [rm] {number} Rounding mode. Integer, 0 to 8 inclusive.\r\n *\r\n * 'toNearest() rounding mode not an integer: {rm}'\r\n * 'toNearest() rounding mode out of range: {rm}'\r\n *\r\n */\r\nP.toNearest = function (y, rm) {\r\n  var x = this,\r\n    Ctor = x.constructor;\r\n\r\n  x = new Ctor(x);\r\n\r\n  if (y == null) {\r\n\r\n    // If x is not finite, return x.\r\n    if (!x.d) return x;\r\n\r\n    y = new Ctor(1);\r\n    rm = Ctor.rounding;\r\n  } else {\r\n    y = new Ctor(y);\r\n    if (rm === void 0) {\r\n      rm = Ctor.rounding;\r\n    } else {\r\n      checkInt32(rm, 0, 8);\r\n    }\r\n\r\n    // If x is not finite, return x if y is not NaN, else NaN.\r\n    if (!x.d) return y.s ? x : y;\r\n\r\n    // If y is not finite, return Infinity with the sign of x if y is Infinity, else NaN.\r\n    if (!y.d) {\r\n      if (y.s) y.s = x.s;\r\n      return y;\r\n    }\r\n  }\r\n\r\n  // If y is not zero, calculate the nearest multiple of y to x.\r\n  if (y.d[0]) {\r\n    external = false;\r\n    x = divide(x, y, 0, rm, 1).times(y);\r\n    external = true;\r\n    finalise(x);\r\n\r\n  // If y is zero, return zero with the sign of x.\r\n  } else {\r\n    y.s = x.s;\r\n    x = y;\r\n  }\r\n\r\n  return x;\r\n};\r\n\r\n\r\n/*\r\n * Return the value of this Decimal converted to a number primitive.\r\n * Zero keeps its sign.\r\n *\r\n */\r\nP.toNumber = function () {\r\n  return +this;\r\n};\r\n\r\n\r\n/*\r\n * Return a string representing the value of this Decimal in base 8, round to `sd` significant\r\n * digits using rounding mode `rm`.\r\n *\r\n * If the optional `sd` argument is present then return binary exponential notation.\r\n *\r\n * [sd] {number} Significant digits. Integer, 1 to MAX_DIGITS inclusive.\r\n * [rm] {number} Rounding mode. Integer, 0 to 8 inclusive.\r\n *\r\n */\r\nP.toOctal = function (sd, rm) {\r\n  return toStringBinary(this, 8, sd, rm);\r\n};\r\n\r\n\r\n/*\r\n * Return a new Decimal whose value is the value of this Decimal raised to the power `y`, rounded\r\n * to `precision` significant digits using rounding mode `rounding`.\r\n *\r\n * ECMAScript compliant.\r\n *\r\n *   pow(x, NaN)                           = NaN\r\n *   pow(x, ±0)                            = 1\r\n\r\n *   pow(NaN, non-zero)                    = NaN\r\n *   pow(abs(x) > 1, +Infinity)            = +Infinity\r\n *   pow(abs(x) > 1, -Infinity)            = +0\r\n *   pow(abs(x) == 1, ±Infinity)           = NaN\r\n *   pow(abs(x) < 1, +Infinity)            = +0\r\n *   pow(abs(x) < 1, -Infinity)            = +Infinity\r\n *   pow(+Infinity, y > 0)                 = +Infinity\r\n *   pow(+Infinity, y < 0)                 = +0\r\n *   pow(-Infinity, odd integer > 0)       = -Infinity\r\n *   pow(-Infinity, even integer > 0)      = +Infinity\r\n *   pow(-Infinity, odd integer < 0)       = -0\r\n *   pow(-Infinity, even integer < 0)      = +0\r\n *   pow(+0, y > 0)                        = +0\r\n *   pow(+0, y < 0)                        = +Infinity\r\n *   pow(-0, odd integer > 0)              = -0\r\n *   pow(-0, even integer > 0)             = +0\r\n *   pow(-0, odd integer < 0)              = -Infinity\r\n *   pow(-0, even integer < 0)             = +Infinity\r\n *   pow(finite x < 0, finite non-integer) = NaN\r\n *\r\n * For non-integer or very large exponents pow(x, y) is calculated using\r\n *\r\n *   x^y = exp(y*ln(x))\r\n *\r\n * Assuming the first 15 rounding digits are each equally likely to be any digit 0-9, the\r\n * probability of an incorrectly rounded result\r\n * P([49]9{14} | [50]0{14}) = 2 * 0.2 * 10^-14 = 4e-15 = 1/2.5e+14\r\n * i.e. 1 in 250,000,000,000,000\r\n *\r\n * If a result is incorrectly rounded the maximum error will be 1 ulp (unit in last place).\r\n *\r\n * y {number|string|Decimal} The power to which to raise this Decimal.\r\n *\r\n */\r\nP.toPower = P.pow = function (y) {\r\n  var e, k, pr, r, rm, s,\r\n    x = this,\r\n    Ctor = x.constructor,\r\n    yn = +(y = new Ctor(y));\r\n\r\n  // Either ±Infinity, NaN or ±0?\r\n  if (!x.d || !y.d || !x.d[0] || !y.d[0]) return new Ctor(mathpow(+x, yn));\r\n\r\n  x = new Ctor(x);\r\n\r\n  if (x.eq(1)) return x;\r\n\r\n  pr = Ctor.precision;\r\n  rm = Ctor.rounding;\r\n\r\n  if (y.eq(1)) return finalise(x, pr, rm);\r\n\r\n  // y exponent\r\n  e = mathfloor(y.e / LOG_BASE);\r\n\r\n  // If y is a small integer use the 'exponentiation by squaring' algorithm.\r\n  if (e >= y.d.length - 1 && (k = yn < 0 ? -yn : yn) <= MAX_SAFE_INTEGER) {\r\n    r = intPow(Ctor, x, k, pr);\r\n    return y.s < 0 ? new Ctor(1).div(r) : finalise(r, pr, rm);\r\n  }\r\n\r\n  s = x.s;\r\n\r\n  // if x is negative\r\n  if (s < 0) {\r\n\r\n    // if y is not an integer\r\n    if (e < y.d.length - 1) return new Ctor(NaN);\r\n\r\n    // Result is positive if x is negative and the last digit of integer y is even.\r\n    if ((y.d[e] & 1) == 0) s = 1;\r\n\r\n    // if x.eq(-1)\r\n    if (x.e == 0 && x.d[0] == 1 && x.d.length == 1) {\r\n      x.s = s;\r\n      return x;\r\n    }\r\n  }\r\n\r\n  // Estimate result exponent.\r\n  // x^y = 10^e,  where e = y * log10(x)\r\n  // log10(x) = log10(x_significand) + x_exponent\r\n  // log10(x_significand) = ln(x_significand) / ln(10)\r\n  k = mathpow(+x, yn);\r\n  e = k == 0 || !isFinite(k)\r\n    ? mathfloor(yn * (Math.log('0.' + digitsToString(x.d)) / Math.LN10 + x.e + 1))\r\n    : new Ctor(k + '').e;\r\n\r\n  // Exponent estimate may be incorrect e.g. x: 0.999999999999999999, y: 2.29, e: 0, r.e: -1.\r\n\r\n  // Overflow/underflow?\r\n  if (e > Ctor.maxE + 1 || e < Ctor.minE - 1) return new Ctor(e > 0 ? s / 0 : 0);\r\n\r\n  external = false;\r\n  Ctor.rounding = x.s = 1;\r\n\r\n  // Estimate the extra guard digits needed to ensure five correct rounding digits from\r\n  // naturalLogarithm(x). Example of failure without these extra digits (precision: 10):\r\n  // new Decimal(2.32456).pow('2087987436534566.46411')\r\n  // should be 1.162377823e+764914905173815, but is 1.162355823e+764914905173815\r\n  k = Math.min(12, (e + '').length);\r\n\r\n  // r = x^y = exp(y*ln(x))\r\n  r = naturalExponential(y.times(naturalLogarithm(x, pr + k)), pr);\r\n\r\n  // r may be Infinity, e.g. (0.9999999999999999).pow(-1e+40)\r\n  if (r.d) {\r\n\r\n    // Truncate to the required precision plus five rounding digits.\r\n    r = finalise(r, pr + 5, 1);\r\n\r\n    // If the rounding digits are [49]9999 or [50]0000 increase the precision by 10 and recalculate\r\n    // the result.\r\n    if (checkRoundingDigits(r.d, pr, rm)) {\r\n      e = pr + 10;\r\n\r\n      // Truncate to the increased precision plus five rounding digits.\r\n      r = finalise(naturalExponential(y.times(naturalLogarithm(x, e + k)), e), e + 5, 1);\r\n\r\n      // Check for 14 nines from the 2nd rounding digit (the first rounding digit may be 4 or 9).\r\n      if (+digitsToString(r.d).slice(pr + 1, pr + 15) + 1 == 1e14) {\r\n        r = finalise(r, pr + 1, 0);\r\n      }\r\n    }\r\n  }\r\n\r\n  r.s = s;\r\n  external = true;\r\n  Ctor.rounding = rm;\r\n\r\n  return finalise(r, pr, rm);\r\n};\r\n\r\n\r\n/*\r\n * Return a string representing the value of this Decimal rounded to `sd` significant digits\r\n * using rounding mode `rounding`.\r\n *\r\n * Return exponential notation if `sd` is less than the number of digits necessary to represent\r\n * the integer part of the value in normal notation.\r\n *\r\n * [sd] {number} Significant digits. Integer, 1 to MAX_DIGITS inclusive.\r\n * [rm] {number} Rounding mode. Integer, 0 to 8 inclusive.\r\n *\r\n */\r\nP.toPrecision = function (sd, rm) {\r\n  var str,\r\n    x = this,\r\n    Ctor = x.constructor;\r\n\r\n  if (sd === void 0) {\r\n    str = finiteToString(x, x.e <= Ctor.toExpNeg || x.e >= Ctor.toExpPos);\r\n  } else {\r\n    checkInt32(sd, 1, MAX_DIGITS);\r\n\r\n    if (rm === void 0) rm = Ctor.rounding;\r\n    else checkInt32(rm, 0, 8);\r\n\r\n    x = finalise(new Ctor(x), sd, rm);\r\n    str = finiteToString(x, sd <= x.e || x.e <= Ctor.toExpNeg, sd);\r\n  }\r\n\r\n  return x.isNeg() && !x.isZero() ? '-' + str : str;\r\n};\r\n\r\n\r\n/*\r\n * Return a new Decimal whose value is the value of this Decimal rounded to a maximum of `sd`\r\n * significant digits using rounding mode `rm`, or to `precision` and `rounding` respectively if\r\n * omitted.\r\n *\r\n * [sd] {number} Significant digits. Integer, 1 to MAX_DIGITS inclusive.\r\n * [rm] {number} Rounding mode. Integer, 0 to 8 inclusive.\r\n *\r\n * 'toSD() digits out of range: {sd}'\r\n * 'toSD() digits not an integer: {sd}'\r\n * 'toSD() rounding mode not an integer: {rm}'\r\n * 'toSD() rounding mode out of range: {rm}'\r\n *\r\n */\r\nP.toSignificantDigits = P.toSD = function (sd, rm) {\r\n  var x = this,\r\n    Ctor = x.constructor;\r\n\r\n  if (sd === void 0) {\r\n    sd = Ctor.precision;\r\n    rm = Ctor.rounding;\r\n  } else {\r\n    checkInt32(sd, 1, MAX_DIGITS);\r\n\r\n    if (rm === void 0) rm = Ctor.rounding;\r\n    else checkInt32(rm, 0, 8);\r\n  }\r\n\r\n  return finalise(new Ctor(x), sd, rm);\r\n};\r\n\r\n\r\n/*\r\n * Return a string representing the value of this Decimal.\r\n *\r\n * Return exponential notation if this Decimal has a positive exponent equal to or greater than\r\n * `toExpPos`, or a negative exponent equal to or less than `toExpNeg`.\r\n *\r\n */\r\nP.toString = function () {\r\n  var x = this,\r\n    Ctor = x.constructor,\r\n    str = finiteToString(x, x.e <= Ctor.toExpNeg || x.e >= Ctor.toExpPos);\r\n\r\n  return x.isNeg() && !x.isZero() ? '-' + str : str;\r\n};\r\n\r\n\r\n/*\r\n * Return a new Decimal whose value is the value of this Decimal truncated to a whole number.\r\n *\r\n */\r\nP.truncated = P.trunc = function () {\r\n  return finalise(new this.constructor(this), this.e + 1, 1);\r\n};\r\n\r\n\r\n/*\r\n * Return a string representing the value of this Decimal.\r\n * Unlike `toString`, negative zero will include the minus sign.\r\n *\r\n */\r\nP.valueOf = P.toJSON = function () {\r\n  var x = this,\r\n    Ctor = x.constructor,\r\n    str = finiteToString(x, x.e <= Ctor.toExpNeg || x.e >= Ctor.toExpPos);\r\n\r\n  return x.isNeg() ? '-' + str : str;\r\n};\r\n\r\n\r\n// Helper functions for Decimal.prototype (P) and/or Decimal methods, and their callers.\r\n\r\n\r\n/*\r\n *  digitsToString           P.cubeRoot, P.logarithm, P.squareRoot, P.toFraction, P.toPower,\r\n *                           finiteToString, naturalExponential, naturalLogarithm\r\n *  checkInt32               P.toDecimalPlaces, P.toExponential, P.toFixed, P.toNearest,\r\n *                           P.toPrecision, P.toSignificantDigits, toStringBinary, random\r\n *  checkRoundingDigits      P.logarithm, P.toPower, naturalExponential, naturalLogarithm\r\n *  convertBase              toStringBinary, parseOther\r\n *  cos                      P.cos\r\n *  divide                   P.atanh, P.cubeRoot, P.dividedBy, P.dividedToIntegerBy,\r\n *                           P.logarithm, P.modulo, P.squareRoot, P.tan, P.tanh, P.toFraction,\r\n *                           P.toNearest, toStringBinary, naturalExponential, naturalLogarithm,\r\n *                           taylorSeries, atan2, parseOther\r\n *  finalise                 P.absoluteValue, P.atan, P.atanh, P.ceil, P.cos, P.cosh,\r\n *                           P.cubeRoot, P.dividedToIntegerBy, P.floor, P.logarithm, P.minus,\r\n *                           P.modulo, P.negated, P.plus, P.round, P.sin, P.sinh, P.squareRoot,\r\n *                           P.tan, P.times, P.toDecimalPlaces, P.toExponential, P.toFixed,\r\n *                           P.toNearest, P.toPower, P.toPrecision, P.toSignificantDigits,\r\n *                           P.truncated, divide, getLn10, getPi, naturalExponential,\r\n *                           naturalLogarithm, ceil, floor, round, trunc\r\n *  finiteToString           P.toExponential, P.toFixed, P.toPrecision, P.toString, P.valueOf,\r\n *                           toStringBinary\r\n *  getBase10Exponent        P.minus, P.plus, P.times, parseOther\r\n *  getLn10                  P.logarithm, naturalLogarithm\r\n *  getPi                    P.acos, P.asin, P.atan, toLessThanHalfPi, atan2\r\n *  getPrecision             P.precision, P.toFraction\r\n *  getZeroString            digitsToString, finiteToString\r\n *  intPow                   P.toPower, parseOther\r\n *  isOdd                    toLessThanHalfPi\r\n *  maxOrMin                 max, min\r\n *  naturalExponential       P.naturalExponential, P.toPower\r\n *  naturalLogarithm         P.acosh, P.asinh, P.atanh, P.logarithm, P.naturalLogarithm,\r\n *                           P.toPower, naturalExponential\r\n *  nonFiniteToString        finiteToString, toStringBinary\r\n *  parseDecimal             Decimal\r\n *  parseOther               Decimal\r\n *  sin                      P.sin\r\n *  taylorSeries             P.cosh, P.sinh, cos, sin\r\n *  toLessThanHalfPi         P.cos, P.sin\r\n *  toStringBinary           P.toBinary, P.toHexadecimal, P.toOctal\r\n *  truncate                 intPow\r\n *\r\n *  Throws:                  P.logarithm, P.precision, P.toFraction, checkInt32, getLn10, getPi,\r\n *                           naturalLogarithm, config, parseOther, random, Decimal\r\n */\r\n\r\n\r\nfunction digitsToString(d) {\r\n  var i, k, ws,\r\n    indexOfLastWord = d.length - 1,\r\n    str = '',\r\n    w = d[0];\r\n\r\n  if (indexOfLastWord > 0) {\r\n    str += w;\r\n    for (i = 1; i < indexOfLastWord; i++) {\r\n      ws = d[i] + '';\r\n      k = LOG_BASE - ws.length;\r\n      if (k) str += getZeroString(k);\r\n      str += ws;\r\n    }\r\n\r\n    w = d[i];\r\n    ws = w + '';\r\n    k = LOG_BASE - ws.length;\r\n    if (k) str += getZeroString(k);\r\n  } else if (w === 0) {\r\n    return '0';\r\n  }\r\n\r\n  // Remove trailing zeros of last w.\r\n  for (; w % 10 === 0;) w /= 10;\r\n\r\n  return str + w;\r\n}\r\n\r\n\r\nfunction checkInt32(i, min, max) {\r\n  if (i !== ~~i || i < min || i > max) {\r\n    throw Error(invalidArgument + i);\r\n  }\r\n}\r\n\r\n\r\n/*\r\n * Check 5 rounding digits if `repeating` is null, 4 otherwise.\r\n * `repeating == null` if caller is `log` or `pow`,\r\n * `repeating != null` if caller is `naturalLogarithm` or `naturalExponential`.\r\n */\r\nfunction checkRoundingDigits(d, i, rm, repeating) {\r\n  var di, k, r, rd;\r\n\r\n  // Get the length of the first word of the array d.\r\n  for (k = d[0]; k >= 10; k /= 10) --i;\r\n\r\n  // Is the rounding digit in the first word of d?\r\n  if (--i < 0) {\r\n    i += LOG_BASE;\r\n    di = 0;\r\n  } else {\r\n    di = Math.ceil((i + 1) / LOG_BASE);\r\n    i %= LOG_BASE;\r\n  }\r\n\r\n  // i is the index (0 - 6) of the rounding digit.\r\n  // E.g. if within the word 3487563 the first rounding digit is 5,\r\n  // then i = 4, k = 1000, rd = 3487563 % 1000 = 563\r\n  k = mathpow(10, LOG_BASE - i);\r\n  rd = d[di] % k | 0;\r\n\r\n  if (repeating == null) {\r\n    if (i < 3) {\r\n      if (i == 0) rd = rd / 100 | 0;\r\n      else if (i == 1) rd = rd / 10 | 0;\r\n      r = rm < 4 && rd == 99999 || rm > 3 && rd == 49999 || rd == 50000 || rd == 0;\r\n    } else {\r\n      r = (rm < 4 && rd + 1 == k || rm > 3 && rd + 1 == k / 2) &&\r\n        (d[di + 1] / k / 100 | 0) == mathpow(10, i - 2) - 1 ||\r\n          (rd == k / 2 || rd == 0) && (d[di + 1] / k / 100 | 0) == 0;\r\n    }\r\n  } else {\r\n    if (i < 4) {\r\n      if (i == 0) rd = rd / 1000 | 0;\r\n      else if (i == 1) rd = rd / 100 | 0;\r\n      else if (i == 2) rd = rd / 10 | 0;\r\n      r = (repeating || rm < 4) && rd == 9999 || !repeating && rm > 3 && rd == 4999;\r\n    } else {\r\n      r = ((repeating || rm < 4) && rd + 1 == k ||\r\n      (!repeating && rm > 3) && rd + 1 == k / 2) &&\r\n        (d[di + 1] / k / 1000 | 0) == mathpow(10, i - 3) - 1;\r\n    }\r\n  }\r\n\r\n  return r;\r\n}\r\n\r\n\r\n// Convert string of `baseIn` to an array of numbers of `baseOut`.\r\n// Eg. convertBase('255', 10, 16) returns [15, 15].\r\n// Eg. convertBase('ff', 16, 10) returns [2, 5, 5].\r\nfunction convertBase(str, baseIn, baseOut) {\r\n  var j,\r\n    arr = [0],\r\n    arrL,\r\n    i = 0,\r\n    strL = str.length;\r\n\r\n  for (; i < strL;) {\r\n    for (arrL = arr.length; arrL--;) arr[arrL] *= baseIn;\r\n    arr[0] += NUMERALS.indexOf(str.charAt(i++));\r\n    for (j = 0; j < arr.length; j++) {\r\n      if (arr[j] > baseOut - 1) {\r\n        if (arr[j + 1] === void 0) arr[j + 1] = 0;\r\n        arr[j + 1] += arr[j] / baseOut | 0;\r\n        arr[j] %= baseOut;\r\n      }\r\n    }\r\n  }\r\n\r\n  return arr.reverse();\r\n}\r\n\r\n\r\n/*\r\n * cos(x) = 1 - x^2/2! + x^4/4! - ...\r\n * |x| < pi/2\r\n *\r\n */\r\nfunction cosine(Ctor, x) {\r\n  var k, len, y;\r\n\r\n  if (x.isZero()) return x;\r\n\r\n  // Argument reduction: cos(4x) = 8*(cos^4(x) - cos^2(x)) + 1\r\n  // i.e. cos(x) = 8*(cos^4(x/4) - cos^2(x/4)) + 1\r\n\r\n  // Estimate the optimum number of times to use the argument reduction.\r\n  len = x.d.length;\r\n  if (len < 32) {\r\n    k = Math.ceil(len / 3);\r\n    y = (1 / tinyPow(4, k)).toString();\r\n  } else {\r\n    k = 16;\r\n    y = '2.3283064365386962890625e-10';\r\n  }\r\n\r\n  Ctor.precision += k;\r\n\r\n  x = taylorSeries(Ctor, 1, x.times(y), new Ctor(1));\r\n\r\n  // Reverse argument reduction\r\n  for (var i = k; i--;) {\r\n    var cos2x = x.times(x);\r\n    x = cos2x.times(cos2x).minus(cos2x).times(8).plus(1);\r\n  }\r\n\r\n  Ctor.precision -= k;\r\n\r\n  return x;\r\n}\r\n\r\n\r\n/*\r\n * Perform division in the specified base.\r\n */\r\nvar divide = (function () {\r\n\r\n  // Assumes non-zero x and k, and hence non-zero result.\r\n  function multiplyInteger(x, k, base) {\r\n    var temp,\r\n      carry = 0,\r\n      i = x.length;\r\n\r\n    for (x = x.slice(); i--;) {\r\n      temp = x[i] * k + carry;\r\n      x[i] = temp % base | 0;\r\n      carry = temp / base | 0;\r\n    }\r\n\r\n    if (carry) x.unshift(carry);\r\n\r\n    return x;\r\n  }\r\n\r\n  function compare(a, b, aL, bL) {\r\n    var i, r;\r\n\r\n    if (aL != bL) {\r\n      r = aL > bL ? 1 : -1;\r\n    } else {\r\n      for (i = r = 0; i < aL; i++) {\r\n        if (a[i] != b[i]) {\r\n          r = a[i] > b[i] ? 1 : -1;\r\n          break;\r\n        }\r\n      }\r\n    }\r\n\r\n    return r;\r\n  }\r\n\r\n  function subtract(a, b, aL, base) {\r\n    var i = 0;\r\n\r\n    // Subtract b from a.\r\n    for (; aL--;) {\r\n      a[aL] -= i;\r\n      i = a[aL] < b[aL] ? 1 : 0;\r\n      a[aL] = i * base + a[aL] - b[aL];\r\n    }\r\n\r\n    // Remove leading zeros.\r\n    for (; !a[0] && a.length > 1;) a.shift();\r\n  }\r\n\r\n  return function (x, y, pr, rm, dp, base) {\r\n    var cmp, e, i, k, logBase, more, prod, prodL, q, qd, rem, remL, rem0, sd, t, xi, xL, yd0,\r\n      yL, yz,\r\n      Ctor = x.constructor,\r\n      sign = x.s == y.s ? 1 : -1,\r\n      xd = x.d,\r\n      yd = y.d;\r\n\r\n    // Either NaN, Infinity or 0?\r\n    if (!xd || !xd[0] || !yd || !yd[0]) {\r\n\r\n      return new Ctor(// Return NaN if either NaN, or both Infinity or 0.\r\n        !x.s || !y.s || (xd ? yd && xd[0] == yd[0] : !yd) ? NaN :\r\n\r\n        // Return ±0 if x is 0 or y is ±Infinity, or return ±Infinity as y is 0.\r\n        xd && xd[0] == 0 || !yd ? sign * 0 : sign / 0);\r\n    }\r\n\r\n    if (base) {\r\n      logBase = 1;\r\n      e = x.e - y.e;\r\n    } else {\r\n      base = BASE;\r\n      logBase = LOG_BASE;\r\n      e = mathfloor(x.e / logBase) - mathfloor(y.e / logBase);\r\n    }\r\n\r\n    yL = yd.length;\r\n    xL = xd.length;\r\n    q = new Ctor(sign);\r\n    qd = q.d = [];\r\n\r\n    // Result exponent may be one less than e.\r\n    // The digit array of a Decimal from toStringBinary may have trailing zeros.\r\n    for (i = 0; yd[i] == (xd[i] || 0); i++);\r\n\r\n    if (yd[i] > (xd[i] || 0)) e--;\r\n\r\n    if (pr == null) {\r\n      sd = pr = Ctor.precision;\r\n      rm = Ctor.rounding;\r\n    } else if (dp) {\r\n      sd = pr + (x.e - y.e) + 1;\r\n    } else {\r\n      sd = pr;\r\n    }\r\n\r\n    if (sd < 0) {\r\n      qd.push(1);\r\n      more = true;\r\n    } else {\r\n\r\n      // Convert precision in number of base 10 digits to base 1e7 digits.\r\n      sd = sd / logBase + 2 | 0;\r\n      i = 0;\r\n\r\n      // divisor < 1e7\r\n      if (yL == 1) {\r\n        k = 0;\r\n        yd = yd[0];\r\n        sd++;\r\n\r\n        // k is the carry.\r\n        for (; (i < xL || k) && sd--; i++) {\r\n          t = k * base + (xd[i] || 0);\r\n          qd[i] = t / yd | 0;\r\n          k = t % yd | 0;\r\n        }\r\n\r\n        more = k || i < xL;\r\n\r\n      // divisor >= 1e7\r\n      } else {\r\n\r\n        // Normalise xd and yd so highest order digit of yd is >= base/2\r\n        k = base / (yd[0] + 1) | 0;\r\n\r\n        if (k > 1) {\r\n          yd = multiplyInteger(yd, k, base);\r\n          xd = multiplyInteger(xd, k, base);\r\n          yL = yd.length;\r\n          xL = xd.length;\r\n        }\r\n\r\n        xi = yL;\r\n        rem = xd.slice(0, yL);\r\n        remL = rem.length;\r\n\r\n        // Add zeros to make remainder as long as divisor.\r\n        for (; remL < yL;) rem[remL++] = 0;\r\n\r\n        yz = yd.slice();\r\n        yz.unshift(0);\r\n        yd0 = yd[0];\r\n\r\n        if (yd[1] >= base / 2) ++yd0;\r\n\r\n        do {\r\n          k = 0;\r\n\r\n          // Compare divisor and remainder.\r\n          cmp = compare(yd, rem, yL, remL);\r\n\r\n          // If divisor < remainder.\r\n          if (cmp < 0) {\r\n\r\n            // Calculate trial digit, k.\r\n            rem0 = rem[0];\r\n            if (yL != remL) rem0 = rem0 * base + (rem[1] || 0);\r\n\r\n            // k will be how many times the divisor goes into the current remainder.\r\n            k = rem0 / yd0 | 0;\r\n\r\n            //  Algorithm:\r\n            //  1. product = divisor * trial digit (k)\r\n            //  2. if product > remainder: product -= divisor, k--\r\n            //  3. remainder -= product\r\n            //  4. if product was < remainder at 2:\r\n            //    5. compare new remainder and divisor\r\n            //    6. If remainder > divisor: remainder -= divisor, k++\r\n\r\n            if (k > 1) {\r\n              if (k >= base) k = base - 1;\r\n\r\n              // product = divisor * trial digit.\r\n              prod = multiplyInteger(yd, k, base);\r\n              prodL = prod.length;\r\n              remL = rem.length;\r\n\r\n              // Compare product and remainder.\r\n              cmp = compare(prod, rem, prodL, remL);\r\n\r\n              // product > remainder.\r\n              if (cmp == 1) {\r\n                k--;\r\n\r\n                // Subtract divisor from product.\r\n                subtract(prod, yL < prodL ? yz : yd, prodL, base);\r\n              }\r\n            } else {\r\n\r\n              // cmp is -1.\r\n              // If k is 0, there is no need to compare yd and rem again below, so change cmp to 1\r\n              // to avoid it. If k is 1 there is a need to compare yd and rem again below.\r\n              if (k == 0) cmp = k = 1;\r\n              prod = yd.slice();\r\n            }\r\n\r\n            prodL = prod.length;\r\n            if (prodL < remL) prod.unshift(0);\r\n\r\n            // Subtract product from remainder.\r\n            subtract(rem, prod, remL, base);\r\n\r\n            // If product was < previous remainder.\r\n            if (cmp == -1) {\r\n              remL = rem.length;\r\n\r\n              // Compare divisor and new remainder.\r\n              cmp = compare(yd, rem, yL, remL);\r\n\r\n              // If divisor < new remainder, subtract divisor from remainder.\r\n              if (cmp < 1) {\r\n                k++;\r\n\r\n                // Subtract divisor from remainder.\r\n                subtract(rem, yL < remL ? yz : yd, remL, base);\r\n              }\r\n            }\r\n\r\n            remL = rem.length;\r\n          } else if (cmp === 0) {\r\n            k++;\r\n            rem = [0];\r\n          }    // if cmp === 1, k will be 0\r\n\r\n          // Add the next digit, k, to the result array.\r\n          qd[i++] = k;\r\n\r\n          // Update the remainder.\r\n          if (cmp && rem[0]) {\r\n            rem[remL++] = xd[xi] || 0;\r\n          } else {\r\n            rem = [xd[xi]];\r\n            remL = 1;\r\n          }\r\n\r\n        } while ((xi++ < xL || rem[0] !== void 0) && sd--);\r\n\r\n        more = rem[0] !== void 0;\r\n      }\r\n\r\n      // Leading zero?\r\n      if (!qd[0]) qd.shift();\r\n    }\r\n\r\n    // logBase is 1 when divide is being used for base conversion.\r\n    if (logBase == 1) {\r\n      q.e = e;\r\n      inexact = more;\r\n    } else {\r\n\r\n      // To calculate q.e, first get the number of digits of qd[0].\r\n      for (i = 1, k = qd[0]; k >= 10; k /= 10) i++;\r\n      q.e = i + e * logBase - 1;\r\n\r\n      finalise(q, dp ? pr + q.e + 1 : pr, rm, more);\r\n    }\r\n\r\n    return q;\r\n  };\r\n})();\r\n\r\n\r\n/*\r\n * Round `x` to `sd` significant digits using rounding mode `rm`.\r\n * Check for over/under-flow.\r\n */\r\n function finalise(x, sd, rm, isTruncated) {\r\n  var digits, i, j, k, rd, roundUp, w, xd, xdi,\r\n    Ctor = x.constructor;\r\n\r\n  // Don't round if sd is null or undefined.\r\n  out: if (sd != null) {\r\n    xd = x.d;\r\n\r\n    // Infinity/NaN.\r\n    if (!xd) return x;\r\n\r\n    // rd: the rounding digit, i.e. the digit after the digit that may be rounded up.\r\n    // w: the word of xd containing rd, a base 1e7 number.\r\n    // xdi: the index of w within xd.\r\n    // digits: the number of digits of w.\r\n    // i: what would be the index of rd within w if all the numbers were 7 digits long (i.e. if\r\n    // they had leading zeros)\r\n    // j: if > 0, the actual index of rd within w (if < 0, rd is a leading zero).\r\n\r\n    // Get the length of the first word of the digits array xd.\r\n    for (digits = 1, k = xd[0]; k >= 10; k /= 10) digits++;\r\n    i = sd - digits;\r\n\r\n    // Is the rounding digit in the first word of xd?\r\n    if (i < 0) {\r\n      i += LOG_BASE;\r\n      j = sd;\r\n      w = xd[xdi = 0];\r\n\r\n      // Get the rounding digit at index j of w.\r\n      rd = w / mathpow(10, digits - j - 1) % 10 | 0;\r\n    } else {\r\n      xdi = Math.ceil((i + 1) / LOG_BASE);\r\n      k = xd.length;\r\n      if (xdi >= k) {\r\n        if (isTruncated) {\r\n\r\n          // Needed by `naturalExponential`, `naturalLogarithm` and `squareRoot`.\r\n          for (; k++ <= xdi;) xd.push(0);\r\n          w = rd = 0;\r\n          digits = 1;\r\n          i %= LOG_BASE;\r\n          j = i - LOG_BASE + 1;\r\n        } else {\r\n          break out;\r\n        }\r\n      } else {\r\n        w = k = xd[xdi];\r\n\r\n        // Get the number of digits of w.\r\n        for (digits = 1; k >= 10; k /= 10) digits++;\r\n\r\n        // Get the index of rd within w.\r\n        i %= LOG_BASE;\r\n\r\n        // Get the index of rd within w, adjusted for leading zeros.\r\n        // The number of leading zeros of w is given by LOG_BASE - digits.\r\n        j = i - LOG_BASE + digits;\r\n\r\n        // Get the rounding digit at index j of w.\r\n        rd = j < 0 ? 0 : w / mathpow(10, digits - j - 1) % 10 | 0;\r\n      }\r\n    }\r\n\r\n    // Are there any non-zero digits after the rounding digit?\r\n    isTruncated = isTruncated || sd < 0 ||\r\n      xd[xdi + 1] !== void 0 || (j < 0 ? w : w % mathpow(10, digits - j - 1));\r\n\r\n    // The expression `w % mathpow(10, digits - j - 1)` returns all the digits of w to the right\r\n    // of the digit at (left-to-right) index j, e.g. if w is 908714 and j is 2, the expression\r\n    // will give 714.\r\n\r\n    roundUp = rm < 4\r\n      ? (rd || isTruncated) && (rm == 0 || rm == (x.s < 0 ? 3 : 2))\r\n      : rd > 5 || rd == 5 && (rm == 4 || isTruncated || rm == 6 &&\r\n\r\n        // Check whether the digit to the left of the rounding digit is odd.\r\n        ((i > 0 ? j > 0 ? w / mathpow(10, digits - j) : 0 : xd[xdi - 1]) % 10) & 1 ||\r\n          rm == (x.s < 0 ? 8 : 7));\r\n\r\n    if (sd < 1 || !xd[0]) {\r\n      xd.length = 0;\r\n      if (roundUp) {\r\n\r\n        // Convert sd to decimal places.\r\n        sd -= x.e + 1;\r\n\r\n        // 1, 0.1, 0.01, 0.001, 0.0001 etc.\r\n        xd[0] = mathpow(10, (LOG_BASE - sd % LOG_BASE) % LOG_BASE);\r\n        x.e = -sd || 0;\r\n      } else {\r\n\r\n        // Zero.\r\n        xd[0] = x.e = 0;\r\n      }\r\n\r\n      return x;\r\n    }\r\n\r\n    // Remove excess digits.\r\n    if (i == 0) {\r\n      xd.length = xdi;\r\n      k = 1;\r\n      xdi--;\r\n    } else {\r\n      xd.length = xdi + 1;\r\n      k = mathpow(10, LOG_BASE - i);\r\n\r\n      // E.g. 56700 becomes 56000 if 7 is the rounding digit.\r\n      // j > 0 means i > number of leading zeros of w.\r\n      xd[xdi] = j > 0 ? (w / mathpow(10, digits - j) % mathpow(10, j) | 0) * k : 0;\r\n    }\r\n\r\n    if (roundUp) {\r\n      for (;;) {\r\n\r\n        // Is the digit to be rounded up in the first word of xd?\r\n        if (xdi == 0) {\r\n\r\n          // i will be the length of xd[0] before k is added.\r\n          for (i = 1, j = xd[0]; j >= 10; j /= 10) i++;\r\n          j = xd[0] += k;\r\n          for (k = 1; j >= 10; j /= 10) k++;\r\n\r\n          // if i != k the length has increased.\r\n          if (i != k) {\r\n            x.e++;\r\n            if (xd[0] == BASE) xd[0] = 1;\r\n          }\r\n\r\n          break;\r\n        } else {\r\n          xd[xdi] += k;\r\n          if (xd[xdi] != BASE) break;\r\n          xd[xdi--] = 0;\r\n          k = 1;\r\n        }\r\n      }\r\n    }\r\n\r\n    // Remove trailing zeros.\r\n    for (i = xd.length; xd[--i] === 0;) xd.pop();\r\n  }\r\n\r\n  if (external) {\r\n\r\n    // Overflow?\r\n    if (x.e > Ctor.maxE) {\r\n\r\n      // Infinity.\r\n      x.d = null;\r\n      x.e = NaN;\r\n\r\n    // Underflow?\r\n    } else if (x.e < Ctor.minE) {\r\n\r\n      // Zero.\r\n      x.e = 0;\r\n      x.d = [0];\r\n      // Ctor.underflow = true;\r\n    } // else Ctor.underflow = false;\r\n  }\r\n\r\n  return x;\r\n}\r\n\r\n\r\nfunction finiteToString(x, isExp, sd) {\r\n  if (!x.isFinite()) return nonFiniteToString(x);\r\n  var k,\r\n    e = x.e,\r\n    str = digitsToString(x.d),\r\n    len = str.length;\r\n\r\n  if (isExp) {\r\n    if (sd && (k = sd - len) > 0) {\r\n      str = str.charAt(0) + '.' + str.slice(1) + getZeroString(k);\r\n    } else if (len > 1) {\r\n      str = str.charAt(0) + '.' + str.slice(1);\r\n    }\r\n\r\n    str = str + (x.e < 0 ? 'e' : 'e+') + x.e;\r\n  } else if (e < 0) {\r\n    str = '0.' + getZeroString(-e - 1) + str;\r\n    if (sd && (k = sd - len) > 0) str += getZeroString(k);\r\n  } else if (e >= len) {\r\n    str += getZeroString(e + 1 - len);\r\n    if (sd && (k = sd - e - 1) > 0) str = str + '.' + getZeroString(k);\r\n  } else {\r\n    if ((k = e + 1) < len) str = str.slice(0, k) + '.' + str.slice(k);\r\n    if (sd && (k = sd - len) > 0) {\r\n      if (e + 1 === len) str += '.';\r\n      str += getZeroString(k);\r\n    }\r\n  }\r\n\r\n  return str;\r\n}\r\n\r\n\r\n// Calculate the base 10 exponent from the base 1e7 exponent.\r\nfunction getBase10Exponent(digits, e) {\r\n  var w = digits[0];\r\n\r\n  // Add the number of digits of the first word of the digits array.\r\n  for ( e *= LOG_BASE; w >= 10; w /= 10) e++;\r\n  return e;\r\n}\r\n\r\n\r\nfunction getLn10(Ctor, sd, pr) {\r\n  if (sd > LN10_PRECISION) {\r\n\r\n    // Reset global state in case the exception is caught.\r\n    external = true;\r\n    if (pr) Ctor.precision = pr;\r\n    throw Error(precisionLimitExceeded);\r\n  }\r\n  return finalise(new Ctor(LN10), sd, 1, true);\r\n}\r\n\r\n\r\nfunction getPi(Ctor, sd, rm) {\r\n  if (sd > PI_PRECISION) throw Error(precisionLimitExceeded);\r\n  return finalise(new Ctor(PI), sd, rm, true);\r\n}\r\n\r\n\r\nfunction getPrecision(digits) {\r\n  var w = digits.length - 1,\r\n    len = w * LOG_BASE + 1;\r\n\r\n  w = digits[w];\r\n\r\n  // If non-zero...\r\n  if (w) {\r\n\r\n    // Subtract the number of trailing zeros of the last word.\r\n    for (; w % 10 == 0; w /= 10) len--;\r\n\r\n    // Add the number of digits of the first word.\r\n    for (w = digits[0]; w >= 10; w /= 10) len++;\r\n  }\r\n\r\n  return len;\r\n}\r\n\r\n\r\nfunction getZeroString(k) {\r\n  var zs = '';\r\n  for (; k--;) zs += '0';\r\n  return zs;\r\n}\r\n\r\n\r\n/*\r\n * Return a new Decimal whose value is the value of Decimal `x` to the power `n`, where `n` is an\r\n * integer of type number.\r\n *\r\n * Implements 'exponentiation by squaring'. Called by `pow` and `parseOther`.\r\n *\r\n */\r\nfunction intPow(Ctor, x, n, pr) {\r\n  var isTruncated,\r\n    r = new Ctor(1),\r\n\r\n    // Max n of 9007199254740991 takes 53 loop iterations.\r\n    // Maximum digits array length; leaves [28, 34] guard digits.\r\n    k = Math.ceil(pr / LOG_BASE + 4);\r\n\r\n  external = false;\r\n\r\n  for (;;) {\r\n    if (n % 2) {\r\n      r = r.times(x);\r\n      if (truncate(r.d, k)) isTruncated = true;\r\n    }\r\n\r\n    n = mathfloor(n / 2);\r\n    if (n === 0) {\r\n\r\n      // To ensure correct rounding when r.d is truncated, increment the last word if it is zero.\r\n      n = r.d.length - 1;\r\n      if (isTruncated && r.d[n] === 0) ++r.d[n];\r\n      break;\r\n    }\r\n\r\n    x = x.times(x);\r\n    truncate(x.d, k);\r\n  }\r\n\r\n  external = true;\r\n\r\n  return r;\r\n}\r\n\r\n\r\nfunction isOdd(n) {\r\n  return n.d[n.d.length - 1] & 1;\r\n}\r\n\r\n\r\n/*\r\n * Handle `max` and `min`. `ltgt` is 'lt' or 'gt'.\r\n */\r\nfunction maxOrMin(Ctor, args, ltgt) {\r\n  var y,\r\n    x = new Ctor(args[0]),\r\n    i = 0;\r\n\r\n  for (; ++i < args.length;) {\r\n    y = new Ctor(args[i]);\r\n    if (!y.s) {\r\n      x = y;\r\n      break;\r\n    } else if (x[ltgt](y)) {\r\n      x = y;\r\n    }\r\n  }\r\n\r\n  return x;\r\n}\r\n\r\n\r\n/*\r\n * Return a new Decimal whose value is the natural exponential of `x` rounded to `sd` significant\r\n * digits.\r\n *\r\n * Taylor/Maclaurin series.\r\n *\r\n * exp(x) = x^0/0! + x^1/1! + x^2/2! + x^3/3! + ...\r\n *\r\n * Argument reduction:\r\n *   Repeat x = x / 32, k += 5, until |x| < 0.1\r\n *   exp(x) = exp(x / 2^k)^(2^k)\r\n *\r\n * Previously, the argument was initially reduced by\r\n * exp(x) = exp(r) * 10^k  where r = x - k * ln10, k = floor(x / ln10)\r\n * to first put r in the range [0, ln10], before dividing by 32 until |x| < 0.1, but this was\r\n * found to be slower than just dividing repeatedly by 32 as above.\r\n *\r\n * Max integer argument: exp('20723265836946413') = 6.3e+9000000000000000\r\n * Min integer argument: exp('-20723265836946411') = 1.2e-9000000000000000\r\n * (Math object integer min/max: Math.exp(709) = 8.2e+307, Math.exp(-745) = 5e-324)\r\n *\r\n *  exp(Infinity)  = Infinity\r\n *  exp(-Infinity) = 0\r\n *  exp(NaN)       = NaN\r\n *  exp(±0)        = 1\r\n *\r\n *  exp(x) is non-terminating for any finite, non-zero x.\r\n *\r\n *  The result will always be correctly rounded.\r\n *\r\n */\r\nfunction naturalExponential(x, sd) {\r\n  var denominator, guard, j, pow, sum, t, wpr,\r\n    rep = 0,\r\n    i = 0,\r\n    k = 0,\r\n    Ctor = x.constructor,\r\n    rm = Ctor.rounding,\r\n    pr = Ctor.precision;\r\n\r\n  // 0/NaN/Infinity?\r\n  if (!x.d || !x.d[0] || x.e > 17) {\r\n\r\n    return new Ctor(x.d\r\n      ? !x.d[0] ? 1 : x.s < 0 ? 0 : 1 / 0\r\n      : x.s ? x.s < 0 ? 0 : x : 0 / 0);\r\n  }\r\n\r\n  if (sd == null) {\r\n    external = false;\r\n    wpr = pr;\r\n  } else {\r\n    wpr = sd;\r\n  }\r\n\r\n  t = new Ctor(0.03125);\r\n\r\n  // while abs(x) >= 0.1\r\n  while (x.e > -2) {\r\n\r\n    // x = x / 2^5\r\n    x = x.times(t);\r\n    k += 5;\r\n  }\r\n\r\n  // Use 2 * log10(2^k) + 5 (empirically derived) to estimate the increase in precision\r\n  // necessary to ensure the first 4 rounding digits are correct.\r\n  guard = Math.log(mathpow(2, k)) / Math.LN10 * 2 + 5 | 0;\r\n  wpr += guard;\r\n  denominator = pow = sum = new Ctor(1);\r\n  Ctor.precision = wpr;\r\n\r\n  for (;;) {\r\n    pow = finalise(pow.times(x), wpr, 1);\r\n    denominator = denominator.times(++i);\r\n    t = sum.plus(divide(pow, denominator, wpr, 1));\r\n\r\n    if (digitsToString(t.d).slice(0, wpr) === digitsToString(sum.d).slice(0, wpr)) {\r\n      j = k;\r\n      while (j--) sum = finalise(sum.times(sum), wpr, 1);\r\n\r\n      // Check to see if the first 4 rounding digits are [49]999.\r\n      // If so, repeat the summation with a higher precision, otherwise\r\n      // e.g. with precision: 18, rounding: 1\r\n      // exp(18.404272462595034083567793919843761) = 98372560.1229999999 (should be 98372560.123)\r\n      // `wpr - guard` is the index of first rounding digit.\r\n      if (sd == null) {\r\n\r\n        if (rep < 3 && checkRoundingDigits(sum.d, wpr - guard, rm, rep)) {\r\n          Ctor.precision = wpr += 10;\r\n          denominator = pow = t = new Ctor(1);\r\n          i = 0;\r\n          rep++;\r\n        } else {\r\n          return finalise(sum, Ctor.precision = pr, rm, external = true);\r\n        }\r\n      } else {\r\n        Ctor.precision = pr;\r\n        return sum;\r\n      }\r\n    }\r\n\r\n    sum = t;\r\n  }\r\n}\r\n\r\n\r\n/*\r\n * Return a new Decimal whose value is the natural logarithm of `x` rounded to `sd` significant\r\n * digits.\r\n *\r\n *  ln(-n)        = NaN\r\n *  ln(0)         = -Infinity\r\n *  ln(-0)        = -Infinity\r\n *  ln(1)         = 0\r\n *  ln(Infinity)  = Infinity\r\n *  ln(-Infinity) = NaN\r\n *  ln(NaN)       = NaN\r\n *\r\n *  ln(n) (n != 1) is non-terminating.\r\n *\r\n */\r\nfunction naturalLogarithm(y, sd) {\r\n  var c, c0, denominator, e, numerator, rep, sum, t, wpr, x1, x2,\r\n    n = 1,\r\n    guard = 10,\r\n    x = y,\r\n    xd = x.d,\r\n    Ctor = x.constructor,\r\n    rm = Ctor.rounding,\r\n    pr = Ctor.precision;\r\n\r\n  // Is x negative or Infinity, NaN, 0 or 1?\r\n  if (x.s < 0 || !xd || !xd[0] || !x.e && xd[0] == 1 && xd.length == 1) {\r\n    return new Ctor(xd && !xd[0] ? -1 / 0 : x.s != 1 ? NaN : xd ? 0 : x);\r\n  }\r\n\r\n  if (sd == null) {\r\n    external = false;\r\n    wpr = pr;\r\n  } else {\r\n    wpr = sd;\r\n  }\r\n\r\n  Ctor.precision = wpr += guard;\r\n  c = digitsToString(xd);\r\n  c0 = c.charAt(0);\r\n\r\n  if (Math.abs(e = x.e) < 1.5e15) {\r\n\r\n    // Argument reduction.\r\n    // The series converges faster the closer the argument is to 1, so using\r\n    // ln(a^b) = b * ln(a),   ln(a) = ln(a^b) / b\r\n    // multiply the argument by itself until the leading digits of the significand are 7, 8, 9,\r\n    // 10, 11, 12 or 13, recording the number of multiplications so the sum of the series can\r\n    // later be divided by this number, then separate out the power of 10 using\r\n    // ln(a*10^b) = ln(a) + b*ln(10).\r\n\r\n    // max n is 21 (gives 0.9, 1.0 or 1.1) (9e15 / 21 = 4.2e14).\r\n    //while (c0 < 9 && c0 != 1 || c0 == 1 && c.charAt(1) > 1) {\r\n    // max n is 6 (gives 0.7 - 1.3)\r\n    while (c0 < 7 && c0 != 1 || c0 == 1 && c.charAt(1) > 3) {\r\n      x = x.times(y);\r\n      c = digitsToString(x.d);\r\n      c0 = c.charAt(0);\r\n      n++;\r\n    }\r\n\r\n    e = x.e;\r\n\r\n    if (c0 > 1) {\r\n      x = new Ctor('0.' + c);\r\n      e++;\r\n    } else {\r\n      x = new Ctor(c0 + '.' + c.slice(1));\r\n    }\r\n  } else {\r\n\r\n    // The argument reduction method above may result in overflow if the argument y is a massive\r\n    // number with exponent >= 1500000000000000 (9e15 / 6 = 1.5e15), so instead recall this\r\n    // function using ln(x*10^e) = ln(x) + e*ln(10).\r\n    t = getLn10(Ctor, wpr + 2, pr).times(e + '');\r\n    x = naturalLogarithm(new Ctor(c0 + '.' + c.slice(1)), wpr - guard).plus(t);\r\n    Ctor.precision = pr;\r\n\r\n    return sd == null ? finalise(x, pr, rm, external = true) : x;\r\n  }\r\n\r\n  // x1 is x reduced to a value near 1.\r\n  x1 = x;\r\n\r\n  // Taylor series.\r\n  // ln(y) = ln((1 + x)/(1 - x)) = 2(x + x^3/3 + x^5/5 + x^7/7 + ...)\r\n  // where x = (y - 1)/(y + 1)    (|x| < 1)\r\n  sum = numerator = x = divide(x.minus(1), x.plus(1), wpr, 1);\r\n  x2 = finalise(x.times(x), wpr, 1);\r\n  denominator = 3;\r\n\r\n  for (;;) {\r\n    numerator = finalise(numerator.times(x2), wpr, 1);\r\n    t = sum.plus(divide(numerator, new Ctor(denominator), wpr, 1));\r\n\r\n    if (digitsToString(t.d).slice(0, wpr) === digitsToString(sum.d).slice(0, wpr)) {\r\n      sum = sum.times(2);\r\n\r\n      // Reverse the argument reduction. Check that e is not 0 because, besides preventing an\r\n      // unnecessary calculation, -0 + 0 = +0 and to ensure correct rounding -0 needs to stay -0.\r\n      if (e !== 0) sum = sum.plus(getLn10(Ctor, wpr + 2, pr).times(e + ''));\r\n      sum = divide(sum, new Ctor(n), wpr, 1);\r\n\r\n      // Is rm > 3 and the first 4 rounding digits 4999, or rm < 4 (or the summation has\r\n      // been repeated previously) and the first 4 rounding digits 9999?\r\n      // If so, restart the summation with a higher precision, otherwise\r\n      // e.g. with precision: 12, rounding: 1\r\n      // ln(135520028.6126091714265381533) = 18.7246299999 when it should be 18.72463.\r\n      // `wpr - guard` is the index of first rounding digit.\r\n      if (sd == null) {\r\n        if (checkRoundingDigits(sum.d, wpr - guard, rm, rep)) {\r\n          Ctor.precision = wpr += guard;\r\n          t = numerator = x = divide(x1.minus(1), x1.plus(1), wpr, 1);\r\n          x2 = finalise(x.times(x), wpr, 1);\r\n          denominator = rep = 1;\r\n        } else {\r\n          return finalise(sum, Ctor.precision = pr, rm, external = true);\r\n        }\r\n      } else {\r\n        Ctor.precision = pr;\r\n        return sum;\r\n      }\r\n    }\r\n\r\n    sum = t;\r\n    denominator += 2;\r\n  }\r\n}\r\n\r\n\r\n// ±Infinity, NaN.\r\nfunction nonFiniteToString(x) {\r\n  // Unsigned.\r\n  return String(x.s * x.s / 0);\r\n}\r\n\r\n\r\n/*\r\n * Parse the value of a new Decimal `x` from string `str`.\r\n */\r\nfunction parseDecimal(x, str) {\r\n  var e, i, len;\r\n\r\n  // Decimal point?\r\n  if ((e = str.indexOf('.')) > -1) str = str.replace('.', '');\r\n\r\n  // Exponential form?\r\n  if ((i = str.search(/e/i)) > 0) {\r\n\r\n    // Determine exponent.\r\n    if (e < 0) e = i;\r\n    e += +str.slice(i + 1);\r\n    str = str.substring(0, i);\r\n  } else if (e < 0) {\r\n\r\n    // Integer.\r\n    e = str.length;\r\n  }\r\n\r\n  // Determine leading zeros.\r\n  for (i = 0; str.charCodeAt(i) === 48; i++);\r\n\r\n  // Determine trailing zeros.\r\n  for (len = str.length; str.charCodeAt(len - 1) === 48; --len);\r\n  str = str.slice(i, len);\r\n\r\n  if (str) {\r\n    len -= i;\r\n    x.e = e = e - i - 1;\r\n    x.d = [];\r\n\r\n    // Transform base\r\n\r\n    // e is the base 10 exponent.\r\n    // i is where to slice str to get the first word of the digits array.\r\n    i = (e + 1) % LOG_BASE;\r\n    if (e < 0) i += LOG_BASE;\r\n\r\n    if (i < len) {\r\n      if (i) x.d.push(+str.slice(0, i));\r\n      for (len -= LOG_BASE; i < len;) x.d.push(+str.slice(i, i += LOG_BASE));\r\n      str = str.slice(i);\r\n      i = LOG_BASE - str.length;\r\n    } else {\r\n      i -= len;\r\n    }\r\n\r\n    for (; i--;) str += '0';\r\n    x.d.push(+str);\r\n\r\n    if (external) {\r\n\r\n      // Overflow?\r\n      if (x.e > x.constructor.maxE) {\r\n\r\n        // Infinity.\r\n        x.d = null;\r\n        x.e = NaN;\r\n\r\n      // Underflow?\r\n      } else if (x.e < x.constructor.minE) {\r\n\r\n        // Zero.\r\n        x.e = 0;\r\n        x.d = [0];\r\n        // x.constructor.underflow = true;\r\n      } // else x.constructor.underflow = false;\r\n    }\r\n  } else {\r\n\r\n    // Zero.\r\n    x.e = 0;\r\n    x.d = [0];\r\n  }\r\n\r\n  return x;\r\n}\r\n\r\n\r\n/*\r\n * Parse the value of a new Decimal `x` from a string `str`, which is not a decimal value.\r\n */\r\nfunction parseOther(x, str) {\r\n  var base, Ctor, divisor, i, isFloat, len, p, xd, xe;\r\n\r\n  if (str.indexOf('_') > -1) {\r\n    str = str.replace(/(\\d)_(?=\\d)/g, '$1');\r\n    if (isDecimal.test(str)) return parseDecimal(x, str);\r\n  } else if (str === 'Infinity' || str === 'NaN') {\r\n    if (!+str) x.s = NaN;\r\n    x.e = NaN;\r\n    x.d = null;\r\n    return x;\r\n  }\r\n\r\n  if (isHex.test(str))  {\r\n    base = 16;\r\n    str = str.toLowerCase();\r\n  } else if (isBinary.test(str))  {\r\n    base = 2;\r\n  } else if (isOctal.test(str))  {\r\n    base = 8;\r\n  } else {\r\n    throw Error(invalidArgument + str);\r\n  }\r\n\r\n  // Is there a binary exponent part?\r\n  i = str.search(/p/i);\r\n\r\n  if (i > 0) {\r\n    p = +str.slice(i + 1);\r\n    str = str.substring(2, i);\r\n  } else {\r\n    str = str.slice(2);\r\n  }\r\n\r\n  // Convert `str` as an integer then divide the result by `base` raised to a power such that the\r\n  // fraction part will be restored.\r\n  i = str.indexOf('.');\r\n  isFloat = i >= 0;\r\n  Ctor = x.constructor;\r\n\r\n  if (isFloat) {\r\n    str = str.replace('.', '');\r\n    len = str.length;\r\n    i = len - i;\r\n\r\n    // log[10](16) = 1.2041... , log[10](88) = 1.9444....\r\n    divisor = intPow(Ctor, new Ctor(base), i, i * 2);\r\n  }\r\n\r\n  xd = convertBase(str, base, BASE);\r\n  xe = xd.length - 1;\r\n\r\n  // Remove trailing zeros.\r\n  for (i = xe; xd[i] === 0; --i) xd.pop();\r\n  if (i < 0) return new Ctor(x.s * 0);\r\n  x.e = getBase10Exponent(xd, xe);\r\n  x.d = xd;\r\n  external = false;\r\n\r\n  // At what precision to perform the division to ensure exact conversion?\r\n  // maxDecimalIntegerPartDigitCount = ceil(log[10](b) * otherBaseIntegerPartDigitCount)\r\n  // log[10](2) = 0.30103, log[10](8) = 0.90309, log[10](16) = 1.20412\r\n  // E.g. ceil(1.2 * 3) = 4, so up to 4 decimal digits are needed to represent 3 hex int digits.\r\n  // maxDecimalFractionPartDigitCount = {Hex:4|Oct:3|Bin:1} * otherBaseFractionPartDigitCount\r\n  // Therefore using 4 * the number of digits of str will always be enough.\r\n  if (isFloat) x = divide(x, divisor, len * 4);\r\n\r\n  // Multiply by the binary exponent part if present.\r\n  if (p) x = x.times(Math.abs(p) < 54 ? mathpow(2, p) : Decimal.pow(2, p));\r\n  external = true;\r\n\r\n  return x;\r\n}\r\n\r\n\r\n/*\r\n * sin(x) = x - x^3/3! + x^5/5! - ...\r\n * |x| < pi/2\r\n *\r\n */\r\nfunction sine(Ctor, x) {\r\n  var k,\r\n    len = x.d.length;\r\n\r\n  if (len < 3) {\r\n    return x.isZero() ? x : taylorSeries(Ctor, 2, x, x);\r\n  }\r\n\r\n  // Argument reduction: sin(5x) = 16*sin^5(x) - 20*sin^3(x) + 5*sin(x)\r\n  // i.e. sin(x) = 16*sin^5(x/5) - 20*sin^3(x/5) + 5*sin(x/5)\r\n  // and  sin(x) = sin(x/5)(5 + sin^2(x/5)(16sin^2(x/5) - 20))\r\n\r\n  // Estimate the optimum number of times to use the argument reduction.\r\n  k = 1.4 * Math.sqrt(len);\r\n  k = k > 16 ? 16 : k | 0;\r\n\r\n  x = x.times(1 / tinyPow(5, k));\r\n  x = taylorSeries(Ctor, 2, x, x);\r\n\r\n  // Reverse argument reduction\r\n  var sin2_x,\r\n    d5 = new Ctor(5),\r\n    d16 = new Ctor(16),\r\n    d20 = new Ctor(20);\r\n  for (; k--;) {\r\n    sin2_x = x.times(x);\r\n    x = x.times(d5.plus(sin2_x.times(d16.times(sin2_x).minus(d20))));\r\n  }\r\n\r\n  return x;\r\n}\r\n\r\n\r\n// Calculate Taylor series for `cos`, `cosh`, `sin` and `sinh`.\r\nfunction taylorSeries(Ctor, n, x, y, isHyperbolic) {\r\n  var j, t, u, x2,\r\n    i = 1,\r\n    pr = Ctor.precision,\r\n    k = Math.ceil(pr / LOG_BASE);\r\n\r\n  external = false;\r\n  x2 = x.times(x);\r\n  u = new Ctor(y);\r\n\r\n  for (;;) {\r\n    t = divide(u.times(x2), new Ctor(n++ * n++), pr, 1);\r\n    u = isHyperbolic ? y.plus(t) : y.minus(t);\r\n    y = divide(t.times(x2), new Ctor(n++ * n++), pr, 1);\r\n    t = u.plus(y);\r\n\r\n    if (t.d[k] !== void 0) {\r\n      for (j = k; t.d[j] === u.d[j] && j--;);\r\n      if (j == -1) break;\r\n    }\r\n\r\n    j = u;\r\n    u = y;\r\n    y = t;\r\n    t = j;\r\n    i++;\r\n  }\r\n\r\n  external = true;\r\n  t.d.length = k + 1;\r\n\r\n  return t;\r\n}\r\n\r\n\r\n// Exponent e must be positive and non-zero.\r\nfunction tinyPow(b, e) {\r\n  var n = b;\r\n  while (--e) n *= b;\r\n  return n;\r\n}\r\n\r\n\r\n// Return the absolute value of `x` reduced to less than or equal to half pi.\r\nfunction toLessThanHalfPi(Ctor, x) {\r\n  var t,\r\n    isNeg = x.s < 0,\r\n    pi = getPi(Ctor, Ctor.precision, 1),\r\n    halfPi = pi.times(0.5);\r\n\r\n  x = x.abs();\r\n\r\n  if (x.lte(halfPi)) {\r\n    quadrant = isNeg ? 4 : 1;\r\n    return x;\r\n  }\r\n\r\n  t = x.divToInt(pi);\r\n\r\n  if (t.isZero()) {\r\n    quadrant = isNeg ? 3 : 2;\r\n  } else {\r\n    x = x.minus(t.times(pi));\r\n\r\n    // 0 <= x < pi\r\n    if (x.lte(halfPi)) {\r\n      quadrant = isOdd(t) ? (isNeg ? 2 : 3) : (isNeg ? 4 : 1);\r\n      return x;\r\n    }\r\n\r\n    quadrant = isOdd(t) ? (isNeg ? 1 : 4) : (isNeg ? 3 : 2);\r\n  }\r\n\r\n  return x.minus(pi).abs();\r\n}\r\n\r\n\r\n/*\r\n * Return the value of Decimal `x` as a string in base `baseOut`.\r\n *\r\n * If the optional `sd` argument is present include a binary exponent suffix.\r\n */\r\nfunction toStringBinary(x, baseOut, sd, rm) {\r\n  var base, e, i, k, len, roundUp, str, xd, y,\r\n    Ctor = x.constructor,\r\n    isExp = sd !== void 0;\r\n\r\n  if (isExp) {\r\n    checkInt32(sd, 1, MAX_DIGITS);\r\n    if (rm === void 0) rm = Ctor.rounding;\r\n    else checkInt32(rm, 0, 8);\r\n  } else {\r\n    sd = Ctor.precision;\r\n    rm = Ctor.rounding;\r\n  }\r\n\r\n  if (!x.isFinite()) {\r\n    str = nonFiniteToString(x);\r\n  } else {\r\n    str = finiteToString(x);\r\n    i = str.indexOf('.');\r\n\r\n    // Use exponential notation according to `toExpPos` and `toExpNeg`? No, but if required:\r\n    // maxBinaryExponent = floor((decimalExponent + 1) * log[2](10))\r\n    // minBinaryExponent = floor(decimalExponent * log[2](10))\r\n    // log[2](10) = 3.321928094887362347870319429489390175864\r\n\r\n    if (isExp) {\r\n      base = 2;\r\n      if (baseOut == 16) {\r\n        sd = sd * 4 - 3;\r\n      } else if (baseOut == 8) {\r\n        sd = sd * 3 - 2;\r\n      }\r\n    } else {\r\n      base = baseOut;\r\n    }\r\n\r\n    // Convert the number as an integer then divide the result by its base raised to a power such\r\n    // that the fraction part will be restored.\r\n\r\n    // Non-integer.\r\n    if (i >= 0) {\r\n      str = str.replace('.', '');\r\n      y = new Ctor(1);\r\n      y.e = str.length - i;\r\n      y.d = convertBase(finiteToString(y), 10, base);\r\n      y.e = y.d.length;\r\n    }\r\n\r\n    xd = convertBase(str, 10, base);\r\n    e = len = xd.length;\r\n\r\n    // Remove trailing zeros.\r\n    for (; xd[--len] == 0;) xd.pop();\r\n\r\n    if (!xd[0]) {\r\n      str = isExp ? '0p+0' : '0';\r\n    } else {\r\n      if (i < 0) {\r\n        e--;\r\n      } else {\r\n        x = new Ctor(x);\r\n        x.d = xd;\r\n        x.e = e;\r\n        x = divide(x, y, sd, rm, 0, base);\r\n        xd = x.d;\r\n        e = x.e;\r\n        roundUp = inexact;\r\n      }\r\n\r\n      // The rounding digit, i.e. the digit after the digit that may be rounded up.\r\n      i = xd[sd];\r\n      k = base / 2;\r\n      roundUp = roundUp || xd[sd + 1] !== void 0;\r\n\r\n      roundUp = rm < 4\r\n        ? (i !== void 0 || roundUp) && (rm === 0 || rm === (x.s < 0 ? 3 : 2))\r\n        : i > k || i === k && (rm === 4 || roundUp || rm === 6 && xd[sd - 1] & 1 ||\r\n          rm === (x.s < 0 ? 8 : 7));\r\n\r\n      xd.length = sd;\r\n\r\n      if (roundUp) {\r\n\r\n        // Rounding up may mean the previous digit has to be rounded up and so on.\r\n        for (; ++xd[--sd] > base - 1;) {\r\n          xd[sd] = 0;\r\n          if (!sd) {\r\n            ++e;\r\n            xd.unshift(1);\r\n          }\r\n        }\r\n      }\r\n\r\n      // Determine trailing zeros.\r\n      for (len = xd.length; !xd[len - 1]; --len);\r\n\r\n      // E.g. [4, 11, 15] becomes 4bf.\r\n      for (i = 0, str = ''; i < len; i++) str += NUMERALS.charAt(xd[i]);\r\n\r\n      // Add binary exponent suffix?\r\n      if (isExp) {\r\n        if (len > 1) {\r\n          if (baseOut == 16 || baseOut == 8) {\r\n            i = baseOut == 16 ? 4 : 3;\r\n            for (--len; len % i; len++) str += '0';\r\n            xd = convertBase(str, base, baseOut);\r\n            for (len = xd.length; !xd[len - 1]; --len);\r\n\r\n            // xd[0] will always be be 1\r\n            for (i = 1, str = '1.'; i < len; i++) str += NUMERALS.charAt(xd[i]);\r\n          } else {\r\n            str = str.charAt(0) + '.' + str.slice(1);\r\n          }\r\n        }\r\n\r\n        str =  str + (e < 0 ? 'p' : 'p+') + e;\r\n      } else if (e < 0) {\r\n        for (; ++e;) str = '0' + str;\r\n        str = '0.' + str;\r\n      } else {\r\n        if (++e > len) for (e -= len; e-- ;) str += '0';\r\n        else if (e < len) str = str.slice(0, e) + '.' + str.slice(e);\r\n      }\r\n    }\r\n\r\n    str = (baseOut == 16 ? '0x' : baseOut == 2 ? '0b' : baseOut == 8 ? '0o' : '') + str;\r\n  }\r\n\r\n  return x.s < 0 ? '-' + str : str;\r\n}\r\n\r\n\r\n// Does not strip trailing zeros.\r\nfunction truncate(arr, len) {\r\n  if (arr.length > len) {\r\n    arr.length = len;\r\n    return true;\r\n  }\r\n}\r\n\r\n\r\n// Decimal methods\r\n\r\n\r\n/*\r\n *  abs\r\n *  acos\r\n *  acosh\r\n *  add\r\n *  asin\r\n *  asinh\r\n *  atan\r\n *  atanh\r\n *  atan2\r\n *  cbrt\r\n *  ceil\r\n *  clamp\r\n *  clone\r\n *  config\r\n *  cos\r\n *  cosh\r\n *  div\r\n *  exp\r\n *  floor\r\n *  hypot\r\n *  ln\r\n *  log\r\n *  log2\r\n *  log10\r\n *  max\r\n *  min\r\n *  mod\r\n *  mul\r\n *  pow\r\n *  random\r\n *  round\r\n *  set\r\n *  sign\r\n *  sin\r\n *  sinh\r\n *  sqrt\r\n *  sub\r\n *  sum\r\n *  tan\r\n *  tanh\r\n *  trunc\r\n */\r\n\r\n\r\n/*\r\n * Return a new Decimal whose value is the absolute value of `x`.\r\n *\r\n * x {number|string|Decimal}\r\n *\r\n */\r\nfunction abs(x) {\r\n  return new this(x).abs();\r\n}\r\n\r\n\r\n/*\r\n * Return a new Decimal whose value is the arccosine in radians of `x`.\r\n *\r\n * x {number|string|Decimal}\r\n *\r\n */\r\nfunction acos(x) {\r\n  return new this(x).acos();\r\n}\r\n\r\n\r\n/*\r\n * Return a new Decimal whose value is the inverse of the hyperbolic cosine of `x`, rounded to\r\n * `precision` significant digits using rounding mode `rounding`.\r\n *\r\n * x {number|string|Decimal} A value in radians.\r\n *\r\n */\r\nfunction acosh(x) {\r\n  return new this(x).acosh();\r\n}\r\n\r\n\r\n/*\r\n * Return a new Decimal whose value is the sum of `x` and `y`, rounded to `precision` significant\r\n * digits using rounding mode `rounding`.\r\n *\r\n * x {number|string|Decimal}\r\n * y {number|string|Decimal}\r\n *\r\n */\r\nfunction add(x, y) {\r\n  return new this(x).plus(y);\r\n}\r\n\r\n\r\n/*\r\n * Return a new Decimal whose value is the arcsine in radians of `x`, rounded to `precision`\r\n * significant digits using rounding mode `rounding`.\r\n *\r\n * x {number|string|Decimal}\r\n *\r\n */\r\nfunction asin(x) {\r\n  return new this(x).asin();\r\n}\r\n\r\n\r\n/*\r\n * Return a new Decimal whose value is the inverse of the hyperbolic sine of `x`, rounded to\r\n * `precision` significant digits using rounding mode `rounding`.\r\n *\r\n * x {number|string|Decimal} A value in radians.\r\n *\r\n */\r\nfunction asinh(x) {\r\n  return new this(x).asinh();\r\n}\r\n\r\n\r\n/*\r\n * Return a new Decimal whose value is the arctangent in radians of `x`, rounded to `precision`\r\n * significant digits using rounding mode `rounding`.\r\n *\r\n * x {number|string|Decimal}\r\n *\r\n */\r\nfunction atan(x) {\r\n  return new this(x).atan();\r\n}\r\n\r\n\r\n/*\r\n * Return a new Decimal whose value is the inverse of the hyperbolic tangent of `x`, rounded to\r\n * `precision` significant digits using rounding mode `rounding`.\r\n *\r\n * x {number|string|Decimal} A value in radians.\r\n *\r\n */\r\nfunction atanh(x) {\r\n  return new this(x).atanh();\r\n}\r\n\r\n\r\n/*\r\n * Return a new Decimal whose value is the arctangent in radians of `y/x` in the range -pi to pi\r\n * (inclusive), rounded to `precision` significant digits using rounding mode `rounding`.\r\n *\r\n * Domain: [-Infinity, Infinity]\r\n * Range: [-pi, pi]\r\n *\r\n * y {number|string|Decimal} The y-coordinate.\r\n * x {number|string|Decimal} The x-coordinate.\r\n *\r\n * atan2(±0, -0)               = ±pi\r\n * atan2(±0, +0)               = ±0\r\n * atan2(±0, -x)               = ±pi for x > 0\r\n * atan2(±0, x)                = ±0 for x > 0\r\n * atan2(-y, ±0)               = -pi/2 for y > 0\r\n * atan2(y, ±0)                = pi/2 for y > 0\r\n * atan2(±y, -Infinity)        = ±pi for finite y > 0\r\n * atan2(±y, +Infinity)        = ±0 for finite y > 0\r\n * atan2(±Infinity, x)         = ±pi/2 for finite x\r\n * atan2(±Infinity, -Infinity) = ±3*pi/4\r\n * atan2(±Infinity, +Infinity) = ±pi/4\r\n * atan2(NaN, x) = NaN\r\n * atan2(y, NaN) = NaN\r\n *\r\n */\r\nfunction atan2(y, x) {\r\n  y = new this(y);\r\n  x = new this(x);\r\n  var r,\r\n    pr = this.precision,\r\n    rm = this.rounding,\r\n    wpr = pr + 4;\r\n\r\n  // Either NaN\r\n  if (!y.s || !x.s) {\r\n    r = new this(NaN);\r\n\r\n  // Both ±Infinity\r\n  } else if (!y.d && !x.d) {\r\n    r = getPi(this, wpr, 1).times(x.s > 0 ? 0.25 : 0.75);\r\n    r.s = y.s;\r\n\r\n  // x is ±Infinity or y is ±0\r\n  } else if (!x.d || y.isZero()) {\r\n    r = x.s < 0 ? getPi(this, pr, rm) : new this(0);\r\n    r.s = y.s;\r\n\r\n  // y is ±Infinity or x is ±0\r\n  } else if (!y.d || x.isZero()) {\r\n    r = getPi(this, wpr, 1).times(0.5);\r\n    r.s = y.s;\r\n\r\n  // Both non-zero and finite\r\n  } else if (x.s < 0) {\r\n    this.precision = wpr;\r\n    this.rounding = 1;\r\n    r = this.atan(divide(y, x, wpr, 1));\r\n    x = getPi(this, wpr, 1);\r\n    this.precision = pr;\r\n    this.rounding = rm;\r\n    r = y.s < 0 ? r.minus(x) : r.plus(x);\r\n  } else {\r\n    r = this.atan(divide(y, x, wpr, 1));\r\n  }\r\n\r\n  return r;\r\n}\r\n\r\n\r\n/*\r\n * Return a new Decimal whose value is the cube root of `x`, rounded to `precision` significant\r\n * digits using rounding mode `rounding`.\r\n *\r\n * x {number|string|Decimal}\r\n *\r\n */\r\nfunction cbrt(x) {\r\n  return new this(x).cbrt();\r\n}\r\n\r\n\r\n/*\r\n * Return a new Decimal whose value is `x` rounded to an integer using `ROUND_CEIL`.\r\n *\r\n * x {number|string|Decimal}\r\n *\r\n */\r\nfunction ceil(x) {\r\n  return finalise(x = new this(x), x.e + 1, 2);\r\n}\r\n\r\n\r\n/*\r\n * Return a new Decimal whose value is `x` clamped to the range delineated by `min` and `max`.\r\n *\r\n * x {number|string|Decimal}\r\n * min {number|string|Decimal}\r\n * max {number|string|Decimal}\r\n *\r\n */\r\nfunction clamp(x, min, max) {\r\n  return new this(x).clamp(min, max);\r\n}\r\n\r\n\r\n/*\r\n * Configure global settings for a Decimal constructor.\r\n *\r\n * `obj` is an object with one or more of the following properties,\r\n *\r\n *   precision  {number}\r\n *   rounding   {number}\r\n *   toExpNeg   {number}\r\n *   toExpPos   {number}\r\n *   maxE       {number}\r\n *   minE       {number}\r\n *   modulo     {number}\r\n *   crypto     {boolean|number}\r\n *   defaults   {true}\r\n *\r\n * E.g. Decimal.config({ precision: 20, rounding: 4 })\r\n *\r\n */\r\nfunction config(obj) {\r\n  if (!obj || typeof obj !== 'object') throw Error(decimalError + 'Object expected');\r\n  var i, p, v,\r\n    useDefaults = obj.defaults === true,\r\n    ps = [\r\n      'precision', 1, MAX_DIGITS,\r\n      'rounding', 0, 8,\r\n      'toExpNeg', -EXP_LIMIT, 0,\r\n      'toExpPos', 0, EXP_LIMIT,\r\n      'maxE', 0, EXP_LIMIT,\r\n      'minE', -EXP_LIMIT, 0,\r\n      'modulo', 0, 9\r\n    ];\r\n\r\n  for (i = 0; i < ps.length; i += 3) {\r\n    if (p = ps[i], useDefaults) this[p] = DEFAULTS[p];\r\n    if ((v = obj[p]) !== void 0) {\r\n      if (mathfloor(v) === v && v >= ps[i + 1] && v <= ps[i + 2]) this[p] = v;\r\n      else throw Error(invalidArgument + p + ': ' + v);\r\n    }\r\n  }\r\n\r\n  if (p = 'crypto', useDefaults) this[p] = DEFAULTS[p];\r\n  if ((v = obj[p]) !== void 0) {\r\n    if (v === true || v === false || v === 0 || v === 1) {\r\n      if (v) {\r\n        if (typeof crypto != 'undefined' && crypto &&\r\n          (crypto.getRandomValues || crypto.randomBytes)) {\r\n          this[p] = true;\r\n        } else {\r\n          throw Error(cryptoUnavailable);\r\n        }\r\n      } else {\r\n        this[p] = false;\r\n      }\r\n    } else {\r\n      throw Error(invalidArgument + p + ': ' + v);\r\n    }\r\n  }\r\n\r\n  return this;\r\n}\r\n\r\n\r\n/*\r\n * Return a new Decimal whose value is the cosine of `x`, rounded to `precision` significant\r\n * digits using rounding mode `rounding`.\r\n *\r\n * x {number|string|Decimal} A value in radians.\r\n *\r\n */\r\nfunction cos(x) {\r\n  return new this(x).cos();\r\n}\r\n\r\n\r\n/*\r\n * Return a new Decimal whose value is the hyperbolic cosine of `x`, rounded to precision\r\n * significant digits using rounding mode `rounding`.\r\n *\r\n * x {number|string|Decimal} A value in radians.\r\n *\r\n */\r\nfunction cosh(x) {\r\n  return new this(x).cosh();\r\n}\r\n\r\n\r\n/*\r\n * Create and return a Decimal constructor with the same configuration properties as this Decimal\r\n * constructor.\r\n *\r\n */\r\nfunction clone(obj) {\r\n  var i, p, ps;\r\n\r\n  /*\r\n   * The Decimal constructor and exported function.\r\n   * Return a new Decimal instance.\r\n   *\r\n   * v {number|string|Decimal} A numeric value.\r\n   *\r\n   */\r\n  function Decimal(v) {\r\n    var e, i, t,\r\n      x = this;\r\n\r\n    // Decimal called without new.\r\n    if (!(x instanceof Decimal)) return new Decimal(v);\r\n\r\n    // Retain a reference to this Decimal constructor, and shadow Decimal.prototype.constructor\r\n    // which points to Object.\r\n    x.constructor = Decimal;\r\n\r\n    // Duplicate.\r\n    if (isDecimalInstance(v)) {\r\n      x.s = v.s;\r\n\r\n      if (external) {\r\n        if (!v.d || v.e > Decimal.maxE) {\r\n\r\n          // Infinity.\r\n          x.e = NaN;\r\n          x.d = null;\r\n        } else if (v.e < Decimal.minE) {\r\n\r\n          // Zero.\r\n          x.e = 0;\r\n          x.d = [0];\r\n        } else {\r\n          x.e = v.e;\r\n          x.d = v.d.slice();\r\n        }\r\n      } else {\r\n        x.e = v.e;\r\n        x.d = v.d ? v.d.slice() : v.d;\r\n      }\r\n\r\n      return;\r\n    }\r\n\r\n    t = typeof v;\r\n\r\n    if (t === 'number') {\r\n      if (v === 0) {\r\n        x.s = 1 / v < 0 ? -1 : 1;\r\n        x.e = 0;\r\n        x.d = [0];\r\n        return;\r\n      }\r\n\r\n      if (v < 0) {\r\n        v = -v;\r\n        x.s = -1;\r\n      } else {\r\n        x.s = 1;\r\n      }\r\n\r\n      // Fast path for small integers.\r\n      if (v === ~~v && v < 1e7) {\r\n        for (e = 0, i = v; i >= 10; i /= 10) e++;\r\n\r\n        if (external) {\r\n          if (e > Decimal.maxE) {\r\n            x.e = NaN;\r\n            x.d = null;\r\n          } else if (e < Decimal.minE) {\r\n            x.e = 0;\r\n            x.d = [0];\r\n          } else {\r\n            x.e = e;\r\n            x.d = [v];\r\n          }\r\n        } else {\r\n          x.e = e;\r\n          x.d = [v];\r\n        }\r\n\r\n        return;\r\n\r\n      // Infinity, NaN.\r\n      } else if (v * 0 !== 0) {\r\n        if (!v) x.s = NaN;\r\n        x.e = NaN;\r\n        x.d = null;\r\n        return;\r\n      }\r\n\r\n      return parseDecimal(x, v.toString());\r\n\r\n    } else if (t !== 'string') {\r\n      throw Error(invalidArgument + v);\r\n    }\r\n\r\n    // Minus sign?\r\n    if ((i = v.charCodeAt(0)) === 45) {\r\n      v = v.slice(1);\r\n      x.s = -1;\r\n    } else {\r\n      // Plus sign?\r\n      if (i === 43) v = v.slice(1);\r\n      x.s = 1;\r\n    }\r\n\r\n    return isDecimal.test(v) ? parseDecimal(x, v) : parseOther(x, v);\r\n  }\r\n\r\n  Decimal.prototype = P;\r\n\r\n  Decimal.ROUND_UP = 0;\r\n  Decimal.ROUND_DOWN = 1;\r\n  Decimal.ROUND_CEIL = 2;\r\n  Decimal.ROUND_FLOOR = 3;\r\n  Decimal.ROUND_HALF_UP = 4;\r\n  Decimal.ROUND_HALF_DOWN = 5;\r\n  Decimal.ROUND_HALF_EVEN = 6;\r\n  Decimal.ROUND_HALF_CEIL = 7;\r\n  Decimal.ROUND_HALF_FLOOR = 8;\r\n  Decimal.EUCLID = 9;\r\n\r\n  Decimal.config = Decimal.set = config;\r\n  Decimal.clone = clone;\r\n  Decimal.isDecimal = isDecimalInstance;\r\n\r\n  Decimal.abs = abs;\r\n  Decimal.acos = acos;\r\n  Decimal.acosh = acosh;        // ES6\r\n  Decimal.add = add;\r\n  Decimal.asin = asin;\r\n  Decimal.asinh = asinh;        // ES6\r\n  Decimal.atan = atan;\r\n  Decimal.atanh = atanh;        // ES6\r\n  Decimal.atan2 = atan2;\r\n  Decimal.cbrt = cbrt;          // ES6\r\n  Decimal.ceil = ceil;\r\n  Decimal.clamp = clamp;\r\n  Decimal.cos = cos;\r\n  Decimal.cosh = cosh;          // ES6\r\n  Decimal.div = div;\r\n  Decimal.exp = exp;\r\n  Decimal.floor = floor;\r\n  Decimal.hypot = hypot;        // ES6\r\n  Decimal.ln = ln;\r\n  Decimal.log = log;\r\n  Decimal.log10 = log10;        // ES6\r\n  Decimal.log2 = log2;          // ES6\r\n  Decimal.max = max;\r\n  Decimal.min = min;\r\n  Decimal.mod = mod;\r\n  Decimal.mul = mul;\r\n  Decimal.pow = pow;\r\n  Decimal.random = random;\r\n  Decimal.round = round;\r\n  Decimal.sign = sign;          // ES6\r\n  Decimal.sin = sin;\r\n  Decimal.sinh = sinh;          // ES6\r\n  Decimal.sqrt = sqrt;\r\n  Decimal.sub = sub;\r\n  Decimal.sum = sum;\r\n  Decimal.tan = tan;\r\n  Decimal.tanh = tanh;          // ES6\r\n  Decimal.trunc = trunc;        // ES6\r\n\r\n  if (obj === void 0) obj = {};\r\n  if (obj) {\r\n    if (obj.defaults !== true) {\r\n      ps = ['precision', 'rounding', 'toExpNeg', 'toExpPos', 'maxE', 'minE', 'modulo', 'crypto'];\r\n      for (i = 0; i < ps.length;) if (!obj.hasOwnProperty(p = ps[i++])) obj[p] = this[p];\r\n    }\r\n  }\r\n\r\n  Decimal.config(obj);\r\n\r\n  return Decimal;\r\n}\r\n\r\n\r\n/*\r\n * Return a new Decimal whose value is `x` divided by `y`, rounded to `precision` significant\r\n * digits using rounding mode `rounding`.\r\n *\r\n * x {number|string|Decimal}\r\n * y {number|string|Decimal}\r\n *\r\n */\r\nfunction div(x, y) {\r\n  return new this(x).div(y);\r\n}\r\n\r\n\r\n/*\r\n * Return a new Decimal whose value is the natural exponential of `x`, rounded to `precision`\r\n * significant digits using rounding mode `rounding`.\r\n *\r\n * x {number|string|Decimal} The power to which to raise the base of the natural log.\r\n *\r\n */\r\nfunction exp(x) {\r\n  return new this(x).exp();\r\n}\r\n\r\n\r\n/*\r\n * Return a new Decimal whose value is `x` round to an integer using `ROUND_FLOOR`.\r\n *\r\n * x {number|string|Decimal}\r\n *\r\n */\r\nfunction floor(x) {\r\n  return finalise(x = new this(x), x.e + 1, 3);\r\n}\r\n\r\n\r\n/*\r\n * Return a new Decimal whose value is the square root of the sum of the squares of the arguments,\r\n * rounded to `precision` significant digits using rounding mode `rounding`.\r\n *\r\n * hypot(a, b, ...) = sqrt(a^2 + b^2 + ...)\r\n *\r\n * arguments {number|string|Decimal}\r\n *\r\n */\r\nfunction hypot() {\r\n  var i, n,\r\n    t = new this(0);\r\n\r\n  external = false;\r\n\r\n  for (i = 0; i < arguments.length;) {\r\n    n = new this(arguments[i++]);\r\n    if (!n.d) {\r\n      if (n.s) {\r\n        external = true;\r\n        return new this(1 / 0);\r\n      }\r\n      t = n;\r\n    } else if (t.d) {\r\n      t = t.plus(n.times(n));\r\n    }\r\n  }\r\n\r\n  external = true;\r\n\r\n  return t.sqrt();\r\n}\r\n\r\n\r\n/*\r\n * Return true if object is a Decimal instance (where Decimal is any Decimal constructor),\r\n * otherwise return false.\r\n *\r\n */\r\nfunction isDecimalInstance(obj) {\r\n  return obj instanceof Decimal || obj && obj.toStringTag === tag || false;\r\n}\r\n\r\n\r\n/*\r\n * Return a new Decimal whose value is the natural logarithm of `x`, rounded to `precision`\r\n * significant digits using rounding mode `rounding`.\r\n *\r\n * x {number|string|Decimal}\r\n *\r\n */\r\nfunction ln(x) {\r\n  return new this(x).ln();\r\n}\r\n\r\n\r\n/*\r\n * Return a new Decimal whose value is the log of `x` to the base `y`, or to base 10 if no base\r\n * is specified, rounded to `precision` significant digits using rounding mode `rounding`.\r\n *\r\n * log[y](x)\r\n *\r\n * x {number|string|Decimal} The argument of the logarithm.\r\n * y {number|string|Decimal} The base of the logarithm.\r\n *\r\n */\r\nfunction log(x, y) {\r\n  return new this(x).log(y);\r\n}\r\n\r\n\r\n/*\r\n * Return a new Decimal whose value is the base 2 logarithm of `x`, rounded to `precision`\r\n * significant digits using rounding mode `rounding`.\r\n *\r\n * x {number|string|Decimal}\r\n *\r\n */\r\nfunction log2(x) {\r\n  return new this(x).log(2);\r\n}\r\n\r\n\r\n/*\r\n * Return a new Decimal whose value is the base 10 logarithm of `x`, rounded to `precision`\r\n * significant digits using rounding mode `rounding`.\r\n *\r\n * x {number|string|Decimal}\r\n *\r\n */\r\nfunction log10(x) {\r\n  return new this(x).log(10);\r\n}\r\n\r\n\r\n/*\r\n * Return a new Decimal whose value is the maximum of the arguments.\r\n *\r\n * arguments {number|string|Decimal}\r\n *\r\n */\r\nfunction max() {\r\n  return maxOrMin(this, arguments, 'lt');\r\n}\r\n\r\n\r\n/*\r\n * Return a new Decimal whose value is the minimum of the arguments.\r\n *\r\n * arguments {number|string|Decimal}\r\n *\r\n */\r\nfunction min() {\r\n  return maxOrMin(this, arguments, 'gt');\r\n}\r\n\r\n\r\n/*\r\n * Return a new Decimal whose value is `x` modulo `y`, rounded to `precision` significant digits\r\n * using rounding mode `rounding`.\r\n *\r\n * x {number|string|Decimal}\r\n * y {number|string|Decimal}\r\n *\r\n */\r\nfunction mod(x, y) {\r\n  return new this(x).mod(y);\r\n}\r\n\r\n\r\n/*\r\n * Return a new Decimal whose value is `x` multiplied by `y`, rounded to `precision` significant\r\n * digits using rounding mode `rounding`.\r\n *\r\n * x {number|string|Decimal}\r\n * y {number|string|Decimal}\r\n *\r\n */\r\nfunction mul(x, y) {\r\n  return new this(x).mul(y);\r\n}\r\n\r\n\r\n/*\r\n * Return a new Decimal whose value is `x` raised to the power `y`, rounded to precision\r\n * significant digits using rounding mode `rounding`.\r\n *\r\n * x {number|string|Decimal} The base.\r\n * y {number|string|Decimal} The exponent.\r\n *\r\n */\r\nfunction pow(x, y) {\r\n  return new this(x).pow(y);\r\n}\r\n\r\n\r\n/*\r\n * Returns a new Decimal with a random value equal to or greater than 0 and less than 1, and with\r\n * `sd`, or `Decimal.precision` if `sd` is omitted, significant digits (or less if trailing zeros\r\n * are produced).\r\n *\r\n * [sd] {number} Significant digits. Integer, 0 to MAX_DIGITS inclusive.\r\n *\r\n */\r\nfunction random(sd) {\r\n  var d, e, k, n,\r\n    i = 0,\r\n    r = new this(1),\r\n    rd = [];\r\n\r\n  if (sd === void 0) sd = this.precision;\r\n  else checkInt32(sd, 1, MAX_DIGITS);\r\n\r\n  k = Math.ceil(sd / LOG_BASE);\r\n\r\n  if (!this.crypto) {\r\n    for (; i < k;) rd[i++] = Math.random() * 1e7 | 0;\r\n\r\n  // Browsers supporting crypto.getRandomValues.\r\n  } else if (crypto.getRandomValues) {\r\n    d = crypto.getRandomValues(new Uint32Array(k));\r\n\r\n    for (; i < k;) {\r\n      n = d[i];\r\n\r\n      // 0 <= n < 4294967296\r\n      // Probability n >= 4.29e9, is 4967296 / 4294967296 = 0.00116 (1 in 865).\r\n      if (n >= 4.29e9) {\r\n        d[i] = crypto.getRandomValues(new Uint32Array(1))[0];\r\n      } else {\r\n\r\n        // 0 <= n <= 4289999999\r\n        // 0 <= (n % 1e7) <= 9999999\r\n        rd[i++] = n % 1e7;\r\n      }\r\n    }\r\n\r\n  // Node.js supporting crypto.randomBytes.\r\n  } else if (crypto.randomBytes) {\r\n\r\n    // buffer\r\n    d = crypto.randomBytes(k *= 4);\r\n\r\n    for (; i < k;) {\r\n\r\n      // 0 <= n < 2147483648\r\n      n = d[i] + (d[i + 1] << 8) + (d[i + 2] << 16) + ((d[i + 3] & 0x7f) << 24);\r\n\r\n      // Probability n >= 2.14e9, is 7483648 / 2147483648 = 0.0035 (1 in 286).\r\n      if (n >= 2.14e9) {\r\n        crypto.randomBytes(4).copy(d, i);\r\n      } else {\r\n\r\n        // 0 <= n <= 2139999999\r\n        // 0 <= (n % 1e7) <= 9999999\r\n        rd.push(n % 1e7);\r\n        i += 4;\r\n      }\r\n    }\r\n\r\n    i = k / 4;\r\n  } else {\r\n    throw Error(cryptoUnavailable);\r\n  }\r\n\r\n  k = rd[--i];\r\n  sd %= LOG_BASE;\r\n\r\n  // Convert trailing digits to zeros according to sd.\r\n  if (k && sd) {\r\n    n = mathpow(10, LOG_BASE - sd);\r\n    rd[i] = (k / n | 0) * n;\r\n  }\r\n\r\n  // Remove trailing words which are zero.\r\n  for (; rd[i] === 0; i--) rd.pop();\r\n\r\n  // Zero?\r\n  if (i < 0) {\r\n    e = 0;\r\n    rd = [0];\r\n  } else {\r\n    e = -1;\r\n\r\n    // Remove leading words which are zero and adjust exponent accordingly.\r\n    for (; rd[0] === 0; e -= LOG_BASE) rd.shift();\r\n\r\n    // Count the digits of the first word of rd to determine leading zeros.\r\n    for (k = 1, n = rd[0]; n >= 10; n /= 10) k++;\r\n\r\n    // Adjust the exponent for leading zeros of the first word of rd.\r\n    if (k < LOG_BASE) e -= LOG_BASE - k;\r\n  }\r\n\r\n  r.e = e;\r\n  r.d = rd;\r\n\r\n  return r;\r\n}\r\n\r\n\r\n/*\r\n * Return a new Decimal whose value is `x` rounded to an integer using rounding mode `rounding`.\r\n *\r\n * To emulate `Math.round`, set rounding to 7 (ROUND_HALF_CEIL).\r\n *\r\n * x {number|string|Decimal}\r\n *\r\n */\r\nfunction round(x) {\r\n  return finalise(x = new this(x), x.e + 1, this.rounding);\r\n}\r\n\r\n\r\n/*\r\n * Return\r\n *   1    if x > 0,\r\n *  -1    if x < 0,\r\n *   0    if x is 0,\r\n *  -0    if x is -0,\r\n *   NaN  otherwise\r\n *\r\n * x {number|string|Decimal}\r\n *\r\n */\r\nfunction sign(x) {\r\n  x = new this(x);\r\n  return x.d ? (x.d[0] ? x.s : 0 * x.s) : x.s || NaN;\r\n}\r\n\r\n\r\n/*\r\n * Return a new Decimal whose value is the sine of `x`, rounded to `precision` significant digits\r\n * using rounding mode `rounding`.\r\n *\r\n * x {number|string|Decimal} A value in radians.\r\n *\r\n */\r\nfunction sin(x) {\r\n  return new this(x).sin();\r\n}\r\n\r\n\r\n/*\r\n * Return a new Decimal whose value is the hyperbolic sine of `x`, rounded to `precision`\r\n * significant digits using rounding mode `rounding`.\r\n *\r\n * x {number|string|Decimal} A value in radians.\r\n *\r\n */\r\nfunction sinh(x) {\r\n  return new this(x).sinh();\r\n}\r\n\r\n\r\n/*\r\n * Return a new Decimal whose value is the square root of `x`, rounded to `precision` significant\r\n * digits using rounding mode `rounding`.\r\n *\r\n * x {number|string|Decimal}\r\n *\r\n */\r\nfunction sqrt(x) {\r\n  return new this(x).sqrt();\r\n}\r\n\r\n\r\n/*\r\n * Return a new Decimal whose value is `x` minus `y`, rounded to `precision` significant digits\r\n * using rounding mode `rounding`.\r\n *\r\n * x {number|string|Decimal}\r\n * y {number|string|Decimal}\r\n *\r\n */\r\nfunction sub(x, y) {\r\n  return new this(x).sub(y);\r\n}\r\n\r\n\r\n/*\r\n * Return a new Decimal whose value is the sum of the arguments, rounded to `precision`\r\n * significant digits using rounding mode `rounding`.\r\n *\r\n * Only the result is rounded, not the intermediate calculations.\r\n *\r\n * arguments {number|string|Decimal}\r\n *\r\n */\r\nfunction sum() {\r\n  var i = 0,\r\n    args = arguments,\r\n    x = new this(args[i]);\r\n\r\n  external = false;\r\n  for (; x.s && ++i < args.length;) x = x.plus(args[i]);\r\n  external = true;\r\n\r\n  return finalise(x, this.precision, this.rounding);\r\n}\r\n\r\n\r\n/*\r\n * Return a new Decimal whose value is the tangent of `x`, rounded to `precision` significant\r\n * digits using rounding mode `rounding`.\r\n *\r\n * x {number|string|Decimal} A value in radians.\r\n *\r\n */\r\nfunction tan(x) {\r\n  return new this(x).tan();\r\n}\r\n\r\n\r\n/*\r\n * Return a new Decimal whose value is the hyperbolic tangent of `x`, rounded to `precision`\r\n * significant digits using rounding mode `rounding`.\r\n *\r\n * x {number|string|Decimal} A value in radians.\r\n *\r\n */\r\nfunction tanh(x) {\r\n  return new this(x).tanh();\r\n}\r\n\r\n\r\n/*\r\n * Return a new Decimal whose value is `x` truncated to an integer.\r\n *\r\n * x {number|string|Decimal}\r\n *\r\n */\r\nfunction trunc(x) {\r\n  return finalise(x = new this(x), x.e + 1, 1);\r\n}\r\n\r\n\r\nP[Symbol.for('nodejs.util.inspect.custom')] = P.toString;\r\nP[Symbol.toStringTag] = 'Decimal';\r\n\r\n// Create and configure initial Decimal constructor.\r\nexport var Decimal = P.constructor = clone(DEFAULTS);\r\n\r\n// Create the internal constants from their string values.\r\nLN10 = new Decimal(LN10);\r\nPI = new Decimal(PI);\r\n\r\nexport default Decimal;\r\n","export const Modes = Object.freeze({\n  RETURN: Symbol('mode:return'),\n  BREAK: Symbol('mode:break'),\n  PAUSE: Symbol('mode:pause'),\n  RUN: Symbol('mode:run'),\n  ABORT: Symbol('mode:abort')\n});","import { LanguageService } from \"../services/languageService\";\nimport { Types } from \"./types\";\nimport Decimal from \"decimal.js\";\nimport { Config } from \"../util/config\";\n\nexport function toInt (str) {\n  return new Decimal(str);\n}\n\nexport function toString (str) {\n  let value = str.replace(/^\"/, \"\");\n  value = value.replace(/\"$/, \"\");\n  value = value.replace(/\\\\b/g, \"\\b\");\n  value = value.replace(/\\\\t/g, \"\\t\");\n  value = value.replace(/\\\\n/g, \"\\n\");\n  value = value.replace(/\\\\r/g, \"\\r\");\n  value = value.replace(/\\\\\"/g, '\"');\n  value = value.replace(/\\\\'/g, \"'\");\n  value = value.replace(/\\\\\\\\/g, \"\\\\\");\n  return value;\n}\n\nexport function toChar (str) {\n  //console.debug(str, str.length);\n  let value = str.replace(/^'/, \"\");\n  value = value.replace(/'$/, \"\");\n  value = value.replace(/\\\\b/g, \"\\b\");\n  value = value.replace(/\\\\t/g, \"\\t\");\n  value = value.replace(/\\\\n/g, \"\\n\");\n  value = value.replace(/\\\\r/g, \"\\r\");\n  value = value.replace(/\\\\\"/g, '\"');\n  value = value.replace(/\\\\'/g, \"'\");\n  value = value[0];\n  return value;\n}\n\nexport function toReal (value) {\n  return new Decimal(value);\n}\n\nexport function toBool (str) {\n  const val = str;\n  const lexer = LanguageService.getCurrentLexer();\n  if (lexer.getReservedKeys()[lexer.getRules().RK_TRUE] === val) {\n    return true;\n  } else if (lexer.getReservedKeys()[lexer.getRules().RK_FALSE] === val) {\n    return false;\n  } else {\n    // TODO: better error message\n    throw new Error(str + \"not a valid boolean\");\n  }\n}\n\nexport function convertBoolToString (bool) {\n  const lexer = LanguageService.getCurrentLexer();\n  let result = null;\n  if (bool) {\n    result = lexer.getReservedKeys()[lexer.getRules().RK_TRUE];\n  } else {\n    result = lexer.getReservedKeys()[lexer.getRules().RK_FALSE];\n  }\n  //console.debug(result)\n  return result.replace(/'/g, \"\");\n}\n\nexport function convertToString (value, type) {\n  switch (type.ord) {\n    case Types.INTEGER.ord:\n      return value.toString();\n    case Types.REAL.ord: {\n      if (value.dp() <= 0) {\n        return value.toFixed(1);\n      } else {\n        return value.toFixed(Config.decimalPlaces);\n      }\n    }\n    case Types.BOOLEAN.ord:\n      return convertBoolToString(value);\n    default:\n      return value;\n  }\n}\n\n","export default function _isNativeReflectConstruct() {\n  if (typeof Reflect === \"undefined\" || !Reflect.construct) return false;\n  if (Reflect.construct.sham) return false;\n  if (typeof Proxy === \"function\") return true;\n  try {\n    Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {}));\n    return true;\n  } catch (e) {\n    return false;\n  }\n}","import setPrototypeOf from \"./setPrototypeOf.js\";\nimport isNativeReflectConstruct from \"./isNativeReflectConstruct.js\";\nexport default function _construct(Parent, args, Class) {\n  if (isNativeReflectConstruct()) {\n    _construct = Reflect.construct.bind();\n  } else {\n    _construct = function _construct(Parent, args, Class) {\n      var a = [null];\n      a.push.apply(a, args);\n      var Constructor = Function.bind.apply(Parent, a);\n      var instance = new Constructor();\n      if (Class) setPrototypeOf(instance, Class.prototype);\n      return instance;\n    };\n  }\n  return _construct.apply(null, arguments);\n}","import getPrototypeOf from \"./getPrototypeOf.js\";\nimport setPrototypeOf from \"./setPrototypeOf.js\";\nimport isNativeFunction from \"./isNativeFunction.js\";\nimport construct from \"./construct.js\";\nexport default function _wrapNativeSuper(Class) {\n  var _cache = typeof Map === \"function\" ? new Map() : undefined;\n  _wrapNativeSuper = function _wrapNativeSuper(Class) {\n    if (Class === null || !isNativeFunction(Class)) return Class;\n    if (typeof Class !== \"function\") {\n      throw new TypeError(\"Super expression must either be null or a function\");\n    }\n    if (typeof _cache !== \"undefined\") {\n      if (_cache.has(Class)) return _cache.get(Class);\n      _cache.set(Class, Wrapper);\n    }\n    function Wrapper() {\n      return construct(Class, arguments, getPrototypeOf(this).constructor);\n    }\n    Wrapper.prototype = Object.create(Class.prototype, {\n      constructor: {\n        value: Wrapper,\n        enumerable: false,\n        writable: true,\n        configurable: true\n      }\n    });\n    return setPrototypeOf(Wrapper, Class);\n  };\n  return _wrapNativeSuper(Class);\n}","export default function _isNativeFunction(fn) {\n  return Function.toString.call(fn).indexOf(\"[native code]\") !== -1;\n}","export class RuntimeError extends Error {\n  constructor (msg, id) {\n    super(msg);\n    this.id = id;\n    this._context = {};\n    if (Error.captureStackTrace) Error.captureStackTrace(this, RuntimeError);\n  }\n\n  get context () {\n    return this._context;\n  }\n\n  set context (contextObj) {\n    this._context = contextObj;\n  }\n}\n","export class SemanticError extends Error {\n  constructor (msg, id) {\n    super(msg);\n    this.id = id;\n    this._context = {};\n    if (Error.captureStackTrace) Error.captureStackTrace(this, SemanticError);\n  }\n\n  get context () {\n    return this._context;\n  }\n\n  set context (contextObj) {\n    this._context = contextObj;\n  }\n}\n","import { RuntimeError } from \"./runtimeError\";\nimport { SemanticError } from \"./semanticError\";\nimport * as LocalizedStringsService from \"./../../services/localizedStringsService\";\nimport { LanguageDefinedFunction } from \"../definedFunctions\";\n\nfunction createRuntimeError (i18n_id, context = []) {\n  const LocalizedStrings = LocalizedStringsService.getInstance();\n  return new RuntimeError(LocalizedStrings.getError(i18n_id, context), i18n_id);\n}\n\nfunction createSemanticError (i18n_id, context = []) {\n  const LocalizedStrings = LocalizedStringsService.getInstance();\n  return new SemanticError(\n    LocalizedStrings.getError(i18n_id, context),\n    i18n_id\n  );\n}\n\nexport const ProcessorErrorFactory = Object.freeze({\n  symbol_not_found_full: (id, sourceInfo) => {\n    if (sourceInfo) {\n      const context = [id, sourceInfo.line, sourceInfo.column];\n      const error = createSemanticError(\"symbol_not_found_full\", context);\n      error.context = { line: sourceInfo.line, column: sourceInfo.column };\n      return error;\n    } else {\n      return ProcessorErrorFactory.symbol_not_found(id);\n    }\n  },\n  symbol_not_found: (id) => {\n    const context = [id];\n    return createSemanticError(\"symbol_not_found\", context);\n  },\n  function_missing_full: (id, sourceInfo) => {\n    if (sourceInfo) {\n      const context = [id, sourceInfo.line, sourceInfo.column];\n      const error = createSemanticError(\"function_missing_full\", context);\n      error.context = { line: sourceInfo.line, column: sourceInfo.column };\n      return error;\n    } else {\n      return ProcessorErrorFactory.function_missing(id);\n    }\n  },\n  function_missing: (id) => {\n    const context = [id];\n    return createSemanticError(\"function_missing\", context);\n  },\n  main_missing: () => {\n    return createSemanticError(\"main_missing\");\n  },\n  array_dimension_not_int_full: (sourceInfo) => {\n    if (sourceInfo) {\n      const context = [sourceInfo.line];\n      const error = createSemanticError(\n        \"array_dimension_not_int_full\",\n        context\n      );\n      error.context = { line: sourceInfo.line, column: sourceInfo.column };\n      return error;\n    } else {\n      return ProcessorErrorFactory.array_dimension_not_int();\n    }\n  },\n  array_dimension_not_int: () => {\n    return createSemanticError(\"array_dimension_not_int\");\n  },\n  unknown_command_full: (sourceInfo) => {\n    if (sourceInfo) {\n      const context = [sourceInfo.line];\n      const error = createRuntimeError(\"unknown_command_full\", context);\n      error.context = { line: sourceInfo.line, column: sourceInfo.column };\n      return error;\n    } else {\n      return ProcessorErrorFactory.unknown_command();\n    }\n  },\n  unknown_command: () => {\n    return createRuntimeError(\"unknown_command\");\n  },\n  incompatible_types_full: (\n    left_type,\n    left_dim,\n    right_type,\n    right_dim,\n    exp,\n    source_info\n  ) => {\n    const LocalizedStrings = LocalizedStringsService.getInstance();\n    if (source_info) {\n      const context = [\n        LocalizedStrings.translateType(left_type, left_dim),\n        exp,\n        source_info.line,\n        LocalizedStrings.translateType(right_type, right_dim),\n      ];\n      const error = createSemanticError(\"incompatible_types_full\", context);\n      error.context = { line: source_info.line, column: source_info.column };\n      return error;\n    } else {\n      return ProcessorErrorFactory.incompatible_types(\n        left_type,\n        left_dim,\n        right_type,\n        right_dim,\n        exp\n      );\n    }\n  },\n  incompatible_types: (left_type, left_dim, right_type, right_dim, exp) => {\n    const LocalizedStrings = LocalizedStringsService.getInstance();\n    const context = [\n      LocalizedStrings.translateType(left_type, left_dim),\n      exp,\n      LocalizedStrings.translateType(right_type, right_dim),\n    ];\n    return createSemanticError(\"incompatible_types\", context);\n  },\n  incompatible_types_array_full: (exp, type, dim, sourceInfo) => {\n    const LocalizedStrings = LocalizedStringsService.getInstance();\n    if (sourceInfo) {\n      const context = [\n        exp,\n        LocalizedStrings.translateType(type, dim),\n        sourceInfo.line,\n        sourceInfo.column,\n      ];\n      const error = createSemanticError(\n        \"incompatible_types_array_full\",\n        context\n      );\n      error.context = { line: sourceInfo.line, column: sourceInfo.column };\n      return error;\n    } else {\n      return ProcessorErrorFactory.incompatible_types_array(exp, type, dim);\n    }\n  },\n  incompatible_types_array: (exp, type, dim) => {\n    const LocalizedStrings = LocalizedStringsService.getInstance();\n    const context = [exp, LocalizedStrings.translateType(type, dim)];\n    return createSemanticError(\"incompatible_types_array\", context);\n  },\n  loop_condition_type_full: (exp, sourceInfo) => {\n    if (sourceInfo) {\n      const context = [sourceInfo.line, sourceInfo.column, exp];\n      const error = createSemanticError(\"loop_condition_type_full\", context);\n      error.context = { line: sourceInfo.line, column: sourceInfo.column };\n      return error;\n    } else {\n      return ProcessorErrorFactory.loop_condition_type(exp);\n    }\n  },\n  loop_condition_type: (exp) => {\n    const context = [exp];\n    return createSemanticError(\"loop_condition_type\", context);\n  },\n  /**\n   * @deprecated 01/10/2019\n   */\n  endless_loop_full: (sourceInfo) => {\n    if (sourceInfo) {\n      const context = [sourceInfo.line];\n      const error = createSemanticError(\"endless_loop_full\", context);\n      error.context = { line: sourceInfo.line, column: sourceInfo.column };\n      return error;\n    } else {\n      return ProcessorErrorFactory.endless_loop();\n    }\n  },\n  endless_loop: () => {\n    return createSemanticError(\"endless_loop\");\n  },\n  if_condition_type_full: (exp, sourceInfo) => {\n    if (sourceInfo) {\n      const context = [sourceInfo.line, sourceInfo.column, exp];\n      const error = createSemanticError(\"if_condition_type_full\", context);\n      error.context = { line: sourceInfo.line, column: sourceInfo.column };\n      return error;\n    } else {\n      return ProcessorErrorFactory.if_condition_type(exp);\n    }\n  },\n  if_condition_type: (exp) => {\n    const context = [exp];\n    return createSemanticError(\"if_condition_type\", context);\n  },\n  invalid_global_var: () => {\n    return createRuntimeError(\"invalid_global_var\");\n  },\n  not_implemented: (id) => {\n    const context = [id];\n    return createRuntimeError(\"not_implemented\", context);\n  },\n  invalid_case_type_full: (exp, type, dim, sourceInfo) => {\n    const LocalizedStrings = LocalizedStringsService.getInstance();\n    if (sourceInfo) {\n      const context = [\n        exp,\n        LocalizedStrings.translateType(type, dim),\n        sourceInfo.line,\n        sourceInfo.column,\n      ];\n      const error = createSemanticError(\"invalid_case_type_full\", context);\n      error.context = { line: sourceInfo.line, column: sourceInfo.column };\n      return error;\n    } else {\n      return ProcessorErrorFactory.invalid_case_type(exp, type, dim);\n    }\n  },\n  invalid_case_type: (exp, type, dim) => {\n    const LocalizedStrings = LocalizedStringsService.getInstance();\n    const context = [exp, LocalizedStrings.translateType(type, dim)];\n    return createSemanticError(\"invalid_case_type\", context);\n  },\n  void_in_expression_full: (id, sourceInfo) => {\n    if (sourceInfo) {\n      const context = [sourceInfo.line, sourceInfo.column, id];\n      const error = createSemanticError(\"void_in_expression_full\", context);\n      error.context = { line: sourceInfo.line, column: sourceInfo.column };\n      return error;\n    } else {\n      return ProcessorErrorFactory.void_in_expression(id);\n    }\n  },\n  void_in_expression: (id) => {\n    const context = [id];\n    return createSemanticError(\"void_in_expression\", context);\n  },\n  invalid_array_access_full: (id, sourceInfo) => {\n    if (sourceInfo) {\n      const context = [id, sourceInfo.line, sourceInfo.column];\n      const error = createSemanticError(\"invalid_array_access_full\", context);\n      error.context = { line: sourceInfo.line, column: sourceInfo.column };\n      return error;\n    } else {\n      return ProcessorErrorFactory.invalid_array_access(id);\n    }\n  },\n  invalid_array_access: (id) => {\n    const context = [id];\n    return createSemanticError(\"invalid_array_access\", context);\n  },\n  invalid_matrix_access_full: (id, sourceInfo) => {\n    if (sourceInfo) {\n      const context = [id, sourceInfo.line, sourceInfo.column];\n      const error = createSemanticError(\"invalid_matrix_access_full\", context);\n      error.context = { line: sourceInfo.line, column: sourceInfo.column };\n      return error;\n    } else {\n      return ProcessorErrorFactory.invalid_matrix_access(id);\n    }\n  },\n  invalid_matrix_access: (id) => {\n    const context = [id];\n    return createSemanticError(\"invalid_matrix_access\", context);\n  },\n  matrix_column_outbounds_full: (id, value, columns, sourceInfo) => {\n    if (sourceInfo) {\n      const context = [sourceInfo.line, value, id, columns];\n      const error = createRuntimeError(\"matrix_column_outbounds_full\", context);\n      error.context = { line: sourceInfo.line, column: sourceInfo.column };\n      return error;\n    } else {\n      return ProcessorErrorFactory.matrix_column_outbounds(id, value, columns);\n    }\n  },\n  matrix_column_outbounds: (id, value, columns) => {\n    const context = [value, id, columns];\n    return createRuntimeError(\"matrix_column_outbounds\", context);\n  },\n  matrix_line_outbounds_full: (id, value, lines, sourceInfo) => {\n    if (sourceInfo) {\n      const context = [sourceInfo.line, value, id, lines];\n      const error = createRuntimeError(\"matrix_line_outbounds_full\", context);\n      error.context = { line: sourceInfo.line, column: sourceInfo.column };\n      return error;\n    } else {\n      return ProcessorErrorFactory.matrix_line_outbounds(id, value, lines);\n    }\n  },\n  matrix_line_outbounds: (id, value, lines) => {\n    const context = [value, id, lines];\n    return createRuntimeError(\"matrix_line_outbounds\", context);\n  },\n  vector_line_outbounds_full: (id, value, lines, sourceInfo) => {\n    if (sourceInfo) {\n      const context = [sourceInfo.line, value, id, lines];\n      const error = createRuntimeError(\"vector_line_outbounds_full\", context);\n      error.context = { line: sourceInfo.line, column: sourceInfo.column };\n      return error;\n    } else {\n      return ProcessorErrorFactory.vector_line_outbounds(id, value, lines);\n    }\n  },\n  vector_line_outbounds: (id, value, lines) => {\n    const context = [value, id, lines];\n    return createRuntimeError(\"vector_line_outbounds\", context);\n  },\n  vector_not_matrix_full: (id, sourceInfo) => {\n    if (sourceInfo) {\n      const context = [sourceInfo.line, id];\n      const error = createRuntimeError(\"vector_not_matrix_full\", context);\n      error.context = { line: sourceInfo.line, column: sourceInfo.column };\n      return error;\n    } else {\n      return ProcessorErrorFactory.vector_not_matrix(id);\n    }\n  },\n  vector_not_matrix: (id) => {\n    const context = [id];\n    return createRuntimeError(\"vector_not_matrix\", context);\n  },\n  function_no_return: (id) => {\n    const context = [id];\n    return createSemanticError(\"function_no_return\", context);\n  },\n  invalid_void_return_full: (id, type, dim, sourceInfo) => {\n    const LocalizedStrings = LocalizedStringsService.getInstance();\n    if (sourceInfo) {\n      const context = [\n        sourceInfo.line,\n        id,\n        LocalizedStrings.translateType(type, dim),\n      ];\n      const error = createSemanticError(\"invalid_void_return_full\", context);\n      error.context = { line: sourceInfo.line, column: sourceInfo.column };\n      return error;\n    } else {\n      return ProcessorErrorFactory.invalid_void_return(id, type, dim);\n    }\n  },\n  invalid_void_return: (id, type, dim) => {\n    const LocalizedStrings = LocalizedStringsService.getInstance();\n    const context = [id, LocalizedStrings.translateType(type, dim)];\n    return createSemanticError(\"invalid_void_return_full\", context);\n  },\n  invalid_return_type_full: (id, type, dim, sourceInfo) => {\n    const LocalizedStrings = LocalizedStringsService.getInstance();\n\n    if (sourceInfo) {\n      const context = [\n        sourceInfo.line,\n        id,\n        LocalizedStrings.translateType(type, dim),\n      ];\n      const error = createSemanticError(\"invalid_return_type_full\", context);\n      error.context = { line: sourceInfo.line, column: sourceInfo.column };\n      return error;\n    } else {\n      return ProcessorErrorFactory.invalid_return_type(id, type, dim);\n    }\n  },\n  invalid_return_type: (id, type, dim) => {\n    const LocalizedStrings = LocalizedStringsService.getInstance();\n    const context = [id, LocalizedStrings.translateType(type, dim)];\n    return createSemanticError(\"invalid_return_type\", context);\n  },\n  invalid_parameters_size_full: (id, expected, actual, sourceInfo) => {\n    if (sourceInfo) {\n      const context = [sourceInfo.line, id, expected, actual];\n      const error = createSemanticError(\n        \"invalid_parameters_size_full\",\n        context\n      );\n      error.context = { line: sourceInfo.line, column: sourceInfo.column };\n      return error;\n    } else {\n      return ProcessorErrorFactory.invalid_parameters_size(\n        id,\n        expected,\n        actual\n      );\n    }\n  },\n  invalid_parameters_size: (id, expected, actual) => {\n    const context = [id, expected, actual];\n    return createSemanticError(\"invalid_parameters_size\", context);\n  },\n  invalid_parameter_type_full: (fun_name, exp, sourceInfo) => {\n    if (sourceInfo) {\n      const context = [\n        exp,\n        LanguageDefinedFunction.getLocalName(fun_name),\n        sourceInfo.line,\n      ];\n      const error = createSemanticError(\"invalid_parameter_type_full\", context);\n      error.context = { line: sourceInfo.line, column: sourceInfo.column };\n      return error;\n    } else {\n      return ProcessorErrorFactory.invalid_parameter_type(fun_name, exp);\n    }\n  },\n  invalid_parameter_type: (fun_name, exp) => {\n    const context = [exp, LanguageDefinedFunction.getLocalName(fun_name)];\n    return createSemanticError(\"invalid_parameter_type_full\", context);\n  },\n  invalid_ref_full: (id, exp, sourceInfo) => {\n    if (sourceInfo) {\n      const context = [exp, id, sourceInfo.line];\n      const error = createSemanticError(\"invalid_ref_full\", context);\n      error.context = { line: sourceInfo.line, column: sourceInfo.column };\n      return error;\n    } else {\n      return ProcessorErrorFactory.invalid_ref(id, exp);\n    }\n  },\n  invalid_ref: (id, exp) => {\n    const context = [exp, id];\n    return createSemanticError(\"invalid_ref\", context);\n  },\n  unexpected_break_command_full: (sourceInfo) => {\n    if (sourceInfo) {\n      const context = [sourceInfo.line];\n      const error = createRuntimeError(\n        \"unexpected_break_command_full\",\n        context\n      );\n      error.context = { line: sourceInfo.line, column: sourceInfo.column };\n      return error;\n    } else {\n      return ProcessorErrorFactory.unexpected_break_command();\n    }\n  },\n  unexpected_break_command: () => {\n    return createRuntimeError(\"unexpected_break_command\");\n  },\n  invalid_array_literal_type_full: (exp, sourceInfo) => {\n    if (sourceInfo) {\n      const context = [sourceInfo.line, exp];\n      const error = createRuntimeError(\n        \"invalid_array_literal_type_full\",\n        context\n      );\n      error.context = { line: sourceInfo.line, column: sourceInfo.column };\n      return error;\n    } else {\n      return ProcessorErrorFactory.invalid_array_literal_type(exp);\n    }\n  },\n  invalid_array_literal_type: (exp) => {\n    const context = [exp];\n    return createRuntimeError(\"invalid_array_literal_type\", context);\n  },\n  invalid_array_literal_line_full: (expected, actual, sourceInfo) => {\n    if (sourceInfo) {\n      const context = [sourceInfo.line, expected, actual];\n      const error = createRuntimeError(\n        \"invalid_array_literal_line_full\",\n        context\n      );\n      error.context = { line: sourceInfo.line, column: sourceInfo.column };\n      return error;\n    } else {\n      return ProcessorErrorFactory.invalid_array_literal_type(expected, actual);\n    }\n  },\n  invalid_array_literal_line: (expected, actual) => {\n    const context = [expected, actual];\n    return createRuntimeError(\"invalid_array_literal_line\", context);\n  },\n  invalid_array_literal_column_full: (expected, actual, sourceInfo) => {\n    if (sourceInfo) {\n      const context = [sourceInfo.line, expected, actual];\n      const error = createRuntimeError(\n        \"invalid_array_literal_column_full\",\n        context\n      );\n      error.context = { line: sourceInfo.line, column: sourceInfo.column };\n      return error;\n    } else {\n      return ProcessorErrorFactory.invalid_array_literal_column(\n        expected,\n        actual\n      );\n    }\n  },\n  invalid_array_literal_column: (expected, actual) => {\n    const context = [expected, actual];\n    return createRuntimeError(\"invalid_array_literal_column\", context);\n  },\n  invalid_unary_op_full: (expString, opName, type, dim, sourceInfo) => {\n    const LocalizedStrings = LocalizedStringsService.getInstance();\n    if (sourceInfo) {\n      const context = [\n        sourceInfo.line,\n        expString,\n        LocalizedStrings.translateOp(opName),\n        LocalizedStrings.translateType(type, dim),\n      ];\n      const error = createRuntimeError(\"invalid_unary_op_full\", context);\n      error.context = { line: sourceInfo.line, column: sourceInfo.column };\n      return error;\n    } else {\n      return ProcessorErrorFactory.invalid_unary_op(opName, type, dim);\n    }\n  },\n  invalid_unary_op: (expString, opName, type, dim) => {\n    const LocalizedStrings = LocalizedStringsService.getInstance();\n    const context = [\n      expString,\n      LocalizedStrings.translateOp(opName),\n      LocalizedStrings.translateType(type, dim),\n    ];\n    return createRuntimeError(\"invalid_unary_op\", context);\n  },\n  invalid_infix_op_full: (\n    expString,\n    opName,\n    typeLeft,\n    dimLeft,\n    typeRight,\n    dimRight,\n    sourceInfo\n  ) => {\n    const LocalizedStrings = LocalizedStringsService.getInstance();\n    if (sourceInfo) {\n      const context = [\n        sourceInfo.line,\n        expString,\n        LocalizedStrings.translateOp(opName),\n        LocalizedStrings.translateType(typeLeft, dimLeft),\n        LocalizedStrings.translateType(typeRight, dimRight),\n      ];\n      const error = createRuntimeError(\"invalid_infix_op_full\", context);\n      error.context = { line: sourceInfo.line, column: sourceInfo.column };\n      return error;\n    } else {\n      return ProcessorErrorFactory.invalid_infix_op(\n        opName,\n        typeLeft,\n        dimLeft,\n        typeRight,\n        dimRight\n      );\n    }\n  },\n  invalid_infix_op: (\n    expString,\n    opName,\n    typeLeft,\n    dimLeft,\n    typeRight,\n    dimRight\n  ) => {\n    const LocalizedStrings = LocalizedStringsService.getInstance();\n    const context = [\n      expString,\n      LocalizedStrings.translateOp(opName),\n      LocalizedStrings.translateType(typeLeft, dimLeft),\n      LocalizedStrings.translateType(typeRight, dimRight),\n    ];\n    return createRuntimeError(\"invalid_infix_op\", context);\n  },\n  array_dimension_not_positive_full: (sourceInfo) => {\n    if (sourceInfo) {\n      const context = [sourceInfo.line];\n      const error = createSemanticError(\n        \"array_dimension_not_positive_full\",\n        context\n      );\n      error.context = { line: sourceInfo.line, column: sourceInfo.column };\n      return error;\n    } else {\n      return ProcessorErrorFactory.array_dimension_not_positive();\n    }\n  },\n  array_dimension_not_positive: () => {\n    return createSemanticError(\"array_dimension_not_positive\");\n  },\n  invalid_type_conversion: (value, type, dim) => {\n    const LocalizedStrings = LocalizedStringsService.getInstance();\n\n    const context = [value, LocalizedStrings.translateType(type, dim)];\n    return createRuntimeError(\"invalid_type_conversion\", context);\n  },\n  invalid_read_type: (exp, type, dim, name, source_info) => {\n    const LocalizedStrings = LocalizedStringsService.getInstance();\n    const context = [\n      source_info.line,\n      exp,\n      LocalizedStrings.translateType(type, dim),\n      name,\n    ];\n    const error = createRuntimeError(\"invalid_read_type\", context);\n    error.context = { line: source_info.line, column: source_info.column };\n    return error;\n  },\n  invalid_read_type_array: (\n    exp,\n    typePos,\n    dimPos,\n    name,\n    typeArray,\n    dimArray,\n    sourceInfo\n  ) => {\n    const LocalizedStrings = LocalizedStringsService.getInstance();\n    const context = [\n      sourceInfo.line,\n      exp,\n      LocalizedStrings.translateType(typePos, dimPos),\n      name,\n      LocalizedStrings.translateType(typeArray, dimArray),\n    ];\n    const error = createRuntimeError(\"invalid_read_type_array\", context);\n    error.context = { line: sourceInfo.line, column: sourceInfo.column };\n    return error;\n  },\n  invalid_const_ref_full: (fun_name, exp, sourceInfo) => {\n    if (sourceInfo) {\n      const context = [\n        exp,\n        LanguageDefinedFunction.getLocalName(fun_name),\n        sourceInfo.line,\n      ];\n      const error = createSemanticError(\"invalid_const_ref_full\", context);\n      error.context = { line: sourceInfo.line, column: sourceInfo.column };\n      return error;\n    } else {\n      return ProcessorErrorFactory.invalid_const_ref(fun_name, exp);\n    }\n  },\n  invalid_const_ref: (fun_name, exp) => {\n    const context = [exp, LanguageDefinedFunction.getLocalName(fun_name)];\n    const error = createSemanticError(\"invalid_const_ref\", context);\n    return error;\n  },\n  invalid_const_assignment_full: (var_id, source_info) => {\n    if (source_info) {\n      const context = [source_info.line, var_id];\n      const error = createSemanticError(\n        \"invalid_const_assignment_full\",\n        context\n      );\n      error.context = { line: source_info.line, column: source_info.column };\n      return error;\n    } else {\n      return ProcessorErrorFactory.invalid_const_assignment(var_id);\n    }\n  },\n  invalid_const_assignment: (var_id) => {\n    const context = [var_id];\n    return createSemanticError(\"invalid_const_assignment\", context);\n  },\n  invalid_vector_assignment_full: (\n    left_id,\n    left_size,\n    right_id,\n    right_size,\n    source_info\n  ) => {\n    if (source_info) {\n      const context = [\n        source_info.line,\n        left_id,\n        left_size,\n        right_id,\n        right_size,\n      ];\n      const error = createRuntimeError(\n        \"invalid_vector_assignment_full\",\n        context\n      );\n      error.context = { line: source_info.line, column: source_info.column };\n      return error;\n    } else {\n      return ProcessorErrorFactory.invalid_vector_assignment(\n        left_id,\n        left_size,\n        right_id,\n        right_size\n      );\n    }\n  },\n  invalid_vector_assignment: (left_id, left_size, right_id, right_size) => {\n    const context = [left_id, left_size, right_id, right_size];\n    return createRuntimeError(\"invalid_vector_assignment\", context);\n  },\n  invalid_matrix_assignment_full: (\n    left_id,\n    left_line,\n    left_column,\n    right_id,\n    right_line,\n    right_column,\n    source_info\n  ) => {\n    if (source_info) {\n      const context = [\n        source_info.line,\n        left_id,\n        left_line,\n        left_column,\n        right_id,\n        right_line,\n        right_column,\n      ];\n      const error = createRuntimeError(\n        \"invalid_matrix_assignment_full\",\n        context\n      );\n      error.context = { line: source_info.line, column: source_info.column };\n      return error;\n    } else {\n      return ProcessorErrorFactory.invalid_matrix_assignment(\n        left_id,\n        left_line,\n        left_column,\n        right_id,\n        right_line,\n        right_column\n      );\n    }\n  },\n  invalid_matrix_assignment: (\n    left_id,\n    left_line,\n    left_column,\n    right_id,\n    right_line,\n    right_column\n  ) => {\n    const context = [\n      left_id,\n      left_line,\n      left_column,\n      right_id,\n      right_line,\n      right_column,\n    ];\n    return createRuntimeError(\"invalid_matrix_assignment\", context);\n  },\n  matrix_to_vector_attr: (left_id, right_id, source_info) => {\n    // SourceInfo have to be valid...\n    const context = [source_info.line, right_id, left_id];\n    const error = createSemanticError(\"matrix_to_vector_attr\", context);\n    error.context = { line: source_info.line, column: source_info.column };\n    return error;\n  },\n  vector_to_matrix_attr: (left_id, right_id, source_info) => {\n    // SourceInfo have to be valid...\n    const context = [source_info.line, right_id, left_id];\n    const error = createSemanticError(\"vector_to_matrix_attr\", context);\n    error.context = { line: source_info.line, column: source_info.column };\n    return error;\n  },\n  invalid_matrix_index_assign_full: (\n    mat_id,\n    mat_line,\n    mat_size,\n    exp,\n    exp_size,\n    source_info\n  ) => {\n    if (source_info) {\n      const context = [\n        source_info.line,\n        mat_line,\n        mat_id,\n        mat_size,\n        exp,\n        exp_size,\n      ];\n      const error = createRuntimeError(\n        \"invalid_matrix_index_assign_full\",\n        context\n      );\n      error.context = { line: source_info.line, column: source_info.column };\n      return error;\n    } else {\n      return ProcessorErrorFactory.invalid_matrix_index_assign(\n        mat_id,\n        mat_line,\n        mat_size,\n        exp,\n        exp_size\n      );\n    }\n  },\n  invalid_matrix_index_assign: (mat_id, mat_line, mat_size, exp, exp_size) => {\n    const context = [mat_line, mat_id, mat_size, exp, exp_size];\n    return createRuntimeError(\"invalid_matrix_index_assign\", context);\n  },\n  invalid_number_elements_vector: (\n    expected_num,\n    exp,\n    actual_num,\n    source_info\n  ) => {\n    // SourceInfo have to be valid...\n    const context = [expected_num, source_info.line, exp, actual_num];\n    const error = createRuntimeError(\"invalid_number_elements_vector\", context);\n    error.context = { line: source_info.line, column: source_info.column };\n    return error;\n  },\n  invalid_number_lines_matrix: (expected_num, exp, actual_num, source_info) => {\n    // SourceInfo have to be valid...\n    const context = [expected_num, source_info.line, exp, actual_num];\n    const error = createRuntimeError(\"invalid_number_lines_matrix\", context);\n    error.context = { line: source_info.line, column: source_info.column };\n    return error;\n  },\n  divsion_by_zero_full: (exp, source_info) => {\n    if (source_info) {\n      const context = [source_info.line, exp];\n      const error = createRuntimeError(\"divsion_by_zero_full\", context);\n      error.context = { line: source_info.line, column: source_info.column };\n      return error;\n    } else {\n      return ProcessorErrorFactory.divsion_by_zero(exp);\n    }\n  },\n  divsion_by_zero: (exp) => {\n    const context = [exp];\n    return createRuntimeError(\"divsion_by_zero\", context);\n  },\n  undefined_tanget_value: (value, source_info) => {\n    const context = [source_info.line, value];\n    const error = createRuntimeError(\"undefined_tanget_value\", context);\n    error.context = { line: source_info.line, column: source_info.column };\n    return error;\n  },\n  negative_log_value: (source_info) => {\n    const error = createRuntimeError(\"negative_log_value\", [source_info.line]);\n    error.context = { line: source_info.line, column: source_info.column };\n    return error;\n  },\n  invalid_string_index: (index, str, source_info) => {\n    const local_fun_name = LanguageDefinedFunction.getLocalName(\"$charAt\");\n    const context = [\n      source_info.line,\n      local_fun_name,\n      index,\n      str,\n      str.length - 1,\n    ];\n    const error = createRuntimeError(\"invalid_string_index\", context);\n    error.context = { line: source_info.line, column: source_info.column };\n    return error;\n  },\n  negative_sqrt_value: (source_info) => {\n    const error = createRuntimeError(\"negative_sqrt_value\", [source_info.line]);\n    error.context = { line: source_info.line, column: source_info.column };\n    return error;\n  },\n  /**\n   * @deprecated 01/10/2019\n   */\n  exceeded_recursive_calls: (source_info) => {\n    const context = [source_info.line];\n    const error = createRuntimeError(\"exceeded_recursive_calls\", context);\n    error.context = { line: source_info.line, column: source_info.column };\n    return error;\n  },\n  invalid_for_variable: (id, source_info) => {\n    const context = [source_info.line, id];\n    const error = createSemanticError(\"invalid_for_variable\", context);\n    error.context = { line: source_info.line, column: source_info.column };\n    return error;\n  },\n  invalid_for_from: (exp, source_info) => {\n    const context = [source_info.line, exp];\n    const error = createSemanticError(\"invalid_for_from\", context);\n    error.context = { line: source_info.line, column: source_info.column };\n    return error;\n  },\n  invalid_for_to: (exp, source_info) => {\n    const context = [source_info.line, exp];\n    const error = createSemanticError(\"invalid_for_to\", context);\n    error.context = { line: source_info.line, column: source_info.column };\n    return error;\n  },\n  invalid_for_pass: (exp, source_info) => {\n    const context = [source_info.line, exp];\n    const error = createSemanticError(\"invalid_for_pass\", context);\n    error.context = { line: source_info.line, column: source_info.column };\n    return error;\n  },\n  exceed_max_instructions: () => {\n    return createRuntimeError(\"exceed_max_instructions\");\n  },\n});\n\n","import { IStoreValue } from \"./istore_value\";\nimport { IType } from \"../../../typeSystem/itype\";\n\nexport class StoreValue implements IStoreValue {\n  \n  public type: IType;\n  public id?: String;\n  public isConst: boolean;\n  public value: any;\n\n  constructor(type: IType, value: any, id?:String, isConst = false) {\n    this.type = type;\n    this.id = id;\n    this.isConst = isConst\n    this.value = value;\n  }\n\n  get (): any {\n    return this.value;\n  }\n\n  inStore () {\n    return this.id != null;\n  }\n\n}","import { IType } from \"./itype\";\nimport { Type } from \"./type\";\n\nexport class ArrayType implements IType {\n\n  public innerType: IType;\n\n  constructor (type: Type, public dimensions: number) {\n    this.innerType = type;\n  }\n\n  get isVector (): boolean {\n    return this.dimensions == 1;\n  }\n\n  isCompatible (another: IType): boolean {\n    if(another instanceof ArrayType){\n      if(this.dimensions !== another.dimensions) {\n        return false;\n      }\n      return this.innerType.isCompatible(another.innerType);\n    }\n    return false;\n  }\n\n  stringInfo (): object[] {\n    const list = this.innerType.stringInfo();\n    list.forEach(v => {\n      // eslint-disable-next-line @typescript-eslint/no-explicit-any\n      const tmp = v as any;\n      tmp.dim = this.dimensions;\n    });\n    return list;\n  }\n\n  get value (): undefined {\n    return undefined;\n  }\n\n  get ord (): undefined {\n    return undefined;\n  }\n\n  canAccept (another: IType, used_dims: number): boolean {\n    const free_dims = this.dimensions - used_dims;\n    if(another instanceof ArrayType) {\n      return free_dims == another.dimensions && this.innerType.isCompatible(another.innerType);\n    } else {\n      return free_dims == 0 && this.innerType.isCompatible(another);\n    }\n  }\n}\n","import { Expression } from './expression';\n\nexport class ArrayAccess extends Expression {\n\t\n\tconstructor (id, line, column) {\n\t\tsuper();\n\t\tthis.id = id;\n\t\tthis.line = line;\n\t\tthis.column = column;\n\t}\n\n\ttoString () {\n\t\tconst strLine = this.line.toString();\n\t\tlet strColumn = null;\n\t\tif(this.column) {\n\t\t\tstrColumn = this.column.toString();\n\t\t}\n\t\tlet text = null;\n\t\tif(strColumn) {\n\t\t\ttext = `${this.id}[${strLine}][${strColumn}]`;\n\t\t} else {\n\t\t\ttext = `${this.id}[${strLine}]`;\n\t\t}\n\t\tif(this.parenthesis ){\n\t\t\treturn `(${text})`\n\t\t} else {\n\t\t\treturn text;\n\t\t}\n\t}\n}","import { Expression } from './expression';\n\nexport class Literal extends Expression {\n  \n  constructor (type) {\n    super();\n    this.type = type;\n  }\n}","import { Literal } from './literal';\nimport { Types } from './../../typeSystem/types';\nimport { convertToString } from './../../typeSystem/parsers';\n\nexport class IntLiteral extends Literal {\n  \n  constructor (value) {\n    super(Types.INTEGER);\n    this.value = value;\n  }\n\n  toString () {\n    const text = convertToString(this.value, this.type);\n    if(this.parenthesis) {\n      return `(${text})`;\n    } else {\n      return text;\n    }\n  }\n}","import { Literal } from './literal';\nimport { Types } from './../../typeSystem/types';\nimport { convertToString } from './../../typeSystem/parsers';\n\nexport class RealLiteral extends Literal {\n  \n  constructor (value) {\n    super(Types.REAL);\n    this.value = value;\n  }\n\n  toString () {\n    const text = convertToString(this.value, this.type);\n    if (this.parenthesis) {\n      return `(${text})`;\n    } else {\n      return text;\n    }\n  }\n}","import { Literal } from './literal';\nimport { Types } from './../../typeSystem/types';\nimport { convertBoolToString } from \"./../../typeSystem/parsers\";\n\nexport class BoolLiteral extends Literal {\n  \n  constructor (value) {\n    super(Types.BOOLEAN);\n    this.value = value;\n  }\n\n  toString () {\n    const text = convertBoolToString(this.value);\n    if(this.parenthesis) {\n      return `(${text})`\n    } else {\n      return text;\n    }\n  }\n}","import { Literal } from './literal';\nimport { Types } from './../../typeSystem/types';\n\nexport class CharLiteral extends Literal {\n  \n  constructor (value) {\n    super(Types.CHAR);\n    this.value = value;\n  }\n\n  toString () {\n    const text = `'${this.value}'`;\n    if(this.parenthesis) {\n      return `(${text})`\n    } else {\n      return text;\n    }\n  }\n}","import { Literal } from './literal';\nimport { Types } from './../../typeSystem/types';\n\nexport class StringLiteral extends Literal {\n  \n  constructor (value) {\n    super(Types.STRING);\n    this.value = value;\n  }\n\n  toString () {\n    const text = '\"' + this.value + '\"';\n    if(this.parenthesis) {\n      return `(${text})`;\n    } else {\n      return text;\n    }\n  }\n}","import { Literal } from './literal';\n\nexport class ArrayLiteral extends Literal {\n  \n  /**\n   * \n   * @param {import('../../typeSystem/itype').IType} type \n   * @param {import('./expression').Expression[]} value \n   */\n  constructor(type, value) {\n    super(type);\n    this.value = value;\n  }\n\n  get subtype () {\n    const element = this.value[0];\n    if (element instanceof ArrayLiteral) {\n      return element.value[0].type;\n    } else {\n      return element.type;\n    }\n  }\n\n  get lines () {\n    return this.value.length;\n  }\n\n  get columns () {\n    const element = this.value[0];\n    if (!(element instanceof ArrayLiteral)){\n      return null;\n    } else {\n      return element.value.length;\n    }\n  }\n\n  get isVector () {\n    return this.columns === null;\n  }\n\n  get isValid () {\n    return this.validateSize() && this.validateType();\n  }\n\n  validateType () {\n    const valid = true;\n    // const subtype = this.subtype;\n    // if(this.columns !== null) {\n    //   const len = this.lines;\n    //   const len2 = this.columns;\n    //   for (let i = len - 1; i >= 0 && valid; --i) {\n    //     for (let j = len2 - 1; j >= 0 && valid; --j) {\n    //       if(!this.value[i].value[j].type.isCompatilbe(subtype)) {\n    //         valid = false;\n    //         break;\n    //       }\n    //     }\n    //   }\n    // } else {\n    //   const len = this.lines;\n    //   for (var i = len - 1; i >= 0 && valid; i--) {\n    //     if(!this.value[i].type.isCompatilbe(subtype)) {\n    //       valid = false;\n    //       break;\n    //     }\n    //   }\n    // }\n    // Cannot validate type since no information on variables literals are available\n    return valid;\n  }\n\n  validateSize () {\n    const valid = true;\n    // if(this.columns !== null) {\n    //   const equalityTest = this.value.map(v => v.value.length)\n    //     .reduce((old, next) => {\n    //       console.log(next);\n    //       if (old == null) {\n    //         return next;\n    //       } else if (old === next) {\n    //         return old\n    //       } else {\n    //         return -1;\n    //       }\n    //     }, null);\n    //   valid = equalityTest !== -1;\n    // }\n    // check is now made inside IVProgParser.parseVectorList(...)\n    return valid;\n  }\n\n  toString () {\n    const strList = this.value.map(arrayLiteral => arrayLiteral.toString());\n    const text = \"{\" + strList.join(',') + \"}\";\n    if(this.parenthesis) {\n      return `(${text})`;\n    } else {\n      return text;\n    }\n  }\n}\n","import { Literal } from './literal';\nimport { Types } from './../../typeSystem/types';\n\nexport class VariableLiteral extends Literal {\n  \n  constructor (id) {\n    super(Types.UNDEFINED);\n    this.id = id;\n  }\n\n  toString () {\n    if(this.parenthesis) {\n      return `(${this.id})`;\n    } else {\n      return this.id;\n    }\n  }\n}","import { Expression } from './expression';\n\nexport class InfixApp extends Expression {\n\n  constructor(op, left, right) {\n    super();\n    this.op = op;\n    this.left = left;\n    this.right = right;\n  }\n\n  toString () {\n    const l = this.left.toString();\n    const op = this.op.value;\n    const r = this.right.toString();\n    if(this.parenthesis) {\n      return  `(${l + op + r})`;\n    } else {\n      return l + op + r;\n    }\n  }\n}","import {InfixApp} from './infixApp';\n\nexport class UnaryApp extends InfixApp {\n  \n  constructor (op, left) {\n    super(op, left, null);\n  }\n\n  toString () {\n    const l = this.left.toString();\n    const op = this.op.value;\n    if(this.parenthesis) {\n      return `(${op + l})`;\n    } else {\n      return op + l;\n    }\n  }\n}","export class SourceInfo {\n\n  /**\n    * @param {moo.Token} token\n    *\n    * @return {SourceInfo}\n    * **/\n  static createSourceInfo (token) {\n    return new SourceInfo(token.line, token.col, token.text, token.text.length);\n  }\n\n  /**\n    * @param {moo.Token} tokenA\n    * @param {moo.Token} tokenB\n    *\n    * @return {SourceInfo}\n    * **/\n  static createSourceInfoFromList (tokenA, tokenB) {\n    const line = tokenA.line;\n    const column = tokenA.col;\n    // adapted from https://github.com/UNIVALI-LITE/Portugol-Studio/blob/master/core/src/main/java/br/univali/portugol/nucleo/analise/sintatica/Portugol.g\n    // No idea why...\n    const size = tokenB.offset + 1 - tokenA.offset\n    return new SourceInfo(line, column, \"\", size);\n  }\n\n  /**\n   * @param {number} line\n   * @param {number} column\n   * @param {string} text\n   * @param {number} size\n    * **/\n  constructor (line, column, text, size) {\n    this.line = line;\n    this.column = column;\n    this.text = text;\n    this.size = size;\n  }\n\n}\n","export type Operator = {ord: number; value: string}\n\nexport const Operators = Object.freeze({\n  ADD: {ord: 0, value: \"+\"},\n  SUB: {ord: 1, value: \"-\"},\n  MULT: {ord: 2, value: '*'},\n  DIV: {ord: 3, value: '/'},\n  MOD: {ord: 4, value: '%'},\n  GT: {ord: 5, value: '>'},\n  GE: {ord: 6, value: '>='},\n  LT: {ord: 7, value: '<'},\n  LE: {ord: 8, value: '<='},\n  EQ: {ord: 9, value: '=='},\n  NEQ: {ord: 10, value: '!='},\n  AND: {ord: 11, value: 'and'},\n  OR: {ord: 12, value: 'or'},\n  NOT: {ord: 13, value: 'not'}\n});\n\nexport function convertFromString (op: string): Operator | null  {\n  switch (op) {\n    case '+' : return Operators.ADD;\n    case '-' : return Operators.SUB;\n    case '*' : return Operators.MULT;\n    case '/' : return Operators.DIV;\n    case '%' : return Operators.MOD;\n    case '>' : return Operators.GT;\n    case '>=' : return Operators.GE;\n    case '<' : return Operators.LT;\n    case '<=' : return Operators.LE;\n    case '==' : return Operators.EQ;\n    case '!=' : return Operators.NEQ;\n    case 'and' : return Operators.AND;\n    case 'or' : return Operators.OR;\n    case 'not' : return Operators.NOT;\n  }\n  return null;\n}","export class SyntaxError extends Error {\n  constructor (msg, id) {\n    super(msg);\n    this.id = id;\n    this._context = {};\n    if (Error.captureStackTrace) Error.captureStackTrace(this, SyntaxError);\n  }\n\n  get context () {\n    return this._context;\n  }\n\n  set context (contextObj) {\n    this._context = contextObj;\n  }\n}\n","import {getInstance as LocalizedStrings} from \"./../../services/localizedStringsService.js\";\nimport { SyntaxError } from \"./syntaxError\";\n\n\nfunction createError (message_id, context = []) {\n  const error_message = LocalizedStrings().getError(message_id, context);\n  return new SyntaxError(\n    error_message,\n    message_id\n  );\n}\n\nexport const SyntaxErrorFactory = Object.freeze({\n  extra_lines: () => new SyntaxError(LocalizedStrings().getError(\"extra_lines\")),\n  token_missing_one: (expected, token) => {\n    const context = [expected, token.text, token.line, token.col];\n    const error = createError(\"token_missing_one\", context);\n    error.context = { line: token.line, column: token.col};\n    return error;\n  },\n  token_missing_list: (expectedList, token) => {\n    const line = expectedList.join(LocalizedStrings().getOR());\n    const error = SyntaxErrorFactory.token_missing_one(line, token);\n    error.context = { line: token.line, column: token.col};\n    return error;\n  },\n  id_missing: (token) => {\n    const context = [token.text, token.line, token.col];\n    const error = createError(\"id_missing\", context);\n    error.context = { line: token.line, column: token.col};\n    return error;\n  },\n  eos_missing: (token) => {\n    const context = [token.line, token.col];\n    const error = createError(\"eos_missing\", context);\n    error.context = { line: token.line, column: token.col};\n    return error;\n  },\n  invalid_array_dimension: (typeName, token) => {\n    const context = [token.line, token.col, typeName];\n    const error = createError(\"invalid_array_dimension\", context);\n    error.context = { line: token.line, column: token.col};\n    return error;\n  },\n  invalid_array_size: (token) => {\n    const context = [token.line];\n    const error = createError(\"invalid_array_size\", context);\n    error.context = { line: token.line, column: token.col};\n    return error;\n  },\n  invalid_main_return: (name, typeName, token) => {\n    const context = [name, typeName, token.line];\n    const error = createError(\"invalid_main_return\", context);\n    error.context = { line: token.line, column: token.col};\n    return error;\n  },\n  invalid_var_declaration: (token) => {\n    const context = [token.line];\n    const error = createError(\"invalid_var_declaration\", context);\n    error.context = { line: token.line, column: token.col};\n    return error;\n  },\n  invalid_break_command: (cmdName, token) => {\n    const context = [token.line, cmdName];\n    const error = createError(\"invalid_break_command\", context);\n    error.context = { line: token.line, column: token.col};\n    return error;\n  },\n  invalid_terminal: (token) => {\n    const context = [token.text, token.line, token.col];\n    const error = createError(\"invalid_terminal\", context);\n    error.context = { line: token.line, column: token.col};\n    return error;\n  },\n  invalid_type: (list, token) => {\n    const line = list.join(LocalizedStrings().getOR());\n    const context = [token.text, token.line, token.col, line];\n    const error = createError(\"invalid_type\", context);\n    error.context = { line: token.line, column: token.col};\n    return error;\n  },\n  const_not_init: (token) => {\n    const context = [token.line, token.col];\n    const error = createError(\"const_not_init\", context);\n    error.context = { line: token.line, column: token.col};\n    return error;\n  },\n  invalid_id_format: (token) => {\n    const context = [token.text, token.line, token.col];\n    const error = createError(\"invalid_id_format\", context);\n    error.context = { line: token.line, column: token.col};\n    return error;\n  },\n  duplicate_function: (token) => {\n    const context = [token.text, token.line, token.col];\n    const error = createError(\"duplicate_function\", context);\n    error.context = { line: token.line, column: token.col};\n    return error;\n  },\n  main_parameters: () => {\n    return createError(\"main_parameters\");\n  },\n  duplicate_variable: (token) => {\n    const context = [token.text, token.line, token.col];\n    const error = createError(\"duplicate_variable\", context);\n    error.context = { line: token.line, column: token.col};\n    return error;\n  },\n  invalid_character: (text, line, column) => {\n    const context = [text, line];\n    const error = createError(\"invalid_character\", context);\n    error.context = { line: line, column: column };\n    return error;\n  },\n  annonymous_array_literal: (token) => {\n    const context = [token.line];\n    const error = createError(\"annonymous_array_literal\", context);\n    error.context = { line: token.line, column: token.col};\n    return error;\n  },\n  invalid_matrix_literal_line: (exp, sourceInfo) => {\n    const context = [exp, sourceInfo.line];\n    const error = createError(\"invalid_matrix_literal_line\", context);\n    error.context = { line: sourceInfo.line, column: sourceInfo.column };\n    return error;\n  },\n  cannot_infer_matrix_line: (name, sourceInfo) => {\n    const context = [name, sourceInfo.line];\n    const error = createError(\"cannot_infer_matrix_line\", context);\n    error.context = { line: sourceInfo.line, column: sourceInfo.column };\n    return error;\n  },\n  cannot_infer_matrix_column: (name, sourceInfo) => {\n    const context = [name, sourceInfo.line];\n    const error = createError(\"cannot_infer_matrix_column\", context);\n    error.context = { line: sourceInfo.line, column: sourceInfo.column };\n    return error;\n  },\n  cannot_infer_vector_size: (name, sourceInfo) => {\n    const context = [name, sourceInfo.line];\n    const error = createError(\"cannot_infer_vector_size\", context);\n    error.context = { line: sourceInfo.line, column: sourceInfo.column };\n    return error;\n  },\n  matrix_to_vector_literal_attr: (name, exp, sourceInfo) => {\n    const context = [sourceInfo.line, exp, name];\n    const error = createError(\"matrix_to_vector_literal_attr\", context);\n    error.context = { line: sourceInfo.line, column: sourceInfo.column };\n    return error;\n  },\n  vector_to_matrix_literal_attr: (name, exp, sourceInfo) => {\n    const context = [sourceInfo.line, exp, name];\n    const error = createError(\"vector_to_matrix_literal_attr\", context);\n    error.context = { line: sourceInfo.line, column: sourceInfo.column };\n    return error;\n  },\n  array_init_not_literal: (sourceInfo) => {\n    const context = [sourceInfo.line];\n    const error = createError(\"array_init_not_literal\", context);\n    error.context = { line: sourceInfo.line, column: sourceInfo.column };\n    return error;\n  },\n  array_exceeds_2d: (sourceInfo) => {\n    const context = [sourceInfo.line];\n    const error = createError(\"array_exceeds_2d\", context);\n    error.context = { line: sourceInfo.line, column: sourceInfo.column };\n    return error;\n  },\n  invalid_matrix_id_dimension: (sourceInfo) => {\n    const context = [sourceInfo.line];\n    const error = createError(\"invalid_matrix_id_dimension\", context);\n    error.context = { line: sourceInfo.line, column: sourceInfo.column };\n    return error;\n  },\n  invalid_vector_init: (sourceInfo) => {\n    const context = [sourceInfo.line];\n    const error = createError(\"invalid_vector_init\", context);\n    error.context = { line: sourceInfo.line, column: sourceInfo.column };\n    return error;\n  },\n  invalid_matrix_init: (sourceInfo) => {\n    const context = [sourceInfo.line];\n    const error = createError(\"invalid_matrix_init\", context);\n    error.context = { line: sourceInfo.line, column: sourceInfo.column };\n    return error;\n  },\n  invalid_syntax: (text, line, column) => {\n    const context = [text, line];\n    const error = createError(\"invalid_syntax\", context);\n    error.context = { line: line, column: column };\n    return error;\n  }\n});\n","import * as Expressions from \"./expressions\";\nimport * as Commands from \"./commands\";\nimport * as Parsers from \"../typeSystem/parsers\";\nimport { Types } from \"../typeSystem/types\";\nimport { ArrayType } from \"../typeSystem/array_type\";\nimport { SourceInfo } from \"./sourceInfo\";\nimport { convertFromString } from \"./operators\";\nimport { SyntaxErrorFactory } from \"./error/syntaxErrorFactory\";\nimport { LanguageDefinedFunction } from \"../processor/definedFunctions\";\nimport { LanguageService } from \"../services/languageService\";\n\nexport class IVProgParser {\n  static createParser (input, fill = true) {\n    const lexer = LanguageService.getCurrentLexer();\n    const parser = new IVProgParser(input, lexer);\n    if (fill) {\n      parser.fill();\n    }\n    return parser;\n  }\n\n  // <BEGIN scope consts>\n  static get BASE () {\n    return 0;\n  }\n  static get FUNCTION () {\n    return 1;\n  }\n  static get COMMAND () {\n    return 2;\n  }\n  static get BREAKABLE () {\n    return 4;\n  }\n  // </ END scope consts>\n  //\n  static get EOF_TOKEN () {\n    return {\n      text: null,\n      line: -1,\n      col: -1,\n      value: null,\n      offset: -1,\n      lineBreaks: false,\n      type: \"EOF\",\n    };\n  }\n\n  /**\n   * @param {string} input\n   * @param {IVProgLexer} ivprogLexer\n   **/\n  constructor (input, ivprogLexer) {\n    this.ivprogLexer = ivprogLexer;\n    this.inputStream = input;\n    this.lexer = ivprogLexer.lexer;\n    this.tokenStream = [];\n    this.pos = 0;\n    this.ruleNames = ivprogLexer.getRules();\n    this.variableTypes = Object.entries(this.ivprogLexer.getTypeKeys()).map(\n      ([key, _]) => key\n    );\n    this.functionTypes = this.variableTypes.concat(this.ruleNames.RK_VOID);\n\n    this.parsingArrayDimension = 0;\n    this.scope = [];\n    this.langFuncs = this.ivprogLexer.getLangFuncs();\n    this.definedFuncsNameList = [];\n    this.definedVariablesStack = [];\n  }\n\n  fill (stream = null) {\n    if (stream) {\n      this.tokenStream = stream;\n      return;\n    }\n    this.tokenStream = Array.from(this.lexer.reset(this.inputStream));\n    this.tokenStream = this.tokenStream.filter((token) => {\n      // Throws an exception in case of invalid syntax\n      if (token.type === this.ruleNames.ERROR) {\n        let text = token.text;\n        const line = token.line;\n        const column = token.col;\n        throw SyntaxErrorFactory.invalid_syntax(text, line, column);\n      }\n      // remove all whitespaces token and comments\n      return (\n        token.type !== this.ruleNames.WHITESPACE &&\n        token.type !== this.ruleNames.COMMENTS\n      );\n    });\n  }\n\n  parseTree () {\n    return this.parseProgram();\n  }\n\n  /**\n   * @param {number} index\n   * @return {moo.Token}\n   * */\n  getToken (index = this.pos) {\n    // if(index === null)\n    //   index = this.pos;\n    if (index >= this.tokenStream.length) {\n      return IVProgParser.EOF_TOKEN;\n    }\n    return this.tokenStream[index];\n  }\n\n  insideScope (scope) {\n    if (this.scope.length <= 0) {\n      return IVProgParser.BASE === scope;\n    } else {\n      return this.scope[this.scope.length - 1] === scope;\n    }\n  }\n\n  pushScope (scope) {\n    this.scope.push(scope);\n  }\n\n  pushVariableStack () {\n    this.definedVariablesStack.push([]);\n  }\n\n  popScope () {\n    return this.scope.pop();\n  }\n\n  popVariableStack () {\n    return this.definedVariablesStack.pop();\n  }\n\n  getCurrentVariableStack () {\n    return this.definedVariablesStack[this.definedVariablesStack.length - 1];\n  }\n\n  isEOF () {\n    return this.getToken(this.pos).type === IVProgParser.EOF_TOKEN.type;\n  }\n\n  parseProgram () {\n    this.consumeNewLines();\n    const token = this.getToken();\n    let globalVars = [];\n    let functions = [];\n\n    if (this.ruleNames.RK_PROGRAM === token.type) {\n      this.pos++;\n      this.consumeNewLines();\n      this.checkOpenCurly();\n      this.pos++;\n      this.pushVariableStack();\n      for (;;) {\n        this.consumeNewLines();\n        const token = this.getToken();\n        if (\n          token.type === this.ruleNames.RK_CONST ||\n          this.isVariableType(token)\n        ) {\n          globalVars = globalVars.concat(this.parseGlobalVariables());\n        } else if (token.type === this.ruleNames.RK_FUNCTION) {\n          this.pushVariableStack();\n          functions = functions.concat(this.parseFunction());\n          this.popVariableStack();\n        } else {\n          break;\n        }\n      }\n      this.consumeNewLines();\n      this.checkCloseCurly();\n      this.pos++;\n      this.consumeNewLines();\n      if (!this.isEOF()) {\n        console.log(this.getToken());\n        throw SyntaxErrorFactory.extra_lines();\n      }\n      this.popVariableStack();\n      return { global: globalVars, functions: functions };\n    } else {\n      throw SyntaxErrorFactory.token_missing_one(\n        this.ivprogLexer.getReservedKeys()[this.ruleNames.RK_PROGRAM],\n        token\n      );\n    }\n  }\n\n  checkOpenCurly (attempt = false) {\n    const token = this.getToken();\n    if (this.ruleNames.OPEN_CURLY !== token.type) {\n      if (!attempt) throw SyntaxErrorFactory.token_missing_one(\"{\", token);\n      else return false;\n    }\n    return true;\n  }\n\n  checkCloseCurly (attempt = false) {\n    const token = this.getToken();\n    if (this.ruleNames.CLOSE_CURLY !== token.type) {\n      if (!attempt) throw SyntaxErrorFactory.token_missing_one(\"}\", token);\n      else return false;\n    }\n    return true;\n  }\n\n  /* It checks if the current token at position pos is a ']'.\n   * As a check function it doesn't increment pos.\n   *\n   * @params bool:attempt, indicates that the token is optional. Defaults: false\n   *\n   * @returns true if the attempt is true and current token is '[',\n   *   false is attempt is true and current token is not '['\n   **/\n  checkOpenBrace (attempt = false) {\n    const token = this.getToken();\n    if (this.ruleNames.OPEN_BRACE !== token.type) {\n      if (!attempt) {\n        throw SyntaxErrorFactory.token_missing_one(\"[\", token);\n      } else {\n        return false;\n      }\n    }\n    return true;\n  }\n\n  checkCloseBrace (attempt = false) {\n    const token = this.getToken();\n    if (this.ruleNames.CLOSE_BRACE !== token.type) {\n      if (!attempt) {\n        throw SyntaxErrorFactory.token_missing_one(\"]\", token);\n      } else {\n        return false;\n      }\n    }\n    return true;\n  }\n\n  checkOpenParenthesis (attempt = false) {\n    const token = this.getToken();\n    if (this.ruleNames.OPEN_PARENTHESIS !== token.type) {\n      if (!attempt) {\n        throw SyntaxErrorFactory.token_missing_one(\"(\", token);\n      } else {\n        return false;\n      }\n    }\n    return true;\n  }\n\n  checkCloseParenthesis (attempt = false) {\n    const token = this.getToken();\n    if (this.ruleNames.CLOSE_PARENTHESIS !== token.type) {\n      if (!attempt) {\n        throw SyntaxErrorFactory.token_missing_one(\")\", token);\n      } else {\n        return false;\n      }\n    }\n    return true;\n  }\n\n  checkEOS (attempt = false) {\n    const eosToken = this.getToken();\n    if (eosToken.type !== this.ruleNames.EOS) {\n      if (!attempt) throw SyntaxErrorFactory.eos_missing(eosToken);\n      else return false;\n    }\n    return true;\n  }\n\n  checkFunctionDuplicate (functionID, funcIDToken) {\n    const id = functionID === null ? \"$main\" : functionID;\n    const index = this.definedFuncsNameList.indexOf(id);\n    if (index !== -1) {\n      throw SyntaxErrorFactory.duplicate_function(funcIDToken);\n    }\n    this.definedFuncsNameList.push(id);\n  }\n  checkVariableDuplicate (variableID, sourceInfo) {\n    const index = this.getCurrentVariableStack().indexOf(variableID);\n    if (index !== -1) {\n      throw SyntaxErrorFactory.duplicate_variable(sourceInfo);\n    }\n    this.getCurrentVariableStack().push(variableID);\n  }\n\n  consumeForSemiColon () {\n    const eosToken = this.getToken();\n    if (eosToken.type === this.ruleNames.EOS && eosToken.text.match(\"^;$\")) {\n      this.pos++;\n      return;\n    }\n    throw SyntaxErrorFactory.token_missing_one(\";\", eosToken);\n  }\n\n  parseGlobalVariables () {\n    const decl = this.parseMaybeConst();\n    this.checkEOS();\n    this.pos++;\n    return decl;\n  }\n\n  /*\n   * Checks if the next token is PR_CONST. It's only available\n   * at global variables declaration level\n   * @returns Declararion(const, type, id, initVal?)\n   **/\n  parseMaybeConst () {\n    const constToken = this.getToken();\n    if (constToken.type === this.ruleNames.RK_CONST) {\n      this.pos++;\n      const typeString = this.parseType();\n      return this.parseDeclaration(typeString, true);\n    } else if (this.isVariableType(constToken)) {\n      const typeString = this.parseType();\n      return this.parseDeclaration(typeString);\n    } else {\n      throw SyntaxErrorFactory.token_missing_list(\n        [this.ivprogLexer.getReservedKeys()[this.ruleNames.RK_CONST]].concat(\n          this.getTypeArray()\n        ),\n        constToken\n      );\n    }\n  }\n\n  /**\n   * Parses a declarion of the form: type --- id --- (= --- EAnd)?\n   * @return {Commands.Declartion[]} a list of Declararion(const, type, id, initVal?)\n   **/\n  parseDeclaration (typeString, isConst = false) {\n    let initial = null;\n    let dim1 = null;\n    let dim2 = null;\n    let dimensions = 0;\n    const sourceInfo = SourceInfo.createSourceInfo(this.getToken());\n    const idString = this.parseID();\n    this.checkVariableDuplicate(idString, sourceInfo);\n    // Check for array or vector\n    // ID[int/IDi?][int/IDj?]\n    if (this.checkOpenBrace(true)) {\n      this.pos += 1;\n      this.consumeNewLines();\n      dim1 = this.parseArrayDimension();\n      this.consumeNewLines();\n      this.checkCloseBrace();\n      this.pos += 1;\n      dimensions += 1;\n      if (this.checkOpenBrace(true)) {\n        this.pos += 1;\n        this.consumeNewLines();\n        dim2 = this.parseArrayDimension();\n        this.consumeNewLines();\n        this.checkCloseBrace();\n        this.pos += 1;\n        dimensions += 1;\n      }\n      return this.parseArrayDeclaration(\n        typeString,\n        isConst,\n        idString,\n        sourceInfo,\n        dimensions,\n        dim1,\n        dim2\n      );\n    } else {\n      const assignmentToken = this.getToken();\n      if (isConst && assignmentToken.type !== this.ruleNames.ASSIGNMENT) {\n        throw SyntaxErrorFactory.const_not_init(sourceInfo);\n      }\n      if (assignmentToken.type === this.ruleNames.ASSIGNMENT) {\n        this.pos++;\n        initial = this.parseExpressionOR();\n      }\n      const declaration = new Commands.Declaration(\n        idString,\n        typeString,\n        initial,\n        isConst\n      );\n      declaration.sourceInfo = sourceInfo;\n      const commaToken = this.getToken();\n      if (commaToken.type === this.ruleNames.COMMA) {\n        this.pos++;\n        this.consumeNewLines();\n        return [declaration].concat(this.parseDeclaration(typeString, isConst));\n      } else {\n        return [declaration];\n      }\n    }\n  }\n\n  parseArrayDeclaration (\n    typeString,\n    isConst,\n    idString,\n    sourceInfo,\n    dimensions,\n    dim1,\n    dim2\n  ) {\n    const assignmentToken = this.getToken();\n    let n_lines = dim1;\n    let n_columns = dim2;\n    let initial = null;\n    let dim_is_id = false;\n    if (\n      dim1 instanceof Expressions.VariableLiteral ||\n      dim2 instanceof Expressions.VariableLiteral\n    ) {\n      dim_is_id = true;\n      if (dimensions > 1 && (dim1 == null || dim2 == null)) {\n        throw SyntaxErrorFactory.invalid_matrix_id_dimension(\n          SourceInfo.createSourceInfo(assignmentToken)\n        );\n      }\n    }\n    if (isConst && assignmentToken.type !== this.ruleNames.ASSIGNMENT) {\n      throw SyntaxErrorFactory.const_not_init(sourceInfo);\n    }\n    if (assignmentToken.type === this.ruleNames.ASSIGNMENT) {\n      if (dim_is_id) {\n        if (dimensions == 1) {\n          throw SyntaxErrorFactory.invalid_vector_init(\n            SourceInfo.createSourceInfo(assignmentToken)\n          );\n        } else {\n          throw SyntaxErrorFactory.invalid_matrix_init(\n            SourceInfo.createSourceInfo(assignmentToken)\n          );\n        }\n      }\n      this.pos += 1;\n      initial = this.parseArrayLiteral(typeString);\n    }\n    if (initial == null && dim1 == null) {\n      if (dimensions > 1) {\n        throw SyntaxErrorFactory.cannot_infer_matrix_line(idString, sourceInfo);\n      }\n      throw SyntaxErrorFactory.cannot_infer_vector_size(idString, sourceInfo);\n    }\n    if (dimensions > 1) {\n      if (initial == null && dim2 == null) {\n        throw SyntaxErrorFactory.cannot_infer_matrix_column(\n          idString,\n          sourceInfo\n        );\n      }\n    }\n\n    if (dimensions === 1 && initial != null && !initial.isVector) {\n      const expString = initial.toString();\n      throw SyntaxErrorFactory.matrix_to_vector_literal_attr(\n        idString,\n        expString,\n        initial.sourceInfo\n      );\n    } else if (dimensions > 1 && initial != null && initial.isVector) {\n      const expString = initial.toString();\n      throw SyntaxErrorFactory.vector_to_matrix_literal_attr(\n        idString,\n        expString,\n        initial.sourceInfo\n      );\n    }\n\n    if (dim1 == null) {\n      n_lines = new Expressions.IntLiteral(Parsers.toInt(initial.lines));\n      n_lines.sourceInfo = sourceInfo;\n    }\n\n    if (dimensions > 1) {\n      if (dim2 == null) {\n        n_columns = new Expressions.IntLiteral(Parsers.toInt(initial.columns));\n        n_columns.sourceInfo = sourceInfo;\n      }\n    }\n    const declaration = new Commands.ArrayDeclaration(\n      idString,\n      new ArrayType(typeString, dimensions),\n      n_lines,\n      n_columns,\n      initial,\n      isConst\n    );\n    declaration.sourceInfo = sourceInfo;\n    const commaToken = this.getToken();\n    if (commaToken.type === this.ruleNames.COMMA) {\n      this.pos++;\n      this.consumeNewLines();\n      return [declaration].concat(this.parseDeclaration(typeString, isConst));\n    } else {\n      return [declaration];\n    }\n  }\n\n  consumeNewLines () {\n    let token = this.getToken();\n    while (\n      token &&\n      token.type === this.ruleNames.EOS &&\n      token.text.match(\"^[\\r\\n]+$\")\n    ) {\n      this.pos++;\n      token = this.getToken();\n    }\n  }\n\n  isVariableType (token) {\n    return this.variableTypes.find((v) => v === token.type);\n  }\n\n  /**\n   * Reads the next token of the stream to check if it is a Integer or an ID.\n   * @returns Integer | ID\n   **/\n  parseArrayDimension () {\n    const dimToken = this.getToken();\n    if (dimToken.type === this.ruleNames.INTEGER) {\n      //parse as int literal\n      this.pos++;\n      return this.getIntLiteral(dimToken);\n    } else if (dimToken.type === this.ruleNames.ID) {\n      //parse as variable\n      this.pos++;\n      return this.parseVariable(dimToken);\n    } else if (dimToken.type === this.ruleNames.CLOSE_BRACE) {\n      return null;\n    } else {\n      throw SyntaxErrorFactory.invalid_array_dimension(\n        this.ivprogLexer.getReservedKeys()[this.ruleNames.RK_INTEGER],\n        dimToken\n      );\n    }\n  }\n\n  /**\n   * Returns an object {type: 'int', value: value}.\n   * It checks for binary and hexadecimal integers.\n   * @param {moo.Token} token\n   * @return {Object} object with fields type and value\n   **/\n  getIntLiteral (token) {\n    const text = token.text;\n    const sourceInfo = SourceInfo.createSourceInfo(token);\n    const exp = new Expressions.IntLiteral(Parsers.toInt(text));\n    exp.sourceInfo = sourceInfo;\n    return exp;\n  }\n\n  getRealLiteral (token) {\n    const sourceInfo = SourceInfo.createSourceInfo(token);\n    const exp = new Expressions.RealLiteral(Parsers.toReal(token.text));\n    exp.sourceInfo = sourceInfo;\n    return exp;\n  }\n\n  getStringLiteral (token) {\n    const text = token.text;\n    const sourceInfo = SourceInfo.createSourceInfo(token);\n    const exp = new Expressions.StringLiteral(Parsers.toString(text));\n    exp.sourceInfo = sourceInfo;\n    return exp;\n  }\n\n  getCharLiteral (token) {\n    const text = token.text;\n    const exp = new Expressions.CharLiteral(Parsers.toChar(text));\n    exp.sourceInfo = SourceInfo.createSourceInfo(token);\n    return exp;\n  }\n\n  getBoolLiteral (token) {\n    const val = Parsers.toBool(token.text);\n    const exp = new Expressions.BoolLiteral(val);\n    exp.sourceInfo = SourceInfo.createSourceInfo(token);\n    return exp;\n  }\n\n  parseArrayLiteral (typeString) {\n    const openCurly = this.checkOpenCurly(true);\n    if (!openCurly) {\n      const invalid_token = this.getToken();\n      throw SyntaxErrorFactory.array_init_not_literal(\n        SourceInfo.createSourceInfo(invalid_token)\n      );\n    }\n    const beginArray = this.getToken();\n    if (this.parsingArrayDimension >= 2) {\n      throw SyntaxErrorFactory.array_exceeds_2d(\n        SourceInfo.createSourceInfo(beginArray)\n      );\n    }\n    this.pos += 1;\n    this.parsingArrayDimension += 1;\n    this.consumeNewLines();\n    let data = null;\n    const maybeCurlyOpen = this.checkOpenCurly(true);\n    if (maybeCurlyOpen) {\n      // This is potentially a list of vectors\n      data = this.parseVectorList(typeString);\n    } else {\n      data = this.parseExpressionList();\n    }\n    this.consumeNewLines();\n    this.checkCloseCurly();\n    const endArray = this.getToken();\n    this.pos += 1;\n    this.parsingArrayDimension -= 1;\n    const sourceInfo = SourceInfo.createSourceInfoFromList(\n      beginArray,\n      endArray\n    );\n    let dataDim = 1;\n    if (data[0] instanceof Expressions.ArrayLiteral) {\n      dataDim += 1;\n    } else if (data.length == 1) {\n      console.log(\"Talvez uma variável seja uma melhor opção\");\n    }\n    const type = new ArrayType(typeString, dataDim);\n    const exp = new Expressions.ArrayLiteral(type, data);\n    exp.sourceInfo = sourceInfo;\n    return exp;\n  }\n\n  /**\n   * Returns a list of ArrayLiterals. Helper function for parsing matrices\n   */\n  parseVectorList (typeString) {\n    const list = [];\n    let lastSize = null;\n    for (;;) {\n      this.checkOpenCurly();\n      const beginArray = this.getToken();\n      if (this.parsingArrayDimension >= 2) {\n        throw SyntaxErrorFactory.array_exceeds_2d(\n          SourceInfo.createSourceInfo(beginArray)\n        );\n      }\n      this.pos += 1;\n      this.parsingArrayDimension += 1;\n      this.consumeNewLines();\n      const data = this.parseExpressionList();\n      this.consumeNewLines();\n      this.checkCloseCurly();\n      const endArray = this.getToken();\n      this.pos += 1;\n      this.parsingArrayDimension -= 1;\n      const sourceInfo = SourceInfo.createSourceInfoFromList(\n        beginArray,\n        endArray\n      );\n      if (lastSize == null) {\n        lastSize = data.length;\n      } else if (lastSize !== data.length) {\n        const expString = this.inputStream.substring(\n          beginArray.offset,\n          endArray.offset + endArray.text.length\n        );\n        throw SyntaxErrorFactory.invalid_matrix_literal_line(\n          expString,\n          sourceInfo\n        );\n      }\n      const type = new ArrayType(typeString, 1);\n      const exp = new Expressions.ArrayLiteral(type, data);\n      exp.sourceInfo = sourceInfo;\n      list.push(exp);\n      const commaToken = this.getToken();\n      if (commaToken.type !== this.ruleNames.COMMA) {\n        break;\n      }\n      this.pos += 1;\n      this.consumeNewLines();\n    }\n    if (list.length == 1) {\n      console.log(\"Talvez um vetor seja uma melhor opção\");\n    }\n    return list;\n  }\n\n  /*\n   * Returns an object {type: 'variable', value: value}.\n   * @returns object with fields type and value\n   **/\n  parseVariable (token) {\n    const sourceInfo = SourceInfo.createSourceInfo(token);\n    const exp = new Expressions.VariableLiteral(token.text);\n    exp.sourceInfo = sourceInfo;\n    return exp;\n  }\n\n  /*\n   * Returns an object representing a function. It has\n   * four attributes: returnType, id, formalParams and block.\n   * The block object has two attributes: declarations and commands\n   **/\n  parseFunction () {\n    this.pushScope(IVProgParser.FUNCTION);\n    let formalParams = [];\n    const token = this.getToken();\n    if (token.type !== this.ruleNames.RK_FUNCTION) {\n      //throw SyntaxError.createError(this.lexer.literalNames[this.lexerClass.PR_FUNCAO], token);\n      return null;\n    }\n    this.pos++;\n    const funType = this.parseType();\n    let dimensions = 0;\n    if (this.checkOpenBrace(true)) {\n      this.pos++;\n      this.checkCloseBrace();\n      this.pos++;\n      dimensions++;\n      if (this.checkOpenBrace(true)) {\n        this.pos++;\n        this.checkCloseBrace();\n        this.pos++;\n        dimensions++;\n      }\n    }\n    const funcIDToken = this.getToken();\n    const functionID = this.parseID();\n    this.checkFunctionDuplicate(functionID, funcIDToken);\n    this.checkOpenParenthesis();\n    this.pos++;\n    this.consumeNewLines();\n    if (!this.checkCloseParenthesis(true)) {\n      formalParams = this.parseFormalParameters(); // formal parameters\n      this.consumeNewLines();\n      this.checkCloseParenthesis();\n      this.pos++;\n    } else {\n      this.pos++;\n    }\n    this.consumeNewLines();\n    const commandsBlock = this.parseCommandBlock();\n    let returnType = funType;\n    if (dimensions > 0) {\n      returnType = new ArrayType(funType, dimensions);\n    }\n    const func = new Commands.Function(\n      functionID,\n      returnType,\n      formalParams,\n      commandsBlock\n    );\n    if (functionID === null && !func.isMain) {\n      throw SyntaxErrorFactory.invalid_main_return(\n        LanguageDefinedFunction.getMainFunctionName(),\n        this.ivprogLexer.getReservedKeys()[this.ruleNames.RK_VOID],\n        token.line\n      );\n    } else if (func.isMain && formalParams.length !== 0) {\n      throw SyntaxErrorFactory.main_parameters();\n    }\n    this.popScope();\n    func.sourceInfo = SourceInfo.createSourceInfo(funcIDToken);\n    return func;\n  }\n\n  /*\n   * Parse the formal parameters of a function.\n   * @returns a list of objects with the following attributes: type, id and dimensions.\n   **/\n  parseFormalParameters () {\n    const list = [];\n    for (;;) {\n      let dimensions = 0;\n      let reference = false;\n      const typeString = this.parseType();\n      let maybeIDToken = this.getToken();\n      if (maybeIDToken.type === this.ruleNames.RK_REFERENCE) {\n        reference = true;\n        this.pos += 1;\n        maybeIDToken = this.getToken();\n      }\n      const idString = this.parseID();\n      this.checkVariableDuplicate(idString, maybeIDToken);\n      if (this.checkOpenBrace(true)) {\n        this.pos += 1;\n        dimensions += 1;\n        this.checkCloseBrace();\n        this.pos += 1;\n        if (this.checkOpenBrace(true)) {\n          this.pos += 1;\n          dimensions += 1;\n          this.checkCloseBrace();\n          this.pos += 1;\n        }\n      }\n      let type = null;\n      if (dimensions > 0) {\n        type = new ArrayType(typeString, dimensions);\n      } else {\n        type = typeString;\n      }\n      const parameter = new Commands.FormalParameter(type, idString, reference);\n      parameter.sourceInfo = SourceInfo.createSourceInfo(maybeIDToken);\n      list.push(parameter);\n      const commaToken = this.getToken();\n      if (commaToken.type !== this.ruleNames.COMMA) break;\n      this.pos++;\n      this.consumeNewLines();\n    }\n    return list;\n  }\n\n  parseID () {\n    const token = this.getToken();\n    if (token.type !== this.ruleNames.ID) {\n      throw SyntaxErrorFactory.id_missing(token);\n    }\n    this.pos++;\n    if (this.insideScope(IVProgParser.FUNCTION)) {\n      if (token.text === LanguageDefinedFunction.getMainFunctionName()) {\n        return null;\n      }\n    }\n    return token.text;\n  }\n\n  /**\n   * @return {string}\n   **/\n  parseMaybeLibID () {\n    const token = this.getToken();\n    if (token.type !== this.ruleNames.ID) {\n      throw SyntaxErrorFactory.id_missing(token);\n    }\n    const maybeDOT = this.getToken(this.pos + 1);\n    if (maybeDOT.type === this.ruleNames.DOT) {\n      this.pos += 2;\n      const anotherID = this.getToken();\n      if (anotherID.type !== this.ruleNames.ID) {\n        throw SyntaxErrorFactory.id_missing(anotherID);\n      }\n      this.pos++;\n      return `${token.text}.${anotherID.text}`;\n    }\n    this.pos++;\n    return token.text;\n  }\n\n  parseType () {\n    const token = this.getToken();\n    if (\n      token.type === this.ruleNames.ID &&\n      this.insideScope(IVProgParser.FUNCTION)\n    ) {\n      return Types.VOID;\n    } else if (\n      token.type === this.ruleNames.RK_VOID &&\n      this.insideScope(IVProgParser.FUNCTION)\n    ) {\n      this.pos++;\n      return Types.VOID;\n    } else if (this.isVariableType(token)) {\n      this.pos++;\n      switch (token.type) {\n        case this.ruleNames.RK_INTEGER:\n          return Types.INTEGER;\n        case this.ruleNames.RK_BOOLEAN:\n          return Types.BOOLEAN;\n        case this.ruleNames.RK_REAL:\n          return Types.REAL;\n        case this.ruleNames.RK_STRING:\n          return Types.STRING;\n        case this.ruleNames.RK_CHARACTER:\n          return Types.CHAR;\n        default:\n          break;\n      }\n    }\n\n    throw SyntaxErrorFactory.invalid_type(this.getTypeArray(), token);\n  }\n\n  parseCommandBlock (optionalCurly = false) {\n    let variablesDecl = [];\n    const commands = [];\n    let hasOpen = false;\n    if (this.checkOpenCurly(optionalCurly)) {\n      this.pos++;\n      hasOpen = true;\n    }\n    this.consumeNewLines();\n    let parsedCommand = false;\n    for (;;) {\n      const cmd = this.parseCommand();\n      if (cmd === null) break;\n      if (cmd !== -1) {\n        if (cmd instanceof Array) {\n          if (parsedCommand) {\n            const lastToken = this.getToken(this.pos - 1);\n            throw SyntaxErrorFactory.invalid_var_declaration(lastToken);\n          }\n          variablesDecl = variablesDecl.concat(cmd);\n        } else {\n          parsedCommand = true;\n          commands.push(cmd);\n        }\n      }\n    }\n    this.consumeNewLines();\n    if (hasOpen) {\n      this.checkCloseCurly();\n      this.pos++;\n      this.consumeNewLines();\n    }\n    return new Commands.CommandBlock(variablesDecl, commands);\n  }\n\n  parseCommand () {\n    const token = this.getToken();\n    if (this.isVariableType(token)) {\n      if (!this.insideScope(IVProgParser.FUNCTION)) {\n        throw SyntaxErrorFactory.invalid_var_declaration(token);\n      }\n      this.pushScope(IVProgParser.BASE);\n      const varType = this.parseType();\n      this.popScope();\n      const cmd = this.parseDeclaration(varType);\n      this.checkEOS();\n      this.pos++;\n      return cmd;\n    } else if (token.type === this.ruleNames.ID) {\n      return this.parseIDCommand();\n    } else if (token.type === this.ruleNames.DOT) {\n      // TODO Check if this is relevant since DOT is a replacement for antlr4 LIB_ID :=> ID . ID\n      throw SyntaxErrorFactory.invalid_syntax(\n        token.text,\n        token.line,\n        token.col\n      );\n    } else if (token.type === this.ruleNames.RK_RETURN) {\n      return this.parseReturn();\n    } else if (\n      token.type === this.ruleNames.RK_WHILE ||\n      token.type === this.ruleNames.RK_WHILE_ALT\n    ) {\n      return this.parseWhile();\n    } else if (\n      token.type === this.ruleNames.RK_FOR ||\n      token.type === this.ruleNames.RK_FOR_ALT\n    ) {\n      return this.parseFor();\n    } else if (token.type === this.ruleNames.RK_BREAK) {\n      if (!this.insideScope(IVProgParser.BREAKABLE)) {\n        throw SyntaxErrorFactory.invalid_break_command(\n          this.ivprogLexer.getReservedKeys()[this.ruleNames.RK_BREAK],\n          token\n        );\n      }\n      return this.parseBreak();\n    } else if (token.type === this.ruleNames.RK_SWITCH) {\n      return this.parseSwitchCase();\n    } else if (token.type === this.ruleNames.RK_DO) {\n      return this.parseRepeatUntil();\n    } else if (token.type === this.ruleNames.RK_IF) {\n      return this.parseIfThenElse();\n    } else if (this.checkEOS(true)) {\n      this.pos++;\n      return -1;\n    } else {\n      return null;\n    }\n  }\n\n  parseSwitchCase () {\n    const token = this.getToken();\n    this.pushScope(IVProgParser.BREAKABLE);\n    this.pos++;\n    this.checkOpenParenthesis();\n    this.pos++;\n    this.consumeNewLines();\n    const exp = this.parseExpressionOR();\n    this.consumeNewLines();\n    this.checkCloseParenthesis();\n    this.pos++;\n    this.consumeNewLines();\n    this.checkOpenCurly();\n    this.pos++;\n    this.consumeNewLines();\n    const casesList = this.parseCases();\n    this.consumeNewLines();\n    this.checkCloseCurly();\n    this.pos++;\n    this.consumeNewLines();\n\n    this.popScope();\n    const command = new Commands.Switch(exp, casesList);\n    command.sourceInfo = SourceInfo.createSourceInfo(token);\n    return command;\n  }\n\n  parseRepeatUntil () {\n    const token = this.getToken();\n    this.pos++;\n    this.consumeNewLines();\n    this.pushScope(IVProgParser.BREAKABLE);\n    const commandsBlock = this.parseCommandBlock();\n    this.consumeNewLines(); //Maybe not...\n    const whileToken = this.getToken();\n    if (whileToken.type !== this.ruleNames.RK_DO_UNTIL) {\n      throw SyntaxErrorFactory.token_missing_one(\n        this.ivprogLexer.getReservedKeys()[this.ruleNames.RK_DO_UNTIL],\n        whileToken\n      );\n    }\n    this.pos++;\n    this.checkOpenParenthesis();\n    this.pos++;\n    this.consumeNewLines();\n    const condition = this.parseExpressionOR();\n    this.consumeNewLines();\n    this.checkCloseParenthesis();\n    this.pos++;\n    this.checkEOS();\n    this.popScope();\n    const command = new Commands.RepeatUntil(condition, commandsBlock);\n    command.sourceInfo = SourceInfo.createSourceInfo(token);\n    return command;\n  }\n\n  parseIfThenElse () {\n    if (this.insideScope(IVProgParser.BREAKABLE)) {\n      this.pushScope(IVProgParser.BREAKABLE);\n    } else {\n      this.pushScope(IVProgParser.COMMAND);\n    }\n    const token = this.getToken();\n    this.pos++;\n    this.checkOpenParenthesis();\n    this.pos++;\n    this.consumeNewLines();\n    const logicalExpression = this.parseExpressionOR();\n    this.consumeNewLines();\n    this.checkCloseParenthesis();\n    this.pos++;\n    this.consumeNewLines();\n    const cmdBlocks = this.parseCommandBlock();\n\n    const maybeElse = this.getToken();\n    if (maybeElse.type === this.ruleNames.RK_ELSE) {\n      this.pos++;\n      this.consumeNewLines();\n      const maybeIf = this.getToken();\n      let elseBlock = null;\n      if (this.checkOpenCurly(true)) {\n        elseBlock = this.parseCommandBlock();\n      } else if (maybeIf.type === this.ruleNames.RK_IF) {\n        elseBlock = this.parseIfThenElse();\n      } else {\n        throw SyntaxErrorFactory.token_missing_list(\n          [this.ivprogLexer.getReservedKeys()[this.ruleNames.RK_IF], \"{\"],\n          maybeIf\n        );\n      }\n      this.popScope();\n      const cmd = new Commands.IfThenElse(\n        logicalExpression,\n        cmdBlocks,\n        elseBlock\n      );\n      cmd.sourceInfo = SourceInfo.createSourceInfo(token);\n      return cmd;\n    }\n    this.popScope();\n\n    const cmd = new Commands.IfThenElse(logicalExpression, cmdBlocks, null);\n    cmd.sourceInfo = SourceInfo.createSourceInfo(token);\n    return cmd;\n  }\n\n  parseFor () {\n    this.pushScope(IVProgParser.BREAKABLE);\n    const for_token = this.getToken();\n    this.pos += 1;\n    // parse ID\n    const id_token = this.getToken();\n    const id = this.parseID();\n    const for_id = new Expressions.VariableLiteral(id);\n    for_id.sourceInfo = SourceInfo.createSourceInfo(id_token);\n    // END parse ID\n    const for_from = this.parseForParameters(this.ruleNames.RK_FOR_FROM);\n    const for_to = this.parseForParameters(this.ruleNames.RK_FOR_TO);\n    const maybePass = this.parseForParameters(this.ruleNames.RK_FOR_PASS);\n    this.consumeNewLines();\n    const commandsBlock = this.parseCommandBlock();\n    this.popScope();\n    const cmd = new Commands.For(\n      for_id,\n      for_from,\n      for_to,\n      maybePass,\n      commandsBlock\n    );\n    cmd.sourceInfo = SourceInfo.createSourceInfo(for_token);\n    return cmd;\n  }\n\n  parseWhile () {\n    this.pushScope(IVProgParser.BREAKABLE);\n    const token = this.getToken();\n    this.pos++;\n    this.checkOpenParenthesis();\n    this.pos++;\n    this.consumeNewLines();\n    const logicalExpression = this.parseExpressionOR();\n    this.consumeNewLines();\n    this.checkCloseParenthesis();\n    this.pos++;\n    this.consumeNewLines();\n    const cmdBlocks = this.parseCommandBlock();\n    this.popScope();\n    const cmd = new Commands.While(logicalExpression, cmdBlocks);\n    cmd.sourceInfo = SourceInfo.createSourceInfo(token);\n    return cmd;\n  }\n\n  parseBreak () {\n    const token = this.getToken();\n    this.pos++;\n    this.checkEOS();\n    this.pos++;\n    const command = new Commands.Break();\n    command.sourceInfo = SourceInfo.createSourceInfo(token);\n    return command;\n  }\n\n  parseReturn () {\n    const token = this.getToken();\n    this.pos++;\n    let exp = null;\n    if (!this.checkEOS(true)) {\n      exp = this.parseExpressionOR();\n      this.checkEOS();\n    }\n    this.pos++;\n    const returnCommand = new Commands.Return(exp);\n    returnCommand.sourceInfo = SourceInfo.createSourceInfo(token);\n    return returnCommand;\n  }\n\n  parseIDCommand () {\n    const refToken = this.getToken();\n    const id = this.parseMaybeLibID();\n    const isID = id.indexOf(\".\") === -1;\n    if (this.checkOpenBrace(true)) {\n      this.pos++;\n      let lineExpression = null;\n      let columnExpression = null;\n      this.consumeNewLines();\n      lineExpression = this.parseExpression();\n      this.consumeNewLines();\n      this.checkCloseBrace();\n      this.pos++;\n      if (this.checkOpenBrace(true)) {\n        this.pos++;\n        this.consumeNewLines();\n        columnExpression = this.parseExpression();\n        this.consumeNewLines();\n        this.checkCloseBrace();\n        this.pos++;\n      }\n      const assignmentToken = this.getToken();\n      if (assignmentToken.type !== this.ruleNames.ASSIGNMENT) {\n        // TODO BETTER MESSAGE\n        throw SyntaxErrorFactory.token_missing_one(\"<-\", assignmentToken);\n      }\n      this.pos++;\n      const exp = this.parseExpressionOR();\n      this.checkEOS();\n      this.pos++;\n      const cmd = new Commands.ArrayIndexAssign(\n        id,\n        lineExpression,\n        columnExpression,\n        exp\n      );\n      cmd.sourceInfo = SourceInfo.createSourceInfo(assignmentToken);\n      return cmd;\n    }\n    const assignmentOrParenthesis = this.getToken();\n    if (isID && assignmentOrParenthesis.type === this.ruleNames.ASSIGNMENT) {\n      this.pos++;\n      const exp = this.parseExpressionOR();\n      this.checkEOS();\n      this.pos++;\n      const cmd = new Commands.Assign(id, exp);\n      cmd.sourceInfo = SourceInfo.createSourceInfo(assignmentOrParenthesis);\n      return cmd;\n    } else if (\n      assignmentOrParenthesis.type === this.ruleNames.OPEN_PARENTHESIS\n    ) {\n      const funcCall = this.parseFunctionCallCommand(id);\n      this.checkEOS();\n      this.pos++;\n      return funcCall;\n    } else if (isID) {\n      throw SyntaxErrorFactory.token_missing_list(\n        [\"<-\", \"(\"],\n        assignmentOrParenthesis\n      );\n    } else {\n      throw SyntaxErrorFactory.invalid_id_format(refToken);\n    }\n  }\n\n  parseForParameters (keyword_code) {\n    if (keyword_code === this.ruleNames.RK_FOR_PASS) {\n      if (this.checkOpenCurly(true)) {\n        return null;\n      }\n    }\n    const from_token = this.getToken();\n    if (from_token.type !== keyword_code) {\n      // TODO better error message\n      const keyword = this.ivprogLexer.getReservedKeys()[keyword_code];\n      throw new Error(\n        \"Error de sintaxe no comando repita_para: esperava-se \" +\n          keyword +\n          \" mas encontrou \" +\n          from_token.text\n      );\n    }\n    this.pos += 1;\n    let int_or_id = this.getToken();\n    let is_unary_op = false;\n    let op = null;\n    if (int_or_id.type === this.ruleNames.SUM_OP) {\n      is_unary_op = true;\n      op = int_or_id.text;\n      this.pos += 1;\n      int_or_id = this.getToken();\n    }\n    let for_from = null;\n    if (int_or_id.type === this.ruleNames.ID) {\n      for_from = new Expressions.VariableLiteral(this.parseID());\n      for_from.sourceInfo = SourceInfo.createSourceInfo(int_or_id);\n    } else if (int_or_id.type === this.ruleNames.INTEGER) {\n      this.pos += 1;\n      for_from = this.getIntLiteral(int_or_id);\n    }\n    if (for_from == null) {\n      // TODO better error message\n      const keyword = this.ivprogLexer.getReservedKeys()[keyword_code];\n      throw new Error(\n        \"Error de sintaxe no comando repeita_para: \" +\n          int_or_id.text +\n          \" não é compativel com o esperado para o paramentro \" +\n          keyword +\n          \". O valor deve ser um inteiro ou variável.\"\n      );\n    }\n    if (is_unary_op) {\n      for_from = new Expressions.UnaryApp(convertFromString(op), for_from);\n    }\n    return for_from;\n  }\n\n  parseCases () {\n    const token = this.getToken();\n    if (token.type !== this.ruleNames.RK_CASE) {\n      throw SyntaxErrorFactory.token_missing_one(\n        this.ivprogLexer.getReservedKeys()[this.ruleNames.RK_CASE],\n        token\n      );\n    }\n    this.pos++;\n    const nextToken = this.getToken();\n    if (nextToken.type === this.ruleNames.RK_DEFAULT) {\n      this.pos++;\n      const colonToken = this.getToken();\n      if (colonToken.type !== this.ruleNames.COLON) {\n        throw SyntaxErrorFactory.token_missing_one(\":\", colonToken);\n      }\n      this.pos++;\n      this.consumeNewLines();\n      const block = this.parseCommandBlock(true);\n      const defaultCase = new Commands.Case(null);\n      defaultCase.sourceInfo = SourceInfo.createSourceInfo(token);\n      defaultCase.setCommands(block.commands);\n      return [defaultCase];\n    } else {\n      const exp = this.parseExpressionOR();\n      const colonToken = this.getToken();\n      if (colonToken.type !== this.ruleNames.COLON) {\n        throw SyntaxErrorFactory.token_missing_one(\":\", colonToken);\n      }\n      this.pos++;\n      this.consumeNewLines();\n      const block = this.parseCommandBlock(true);\n      const aCase = new Commands.Case(exp);\n      aCase.sourceInfo = SourceInfo.createSourceInfo(token);\n      aCase.setCommands(block.commands);\n      const caseToken = this.getToken();\n      if (caseToken.type === this.ruleNames.RK_CASE) {\n        return [aCase].concat(this.parseCases());\n      } else {\n        return [aCase];\n      }\n    }\n  }\n\n  /*\n   * Parses an Expression following the structure:\n   *\n   * EOR  => EAnd ( 'or' EOR)? #expression and\n   *\n   * EAnd   => ENot ('and' EAnd)? #expression or\n   *\n   * ENot  => 'not'? ER #expression not\n   *\n   * ER    => E ((>=, <=, ==, >, <) ER)? #expression relational\n   *\n   * E     => factor ((+, -) E)? #expression\n   *\n   * factor=> term ((*, /, %) factor)?\n   *\n   * term  => literal || arrayAccess || FuncCall || ID || '('EOR')'\n   **/\n  parseExpressionOR () {\n    let exp1 = this.parseExpressionAND();\n    while (this.getToken().type === this.ruleNames.RK_LOGICAL_OR) {\n      const opToken = this.getToken();\n      this.pos++;\n      const or = convertFromString(\"or\");\n      this.consumeNewLines();\n      const exp2 = this.parseExpressionAND();\n      const finalExp = new Expressions.InfixApp(or, exp1, exp2);\n      finalExp.sourceInfo = SourceInfo.createSourceInfo(opToken);\n      exp1 = finalExp;\n    }\n    return exp1;\n  }\n\n  parseExpressionAND () {\n    let exp1 = this.parseExpressionNot();\n    while (this.getToken().type === this.ruleNames.RK_LOGICAL_AND) {\n      const opToken = this.getToken();\n      this.pos++;\n      const and = convertFromString(\"and\");\n      this.consumeNewLines();\n      const exp2 = this.parseExpressionNot();\n      const finalExp = new Expressions.InfixApp(and, exp1, exp2);\n      finalExp.sourceInfo = SourceInfo.createSourceInfo(opToken);\n      exp1 = finalExp;\n    }\n    return exp1;\n  }\n\n  parseExpressionNot () {\n    const maybeNotToken = this.getToken();\n    if (maybeNotToken.type === this.ruleNames.RK_LOGICAL_NOT) {\n      const opToken = this.getToken();\n      this.pos++;\n      const not = convertFromString(\"not\");\n      const exp1 = this.parseExpressionRel();\n      const finalExp = new Expressions.UnaryApp(not, exp1);\n      finalExp.sourceInfo = SourceInfo.createSourceInfo(opToken);\n      return finalExp;\n    } else {\n      return this.parseExpressionRel();\n    }\n  }\n\n  parseExpressionRel () {\n    let exp1 = this.parseExpression();\n    while (this.getToken().type === this.ruleNames.RELATIONAL_OPERATOR) {\n      const relToken = this.getToken();\n      this.pos++;\n      const rel = convertFromString(relToken.text);\n      const exp2 = this.parseExpression();\n      const finalExp = new Expressions.InfixApp(rel, exp1, exp2);\n      finalExp.sourceInfo = SourceInfo.createSourceInfo(relToken);\n      exp1 = finalExp;\n    }\n    return exp1;\n  }\n\n  parseExpression () {\n    let factor = this.parseFactor();\n    while (this.getToken().type === this.ruleNames.SUM_OP) {\n      const sumOpToken = this.getToken();\n      this.pos++;\n      const op = convertFromString(sumOpToken.text);\n      const factor2 = this.parseFactor();\n      const finalExp = new Expressions.InfixApp(op, factor, factor2);\n      finalExp.sourceInfo = SourceInfo.createSourceInfo(sumOpToken);\n      factor = finalExp;\n    }\n    return factor;\n  }\n\n  parseFactor () {\n    let term = this.parseTerm();\n    while (this.getToken().type === this.ruleNames.MULTI_OP) {\n      const multOpToken = this.getToken();\n      this.pos++;\n      const op = convertFromString(multOpToken.text);\n      const term2 = this.parseTerm();\n      const finalExp = new Expressions.InfixApp(op, term, term2);\n      finalExp.sourceInfo = SourceInfo.createSourceInfo(multOpToken);\n      term = finalExp;\n    }\n    return term;\n  }\n\n  parseTerm () {\n    const token = this.getToken();\n    let sourceInfo = null;\n    let exp = null;\n    switch (token.type) {\n      case this.ruleNames.SUM_OP:\n        this.pos++;\n        sourceInfo = SourceInfo.createSourceInfo(token);\n        exp = new Expressions.UnaryApp(\n          convertFromString(token.text),\n          this.parseTerm()\n        );\n        exp.sourceInfo = sourceInfo;\n        return exp;\n      case this.ruleNames.INTEGER:\n        this.pos++;\n        return this.getIntLiteral(token);\n      case this.ruleNames.REAL:\n        this.pos++;\n        return this.getRealLiteral(token);\n      case this.ruleNames.STRING:\n        this.pos++;\n        return this.getStringLiteral(token);\n      case this.ruleNames.CHARACTER:\n        this.pos++;\n        return this.getCharLiteral(token);\n      case this.ruleNames.RK_TRUE:\n      case this.ruleNames.RK_FALSE:\n        this.pos++;\n        return this.getBoolLiteral(token);\n      case this.ruleNames.OPEN_CURLY:\n        // No more annonymous array\n        // return this.parseArrayLiteral();\n        throw SyntaxErrorFactory.annonymous_array_literal(token);\n      case this.ruleNames.ID:\n        return this.parseIDTerm();\n      case this.ruleNames.OPEN_PARENTHESIS:\n        return this.parseParenthesisExp();\n      default:\n        throw SyntaxErrorFactory.invalid_terminal(token);\n    }\n  }\n\n  parseIDTerm () {\n    const tokenA = this.getToken();\n    const id = this.parseMaybeLibID();\n    const isID = id.indexOf(\".\") === -1;\n    if (isID && this.checkOpenBrace(true)) {\n      let tokenB = null;\n      this.pos++;\n      const firstIndex = this.parseExpression();\n      let secondIndex = null;\n      this.consumeNewLines();\n      this.checkCloseBrace();\n      tokenB = this.getToken();\n      this.pos++;\n      if (this.checkOpenBrace(true)) {\n        this.pos++;\n        secondIndex = this.parseExpression();\n        this.consumeNewLines();\n        this.checkCloseBrace();\n        tokenB = this.getToken();\n        this.pos++;\n      }\n      const sourceInfo = SourceInfo.createSourceInfoFromList(tokenA, tokenB);\n      const exp = new Expressions.ArrayAccess(id, firstIndex, secondIndex);\n      exp.sourceInfo = sourceInfo;\n      return exp;\n    } else if (this.checkOpenParenthesis(true)) {\n      return this.parseFunctionCallExpression(id);\n    } else if (isID) {\n      const sourceInfo = SourceInfo.createSourceInfo(tokenA);\n      const exp = new Expressions.VariableLiteral(id);\n      exp.sourceInfo = sourceInfo;\n      return exp;\n    } else {\n      throw SyntaxErrorFactory.invalid_id_format(tokenA);\n    }\n  }\n\n  getFunctionName (id) {\n    const name = LanguageDefinedFunction.getInternalName(id);\n    if (name === null) {\n      if (id === LanguageDefinedFunction.getMainFunctionName()) {\n        return null;\n      }\n      return id;\n    } else {\n      return name;\n    }\n  }\n\n  parseFunctionCallExpression (id) {\n    const stepBack = id.indexOf(\".\") === -1 ? 1 : 3;\n    const tokenA = this.getToken(this.pos - stepBack);\n    const actualParameters = this.parseActualParameters();\n    const tokenB = this.getToken(this.pos - 1);\n    const funcName = this.getFunctionName(id);\n    const sourceInfo = SourceInfo.createSourceInfoFromList(tokenA, tokenB);\n    const cmd = new Expressions.FunctionCall(funcName, actualParameters);\n    cmd.sourceInfo = sourceInfo;\n    return cmd;\n  }\n\n  parseFunctionCallCommand (id) {\n    return this.parseFunctionCallExpression(id);\n  }\n\n  parseParenthesisExp () {\n    this.checkOpenParenthesis();\n    const tokenA = this.getToken();\n    this.pos += 1;\n    this.consumeNewLines();\n    const exp = this.parseExpressionOR();\n    this.consumeNewLines();\n    this.checkCloseParenthesis();\n    const tokenB = this.getToken();\n    this.pos += 1;\n    exp.sourceInfo = SourceInfo.createSourceInfoFromList(tokenA, tokenB);\n    exp.parenthesis = true;\n    return exp;\n  }\n\n  parseActualParameters () {\n    this.checkOpenParenthesis();\n    this.pos++;\n    if (this.checkCloseParenthesis(true)) {\n      this.pos++;\n      return [];\n    }\n    this.consumeNewLines();\n    const list = this.parseExpressionList();\n    this.consumeNewLines();\n    this.checkCloseParenthesis();\n    this.pos++;\n    return list;\n  }\n\n  parseExpressionList () {\n    const list = [];\n    for (;;) {\n      const exp = this.parseExpressionOR();\n      list.push(exp);\n      const maybeToken = this.getToken();\n      if (maybeToken.type !== this.ruleNames.COMMA) {\n        break;\n      } else {\n        this.pos++;\n        this.consumeNewLines();\n      }\n    }\n    return list;\n  }\n\n  getTypeArray () {\n    const types = this.insideScope(IVProgParser.FUNCTION)\n      ? this.functionTypes\n      : this.variableTypes;\n    return types.map((x) => this.lexer.literalNames[x]);\n  }\n}\n","import arrayWithoutHoles from \"./arrayWithoutHoles.js\";\nimport iterableToArray from \"./iterableToArray.js\";\nimport unsupportedIterableToArray from \"./unsupportedIterableToArray.js\";\nimport nonIterableSpread from \"./nonIterableSpread.js\";\nexport default function _toConsumableArray(arr) {\n  return arrayWithoutHoles(arr) || iterableToArray(arr) || unsupportedIterableToArray(arr) || nonIterableSpread();\n}","import arrayLikeToArray from \"./arrayLikeToArray.js\";\nexport default function _arrayWithoutHoles(arr) {\n  if (Array.isArray(arr)) return arrayLikeToArray(arr);\n}","export default function _iterableToArray(iter) {\n  if (typeof Symbol !== \"undefined\" && iter[Symbol.iterator] != null || iter[\"@@iterator\"] != null) return Array.from(iter);\n}","export default function _nonIterableSpread() {\n  throw new TypeError(\"Invalid attempt to spread non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.\");\n}","import * as Commands from './../../ast/commands';\nimport { Types } from './../../typeSystem/types';\nimport * as Parsers from \"./../../typeSystem/parsers\";\nimport { Decimal } from 'decimal.js';\nimport { MultiType } from '../../typeSystem/multiType';\nimport { ArrayType } from '../../typeSystem/array_type';\nimport { Modes } from '../modes';\nimport { StoreValue } from '../store/value/store_value';\nimport { ProcessorErrorFactory } from '../error/processorErrorFactory';\n\n/**\n * sin\n * cos\n * tan\n * sqrt\n * pow\n * log\n * abs\n * negate\n * invert\n * max\n * min\n */\n\nfunction convertToRadians (degrees) {\n  return degrees.times(Decimal.acos(-1)).div(180);\n}\n\nexport function createSinFun () {\n   const sinFun = async (sto, _) => {\n     const x = sto.applyStore('x');\n     const angle = x.get().mod(360);\n     let result = null;\n     if(angle.eq(90)) {\n       result = new Decimal(1);\n     } else if (angle.eq(180)) {\n      result = new Decimal(0);\n     } else if (angle.eq(270)) {\n       result = new Decimal(-1);\n     } else {\n       result = Decimal.sin(convertToRadians(angle));\n     }\n     const temp = new StoreValue(Types.REAL, result);\n     sto.insertStore(\"$\", temp);\n     sto.mode = Modes.RETURN;\n     return sto;\n   };\n\n  const block = new Commands.CommandBlock([], [new Commands.SysCall(sinFun)]);\n  const func = new Commands.Function(\n    \"$sin\",\n    Types.REAL,\n    [\n      new Commands.FormalParameter(\n        new MultiType([Types.INTEGER, Types.REAL]),\n        \"x\",\n        false\n      )\n    ],\n    block\n  );\n  return func;\n}\n\nexport function createCosFun () {\n  const cosFun = async (sto, _) => {\n    const x = sto.applyStore('x');\n    const angle = x.get().mod(360);\n    let result = null;\n    if (angle.eq(90)) {\n      result = new Decimal(0);\n    } else if (angle.eq(180)) {\n      result = new Decimal(-1);\n    } else if (angle.eq(270)) {\n      result = new Decimal(0);\n    }\n    result = Decimal.cos(convertToRadians(angle));\n    const temp = new StoreValue(Types.REAL, result);\n    sto.insertStore(\"$\", temp);\n    sto.mode = Modes.RETURN;\n    return sto;\n  };\n\n  const block = new Commands.CommandBlock([], [new Commands.SysCall(cosFun)]);\n  const func = new Commands.Function(\n    \"$cos\",\n    Types.REAL,\n    [\n      new Commands.FormalParameter(\n        new MultiType([Types.INTEGER, Types.REAL]),\n        \"x\",\n        false\n      )\n    ],\n    block\n  );\n  return func;\n}\n\nexport function createTanFun () {\n  const tanFun = async function (sto, _) {\n    const x = sto.applyStore('x');\n    const angle = x.get().mod(360);\n    if(angle.eq(90) || angle.eq(270)) {\n      throw ProcessorErrorFactory.undefined_tanget_value(x.get().toNumber(),\n        this.function_call_stack.pop());\n    }\n    const result = Decimal.tan(convertToRadians(angle));\n    const temp = new StoreValue(Types.REAL, result);\n    sto.insertStore(\"$\", temp);\n    sto.mode = Modes.RETURN;\n    return sto;\n  };\n\n  const block = new Commands.CommandBlock([], [new Commands.SysCall(tanFun)]);\n  const func = new Commands.Function(\n    \"$tan\",\n    Types.REAL,\n    [\n      new Commands.FormalParameter(\n        new MultiType([Types.INTEGER, Types.REAL]),\n        \"x\",\n        false\n      )\n    ],\n    block\n  );\n  return func;\n}\n\nexport function createSqrtFun () {\n  const sqrtFun = async function (sto, _) {\n    const x = sto.applyStore('x');\n    if(x.get().isNeg()) {\n      return Promise.reject(ProcessorErrorFactory.negative_sqrt_value(this.function_call_stack.pop()));\n    }\n    const result = x.get().sqrt();\n    const temp = new StoreValue(Types.REAL, result);\n    sto.insertStore(\"$\", temp);\n    sto.mode = Modes.RETURN;\n    return sto;\n  };\n\n  const block = new Commands.CommandBlock([], [new Commands.SysCall(sqrtFun)]);\n  const func = new Commands.Function(\n    \"$sqrt\",\n    Types.REAL,\n    [\n      new Commands.FormalParameter(\n        new MultiType([Types.INTEGER, Types.REAL]),\n        \"x\",\n        false\n      )\n    ],\n    block\n  );\n  return func;\n}\n\nexport function createPowFun () {\n  const powFun = async (sto, _) => {\n    const x = sto.applyStore('x');\n    const y = sto.applyStore('y');\n    const result = x.get().pow(y.get());\n    const temp = new StoreValue(Types.REAL, result);\n    sto.insertStore(\"$\", temp);\n    sto.mode = Modes.RETURN;\n    return sto;\n  };\n\n  const block = new Commands.CommandBlock([], [new Commands.SysCall(powFun)]);\n  const func = new Commands.Function(\n    \"$pow\",\n    Types.REAL,\n    [\n      new Commands.FormalParameter(\n        new MultiType([Types.INTEGER, Types.REAL]),\n        \"x\",\n        false\n      ),\n      new Commands.FormalParameter(\n        new MultiType([Types.INTEGER, Types.REAL]),\n        \"y\",\n        false\n      )\n    ],\n    block\n  );\n  return func;\n}\n\nexport function createLogFun () {\n  const logFun = async function (sto, _) {\n    const x = sto.applyStore('x');\n    if (x.get().isNegative()) {\n      return Promise.reject(\n        ProcessorErrorFactory.negative_log_value(this.function_call_stack.pop())\n      );\n    }\n    const result = Decimal.log10(x.get());\n    const temp = new StoreValue(Types.REAL, result);\n    sto.insertStore(\"$\", temp);\n    sto.mode = Modes.RETURN;\n    return sto;\n  };\n\n  const block = new Commands.CommandBlock([], [new Commands.SysCall(logFun)]);\n  const func = new Commands.Function(\n    \"$log\",\n    Types.REAL,\n    [\n      new Commands.FormalParameter(\n        new MultiType([Types.INTEGER, Types.REAL]),\n        \"x\",\n        false\n      )\n    ],\n    block\n  );\n  return func;\n}\n\nexport function createAbsFun () {\n  const absFun = async (sto, _) => {\n    const x = sto.applyStore('x');\n    const result = x.get().abs();\n    const temp = new StoreValue(x.type, result);\n    sto.insertStore(\"$\", temp);\n    sto.mode = Modes.RETURN;\n    return sto;\n  };\n\n  const block = new Commands.CommandBlock([], [new Commands.SysCall(absFun)]);\n  const func = new Commands.Function(\n    \"$abs\",\n    new MultiType([Types.INTEGER, Types.REAL]),\n    [\n      new Commands.FormalParameter(\n        new MultiType([Types.INTEGER, Types.REAL]),\n        \"x\",\n        false\n      )\n    ],\n    block\n  );\n  return func;\n}\n\nexport function createNegateFun () {\n  const negateFun = async (sto, _) => {\n    const x = sto.applyStore('x');\n    const result = x.get().negated();\n    const temp = new StoreValue(x.type, result);\n    sto.insertStore(\"$\", temp);\n    sto.mode = Modes.RETURN;\n    return sto;\n  };\n\n  const block = new Commands.CommandBlock(\n    [],\n    [new Commands.SysCall(negateFun)]\n  );\n  const func = new Commands.Function(\n    \"$negate\",\n    new MultiType([Types.INTEGER, Types.REAL]),\n    [\n      new Commands.FormalParameter(\n        new MultiType([Types.INTEGER, Types.REAL]),\n        \"x\",\n        false\n      )\n    ],\n    block\n  );\n  return func;\n}\n\nexport function createInvertFun () {\n  const invertFun = async (sto, _) => {\n    const x = sto.applyStore('x');\n    const result = Parsers.toReal(1).dividedBy(x.get());\n    const temp = new StoreValue(Types.REAL, result);\n    sto.insertStore(\"$\", temp);\n    sto.mode = Modes.RETURN;\n    return sto;\n  };\n\n  const block = new Commands.CommandBlock(\n    [],\n    [new Commands.SysCall(invertFun)]\n  );\n  const func = new Commands.Function(\n    \"$invert\",\n    Types.REAL,\n    [\n      new Commands.FormalParameter(\n        new MultiType([Types.INTEGER, Types.REAL]),\n        \"x\",\n        false\n      )\n    ],\n    block\n  );\n  return func;\n}\n\nexport function createMaxFun () {\n  const maxFun = async (sto, _) => {\n    const x = sto.applyStore('x');\n    const numbers = x.get().map(sto_addrs => sto_addrs.get());\n    const result = Decimal.max(...numbers);\n    const temp = new StoreValue(x.type.innerType, result);\n    sto.insertStore(\"$\", temp);\n    sto.mode = Modes.RETURN;\n    return sto;\n  };\n  const paramType = new ArrayType(\n    new MultiType([Types.INTEGER, Types.REAL]),\n    1\n  );\n  const block = new Commands.CommandBlock([], [new Commands.SysCall(maxFun)]);\n  const func = new Commands.Function(\n    \"$max\",\n    new MultiType([Types.INTEGER, Types.REAL]),\n    [new Commands.FormalParameter(paramType, \"x\", false)],\n    block\n  );\n  return func;\n}\n\nexport function createMinFun () {\n  const minFun = async (sto, _) => {\n    const x = sto.applyStore('x');\n    const numbers = x.get().map(sto_addrs => sto_addrs.get());\n    const result = Decimal.min(...numbers);\n    const temp = new StoreValue(x.type.innerType, result);\n    sto.insertStore(\"$\", temp);\n    sto.mode = Modes.RETURN;\n    return sto;\n  };\n  const paramType = new ArrayType(\n    new MultiType([Types.INTEGER, Types.REAL]),\n    1\n  );\n  const block = new Commands.CommandBlock([], [new Commands.SysCall(minFun)]);\n  const func = new Commands.Function(\n    \"$min\",\n    new MultiType([Types.INTEGER, Types.REAL]),\n    [new Commands.FormalParameter(paramType, \"x\", false)],\n    block\n  );\n  return func;\n}\n\nlet seed = Date.now();\nexport function createRandFun () {\n  const a = 16807;\n  const m = 2147483647;\n  const c = 12345;\n  const randFun = async (sto, _) => {\n    seed = (a * seed + c) % m;\n    const val = seed / (m - 1);\n    const temp = new StoreValue(Types.REAL, new Decimal(val));\n    sto.insertStore(\"$\", temp);\n    sto.mode = Modes.RETURN;\n    return sto;\n  };\n  const block = new Commands.CommandBlock([], [new Commands.SysCall(randFun)]);\n  const func = new Commands.Function(\"$rand\", Types.REAL, [], block);\n  return func;\n}\n\nexport function createSetSeedFun () {\n  const setSeedFun = async (sto, _) => {\n    const value = sto.applyStore(\"x\");\n    seed = value.get().toNumber();\n    sto.mode = Modes.RETURN;\n    return sto;\n  };\n  const block = new Commands.CommandBlock(\n    [],\n    [new Commands.SysCall(setSeedFun)]\n  );\n  const func = new Commands.Function(\n    \"$setSeed\",\n    Types.VOID,\n    [new Commands.FormalParameter(Types.INTEGER, \"x\", false)],\n    block\n  );\n  return func;\n}\n","import { LanguageService } from '../services/languageService';\nimport {createInputFun, createOutputFun} from './lib/io';\nimport {createLengthFun, createLowercaseFun,\n  createrCharAtFun, createSubstringFun,\n  createUppercaseFun} from './lib/strings';\nimport {createMatrixColumnsFun, createMatrixLinesFun,\n  createNumElementsFun} from './lib/arrays';\nimport {createCastBoolFun, createCastIntFun,\n  createCastRealFun, createCastStringFun,\n  createIsBoolFun, createIsIntFun,\n  createIsRealFun, createCastCharFun} from './lib/lang';\nimport {createAbsFun, createCosFun,\n  createInvertFun, createLogFun,\n  createMaxFun, createMinFun,\n  createNegateFun, createPowFun,\n  createSinFun, createSqrtFun,\n  createTanFun, createRandFun} from './lib/math';\n\nfunction valueToKey (value, object) {\n  for (const key in object) {\n    if(Object.prototype.hasOwnProperty.call(object, key)){\n      if (object[key] === value) {\n        return key;\n      }\n    }\n  }\n  return null;\n}\n\nfunction concatObjects (...objs) {\n  const result = {};\n  for (let i = 0; i < objs.length; i++) {\n    const obj = objs[i];\n    for(const key in obj) {\n      if(Object.prototype.hasOwnProperty.call(obj, key)) {\n        result[key] = obj[key];\n      }\n    }\n  }\n  return result;\n}\n\nconst libsObject = {\n  $mathLib: {\n    $sin: createSinFun(),\n    $cos: createCosFun(),\n    $tan: createTanFun(),\n    $sqrt: createSqrtFun(),\n    $pow: createPowFun(),\n    $log: createLogFun(),\n    $abs: createAbsFun(),\n    $negate: createNegateFun(),\n    $invert: createInvertFun(),\n    $max: createMaxFun(),\n    $min: createMinFun(),\n    $rand: createRandFun()\n  },\n  $ioLib: {\n    $read: createInputFun(),\n    $write: createOutputFun()\n  },\n  $strLib: {\n    $substring: createSubstringFun(),\n    $length: createLengthFun(),\n    $uppercase: createUppercaseFun(),\n    $lowercase: createLowercaseFun(),\n    $charAt: createrCharAtFun(),\n  },\n  $arrayLib: {\n    $numElements: createNumElementsFun(),\n    $matrixLines: createMatrixLinesFun(),\n    $matrixColumns: createMatrixColumnsFun()\n  },\n  $langLib: {\n    $isReal: createIsRealFun(),\n    $isInt: createIsIntFun(),\n    $isBool: createIsBoolFun(),\n    $castReal: createCastRealFun(),\n    $castInt: createCastIntFun(),\n    $castBool: createCastBoolFun(),\n    $castString: createCastStringFun(),\n    $castChar: createCastCharFun()\n  }\n}\n\nconst funcsObject = concatObjects(libsObject.$ioLib, libsObject.$langLib,\n  libsObject.$strLib, libsObject.$arrayLib);\n\nexport const LanguageDefinedFunction = Object.freeze({\n  getMainFunctionName: () => LanguageService.getCurrentLangFuncs().main_function,\n  getInternalName: (localName) => {\n    if (localName.indexOf(\".\") !== -1) {\n      const names = localName.split(\".\");\n      const lib = valueToKey(names[0], LanguageService.getCurrentLangLibs());\n      const internalName = valueToKey(names[1], LanguageService.getCurrentLangFuncs());\n      if (lib === null || internalName === null) {\n        return null;\n      }\n      return lib + \".\" + internalName;\n    }\n    const funcName = valueToKey(localName, LanguageService.getCurrentLangFuncs());\n    if(funcName !== null) {\n      if(funcsObject[funcName]) {\n        return funcName;\n      }\n    }\n    return null;\n  },\n  getFunction: (internalName) => {\n    if (internalName.indexOf(\".\") !== -1) {\n      const names = internalName.split(\".\");\n      const libName = names[0];\n      const funName = names[1];\n      return libsObject[libName][funName];\n    }\n    return funcsObject[internalName];\n  },\n  getLocalName: (internalName) => {\n    if (internalName.indexOf(\".\") !== -1) {\n      const names = internalName.split(\".\");\n      const libName = LanguageService.getCurrentLangLibs()[names[0]];\n      const funName = LanguageService.getCurrentLangFuncs()[names[1]];\n      return `${libName}.${funName}`;\n    } else if (LanguageService.getCurrentLangFuncs()[internalName]) {\n      return LanguageService.getCurrentLangFuncs()[internalName];\n    } else { \n      return internalName\n    }\n  }\n});","import * as Commands from \"./../../ast/commands\";\nimport { Modes } from \"../modes\";\nimport * as Parsers from \"./../../typeSystem/parsers\";\nimport { Types } from \"./../../typeSystem/types\";\nimport { ProcessorErrorFactory } from \"./../error/processorErrorFactory\";\nimport { StoreValue } from \"../store/value/store_value\";\n\nexport function createOutputFun () {\n  const writeFunction = async function (store, _) {\n    const totalSV = store.applyStore(\"p1.0\");\n    const total = totalSV.get();\n    for (let i = 1; i < total; i += 1) {\n      const val = store.applyStore(`p1.${i}`);\n      this.output.sendOutput(Parsers.convertToString(val.get(), val.type));\n    }\n    store.mode = Modes.RETURN;\n    return store;\n  };\n  const block = new Commands.CommandBlock(\n    [],\n    [new Commands.SysCall(writeFunction)]\n  );\n  const func = new Commands.Function(\n    \"$write\",\n    Types.VOID,\n    [new Commands.FormalParameter(Types.ALL, \"p1\", false, true)],\n    block\n  );\n  return func;\n}\n\nexport function createInputFun () {\n  const readFunction = async function (store, _) {\n    const text = await this.input.requestInput();\n    const typeToConvert = store.applyStore(\"p1\").type;\n    let type = null;\n    let result = null;\n    try {\n      if (typeToConvert.isCompatible(Types.INTEGER)) {\n        result = Parsers.toInt(text.trim()).trunc();\n        type = Types.INTEGER;\n      } else if (typeToConvert.isCompatible(Types.REAL)) {\n        result = Parsers.toReal(text.trim());\n        type = Types.REAL;\n      } else if (typeToConvert.isCompatible(Types.BOOLEAN)) {\n        result = Parsers.toBool(text.trim());\n        type = Types.BOOLEAN;\n      } else if (typeToConvert.isCompatible(Types.STRING)) {\n        result = Parsers.toString(text);\n        type = Types.STRING;\n      } else if (typeToConvert.isCompatible(Types.CHAR)) {\n        result = Parsers.toChar(text);\n        type = Types.CHAR;\n      } else {\n        throw new Error(\"!!!!Critical error: Unknown type in readFunction!!!!\");\n      }\n    } catch (_) {\n      if (this.mode == Modes.ABORT) {\n        store.mode = Modes.RETURN;\n        return store;\n      }\n      const stringInfo = typeToConvert.stringInfo()[0];\n      const realObject = store.getStoreObject(\"p1\");\n      if (realObject.getReferenceDimension() > 0) {\n        const arrayInfo = realObject.type.stringInfo()[0];\n        const dim = realObject.getReferenceDimension();\n        throw ProcessorErrorFactory.invalid_read_type_array(\n          text,\n          stringInfo.type,\n          stringInfo.dim,\n          realObject.getRefObj(),\n          arrayInfo.type,\n          dim,\n          this.function_call_stack.pop()\n        );\n      }\n      throw ProcessorErrorFactory.invalid_read_type(\n        text,\n        stringInfo.type,\n        stringInfo.dim,\n        realObject.getRefObj(),\n        this.function_call_stack.pop()\n      );\n    }\n    const stoValue = new StoreValue(type, result);\n    store.updateStore(\"p1\", stoValue);\n    store.mode = Modes.RETURN;\n    return store;\n  };\n  const block = new Commands.CommandBlock(\n    [],\n    [new Commands.SysCall(readFunction)]\n  );\n  const func = new Commands.Function(\n    \"$read\",\n    Types.VOID,\n    [new Commands.FormalParameter(Types.ALL, \"p1\", true)],\n    block\n  );\n  return func;\n}\n","import * as Commands from './../../ast/commands';\nimport { Types } from './../../typeSystem/types';\nimport { toInt } from \"./../../typeSystem/parsers\";\nimport { Modes } from '../modes';\nimport { StoreValue } from '../store/value/store_value';\nimport { ProcessorErrorFactory } from '../error/processorErrorFactory';\n\n/*\n*  substring\n*  length\n*  uppercase\n*  lowercase\n*  charAt\n**/\n\nexport function createSubstringFun () {\n  const substringFun = async (sto, _) => {\n    const str = sto.applyStore(\"str\");\n    const start = sto.applyStore(\"start\");\n    const end = sto.applyStore(\"end\");\n    const result = str.get().substring(start.get(), end.get());\n    const temp = new StoreValue(Types.STRING, result);\n    sto.insertStore(\"$\", temp);\n    sto.mode = Modes.RETURN;\n    return sto;\n  };\n\n  const block = new Commands.CommandBlock([],  [new Commands.SysCall(substringFun)]);\n  const func = new Commands.Function('$substring', Types.STRING,\n    [new Commands.FormalParameter(Types.STRING, 'str', false),\n    new Commands.FormalParameter(Types.INTEGER, 'start', false),\n    new Commands.FormalParameter(Types.INTEGER, 'end', false)],\n    block);\n  return func;\n}\n\nexport function createLengthFun () {\n  const lengthFun = async (sto, _) => {\n    const str = sto.applyStore(\"str\");\n    const temp = new StoreValue(Types.INTEGER, toInt(str.value.length));\n    sto.insertStore(\"$\", temp);\n    sto.mode = Modes.RETURN;\n    return sto;\n  }\n  const block = new Commands.CommandBlock([],  [new Commands.SysCall(lengthFun)]);\n  const func = new Commands.Function('$length', Types.INTEGER,\n    [new Commands.FormalParameter(Types.STRING, 'str', false)],\n    block);\n  return func;\n}\n\nexport function createUppercaseFun () {\n  const uppercaseFun = async (sto, _) => {\n    const str = sto.applyStore(\"str\");\n    const temp = new StoreValue(Types.STRING, str.get().toUpperCase());\n    sto.insertStore(\"$\", temp);\n    sto.mode = Modes.RETURN;\n    return sto;\n  }\n  const block = new Commands.CommandBlock([],  [new Commands.SysCall(uppercaseFun)]);\n  const func = new Commands.Function('$uppercase', Types.STRING,\n    [new Commands.FormalParameter(Types.STRING, 'str', false)],\n    block);\n  return func;\n}\n\nexport function createLowercaseFun () {\n  const lowercaseFun = async (sto, _) => {\n    const str = sto.applyStore(\"str\");\n    const temp = new StoreValue(Types.STRING, str.get().toLowerCase());\n    sto.insertStore(\"$\", temp);\n    sto.mode = Modes.RETURN;\n    return sto;\n  }\n  const block = new Commands.CommandBlock([],  [new Commands.SysCall(lowercaseFun)]);\n  const func = new Commands.Function('$lowercase', Types.STRING,\n    [new Commands.FormalParameter(Types.STRING, 'str', false)],\n    block);\n  return func;\n}\n\nexport function createrCharAtFun () {\n  const charAtFun = async function (sto, _) {\n    const str = sto.applyStore(\"str\");\n    const idx = sto.applyStore(\"index\");\n    if (idx.get().toNumber() < 0 || idx.get().toNumber() >= str.get().length) {\n      throw ProcessorErrorFactory.invalid_string_index(idx.get().toNumber(), str.get(),\n        this.function_call_stack.pop());\n    }\n    const temp = new StoreValue(Types.CHAR, str.get().charAt(idx.get().toNumber()));\n    sto.insertStore(\"$\", temp);\n    sto.mode = Modes.RETURN;\n    return sto;\n  }\n  const block = new Commands.CommandBlock([],  [new Commands.SysCall(charAtFun)]);\n  const func = new Commands.Function('$charAt', Types.CHAR,\n    [new Commands.FormalParameter(Types.STRING, 'str', false),\n    new Commands.FormalParameter(Types.INTEGER, 'index', false)],\n    block);\n  return func;\n}\n","import * as Commands from './../../ast/commands';\nimport { Types } from './../../typeSystem/types';\nimport { toInt } from \"./../../typeSystem/parsers\";\nimport { ArrayType } from '../../typeSystem/array_type';\nimport { Modes } from '../modes';\nimport { StoreValue } from '../store/value/store_value';\n\n/**\n * num_elements\n * matrix_lines\n * matrix_columns\n */\n\nexport function createNumElementsFun () {\n  const numElementsFun = async (sto, _) => {\n    const vector  = sto.applyStore(\"vector\");\n    const temp = new StoreValue(Types.INTEGER, toInt(vector.lines));\n    sto.mode = Modes.RETURN;\n    sto.insertStore(\"$\", temp);\n    return sto;\n  }\n\n  const block = new Commands.CommandBlock([],  [new Commands.SysCall(numElementsFun)]);\n  const func = new Commands.Function('$numElements', Types.INTEGER,\n    [new Commands.FormalParameter(new ArrayType(Types.ALL, 1), 'vector', false)],\n    block);\n  return func;\n }\n\nexport function createMatrixLinesFun () {\n  const matrixLinesFun = async (sto, _) => {\n    const matrix  = sto.applyStore(\"matrix\");\n    const temp = new StoreValue(Types.INTEGER, toInt(matrix.lines));\n    sto.mode = Modes.RETURN;\n    sto.insertStore(\"$\", temp);\n    return sto;\n  }\n\n  const block = new Commands.CommandBlock([],  [new Commands.SysCall(matrixLinesFun)]);\n  const func = new Commands.Function('$matrixLines', Types.INTEGER,\n    [new Commands.FormalParameter(new ArrayType(Types.ALL, 2), 'matrix', false)],\n    block);\n  return func;\n }\n\nexport function createMatrixColumnsFun () {\n  const matrixColumnsFun = async (sto, _) => {\n    const matrix  = sto.applyStore(\"matrix\");\n    const temp = new StoreValue(Types.INTEGER, toInt(matrix.columns));\n    sto.mode = Modes.RETURN;\n    sto.insertStore(\"$\", temp);\n    return sto;\n  }\n\n  const block = new Commands.CommandBlock([],  [new Commands.SysCall(matrixColumnsFun)]);\n  const func = new Commands.Function('$matrixColumns', Types.INTEGER,\n    [new Commands.FormalParameter(new ArrayType(Types.ALL, 2), 'matrix', false)],\n    block);\n  return func;\n }\n ","import * as Commands from \"./../../ast/commands\";\nimport { Types } from \"./../../typeSystem/types\";\nimport * as Parsers from \"./../../typeSystem/parsers\";\nimport { IVProgParser } from \"../../ast/ivprogParser\";\nimport { RealLiteral, IntLiteral, BoolLiteral } from \"../../ast/expressions\";\nimport { Modes } from \"../modes\";\nimport { MultiType } from \"../../typeSystem/multiType\";\nimport { ProcessorErrorFactory } from \"../error/processorErrorFactory\";\nimport { StoreValue } from \"../store/value/store_value\";\n\n/**\n *\n * is_real\n * is_int\n * is_bool\n * cast_real\n * cast_int\n * cast_bool\n * cast_string\n * cast_char\n */\n\nexport function createIsRealFun () {\n  const isRealFun = async (sto, _) => {\n    const str = sto.applyStore(\"str\");\n    const parser = IVProgParser.createParser(str.get());\n    let result = false;\n    try {\n      const val = parser.parseTerm();\n      if (val instanceof RealLiteral) {\n        result = true;\n      }\n    } catch (error) {\n      // ignore\n    }\n    const temp = new StoreValue(Types.BOOLEAN, result);\n    sto.insertStore(\"$\", temp);\n    sto.mode = Modes.RETURN;\n    return sto;\n  };\n\n  const block = new Commands.CommandBlock(\n    [],\n    [new Commands.SysCall(isRealFun)]\n  );\n  const func = new Commands.Function(\n    \"$isReal\",\n    Types.BOOLEAN,\n    [new Commands.FormalParameter(Types.STRING, \"str\", false)],\n    block\n  );\n  return func;\n}\n\nexport function createIsIntFun () {\n  const isIntFun = async (sto, _) => {\n    const str = sto.applyStore(\"str\");\n    const parser = IVProgParser.createParser(str.get());\n    let result = false;\n    try {\n      const val = parser.parseTerm();\n      if (val instanceof IntLiteral) {\n        result = true;\n      }\n    } catch {\n      // ignore\n    }\n    const temp = new StoreValue(Types.BOOLEAN, result);\n    sto.insertStore(\"$\", temp);\n    sto.mode = Modes.RETURN;\n    return sto;\n  };\n\n  const block = new Commands.CommandBlock([], [new Commands.SysCall(isIntFun)]);\n  const func = new Commands.Function(\n    \"$isInt\",\n    Types.BOOLEAN,\n    [new Commands.FormalParameter(Types.STRING, \"str\", false)],\n    block\n  );\n  return func;\n}\n\nexport function createIsBoolFun () {\n  const isBoolFun = (sto, _) => {\n    const str = sto.applyStore(\"str\");\n    const parser = IVProgParser.createParser(str.get());\n    let result = false;\n    try {\n      const val = parser.parseTerm();\n      if (val instanceof BoolLiteral) {\n        result = true;\n      }\n    } catch (error) {\n      // ignore\n    }\n    const temp = new StoreValue(Types.BOOLEAN, result);\n    sto.insertStore(\"$\", temp);\n    sto.mode = Modes.RETURN;\n    return sto;\n  };\n\n  const block = new Commands.CommandBlock(\n    [],\n    [new Commands.SysCall(isBoolFun)]\n  );\n  const func = new Commands.Function(\n    \"$isBool\",\n    Types.BOOLEAN,\n    [new Commands.FormalParameter(Types.STRING, \"str\", false)],\n    block\n  );\n  return func;\n}\n\nexport function createCastRealFun () {\n  const castRealFun = async (sto, _) => {\n    const val = sto.applyStore(\"val\");\n    let value = val.get();\n    switch (val.type.ord) {\n      case Types.INTEGER.ord: {\n        value = value.toNumber();\n        const temp = new StoreValue(Types.REAL, Parsers.toReal(value));\n        sto.insertStore(\"$\", temp);\n        sto.mode = Modes.RETURN;\n        return sto;\n      }\n      case Types.STRING.ord: {\n        const parser = IVProgParser.createParser(value);\n        try {\n          const result = parser.parseTerm();\n          if (result instanceof RealLiteral) {\n            const temp = new StoreValue(\n              Types.REAL,\n              Parsers.toReal(result.value)\n            );\n            sto.insertStore(\"$\", temp);\n            sto.mode = Modes.RETURN;\n            return sto;\n          }\n        } catch (error) {\n          // ignore\n        }\n      }\n    }\n    const typeStringInfoArray = Types.REAL.stringInfo();\n    const typeInfo = typeStringInfoArray[0];\n    throw ProcessorErrorFactory.invalid_type_conversion(\n      value,\n      typeInfo.type,\n      typeInfo.dim\n    );\n  };\n\n  const block = new Commands.CommandBlock(\n    [],\n    [new Commands.SysCall(castRealFun)]\n  );\n  const func = new Commands.Function(\n    \"$castReal\",\n    Types.REAL,\n    [\n      new Commands.FormalParameter(\n        new MultiType([Types.INTEGER, Types.STRING]),\n        \"val\",\n        false\n      ),\n    ],\n    block\n  );\n  return func;\n}\n\nexport function createCastIntFun () {\n  const castIntFun = async (sto, _) => {\n    const val = sto.applyStore(\"val\");\n    let value = val.get();\n    switch (val.type.ord) {\n      case Types.REAL.ord: {\n        value = value.toNumber();\n        const temp = new StoreValue(\n          Types.INTEGER,\n          Parsers.toInt(Math.floor(value))\n        );\n        sto.insertStore(\"$\", temp);\n        sto.mode = Modes.RETURN;\n        return sto;\n      }\n      case Types.CHAR.ord: {\n        const temp = new StoreValue(\n          Types.INTEGER,\n          Parsers.toInt(value.charCodeAt(0))\n        );\n        sto.insertStore(\"$\", temp);\n        sto.mode = Modes.RETURN;\n        return sto;\n      }\n      case Types.STRING.ord: {\n        const parser = IVProgParser.createParser(value);\n        try {\n          const result = parser.parseTerm();\n          if (result instanceof IntLiteral) {\n            const temp = new StoreValue(\n              Types.INTEGER,\n              Parsers.toInt(result.value)\n            );\n            sto.insertStore(\"$\", temp);\n            sto.mode = Modes.RETURN;\n            return sto;\n          }\n        } catch (error) {\n          // ignore\n        }\n      }\n    }\n    const typeStringInfoArray = Types.INTEGER.stringInfo();\n    const typeInfo = typeStringInfoArray[0];\n    throw ProcessorErrorFactory.invalid_type_conversion(\n      value,\n      typeInfo.type,\n      typeInfo.dim\n    );\n  };\n\n  const block = new Commands.CommandBlock(\n    [],\n    [new Commands.SysCall(castIntFun)]\n  );\n  const func = new Commands.Function(\n    \"$castInt\",\n    Types.INTEGER,\n    [\n      new Commands.FormalParameter(\n        new MultiType([Types.REAL, Types.STRING, Types.CHAR]),\n        \"val\",\n        false\n      ),\n    ],\n    block\n  );\n  return func;\n}\n\nexport function createCastBoolFun () {\n  const castBoolFun = async (sto, _) => {\n    const str = sto.applyStore(\"str\");\n    const value = str.get();\n    const parser = IVProgParser.createParser(value);\n    try {\n      const val = parser.parseTerm();\n      if (val instanceof BoolLiteral) {\n        const temp = new StoreValue(Types.BOOLEAN, val.value);\n        sto.insertStore(\"$\", temp);\n        sto.mode = Modes.RETURN;\n        return sto;\n      }\n    } catch (error) {\n      // ignore\n    }\n    const typeStringInfoArray = Types.BOOLEAN.stringInfo();\n    const typeInfo = typeStringInfoArray[0];\n    throw ProcessorErrorFactory.invalid_type_conversion(\n      value,\n      typeInfo.type,\n      typeInfo.dim\n    );\n  };\n\n  const block = new Commands.CommandBlock(\n    [],\n    [new Commands.SysCall(castBoolFun)]\n  );\n  const func = new Commands.Function(\n    \"$castBool\",\n    Types.BOOLEAN,\n    [new Commands.FormalParameter(Types.STRING, \"str\", false)],\n    block\n  );\n  return func;\n}\n\nexport function createCastStringFun () {\n  const castStringFun = async function (store, _) {\n    const val = store.applyStore(\"str\");\n    const result = Parsers.convertToString(val.get(), val.type);\n    const temp = new StoreValue(Types.STRING, result);\n    store.insertStore(\"$\", temp);\n    store.mode = Modes.RETURN;\n    return store;\n  };\n  const block = new Commands.CommandBlock(\n    [],\n    [new Commands.SysCall(castStringFun)]\n  );\n  const func = new Commands.Function(\n    \"$castString\",\n    Types.STRING,\n    [new Commands.FormalParameter(Types.ALL, \"str\", false)],\n    block\n  );\n  return func;\n}\n\nexport function createCastCharFun () {\n  const castCharFun = (store, _) => {\n    const valSV = store.applyStore(\"charCode\");\n    // Force the int value to the range [0, 255]\n    const value = valSV.get().toNumber() & 0xff;\n    const result = String.fromCharCode(value);\n    const temp = new StoreValue(Types.CHAR, result);\n    store.insertStore(\"$\", temp);\n    store.mode = Modes.RETURN;\n    return store;\n  };\n  const block = new Commands.CommandBlock(\n    [],\n    [new Commands.SysCall(castCharFun)]\n  );\n  const func = new Commands.Function(\n    \"$castChar\",\n    Types.CHAR,\n    [new Commands.FormalParameter(Types.INTEGER, \"charCode\", false)],\n    block\n  );\n  return func;\n}\n\n","import line_i18n from \"line-i18n\";\nimport Langs from \"./../../i18n\";\nimport { LanguageService } from \"./languageService\";\nimport { LanguageDefinedFunction } from \"./../processor/definedFunctions\";\nimport { Operators } from \"./../ast/operators\";\n\nclass IVProgLocalizedStrings extends line_i18n.LocalizedStrings {\n  constructor (langService, langsJsons, shouldListenToChange = false) {\n    super(langService, langsJsons, shouldListenToChange);\n  }\n\n  translateType (type, dim) {\n    const type_string = this.getUI(`type_${type}`);\n    switch (dim) {\n      case 0:\n        return type_string;\n      default:\n        if (dim > 1) return this.getUI(\"matrix_info_string\", [type_string]);\n        else return this.getUI(\"vector_info_string\", [type_string]);\n    }\n  }\n\n  translateOp (op) {\n    switch (op.ord) {\n      case Operators.AND.ord:\n      case Operators.OR.ord:\n      case Operators.NOT.ord:\n        return this.getUI(`logic_operator_${op.value}`);\n      default:\n        return op.value;\n    }\n  }\n\n  translateInternalFunction (name, category = null) {\n    if (category == null) {\n      return LanguageDefinedFunction.getLocalName(name);\n    } else {\n      return LanguageDefinedFunction.getLocalName(`${category}.${name}`);\n    }\n  }\n}\n\nconst _instance = new IVProgLocalizedStrings(LanguageService, Langs);\n\nexport const getInstance =  () => {\n  return _instance;\n}\n","import { LanguageService } from \"./../services/languageService\";\nimport { getInstance as LocalizedStrings } from \"./../services/localizedStringsService\";\nimport { Operators } from \"./../ast/operators\";\n\n\n/**\n *\n * source: https://stackoverflow.com/a/16270434\n */\nexport function isElementInViewport (el) {\n  const rect = el.getBoundingClientRect();\n\n  return (\n    rect.bottom > 0 &&\n    rect.right > 0 &&\n    rect.left < (window.innerWidth || document.documentElement.clientWidth) &&\n    rect.top < (window.innerHeight || document.documentElement.clientHeight)\n  );\n}\n\nlet cacheMainList = null;\nlet cacheOp = null;\n\nfunction fillCache () {\n  if (cacheMainList == null) {\n    cacheMainList = [];\n    const mainList = [\n      \"RK_PROGRAM\",\n      \"RK_REAL\",\n      \"RK_VOID\",\n      \"RK_BOOLEAN\",\n      \"RK_STRING\",\n      \"RK_INTEGER\",\n      \"RK_CHARACTER\",\n      \"RK_SWITCH\",\n      \"RK_CASE\",\n      \"RK_DEFAULT\",\n      \"RK_CONST\",\n      \"RK_FUNCTION\",\n      \"RK_RETURN\",\n      \"RK_FOR\",\n      \"RK_BREAK\",\n      \"RK_DO\",\n      \"RK_WHILE\",\n      \"RK_IF\",\n      \"RK_ELSE\",\n      \"RK_FALSE\",\n      \"RK_TRUE\",\n    ];\n    const lexer = LanguageService.getCurrentLexer();\n    const names = lexer.getReservedKeys();\n    for (let key = 0; key < mainList.length; ++key) {\n      const word = mainList[key];\n      const keyword = names[word];\n      cacheMainList.push(keyword);\n    }\n  }\n  if (cacheOp == null) {\n    cacheOp = [];\n    const logicOpList = [\n      Operators.AND.value,\n      Operators.OR.value,\n      Operators.NOT.value,\n    ];\n    for (let op = 0; op < logicOpList.length; ++op) {\n      const lOp = `logic_operator_${logicOpList[op]}`;\n      cacheOp.push(LocalizedStrings().getUI(lOp));\n    }\n  }\n}\n\nexport function isKeyword (text) {\n  fillCache();\n  for (let key = 0; key < cacheMainList.length; ++key) {\n    const keyword = cacheMainList[key];\n    if (keyword == text) {\n      return true;\n    }\n  }\n  // not in main list, check op\n  for (let op = 0; op < cacheOp.length; op++) {\n    const lOp = cacheOp[op];\n    if (lOp == text) {\n      return true;\n    }\n  }\n  return false;\n}\n\nexport function isValidIdentifier (identifier_str) {\n  const validRegex = /^[a-zA-Z_][a-zA-Z0-9_]*$/.test(identifier_str);\n  return validRegex && !isKeyword(identifier_str)\n}\n\nexport function getCodeEditorModeConfig () {\n  const blockList = [\n    \"RK_SWITCH\",\n    \"RK_PROGRAM\",\n    \"RK_CASE\",\n    \"RK_DEFAULT\",\n    \"RK_FOR\",\n    \"RK_FOR_ALT\",\n    \"RK_FUNCTION\",\n    \"RK_DO\",\n    \"RK_WHILE\",\n    \"RK_WHILE_ALT\",\n    \"RK_IF\",\n    \"RK_ELSE\",\n  ];\n  const keywordsList = [\n    \"RK_CONST\",\n    \"RK_RETURN\",\n    \"RK_BREAK\",\n    \"RK_FOR_FROM\",\n    \"RK_FOR_TO\",\n    \"RK_FOR_PASS\",\n    \"RK_DO_UNTIL\",\n  ];\n  const typeList = [\n    \"RK_REAL\",\n    \"RK_VOID\",\n    \"RK_BOOLEAN\",\n    \"RK_STRING\",\n    \"RK_INTEGER\",\n    \"RK_CHARACTER\",\n  ];\n  const atomList = [\"RK_FALSE\", \"RK_TRUE\"];\n\n  const case_default = [];\n  const blocks = [];\n  const keywords = [];\n  const types = [];\n  const atoms = [];\n  let switchString = \"\";\n\n  cacheMainList = [];\n  const lexer = LanguageService.getCurrentLexer();\n  const names = lexer.getReservedKeys();\n  //console.debug(names);\n  blockList.forEach((v) => {\n    const keyword = names[v];\n    const value = keyword;\n    cacheMainList.push(value);\n    keywords.push(value);\n    blocks.push(value);\n    if (v == \"RK_SWITCH\") {\n      switchString = value;\n    } else if (v == \"RK_CASE\" || v == \"RK_DEFAULT\") {\n      case_default.push(value);\n    }\n  });\n  keywordsList.forEach((v) => {\n    const keyword = names[v];\n    const value = keyword;\n    cacheMainList.push(value);\n    keywords.push(value);\n  });\n  typeList.forEach((v) => {\n    const keyword = names[v];\n    const value = keyword;\n    cacheMainList.push(value);\n    types.push(value);\n  });\n  atomList.forEach((v) => {\n    const keyword = names[v];\n    const value = keyword;\n    cacheMainList.push(value);\n    atoms.push(value);\n  });\n\n  cacheOp = [];\n  const logicOpList = [\"NOT_OPERATOR\", \"OR_OPERATOR\", \"AND_OPERATOR\"];\n\n  logicOpList.forEach((v) => {\n    const keyword = names[v];\n    const value = keyword;\n    cacheOp.push(value);\n    keywords.push(value);\n  });\n  cacheMainList.push(lexer.getLangFuncs().main_function);\n  return {\n    case_default: case_default,\n    atoms: atoms,\n    keywords: keywords,\n    switchString: switchString,\n    types: types,\n    blocks: blocks,\n  };\n}\n\n/**\n * Source: https://gist.github.com/andrei-m/982927\n * @param {string} a\n * @param {string} b\n */\nexport function levenshteinDistance (a, b) {\n  if (a.length == 0) return b.length;\n  if (b.length == 0) return a.length;\n\n  const matrix = [];\n\n  // increment along the first column of each row\n  let i;\n  for (i = 0; i <= b.length; i++) {\n    matrix[i] = [i];\n  }\n\n  // increment each column in the first row\n  let j;\n  for (j = 0; j <= a.length; j++) {\n    matrix[0][j] = j;\n  }\n\n  // Fill in the rest of the matrix\n  for (i = 1; i <= b.length; i++) {\n    for (j = 1; j <= a.length; j++) {\n      if (b.charCodeAt(i - 1) == a.charCodeAt(j - 1)) {\n        matrix[i][j] = matrix[i - 1][j - 1];\n      } else {\n        matrix[i][j] = Math.min(\n          matrix[i - 1][j - 1] + 1, // substitution\n          Math.min(\n            matrix[i][j - 1] + 1, // insertion\n            matrix[i - 1][j] + 1\n          )\n        ); // deletion\n      }\n    }\n  }\n  return matrix[b.length][a.length];\n}\n\nlet win = null;\nexport function openAssessmentDetail (event) {\n  event.preventDefault();\n  const page_code = event.currentTarget.dataset.page;\n  if (win != null) {\n    win.close();\n  }\n  win = window.open(\"\", \"DetailWindow\", \"width=550,height=600\");\n  win.document.open();\n  win.document.write(page_code);\n  win.document.close();\n}\n\nexport function range (size, startAt = 0) {\n  return [...Array(size).keys()].map((i) => i + startAt);\n}\n\n/**\n *\n * @param {number} ms\n */\nexport async function sleep (ms) {\n  return new Promise((res, _) => setTimeout(res, ms));\n}\n","export function processData () {\n  const folderInput = document.querySelector(\"#folder\");\n  const header = [\n    \"submissionid\",\n    \"file\",\n    \"filesize\",\n    \"timestamp\",\n    \"humandate\",\n    \"grade\",\n    \"userid\",\n    \"exerciseid\",\n  ];\n\n  function generateSubCode (algorithmInIlm) {\n    window.program_obj.functions = JSON.parse(algorithmInIlm).functions;\n    window.program_obj.globals = JSON.parse(algorithmInIlm).globals;\n    return window.ivprogCore.generateCode();\n  }\n\n  function prepareData (map, submission) {\n    if (!submission) {\n      return map;\n    }\n    const exercID = submission[\"exerciseid\"];\n    const studentID = submission[\"userid\"];\n    let exercMap = null;\n    if (map.has(exercID)) {\n      exercMap = map.get(exercID);\n    } else {\n      exercMap = new Map();\n      map.set(exercID, exercMap);\n    }\n    if (exercMap.has(studentID)) {\n      exercMap.get(studentID).push(submission);\n    } else {\n      exercMap.set(studentID, [submission]);\n    }\n    return map;\n  }\n\n  folderInput.addEventListener(\"change\", async () => {\n    const files = Array.from(folderInput.files);\n    const idx = files.find((f) => f.name == \"index.csv\");\n    const folderName = idx.webkitRelativePath.replace(idx.name, \"\");\n    //console.debug(idx);\n    //console.debug(folderName);\n    const data = await idx.text();\n    //console.debug(data);\n    const csvEntries = data\n      .split(\"\\n\")\n      .slice(1)\n      .filter((line) => line.length > 0)\n      .map((line) => line.split(\",\"))\n      .map((vec) => {\n        const obj = {};\n        vec.forEach((val, i) => (obj[header[i]] = val));\n        return obj;\n      });\n    //console.debug(csvEntries);\n    const blockExercMap = csvEntries.reduce(prepareData, new Map());\n    //console.log(Array.from(blockExercMatrix.entries()));\n    const getFilePath = async function (submission) {\n      const path = `${folderName}${submission[\"file\"]}`;\n      const file = files.find((f) => f.webkitRelativePath == path);\n      const text = await file.text();\n      return text;\n    };\n    const matrix = {};\n    let counter = 0;\n    blockExercMap.forEach((studentsMap, exercID) => {\n      const column = [];\n      studentsMap.forEach(async (submissions, studentID) => {\n        submissions = submissions.sort((a, b) => {\n          return parseInt(a[\"timestamp\"]) - parseInt(b[\"timestamp\"]);\n        });\n        counter++;\n        submissions.forEach(async (submission, index, array) => {\n          counter++;\n          const student = {};\n          student[\"grade\"] = Math.max(0, parseFloat(submission[\"grade\"]));\n          student[\"timestamp\"] = parseInt(submission[\"timestamp\"]);\n          student[\"student_id\"] = studentID;\n          student[\"TES\"] = 0;\n          student[\"DES\"] = 0;\n          student[\"D/T\"] = 0;\n          let previousCode = \"\";\n          if (index > 0) {\n            student[\"TES\"] =\n              parseInt(submission[\"timestamp\"]) -\n              parseInt(array[index - 1][\"timestamp\"]);\n            const previousFile = await getFilePath(array[index - 1]);\n            const previous = window.ivprogCore\n              .prepareActivityToStudentHelper(previousFile)\n              .getOrElse(1);\n            if (previous == 1) {\n              console.error(\n                `A submission from ${studentID} to ${exercID} is invalid`\n              );\n              return;\n            }\n            previousCode = generateSubCode(previous.algorithmInIlm);\n          }\n          const currentFile = await getFilePath(submission);\n          const current = window.ivprogCore\n            .prepareActivityToStudentHelper(currentFile)\n            .getOrElse(2);\n          if (current == 2) {\n            console.error(\n              `A submission from ${studentID} to ${exercID} is invalid`\n            );\n            return;\n          }\n          const currentCode = generateSubCode(current.algorithmInIlm);\n          if (previousCode === \"\") {\n            const logs = JSON.parse(currentFile.split(\"::logs::\")[1]);\n            const event = logs[0];\n            if (event == null) {\n              // empty submission\n              student[\"TES\"] = 0;\n            } else if (event.length === 4) {\n              student[\"TES\"] =\n                parseInt(submission[\"timestamp\"]) -\n                Math.floor(parseInt(event[2]) / 1000);\n            } else {\n              student[\"TES\"] =\n                parseInt(submission[\"timestamp\"]) -\n                Math.floor(parseInt(event[1]) / 1000);\n            }\n          }\n          student[\"DES\"] = window.ivprogCore.levenshteinDistance(\n            previousCode,\n            currentCode\n          );\n          const ratio =\n            student[\"TES\"] === 0 ? 0 : student[\"DES\"] / student[\"TES\"];\n          student[\"D/T\"] = isNaN(ratio) ? 0 : ratio;\n          column.push(student);\n          counter--;\n        });\n        counter--;\n      });\n      matrix[exercID] = column;\n    });\n    function download (file, text) {\n      //creating an invisible element\n      const element = document.createElement(\"a\");\n      element.setAttribute(\n        \"href\",\n        \"data:text/plain,\" + encodeURIComponent(text)\n      );\n      element.setAttribute(\"download\", file);\n      element.innerHTML = file;\n      element.classList.add(\"ui\", \"primary\", \"button\");\n\n      // Above code is equivalent to\n      // <a href=\"path of file\" download=\"file name\">\n\n      document.querySelector(\"#downloads\").appendChild(element);\n    }\n    function getExercHeader (id) {\n      const props = [\"TES\", \"DES\", \"grade\", \"D/T\", \"timestamp\"];\n      return props.reduce((acc, prop) => acc + `${id}_${prop},`, \"\");\n    }\n    const id = setInterval(() => {\n      if (counter == 0) {\n        clearInterval(id);\n        for (const exercID in matrix) {\n          let csv = \"\";\n          let firstLine = \"student_id,\";\n          firstLine += getExercHeader(exercID);\n          for (const submission of matrix[exercID]) {\n            csv += `${submission[\"student_id\"]},`;\n            csv += `${submission[\"TES\"]},`;\n            csv += `${submission[\"DES\"]},`;\n            csv += `${submission[\"grade\"]},`;\n            csv += `${submission[\"D/T\"]},`;\n            csv += `${submission[\"timestamp\"]}`;\n            csv += \"\\n\";\n          }\n          download(`${exercID}.csv`, `${firstLine}\\n${csv}`);\n        }\n      }\n    }, 1000);\n  });\n}\n","import { IVProgParser } from \"../ast/ivprogParser\";\nimport * as Expressions from \"../ast/expressions\";\nimport { Types } from \"../typeSystem/types\";\nimport { convertBoolToString } from \"../typeSystem/parsers\";\nimport * as Commands from \"../ast/commands\";\nimport { ArrayType } from \"../typeSystem/array_type\";\nimport { Literal } from \"../ast/expressions/literal\";\n\nconst TYPES = {\n  VARIABLE: \"var\",\n  CONST: \"const\",\n  FUNCTION: \"function\",\n  RELATIONAL: \"relational\",\n  LOGIC: \"logic\",\n  ARITHMETIC: \"arithmetic\",\n};\n\nfunction translateOp (type, op) {\n  switch (type) {\n    case TYPES.ARITHMETIC:\n      return op.value;\n    case TYPES.RELATIONAL:\n      return op.value;\n    case TYPES.LOGIC: {\n      if (op.ord === 11) {\n        return \"and\";\n      } else if (op.ord === 12) {\n        return \"or\";\n      } else {\n        return \"not\";\n      }\n    }\n  }\n}\n\nfunction getOpType (op) {\n  switch (op.ord) {\n    case 0:\n    case 1:\n    case 2:\n    case 3:\n    case 4:\n      return TYPES.ARITHMETIC;\n    case 5:\n    case 6:\n    case 7:\n    case 8:\n    case 9:\n    case 10:\n      return TYPES.RELATIONAL;\n    default:\n      return TYPES.LOGIC;\n  }\n}\n\n/**\n * @param {Commands.Case} switchCase\n * */\nfunction switchCaseWalker (switchCase) {\n  const commands = switchCase.commands.map(commandWalker);\n  const expression = switchCase.isDefault\n    ? null\n    : expressionWalker(switchCase.expression);\n  return {\n    type: \"switchcase\",\n    line: switchCase.sourceInfo.line,\n    expression,\n    commands,\n  };\n}\n\n/**\n * @param {Commands.Switch} switchCommand\n * */\nfunction switchWalker (switchCommand) {\n  const expression = expressionWalker(switchCommand.expression);\n  const cases = switchCommand.cases.map(switchCaseWalker);\n  return {\n    type: \"switch\",\n    expression,\n    cases,\n  };\n}\n\n/**\n * @param {Commands.Return} returnCommand\n * */\nfunction returnWalker (returnCommand) {\n  const expression = expressionWalker(returnCommand.expression);\n  return {\n    type: \"return\",\n    expression,\n  };\n}\n\nfunction breakWalker (_) {\n  return { type: \"break\" };\n}\n\n/**\n * @param {Commands.For} forLoop\n * */\nfunction forWalker (forLoop) {\n  const var_attribution = expressionWalker(forLoop.for_id);\n  const var_initial = expressionWalker(forLoop.for_from);\n  const condition = expressionWalker(forLoop.for_to);\n  const step_expression = forLoop.for_pass\n    ? expressionWalker(forLoop.for_pass)\n    : [];\n  const commands = forLoop.commands.map(commandWalker);\n  return {\n    type: \"repeatNtimes\",\n    var_attribution,\n    var_initial,\n    condition,\n    step_expression,\n    commands,\n  };\n}\n\n/**\n * @param {Commands.While} whileLoop\n * */\nfunction whileWalker (whileLoop) {\n  const expression = expressionWalker(whileLoop.expression);\n  const commands = whileLoop.commands.map(commandWalker);\n  let type = whileLoop.testFirst ? \"whiletrue\" : \"dowhiletrue\";\n  return {\n    type,\n    expression,\n    commands,\n  };\n}\n\n/**\n * @param {Commands.IfThenElse} ifthenelse\n * */\nfunction ifThenElseWalker (ifthenelse) {\n  //ifthenelse.\n  const expression = expressionWalker(ifthenelse.condition);\n  const ifTrue = ifthenelse.ifTrue.commands.map(commandWalker);\n  let ifFalse = [];\n  if (ifthenelse.ifFalse) {\n    if (ifthenelse.ifFalse instanceof Commands.CommandBlock) {\n      ifFalse = ifthenelse.ifFalse.commands.map(commandWalker);\n    } else {\n      ifFalse = [ifThenElseWalker(ifthenelse.ifFalse)];\n    }\n  }\n  return {\n    type: \"iftrue\",\n    expression,\n    ifTrue,\n    ifFalse,\n  };\n}\n\n/**\n * @param {Commands.Assign} assingment\n * */\nfunction assignmentWalker (assingment) {\n  let variable = null;\n  if (assingment instanceof Commands.ArrayIndexAssign) {\n    const line = expressionWalker(assingment.line);\n    let arrayClass = \"vector\";\n    let column = null;\n    if (assingment.column) {\n      arrayClass = \"matrix\";\n      column = expressionWalker(assingment.column);\n    }\n    variable = [\n      {\n        instance: \"expression\",\n        type: TYPES.VARIABLE,\n        class: arrayClass,\n        column: column,\n        line: line,\n        value: assingment.id,\n      },\n    ];\n  } else {\n    variable = [\n      { instance: \"expression\", type: TYPES.VARIABLE, value: assingment.id },\n    ];\n  }\n  const expression = expressionWalker(assingment.expression);\n  return {\n    type: \"attribution\",\n    variable,\n    expression,\n  };\n}\n\n/**\n * @param {Command} command\n * */\nfunction commandWalker (command) {\n  let parsedCommand = null;\n  if (command instanceof Commands.FunctionCall) {\n    parsedCommand = functionCallWalker(command);\n  } else if (command instanceof Commands.Assign) {\n    parsedCommand = assignmentWalker(command);\n  } else if (command instanceof Commands.IfThenElse) {\n    parsedCommand = ifThenElseWalker(command);\n  } else if (command instanceof Commands.While) {\n    parsedCommand = whileWalker(command);\n  } else if (command instanceof Commands.Break) {\n    parsedCommand = breakWalker(command);\n  } else if (command instanceof Commands.Return) {\n    parsedCommand = returnWalker(command);\n  } else if (command instanceof Commands.Switch) {\n    parsedCommand = switchWalker(command);\n  } else if (command instanceof Commands.For) {\n    parsedCommand = forWalker(command);\n  } else {\n    throw new Error(\"not implemented\");\n  }\n  parsedCommand.line = command.sourceInfo.line;\n  return parsedCommand;\n}\n\n/**\n * @param {Commands.FunctionCall} functionCall\n * */\nfunction functionCallWalker (functionCall) {\n  let name = functionCall.id;\n  if (name.indexOf(\".\") !== -1) {\n    name = name.split(\".\")[1];\n  }\n  const parameters = functionCall.actualParameters.map(expressionWalker);\n  if (name === \"$write\") {\n    const lastInput = parameters[parameters.length - 1][0];\n    // if lastInput is an object with value === '\\n', newLine is true\n    const newLine = lastInput.value && lastInput.value.match(/^\\n$/) !== null;\n    const content = newLine\n      ? parameters.slice(0, parameters.length - 1)\n      : parameters;\n    return {\n      type: \"writer\",\n      newLine,\n      content,\n    };\n  }\n  if (name === \"$read\") {\n    return {\n      type: \"reader\",\n      variable: parameters[0],\n    };\n  }\n  return {\n    type: \"functioncall\",\n    parameters_list: parameters,\n    name: functionCall.id,\n  };\n}\n/**\n * @param {Commands.Function} func\n * */\nfunction functionWalker (func) {\n  const funcDeclaration = {\n    name: func.name,\n    line: func.sourceInfo.line,\n    return_type: \"\",\n    return_dimensions: 0,\n    parameters_list: [],\n    variables_list: [],\n    commands: [],\n  };\n  if (func.returnType instanceof ArrayType) {\n    funcDeclaration.return_type = func.returnType.innerType.value;\n    funcDeclaration.return_dimensions = func.returnType.dimensions;\n  } else {\n    funcDeclaration.return_type = func.returnType.value;\n  }\n  funcDeclaration.parameters_list = func.formalParameters.map(\n    functionParameterWalker\n  );\n  funcDeclaration.variables_list = func.variablesDeclarations.map(\n    variableDeclarationWalker\n  );\n  funcDeclaration.commands = func.commands.map(commandWalker);\n  return funcDeclaration;\n}\n\n/**\n * @param {Commands.FormalParameter} formalParameter\n * */\nfunction functionParameterWalker (formalParameter) {\n  const variable = {\n    name: formalParameter.id,\n    line: formalParameter.sourceInfo.line,\n    type: \"\",\n    rows: 0,\n    columns: 0,\n    dimension: 0,\n    value: 0,\n    is_const: false,\n    reference: formalParameter.byRef,\n  };\n  if (formalParameter.type instanceof ArrayType) {\n    variable.type = formalParameter.type.innerType.value;\n    variable.dimension = formalParameter.type.dimensions;\n  } else {\n    variable.type = formalParameter.type.value;\n  }\n  return variable;\n}\n\n/**\n * @param {Commands.Declaration} command\n * @param {boolean} global\n * */\nfunction variableDeclarationWalker (command, global = false) {\n  const variable = {\n    name: command.id,\n    line: command.sourceInfo.line,\n    type: \"\",\n    rows: 0,\n    columns: 0,\n    dimension: 0,\n    value: 0,\n    is_const: false,\n  };\n  variable.is_const = global && command.isConst;\n  if (command instanceof Commands.ArrayDeclaration) {\n    // array\n    const lines = expressionWalker(command.lines).pop();\n    variable.type = command.type.innerType.value;\n    if (command.isVector) {\n      variable.columns = lines.value;\n      variable.dimension = 1;\n      const values = command.initial.value.map((exp) =>\n        variableInitialWalker(exp)\n      );\n      variable.value = values;\n    } else {\n      const columns = expressionWalker(command.columns).pop();\n      variable.dimension = 2;\n      variable.rows = lines.value;\n      variable.columns = columns.value;\n      const values = command.initial.value.map((rows) =>\n        rows.value.map((exp) => variableInitialWalker(exp))\n      );\n      variable.value = values;\n    }\n  } else {\n    // atomic\n    variable.type = command.type.value;\n    variable.value = variableInitialWalker(command.initial);\n  }\n  return variable;\n}\n\n/**\n * @param {any} expression\n * */\nfunction variableInitialWalker (expression) {\n  if (expression instanceof Expressions.UnaryApp) {\n    const left = variableInitialWalker(expression.left);\n    const opType = getOpType(expression.op);\n    if (opType !== TYPES.ARITHMETIC) {\n      throw new Error(\n        \"invalid variable initial value: \" + expression.toString()\n      );\n    }\n    return `${expression.op.value}${left}`;\n  } else if (expression instanceof Expressions.BoolLiteral) {\n    const value = expression.value;\n    return convertBoolToString(value);\n  } else if (expression instanceof Literal) {\n    let value = expression.value;\n    if (expression.value.toNumber) {\n      if (\n        Types.REAL.isCompatible(expression.type) &&\n        expression.value.decimalPlaces() == 0\n      ) {\n        value = Number(expression.value.toFixed(2));\n      } else {\n        value = expression.value.toNumber();\n      }\n    }\n    return value;\n  }\n  throw new Error(\"invalid variable initial value: \" + expression.toString());\n}\n\n/**\n *\n * @return {[]}\n **/\nfunction expressionWalker (expression) {\n  let result;\n  if (expression instanceof Expressions.VariableLiteral) {\n    result = [\n      { instance: \"expression\", type: TYPES.VARIABLE, value: expression.id },\n    ];\n  } else if (expression instanceof Expressions.FunctionCall) {\n    const funcObj = {\n      instance: \"expression\",\n      type: TYPES.FUNCTION,\n      value: expression.id,\n    };\n    const paramsList = expression.actualParameters.map((e) =>\n      expressionWalker(e)\n    );\n    //const params = Array.prototype.concat.apply([], paramsList);\n    funcObj.params = paramsList;\n    result = [funcObj];\n  } else if (expression instanceof Expressions.UnaryApp) {\n    const left = expressionWalker(expression.left);\n    const opType = getOpType(expression.op);\n    const opValue = translateOp(opType, expression.op);\n    result = [{ instance: \"operator\", type: opType, value: opValue }, ...left];\n  } else if (expression instanceof Expressions.InfixApp) {\n    const left = expressionWalker(expression.left);\n    const right = expressionWalker(expression.right);\n    const opType = getOpType(expression.op);\n    const opValue = translateOp(opType, expression.op);\n    result = [\n      ...left,\n      { instance: \"operator\", type: opType, value: opValue },\n      ...right,\n    ];\n  } else if (expression instanceof Expressions.ArrayAccess) {\n    const line = expressionWalker(expression.line);\n    let arrayClass = \"vector\";\n    let column = null;\n    if (expression.column) {\n      arrayClass = \"matrix\";\n      column = expressionWalker(expression.column);\n    }\n    result = [\n      {\n        instance: \"expression\",\n        type: TYPES.VARIABLE,\n        class: arrayClass,\n        column: column,\n        line: line,\n        value: expression.id,\n      },\n    ];\n  } else if (expression instanceof Expressions.BoolLiteral) {\n    const value = expression.value;\n    result = [\n      {\n        instance: \"expression\",\n        class: \"simple\",\n        type: TYPES.CONST,\n        value: convertBoolToString(value),\n      },\n    ];\n  } else {\n    let value = expression.value;\n    if (expression.value.toNumber) {\n      if (\n        Types.REAL.isCompatible(expression.type) &&\n        expression.value.decimalPlaces() == 0\n      ) {\n        value = Number(expression.value.toFixed(2));\n      } else {\n        value = expression.value.toNumber();\n      }\n    }\n    result = [\n      {\n        instance: \"expression\",\n        class: \"simple\",\n        type: TYPES.CONST,\n        value: value,\n      },\n    ];\n  }\n  if (expression.parenthesis) return [\"(\", ...result, \")\"];\n  else return result;\n}\n\nexport function parseExpression (text) {\n  const parser = IVProgParser.createParser(text);\n  const expressionAST = parser.parseExpressionOR();\n  return expressionWalker(expressionAST);\n}\n\n/**\n * @param {string} text\n * */\nexport function parseCode (text) {\n  const parser = IVProgParser.createParser(text, false);\n  const codeLinesMap = new Map();\n  const tokens = Array.from(parser.lexer.reset(text));\n  const tokenStream = [];\n  for (const token of tokens) {\n    if (token.type === parser.ruleNames.ERROR) {\n      return null;\n    }\n    if (token.type === parser.ruleNames.COMMENTS) {\n      for (let i = 0; i <= token.lineBreaks; i++) {\n        if (codeLinesMap.has(i + token.line))\n          codeLinesMap.get(i + token.line).push(token);\n        else codeLinesMap.set(i + token.line, [token]);\n      }\n      continue;\n    }\n    if (token.type !== parser.ruleNames.WHITESPACE) {\n      tokenStream.push(token);\n    }\n  }\n  parser.fill(tokenStream);\n  try {\n    const program = parser.parseTree();\n    const globals = program.global.map((decl) =>\n      variableDeclarationWalker(decl, true)\n    );\n    const functions = program.functions.map(functionWalker);\n    return { globals, functions };\n  } catch (e) {\n    console.error(e);\n    return null;\n  }\n}\n","import { Types } from '../typeSystem/types';\nimport { IType } from '../typeSystem/itype';\nimport { Type } from '../typeSystem/type';\nimport { Operators, Operator } from '../ast/operators';\nimport { MultiType } from '../typeSystem/multiType';\nimport { Config } from '../util/config';\n\nfunction buildInfixAddTable (): IType[][] {\n  const table: IType[][] = [[], [], [], [], []]\n\n  table[Types.INTEGER.ord][Types.INTEGER.ord] = Types.INTEGER;\n  table[Types.INTEGER.ord][Types.REAL.ord] = Types.REAL;\n  table[Types.INTEGER.ord][Types.STRING.ord] = Types.STRING;\n\n  table[Types.REAL.ord][Types.INTEGER.ord] = Types.REAL;\n  table[Types.REAL.ord][Types.REAL.ord] = Types.REAL;\n  table[Types.REAL.ord][Types.STRING.ord] = Types.STRING;\n\n  table[Types.STRING.ord][Types.INTEGER.ord] = Types.STRING;\n  table[Types.STRING.ord][Types.REAL.ord] = Types.STRING;\n  table[Types.STRING.ord][Types.STRING.ord] = Types.STRING;\n  table[Types.STRING.ord][Types.BOOLEAN.ord] = Types.STRING;\n  table[Types.STRING.ord][Types.CHAR.ord] = Types.STRING;\n\n  table[Types.CHAR.ord][Types.CHAR.ord] = Types.STRING;\n  table[Types.CHAR.ord][Types.STRING.ord] = Types.STRING;\n\n  return table;\n}\n\nfunction buildInfixMultiDivSubTable (): IType[][] {\n  const table: IType[][] = [[], []];\n\n  table[Types.INTEGER.ord][Types.INTEGER.ord] = Types.INTEGER;\n  table[Types.INTEGER.ord][Types.REAL.ord] = Types.REAL;\n\n  table[Types.REAL.ord][Types.INTEGER.ord] = Types.REAL;\n  table[Types.REAL.ord][Types.REAL.ord] = Types.REAL;\n\n  return table;\n}\n\nfunction buildInfixEqualityInequalityTable (): IType[][] {\n  const table: IType[][] = [[], [], [], [], []];\n\n  table[Types.INTEGER.ord][Types.INTEGER.ord] = Types.BOOLEAN;\n\n  table[Types.REAL.ord][Types.REAL.ord] = Types.BOOLEAN;\n\n  table[Types.BOOLEAN.ord][Types.BOOLEAN.ord] = Types.BOOLEAN;\n\n  table[Types.STRING.ord][Types.STRING.ord] = Types.BOOLEAN;\n\n  table[Types.CHAR.ord][Types.CHAR.ord] = Types.BOOLEAN;\n\n  return table;\n}\n\nfunction buildInfixRelationalTable (): IType[][] {\n  const table: IType[][] = [[], [], [], [], []];\n\n  table[Types.INTEGER.ord][Types.INTEGER.ord] = Types.BOOLEAN;\n\n  table[Types.REAL.ord][Types.REAL.ord] = Types.BOOLEAN;\n\n  table[Types.STRING.ord][Types.STRING.ord] = Types.BOOLEAN;\n\n  table[Types.CHAR.ord][Types.CHAR.ord] = Types.BOOLEAN;\n\n  return table;\n}\n\nfunction buildInfixAndOrTable (): IType[][] {\n  const table: IType[][] = [[], [], [], []];\n\n  table[Types.BOOLEAN.ord][Types.BOOLEAN.ord] = Types.BOOLEAN;\n\n  return table;\n}\n\nfunction buildInfixModTable (): IType[][] {\n  const table: IType[][] = [[]];\n\n  table[Types.INTEGER.ord][Types.INTEGER.ord] = Types.INTEGER;\n\n  return table;\n}\n\nfunction buildUnarySumSubList (): IType[] {\n  const list: IType[] = [];\n\n  list[Types.INTEGER.ord] = Types.INTEGER;\n\n  list[Types.REAL.ord] = Types.REAL;\n\n  return list;\n}\n\nfunction buildUnaryNegList (): IType[] {\n  const list: IType[] = [];\n\n  list[Types.BOOLEAN.ord] = Types.BOOLEAN;\n\n  return list;\n}\n\nfunction buildInfixCompatibilityTable (): WeakMap<Operator, IType[][]> {\n  const compatibilityMap = new WeakMap();\n  compatibilityMap.set(Operators.ADD, buildInfixAddTable());\n  compatibilityMap.set(Operators.SUB, buildInfixMultiDivSubTable());\n  compatibilityMap.set(Operators.MULT, buildInfixMultiDivSubTable());\n  compatibilityMap.set(Operators.DIV, buildInfixMultiDivSubTable());\n  compatibilityMap.set(Operators.EQ, buildInfixEqualityInequalityTable());\n  compatibilityMap.set(Operators.NEQ, buildInfixEqualityInequalityTable());\n  compatibilityMap.set(Operators.GE, buildInfixRelationalTable());\n  compatibilityMap.set(Operators.GT, buildInfixRelationalTable());\n  compatibilityMap.set(Operators.LE, buildInfixRelationalTable());\n  compatibilityMap.set(Operators.LT, buildInfixRelationalTable());\n  compatibilityMap.set(Operators.OR, buildInfixAndOrTable());\n  compatibilityMap.set(Operators.AND, buildInfixAndOrTable());\n  compatibilityMap.set(Operators.MOD, buildInfixModTable());\n  return compatibilityMap;\n}\n\nfunction buildUnaryCompatibilityTable (): WeakMap<Operator, IType[]> {\n  const compatibilityMap = new WeakMap();\n  compatibilityMap.set(Operators.ADD, buildUnarySumSubList());\n  compatibilityMap.set(Operators.SUB, buildUnarySumSubList());\n  compatibilityMap.set(Operators.NOT, buildUnaryNegList());\n  return compatibilityMap;\n}\n\nconst infixMap = buildInfixCompatibilityTable();\nconst unaryMap = buildUnaryCompatibilityTable();\n\nexport function resultTypeAfterInfixOp (\n  operator: Operator,\n  leftExpressionType: IType,\n  rightExpressionType: IType\n): IType {\n  try {\n    if (leftExpressionType instanceof MultiType && rightExpressionType instanceof MultiType) {\n      let newMulti = [];\n      for (let i = 0; i < leftExpressionType.types.length; ++i) {\n        const typeA = leftExpressionType.types[i];\n        for (let j = 0; j < rightExpressionType.types.length; ++i) {\n          const typeB = rightExpressionType.types[j];\n          newMulti.push(resultTypeAfterInfixOp(operator, typeA, typeB));\n        }\n      }\n      newMulti = newMulti.filter(x => !x.isCompatible(Types.UNDEFINED));\n      if (newMulti.length <= 0) {\n        if (Config.enable_type_casting) {\n          if (leftExpressionType.isCompatible(Types.INTEGER) || leftExpressionType.isCompatible(Types.REAL)) {\n            if (rightExpressionType.isCompatible(Types.INTEGER) || rightExpressionType.isCompatible(Types.REAL)) {\n              return new MultiType([Types.INTEGER, Types.REAL]);\n            }\n          }\n        }\n        return Types.UNDEFINED;\n      } else {\n        return new MultiType(newMulti as Type[])\n      }\n    } else if (leftExpressionType instanceof MultiType) {\n      if (leftExpressionType.isCompatible(rightExpressionType as Type)) {\n        return resultTypeAfterInfixOp(operator, rightExpressionType, rightExpressionType);\n      } else {\n        if (Config.enable_type_casting) {\n          if (leftExpressionType.isCompatible(Types.INTEGER) || leftExpressionType.isCompatible(Types.REAL)) {\n            if (rightExpressionType.isCompatible(Types.INTEGER) || rightExpressionType.isCompatible(Types.REAL)) {\n              return rightExpressionType;\n            }\n          }\n        }\n        return Types.UNDEFINED;\n      }\n    } else if (rightExpressionType instanceof MultiType) {\n      if (rightExpressionType.isCompatible(leftExpressionType as Type)) {\n        return resultTypeAfterInfixOp(operator, leftExpressionType, leftExpressionType);\n      } else {\n        if (Config.enable_type_casting) {\n          if (leftExpressionType.isCompatible(Types.INTEGER) || leftExpressionType.isCompatible(Types.REAL)) {\n            if (rightExpressionType.isCompatible(Types.INTEGER) || rightExpressionType.isCompatible(Types.REAL)) {\n              return leftExpressionType;\n            }\n          }\n        }\n        return Types.UNDEFINED;\n      }\n    }\n    const resultTable = infixMap.get(operator) || [];\n    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion\n    const resultType = resultTable[leftExpressionType.ord!][rightExpressionType.ord!];\n    if (resultType === null || resultType === undefined) {\n      if (Config.enable_type_casting) {\n        if (leftExpressionType.isCompatible(Types.INTEGER) || leftExpressionType.isCompatible(Types.REAL)) {\n          if (rightExpressionType.isCompatible(Types.INTEGER) || rightExpressionType.isCompatible(Types.REAL)) {\n            if (operator === Operators.MOD) {\n              return Types.INTEGER;\n            } else if (operator.ord >= 5 && operator.ord <= 10) {\n              return Types.BOOLEAN;\n            }\n          }\n        }\n      }\n      return Types.UNDEFINED\n    }\n    return resultType;\n  } catch (e) {\n    if (e instanceof TypeError) {\n      return Types.UNDEFINED;\n    } else {\n      throw e;\n    }\n  }\n}\n\nexport function resultTypeAfterUnaryOp (operator: Operator, leftExpressionType: IType): IType {\n  try {\n    if (leftExpressionType instanceof MultiType) {\n      let newMulti = [];\n      for (let i = 0; i < leftExpressionType.types.length; ++i) {\n        const type = leftExpressionType.types[i];\n        newMulti.push(resultTypeAfterUnaryOp(operator, type));\n      }\n      newMulti = newMulti.filter(x => !x.isCompatible(Types.UNDEFINED));\n      if (newMulti.length <= 0) {\n        return Types.UNDEFINED;\n      }\n      return new MultiType(newMulti as Type[]);\n    }\n    const resultTable = unaryMap.get(operator) || [];\n    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion\n    const resultType = resultTable[leftExpressionType.ord!];\n    if (resultType == null) {\n      return Types.UNDEFINED;\n    }\n    return resultType;\n  } catch (e) {\n    if (e instanceof TypeError) {\n      return Types.UNDEFINED;\n    } else {\n      throw e;\n    }\n  }\n}","export class Address {\n\n  public id: number;\n  public value: unknown;\n\n  /**\n   * \n   * @param {Number} id the address id\n   * @param {never} value the value stored at this address\n   */\n  constructor (id: number, value: unknown) {\n    this.id = id;\n    this.value = value;\n  }\n}","import { Address } from \"./address\";\n\nclass LocationHolder {\n\n  public data: Address[];\n  private address_id: number\n\n  constructor () {\n    this.data = [];\n    this.address_id = 0;\n  }\n\n  /**\n   * \n   * @param {never} value the value to be allocated\n   * @returns {number} - the address id\n   */\n  allocate (value: unknown): number {\n    const id = this.address_id;\n    // console.log(\"Allocation address \"+ id);\n    const address = new Address(id, value);\n    this.data.push(address);\n    this.address_id += 1;\n    return id;\n  }\n\n  /**\n   * \n   * @param {number} id \n   */\n  deallocate (id: number): boolean {\n    const index = this.findIndex(id);\n    // console.log(\"Deallocation address \"+ id);\n    if(index !== -1) {\n      this.data.splice(index, 1);\n      return true;\n    }\n    return false;\n  }\n\n  /**\n   * \n   * @param {number} id \n   * @returns {Address} the address identified by id\n   */\n  find (id: number): Address | undefined {\n    let beg = 0\n    let end = this.data.length;\n    // console.log(\"Finding address \"+id);\n    while (beg < end) {\n      const med = Math.floor((beg + end)/2);\n      const address = this.getAddressAt(med);\n      if(address.id === id) {\n        return address;\n      } else if (id > address.id) {\n        beg = med;\n      } else {\n        end = med\n      }\n    }\n    return undefined;\n  }\n\n  getAddressAt (pos: number): Address {\n    return this.data[pos];\n  }\n\n  /**\n   * \n   * @param {number} id address id\n   * @returns {number} the index of the address identified by id\n   */\n  findIndex (id: number): number {\n    let beg = 0\n    let end = this.data.length;\n    while (beg < end) {\n      const med = Math.floor((beg + end)/2);\n      const address = this.getAddressAt(med);\n      if(address.id === id) {\n        return med;\n      } else if (id > address.id) {\n        beg = med;\n      } else {\n        end = med\n      }\n    }\n    return -1;\n  }\n\n  updateAddress (id: number, value: unknown): void {\n    const index = this.findIndex(id);\n    if(index === -1) {\n      throw new Error(\"Invalid address...\" + id);\n    }\n    this.data[index].value = value;\n  }\n\n  clear (): void {\n    for (let i = 0; i < this.data.length; i += 1) {\n      delete this.data[i];\n    }\n    this.data = [];\n    this.address_id = 0;\n  }\n}\n\nconst inner_ref = new LocationHolder();\n\nexport const Location = Object.freeze({\n  allocate: inner_ref.allocate.bind(inner_ref),\n  deallocate: inner_ref.deallocate.bind(inner_ref),\n  find: inner_ref.find.bind(inner_ref),\n  updateAddress: inner_ref.updateAddress.bind(inner_ref),\n  clear: inner_ref.clear.bind(inner_ref),\n  size: () => inner_ref.data.length\n});","import { Location } from \"../../memory/location\";\nimport { IType } from \"../../typeSystem/itype\";\nimport { IStoreValue } from \"./value/istore_value\";\n\nexport class StoreObject {\n\n  private _type: IType;\n  private _loc_address: number;\n  private _readOnly: boolean;\n  private _id?: String;\n\n  /**\n   * \n   * @param {Type} type \n   * @param {Number} loc_address \n   * @param {Boolean} readOnly \n   */\n  constructor (type: IType, loc_address: number, readOnly = false) {\n    this._loc_address = loc_address;\n    this._type = type;\n    this._readOnly = readOnly;\n    this._id = undefined;\n  }\n\n  setID (id: String) {\n    this._id = id;\n  }\n\n  get id () {\n    return this._id;\n  }\n\n  get inStore () {\n    return this.id !== null;\n  }\n\n  get type () {\n    return this._type;\n  }\n\n  /**\n   * Returns the actual value stored at the loccation address present in this object.\n   * The returned value is compatible with @prop{StoreObject.type}\n  */\n  get value () {\n    const address = Location.find(this._loc_address);\n    if (address != null) {\n      return address.value\n    } else {\n      throw new Error(\"!!!Critical Error: variable \"+this.id+\" does not have a valid address. Loc-Address \"+ this.locAddress);\n    }\n  }\n  \n  get number () {\n    throw new Error(\"DOT NOT USE THIS PROPERTY!\");\n  }\n\n  get readOnly () {\n    return this._readOnly;\n  }\n\n  set readOnly (value) {\n    this._readOnly = value;\n  }\n\n  isCompatible (another: IStoreValue) {\n    return this.type.isCompatible(another.type);\n  }\n\n  destroy () {\n    return Location.deallocate(this._loc_address);\n  }\n\n  get locAddress () {\n    return this._loc_address;\n  }\n}\n","import { StoreObject } from './storeObject';\nimport { StoreValueRef } from './value/store_value_ref';\n\nexport class StoreObjectRef extends StoreObject {\n\n  private refObj: String;\n  private reference_dimension: number;\n\n  /**\n   * \n   * @param {StoreObject} stoValue \n   */\n  constructor (stoValue: StoreValueRef) {\n    super(stoValue.type, stoValue.getRefAddress(), false);\n    this.refObj = stoValue.id!;\n    this.reference_dimension = stoValue.getReferenceDimension();\n  }\n\n  get isRef () {\n    return true;\n  }\n\n  getRefObj (): String {\n    return this.refObj;\n  }\n\n  getReferenceDimension (): number {\n    return this.reference_dimension;\n  }\n\n  destroy () {\n    return false;\n  }\n}","import { StoreValue } from \"./store_value\";\nimport { IType } from \"../../../typeSystem/itype\";\n\nexport class StoreValueAddress extends StoreValue {\n\n  constructor (type: IType, value: any, public line: number, public column?: number, id?:String, isConst = false)  {\n    super(type,value,id, isConst);\n  }\n}","import { IStoreValue } from \"./istore_value\";\nimport { ArrayType } from \"../../../typeSystem/array_type\";\nimport { IType } from \"../../../typeSystem/itype\";\nimport { Type } from \"../../../typeSystem/type\";\nimport { StoreValueAddress } from \"./store_value_address\";\n\nexport class ArrayStoreValue implements IStoreValue {\n\n  public type: IType; \n  public id?: String;\n  public isConst: boolean;\n  public lines: number;\n  public columns?: number;\n  public values: StoreValueAddress[];\n\n  constructor(type: ArrayType, values: StoreValueAddress[], lines: number, columns?: number, id?: String, isConst = false) {\n    this.type = type;\n    this.id = id;\n    this.isConst = isConst\n    this.values = values;\n    this.lines = lines;\n    this.columns = columns;\n  }\n\n  get (): StoreValueAddress[] {\n    return this.values;\n  }\n\n  /**\n   * @deprecated\n   * Potential not necessary since array access is occuring directly in the StoreObject\n   * @param line \n   * @param column \n   */\n  getAt (line: number, column?: number): IStoreValue {\n    console.log(\"Column \", column);\n    if(this.isVector()) {\n      if(column != null) {\n        throw new Error(this.id + \" is not a matrix!\");\n      }\n      column = line;\n      line = 0;\n    } else if (column == null) {\n      const values: StoreValueAddress[] = [];\n      for(let col = 0; col < this.columns!; col += 1) {\n        const index = line * this.lines + col;\n        values.push(this.values[index]);\n      }\n      const array_type = this.type as ArrayType\n      const vector_type = new ArrayType(array_type.innerType as Type, array_type.dimensions - 1);\n      return new ArrayStoreValue(vector_type, values, this.columns!, 0, this.id, this.isConst);\n    }\n    const index = line * this.lines + column;\n    console.log(\"Get at: \",index);\n    return this.values[index];\n  }\n\n  setAt (value: IStoreValue, line:number, column?: number): void {\n    let used_dims = 1;\n    if(column != null) {\n      used_dims += 1;\n    }\n    let actual_line = line;\n    let actual_column = column;\n    if(!(this.type as ArrayType).canAccept(value.type, used_dims)) {\n      throw new Error(\"!!!Internal Error: Attempting to insert an invalid value inside array \"+this.id);\n    }\n    if(this.isVector()) {\n      if(column != null) {\n        throw new Error(this.id + \" is not a matrix!\");\n      }\n      actual_column = actual_line;\n      actual_line = 0;\n    } else if (column == null) {\n      if(!(value instanceof ArrayStoreValue)) {\n        throw new Error(\"Attempting to insert a single value as a line of matrix \" + this.id);\n      }\n      const actual_values = value.get()\n      for(let i = 0; i < this.columns!; i += 1) {\n        const pos = actual_line * this.columns! + i;\n        const val = actual_values[i]\n        this.values[pos] = new StoreValueAddress(value.type, val.get(), actual_line, i, this.id, this.isConst);\n      }\n    }\n    const columns =  this.columns == null ? 0 : this.columns;\n    const pos = actual_line * columns + actual_column!;\n    this.values[pos] = new StoreValueAddress(value.type, value.get(), line, column, this.id, this.isConst);\n  }\n\n  inStore () {\n    return this.id != null;\n  }\n\n  isVector (): boolean {\n    return (this.type as ArrayType).dimensions == 1;\n  }\n}\n","import getPrototypeOf from \"./getPrototypeOf.js\";\nexport default function _superPropBase(object, property) {\n  while (!Object.prototype.hasOwnProperty.call(object, property)) {\n    object = getPrototypeOf(object);\n    if (object === null) break;\n  }\n  return object;\n}","import superPropBase from \"./superPropBase.js\";\nexport default function _get() {\n  if (typeof Reflect !== \"undefined\" && Reflect.get) {\n    _get = Reflect.get.bind();\n  } else {\n    _get = function _get(target, property, receiver) {\n      var base = superPropBase(target, property);\n      if (!base) return;\n      var desc = Object.getOwnPropertyDescriptor(base, property);\n      if (desc.get) {\n        return desc.get.call(arguments.length < 3 ? target : receiver);\n      }\n      return desc.value;\n    };\n  }\n  return _get.apply(this, arguments);\n}","import { StoreObject } from './storeObject';\nimport { ArrayType } from '../../typeSystem/array_type';\nimport { ArrayStoreValue } from './value/array_store_value';\nimport { Location } from \"../../memory/location\";\nimport { IStoreValue } from './value/istore_value';\nimport { StoreValue } from './value/store_value';\n\nexport class StoreObjectArray extends StoreObject {\n\n  constructor (type: ArrayType, private _lines:number, private _columns:number, private loc_addresses: number[], readOnly = false) {\n    super(type, -1, readOnly);\n  }\n\n  get lines () {\n    return this._lines;\n  }\n\n  get columns () {\n    return this._columns;\n  }\n\n  isCompatible (another: IStoreValue): boolean {\n    if(another instanceof ArrayStoreValue) {\n      const cols = another.columns == null ? 0 :  another.columns;\n      if(this.lines === another.lines && this.columns === cols) {\n          return super.isCompatible(another);\n      }\n    }\n    return false;\n  }\n\n  get isVector () {\n    return (this.type as ArrayType).dimensions === 1;\n  }\n\n  /**@override \n     * Returns the list of values stored by this array.\n     * All returned values are compatible with @prop{StoreObject.type}\n    */\n  get value () {\n    const values = [];\n    for(let i = 0; i < this.addresses.length; i += 1) {\n      const address = Location.find(this.addresses[i]);\n      if (address != null) {\n        values.push(address.value);\n      } else {\n        throw new Error(\"!!!Critical Error: variable \"+this.id+\" does not have a valid address. Loc-Address \"+ this.locAddress);\n      }\n    }\n    return values;\n  }\n\n  destroy () {\n    let bool =  true;\n    for(let i = 0; i < this.addresses.length; i += 1) {\n      bool = bool && Location.deallocate(this.addresses[i]);\n    }\n    return bool;\n  }\n\n  /**\n   * @override\n   * \n   * Returns the address that contains a list of all addresses of the values present in the array\n   */\n  get locAddress (): number {\n    throw new Error(\"!!!Internal Error: Cannot invoke locAddress on StoreObjectArray\");\n  }\n\n  protected get addresses (): number[] {\n    return this.loc_addresses;\n  }\n\n  getAt (line: number, column?: number): any {\n    if(this.isVector) {\n      if(column != null) {\n        throw new Error(this.id + \" is not a matrix!\");\n      }\n      column = line;\n      line = 0;\n    } else if (column == null) {\n      // this is a whole line...\n      const values = [];\n      for(let col = 0; col < this.columns; col += 1) {\n        const index = this.getIndexOf(line, col);\n        const address = Location.find(this.addresses[index])!;\n        values.push(address.value);\n      }\n      return values;\n    }\n    const index = this.getIndexOf(line, column);\n    const address = Location.find(this.addresses[index])!;\n    return address.value;\n  }\n\n  setAt (value: StoreValue, line:number, column?: number): void {\n    let used_dims = 1;\n    if(column != null) {\n      used_dims += 1;\n    }\n    if(!(this.type as ArrayType).canAccept(value.type, used_dims)) {\n      throw new Error(\"!!!Internal Error: Attempting to insert an invalid value inside array \"+this.id);\n    }\n    if(this.isVector) {\n      if(column != null) {\n        throw new Error(this.id + \" is not a matrix!\");\n      }\n      column = line;\n      line = 0;\n    } else if (column == null) {\n      throw new Error(\"!!!Internal Error: Attempting to insert a line into matrix \"+ this.id );\n    }\n    const pos = this.getIndexOf(line, column);\n    Location.updateAddress(this.addresses[pos], value.get());\n  }\n\n  protected getIndexOf (line: number, column: number): number {\n    return line * this.columns + column;\n  }\n\n  getLocAddressOf (line: number, column?: number): number | number[] {\n    if(this.isVector) {\n      if(column != null) {\n        throw new Error(this.id + \" is not a matrix!\");\n      }\n      column = line;\n      line = 0;\n    } else if (column == null) {\n      // this is a whole line...\n      const values: number[] = [];\n      for(let col = 0; col < this.columns; col += 1) {\n        const index = this.getIndexOf(line, col);\n        values.push(this.addresses[index]);\n      }\n      return values;\n    }\n    const index = this.getIndexOf(line, column);\n    return this.addresses[index];\n  }\n}\n","import { IStoreValue } from \"./istore_value\";\nimport { Type } from \"../../../typeSystem/type\";\n\nexport class StoreValueRef implements IStoreValue {\n\n  public isConst = false;\n  private reference_dimesion = 0;\n\n  constructor(public type: Type, public value: any, private loc_address: number, public id:String) {\n\n  }\n\n  get () {\n    return this.value;\n  }\n\n  getRefAddress () : number {\n    return this.loc_address;\n  }\n\n  inStore () {\n    return this.id != null;\n  }\n\n  getReferenceDimension (): number {\n    return this.reference_dimesion;\n  }\n\n  setReferenceDimension (dimension: number):void {\n    this.reference_dimesion = dimension;\n  }\n}","import { IStoreValue } from \"./istore_value\";\nimport { StoreValueAddress } from \"./store_value_address\";\nimport { ArrayType } from \"../../../typeSystem/array_type\";\n\nexport class ArrayStoreValueRef implements IStoreValue {\n\n  public isConst = false;\n\n  constructor(public type: ArrayType, private values: StoreValueAddress[],\n    private addresses: number[], public lines: number, public columns:number,\n    public id:String) { }\n\n  get () {\n    return this.values;\n  }\n\n  getAddresses (): number[] {\n    return this.addresses;\n  }\n\n  inStore () {\n    return this.id != null;\n  }\n}","import { StoreObjectArray } from \"./storeObjectArray\";\nimport { ArrayStoreValueRef } from \"./value/array_store_value_ref\";\n\nexport class StoreObjectArrayRef extends StoreObjectArray {\n\n  private refObj: String;\n\n  constructor(stoValue: ArrayStoreValueRef, lines:number, columns:number) {\n    super(stoValue.type, lines, columns, stoValue.getAddresses(), false);\n    this.refObj = stoValue.id;\n  }\n\n  get isRef () {\n    return true;\n  }\n\n  getRefObj (): String {\n    return this.refObj;\n  }\n\n  destroy () {\n    return false;\n  }\n}","/* eslint-disable @typescript-eslint/no-non-null-assertion */\nimport { Modes } from '../modes';\nimport { Types } from \"../../typeSystem/types\";\nimport { StoreObject } from './storeObject';\nimport { IType } from '../../typeSystem/itype';\nimport { StoreObjectRef } from './storeObjectRef';\nimport { ArrayType } from '../../typeSystem/array_type';\nimport { ArrayStoreValue } from './value/array_store_value';\nimport { Location } from '../../memory/location';\nimport { StoreObjectArray } from './storeObjectArray';\nimport { IStoreValue } from './value/istore_value';\nimport { StoreValue } from './value/store_value';\nimport { StoreValueAddress } from './value/store_value_address';\nimport { StoreValueRef } from './value/store_value_ref';\nimport { ArrayStoreValueRef } from './value/array_store_value_ref';\nimport { StoreObjectArrayRef } from './store_object_array_ref';\n\nexport class Store {\n\n  static canImplicitTypeCast (castType: IType, sourceType: IType): boolean {\n    if (castType.isCompatible(Types.INTEGER) || castType.isCompatible(Types.REAL)) {\n      if (sourceType.isCompatible(Types.INTEGER) || sourceType.isCompatible(Types.REAL)) {\n        return true;\n      }\n    }\n    return false;\n  }\n\n  static doImplicitCasting (castType: IType, stoObj: IStoreValue): IStoreValue {\n    if(!Store.canImplicitTypeCast(castType, stoObj.type)) {\n      throw new Error(\"!!!Critical error: attempted to type cast invalid types\");\n    }\n    if(castType.isCompatible(Types.INTEGER)) {\n      return new StoreValue(Types.INTEGER, stoObj.get().trunc());\n    } else {\n      return new StoreValue(Types.REAL, stoObj.get());\n    }\n  }\n\n  private store: Map<string, StoreObject>;\n  public nextStore?: Store\n  public mode: symbol;\n\n  constructor(public name: string) {\n    this.store = new Map<string, StoreObject>();\n    this.mode = Modes.RUN; \n  }\n\n  extendStore (nextStore: Store): void {\n    this.nextStore = nextStore;\n  }\n\n  applyStore (id: string): IStoreValue {\n    if (!this.store.has(id)) {\n      if (this.nextStore != null) {\n        return this.nextStore.applyStore(id);\n      } else {\n        throw new Error(`Variable ${id} not found.`);\n      }\n    }\n    const val = this.store.get(id)!;\n    let result = null\n    if (val.type instanceof ArrayType) {\n      const array = val as StoreObjectArray;\n      const array_type = array.type as ArrayType;\n      let l = 0, c = 0;\n      const values = array.value.map( v => {\n        if(array.isVector) {\n          return new StoreValueAddress(array_type.innerType, v, l++, undefined, array.id, array.readOnly);  \n        } else {\n          if(c >= array.columns) {\n            c = 0;\n            l += 1;\n          }\n          return new StoreValueAddress(array_type.innerType, v, l, c++, array.id, array.readOnly);  \n        }\n      });\n      result = new ArrayStoreValue(array_type, values, array.lines, array.columns, val.id, val.readOnly);\n    } else {\n      result = new StoreValue(val.type, val.value, val.id, val.readOnly);\n    }\n    \n    return result;\n  }\n\n  updateStore (id: string, stoValue: IStoreValue): Store {\n    if (!this.store.has(id)) {\n      if (this.nextStore != null) {\n        this.nextStore.updateStore(id, stoValue);\n        return this;\n      } else {\n        // TODO: better error message\n        throw new Error(`Variable ${id} not found.`);\n      }\n    } else {\n      const oldObj = this.store.get(id)!;\n      if (oldObj.readOnly) {\n        // TODO: better error message\n        throw new Error(\"Cannot change value of a read only variable: \" + id);\n      }\n\n      if (oldObj instanceof StoreObjectArray) {\n        const array_value = stoValue as ArrayStoreValue;\n        if(oldObj.isCompatible(array_value)) {\n          if(oldObj.isVector) {\n            array_value.get().forEach((val, index) => {\n              oldObj.setAt(val, index, undefined);\n            });\n          } else {\n            let line = 0;\n            let column = 0;\n            array_value.get().forEach((val) => {\n              oldObj.setAt(val, line, column);\n              column += 1;\n              if(column >= oldObj.columns) {\n                line += 1;\n                column = 0;\n              }\n            });\n          }\n          return this;\n        }\n      } else if (oldObj.isCompatible(stoValue)) {\n        const loc_address = oldObj.locAddress;\n        Location.updateAddress(loc_address, stoValue.get());\n        return this;\n      }\n      const oldType = oldObj.type;\n      const stoType = stoValue.type;\n      // TODO: better error message\n      throw new Error(`${oldType.value} is not compatible with type ${stoType.value} given`);\n      \n    }\n  }\n\n  /**\n   * Method used to update regions of an array (vector or matrix). The should only be used when update an specific\n   * possition since it will only update the required addresses.\n   * @param {string} id the variable id to be updated\n   * @param {IStoreValue} sto_value the value to be used in the update process\n   * @param {number} line the line address of the vector/matrix\n   * @param {number} column the matrix column, which can be undefined\n   */\n  updateStoreArray (id: string, sto_value: IStoreValue, line: number, column?: number): Store {\n    if (!this.store.has(id)) {\n      if (this.nextStore != null) {\n        this.nextStore.updateStoreArray(id, sto_value, line, column);\n        return this;\n      } else {\n        // TODO: better error message\n        throw new Error(`Variable ${id} not found.`);\n      }\n    } else {\n      const oldObj = this.store.get(id)!;\n      if (oldObj.readOnly) {\n        // TODO: better error message\n        throw new Error(\"Cannot change value of a read only variable: \" + id);\n      }\n\n      if (oldObj instanceof StoreObjectArray) {\n        if(sto_value instanceof ArrayStoreValue) {\n          // this must be a vector  or matrix line update\n          const actual_values =  sto_value.get();\n          if(oldObj.isVector && sto_value.isVector()) {\n            for(let i = 0;i < sto_value.lines; i += 1) {\n              const val = actual_values[i]\n              oldObj.setAt(val, i, undefined);\n            }\n          } else if(!oldObj.isVector && column == null && sto_value.isVector()) {\n            for(let i = 0;i < oldObj.columns; i += 1) {\n              const val = actual_values[i]\n              oldObj.setAt(val, line, i);\n            }\n          } else {\n            // TODO: better error message\n            throw new Error(`Attempting to assign an invalid value to array ${id}`);\n          }\n        } else {\n          if(!oldObj.isVector && column == null) {\n            // TODO: better error message\n            throw new Error(`Attempting to assign an invalid value to array ${id}`);\n          }\n          oldObj.setAt(sto_value as StoreValue, line, column);\n        }\n      } else {\n        throw new Error(\"Cannot update a non-array variable using updateStoreArray\");\n      }\n      // const oldType = oldObj.type;\n      // const stoType = sto_value.type;\n      // // TODO: better error message\n      // throw new Error(`${oldType.value} is not compatible with type ${stoType.value} given`);\n      return this;\n    }\n  }\n\n  /**\n   * Inserts a new variable into the Store. This method should be used when declaring a new variable,\n   * including the special return variable $.\n   * @param id variable id\n   * @param stoValue the value to be used as the initial value of id\n   */\n  insertStore (id: string, stoValue: IStoreValue): Store {\n    if (this.store.has(id)) {\n      // TODO: better error message\n      throw new Error(`${id} is already defined`);\n    }\n    // TODO check for array....\n    let newObj: StoreObject;\n    if(stoValue instanceof StoreValueRef) {\n      newObj = new StoreObjectRef(stoValue);\n    } else if (stoValue instanceof ArrayStoreValueRef) {\n      newObj = new StoreObjectArrayRef(stoValue, stoValue.lines, stoValue.columns);\n    } else if (stoValue instanceof ArrayStoreValue) {\n      const columns = stoValue.isVector() ? 0 : stoValue.columns!;\n      const addresses: number[] = [];\n      const all_values = stoValue.get();\n      if(all_values.length > 0) {\n        for(let i = 0; i < stoValue.get().length; i += 1) {\n          const val = all_values[i].get();\n          addresses.push(Location.allocate(val));\n        }\n      } else {\n        let total = stoValue.lines;\n        total = stoValue.isVector() ? total : total * columns;\n        for(let i = 0; i < total; i += 1) {\n          addresses.push(Location.allocate(null));\n        }\n      }\n      newObj = new StoreObjectArray(stoValue.type as ArrayType, stoValue.lines, columns, addresses, stoValue.isConst);\n    } else {\n      const loc_address = Location.allocate(stoValue.get());\n      newObj = new StoreObject(stoValue.type, loc_address, stoValue.isConst);\n    }\n    newObj.setID(id);\n    this.store.set(id, newObj);\n    return this;\n  }\n  /**\n   * Helper function similar to applyStore. But it returns the actual object in the store be it ref or not\n   * applyStore will return the refferenced object if the object in the store is a ref\n   */\n  getStoreObject (id: string): StoreObject {\n    if (!this.store.has(id)) {\n      if (this.nextStore != null) {\n        return this.nextStore.getStoreObject(id);\n      } else {\n        throw new Error(`Variable ${id} not found.`);\n      }\n    }\n    return this.store.get(id)!;\n  }\n\n  destroy (): void {\n    this.store.forEach(sto => sto.destroy(), this);\n  }\n\n  isDefined (id: string): boolean {\n    if (!this.store.has(id)) {\n      if (this.nextStore != null) {\n        return this.nextStore.isDefined(id);\n      } else {\n        return false;\n      }\n    }\n    return true;\n  }\n}","import { ProcessorErrorFactory } from \"./../error/processorErrorFactory\";\nimport { LanguageDefinedFunction } from \"./../definedFunctions\";\nimport {\n  ArrayDeclaration,\n  While,\n  For,\n  Switch,\n  Assign,\n  Break,\n  IfThenElse,\n  Return,\n  ArrayIndexAssign,\n} from \"../../ast/commands\";\n// eslint-disable-next-line @typescript-eslint/no-unused-vars\nimport { Expression } from \"./../../ast/expressions/expression\";\nimport {\n  InfixApp,\n  UnaryApp,\n  FunctionCall,\n  IntLiteral,\n  RealLiteral,\n  StringLiteral,\n  BoolLiteral,\n  VariableLiteral,\n  ArrayAccess,\n  CharLiteral,\n} from \"../../ast/expressions\";\nimport { Literal } from \"../../ast/expressions/literal\";\nimport {\n  resultTypeAfterInfixOp,\n  resultTypeAfterUnaryOp,\n} from \"../compatibilityTable\";\nimport { Types } from \"../../typeSystem/types\";\nimport { ArrayType } from \"../../typeSystem/array_type\";\nimport { MultiType } from \"../../typeSystem/multiType\";\nimport { Config } from \"../../util/config\";\nimport { Store } from \"../store/store\";\nimport { IVProgParser } from \"../../ast/ivprogParser\";\n\nexport class SemanticAnalyser {\n  static analyseFromSource (stringCode) {\n    const parser = IVProgParser.createParser(stringCode);\n    const semantic = new SemanticAnalyser(parser.parseTree());\n    return semantic.analyseTree();\n  }\n\n  constructor (ast) {\n    this.ast = ast;\n    this.symbolMap = null;\n    this.currentFunction = null;\n  }\n\n  pushMap () {\n    if (this.symbolMap === null) {\n      this.symbolMap = { map: {}, next: null };\n    } else {\n      const n = { map: {}, next: this.symbolMap };\n      this.symbolMap = n;\n    }\n  }\n\n  popMap () {\n    if (this.symbolMap !== null) {\n      this.symbolMap = this.symbolMap.next;\n    }\n  }\n\n  insertSymbol (id, typeInfo) {\n    this.symbolMap.map[id] = typeInfo;\n  }\n\n  findSymbol (id, symbol_map) {\n    if (!symbol_map.map[id]) {\n      if (symbol_map.next) {\n        return this.findSymbol(id, symbol_map.next);\n      }\n      return null;\n    } else {\n      return symbol_map.map[id];\n    }\n  }\n\n  getMainFunction () {\n    return this.ast.functions.find((v) => v.isMain);\n  }\n\n  findFunction (name) {\n    if (name.match(/^\\$.+$/)) {\n      const fun = LanguageDefinedFunction.getFunction(name);\n      if (!fun) {\n        throw ProcessorErrorFactory.not_implemented(name);\n      }\n      return fun;\n    } else {\n      const val = this.ast.functions.find((v) => v.name === name);\n      if (!val) {\n        return null;\n      }\n      return val;\n    }\n  }\n\n  analyseTree () {\n    const globalVars = this.ast.global;\n    this.pushMap();\n    this.assertDeclarations(globalVars);\n    const functions = this.ast.functions;\n    const mainFunc = functions.filter((f) => f.name === null);\n    if (mainFunc.length <= 0) {\n      throw ProcessorErrorFactory.main_missing();\n    }\n    for (let i = 0; i < functions.length; i++) {\n      const fun = functions[i];\n      this.assertFunction(fun);\n    }\n    return this.ast;\n  }\n\n  assertDeclarations (list) {\n    for (let i = 0; i < list.length; i++) {\n      this.assertDeclaration(list[i]);\n    }\n  }\n\n  assertDeclaration (declaration) {\n    if (declaration instanceof ArrayDeclaration) {\n      this.assertArrayDeclaration(declaration);\n      this.insertSymbol(declaration.id, {\n        id: declaration.id,\n        lines: declaration.lines,\n        columns: declaration.columns,\n        type: declaration.type,\n        isConst: declaration.isConst,\n      });\n    } else {\n      if (declaration.initial === null) {\n        this.insertSymbol(declaration.id, {\n          id: declaration.id,\n          type: declaration.type,\n          isConst: declaration.isConst,\n        });\n        return;\n      }\n      const resultType = this.evaluateExpressionType(declaration.initial);\n      if (resultType instanceof MultiType) {\n        if (!resultType.isCompatible(declaration.type)) {\n          const stringInfo = declaration.type.stringInfo();\n          const info = stringInfo[0];\n          const result_string_info = resultType.stringInfo();\n          const result_info = result_string_info[0];\n          const exp = declaration.initial;\n          throw ProcessorErrorFactory.incompatible_types_full(\n            info.type,\n            info.dim,\n            result_info.type,\n            result_info.dim,\n            exp.toString(),\n            declaration.sourceInfo\n          );\n        }\n        this.insertSymbol(declaration.id, {\n          id: declaration.id,\n          type: declaration.type,\n          isConst: declaration.isConst,\n        });\n      } else if (\n        (!declaration.type.isCompatible(resultType) &&\n          !Config.enable_type_casting) ||\n        (!declaration.type.isCompatible(resultType) &&\n          Config.enable_type_casting &&\n          !Store.canImplicitTypeCast(declaration.type, resultType))\n      ) {\n        const stringInfo = declaration.type.stringInfo();\n        const info = stringInfo[0];\n        const result_string_info = resultType.stringInfo();\n        const result_info = result_string_info[0];\n        const exp = declaration.initial;\n        throw ProcessorErrorFactory.incompatible_types_full(\n          info.type,\n          info.dim,\n          result_info.type,\n          result_info.dim,\n          exp.toString(),\n          declaration.sourceInfo\n        );\n      } else {\n        this.insertSymbol(declaration.id, {\n          id: declaration.id,\n          type: declaration.type,\n          isConst: declaration.isConst,\n        });\n      }\n    }\n  }\n\n  assertArrayDeclaration (declaration) {\n    if (declaration.initial === null) {\n      const lineType = this.evaluateExpressionType(declaration.lines);\n      if (!lineType.isCompatible(Types.INTEGER)) {\n        throw ProcessorErrorFactory.array_dimension_not_int_full(\n          declaration.sourceInfo\n        );\n      }\n      if (declaration.columns !== null) {\n        const columnType = this.evaluateExpressionType(declaration.columns);\n        if (!columnType.isCompatible(Types.INTEGER)) {\n          throw ProcessorErrorFactory.array_dimension_not_int_full(\n            declaration.sourceInfo\n          );\n        }\n      }\n    } else {\n      this.evaluateArrayLiteral(declaration);\n    }\n    this.insertSymbol(declaration.id, {\n      id: declaration.id,\n      lines: declaration.lines,\n      columns: declaration.columns,\n      type: declaration.type,\n    });\n    return;\n  }\n\n  evaluateExpressionType (expression) {\n    // TODO: Throw operator error in case type == UNDEFINED\n    if (expression instanceof UnaryApp) {\n      const op = expression.op;\n      const resultType = this.evaluateExpressionType(expression.left);\n      const finalResult = resultTypeAfterUnaryOp(op, resultType);\n      if (Types.UNDEFINED.isCompatible(finalResult)) {\n        const stringInfo = resultType.stringInfo();\n        const info = stringInfo[0];\n        const expString = expression.toString();\n        throw ProcessorErrorFactory.invalid_unary_op_full(\n          expString,\n          op,\n          info.type,\n          info.dim,\n          expression.sourceInfo\n        );\n      }\n      return finalResult;\n    } else if (expression instanceof InfixApp) {\n      const op = expression.op;\n      const resultTypeLeft = this.evaluateExpressionType(expression.left);\n      const resultTypeRight = this.evaluateExpressionType(expression.right);\n      const finalResult = resultTypeAfterInfixOp(\n        op,\n        resultTypeLeft,\n        resultTypeRight\n      );\n      if (Types.UNDEFINED.isCompatible(finalResult)) {\n        const stringInfoLeft = resultTypeLeft.stringInfo();\n        const infoLeft = stringInfoLeft[0];\n        const stringInfoRight = resultTypeRight.stringInfo();\n        const infoRight = stringInfoRight[0];\n        const expString = expression.toString();\n        throw ProcessorErrorFactory.invalid_infix_op_full(\n          expString,\n          op,\n          infoLeft.type,\n          infoLeft.dim,\n          infoRight.type,\n          infoRight.dim,\n          expression.sourceInfo\n        );\n      }\n      return finalResult;\n    } else if (expression instanceof Literal) {\n      return this.evaluateLiteralType(expression);\n    } else if (expression instanceof FunctionCall) {\n      if (expression.isMainCall) {\n        throw ProcessorErrorFactory.void_in_expression_full(\n          LanguageDefinedFunction.getMainFunctionName(),\n          expression.sourceInfo\n        );\n      }\n      const fun = this.findFunction(expression.id);\n      if (fun === null) {\n        throw ProcessorErrorFactory.function_missing_full(\n          expression.id,\n          expression.sourceInfo\n        );\n      }\n      if (fun.returnType.isCompatible(Types.VOID)) {\n        throw ProcessorErrorFactory.void_in_expression_full(\n          expression.id,\n          expression.sourceInfo\n        );\n      }\n      this.assertParameters(fun, expression.actualParameters);\n      return fun.returnType;\n    } else if (expression instanceof ArrayAccess) {\n      const arrayTypeInfo = this.findSymbol(expression.id, this.symbolMap);\n      if (arrayTypeInfo === null) {\n        throw ProcessorErrorFactory.symbol_not_found_full(\n          expression.id,\n          expression.sourceInfo\n        );\n      }\n      if (!(arrayTypeInfo.type instanceof ArrayType)) {\n        throw ProcessorErrorFactory.invalid_array_access_full(\n          expression.id,\n          expression.sourceInfo\n        );\n      }\n      const lineType = this.evaluateExpressionType(expression.line);\n      if (!lineType.isCompatible(Types.INTEGER)) {\n        throw ProcessorErrorFactory.array_dimension_not_int_full(\n          expression.sourceInfo\n        );\n      }\n      if (expression.column !== null) {\n        if (arrayTypeInfo.columns === null) {\n          throw ProcessorErrorFactory.invalid_matrix_access_full(\n            expression.id,\n            expression.sourceInfo\n          );\n        }\n        const columnType = this.evaluateExpressionType(expression.column);\n        if (!columnType.isCompatible(Types.INTEGER)) {\n          throw ProcessorErrorFactory.array_dimension_not_int_full(\n            expression.sourceInfo\n          );\n        }\n      }\n      const arrType = arrayTypeInfo.type;\n      if (expression.column !== null) {\n        // indexing matrix\n        return arrType.innerType;\n      } else {\n        if (arrayTypeInfo.columns === null) {\n          return arrType.innerType;\n        }\n        return new ArrayType(arrType.innerType, 1);\n      }\n    }\n  }\n\n  evaluateLiteralType (literal) {\n    if (literal instanceof IntLiteral) {\n      return literal.type;\n    } else if (literal instanceof RealLiteral) {\n      return literal.type;\n    } else if (literal instanceof StringLiteral) {\n      return literal.type;\n    } else if (literal instanceof BoolLiteral) {\n      return literal.type;\n    } else if (literal instanceof CharLiteral) {\n      return literal.type;\n    } else if (literal instanceof VariableLiteral) {\n      const typeInfo = this.findSymbol(literal.id, this.symbolMap);\n      if (typeInfo === null) {\n        throw ProcessorErrorFactory.symbol_not_found_full(\n          literal.id,\n          literal.sourceInfo\n        );\n      }\n      if (typeInfo.type instanceof ArrayType) {\n        return typeInfo.type;\n      }\n      return typeInfo.type;\n    } else {\n      // console.warn(\"Evaluating type only for an array literal...\");\n      let last = null;\n      if (literal.value.length === 1) {\n        last = this.evaluateExpressionType(literal.value[0]);\n      } else {\n        for (let i = 0; i < literal.value.length; i++) {\n          const e = this.evaluateExpressionType(literal.value[i]);\n          if (last === null) {\n            last = e;\n          } else if (!last.isCompatible(e)) {\n            const strInfo = last.stringInfo();\n            const info = strInfo[0];\n            const strExp = literal.toString();\n            throw ProcessorErrorFactory.incompatible_types_array_full(\n              strExp,\n              info.type,\n              info.dim,\n              literal.sourceInfo\n            );\n          }\n        }\n      }\n      if (last instanceof ArrayType) {\n        return new ArrayType(last.innerType, last.dimensions + 1);\n      }\n      return new ArrayType(last, 1);\n    }\n  }\n\n  evaluateArrayLiteral (arrayDeclaration) {\n    const type = arrayDeclaration.type;\n    const literal = arrayDeclaration.initial;\n    // console.log(arrayDeclaration);\n    if (arrayDeclaration.isVector) {\n      this.evaluateVectorLiteralType(literal, type);\n    } else {\n      // TODO matrix type check\n      for (let i = 0; i < literal.lines; ++i) {\n        const line_literal = literal.value[i];\n        this.evaluateVectorLiteralType(\n          line_literal,\n          new ArrayType(type.innerType, 1)\n        );\n      }\n    }\n    return true;\n  }\n\n  assertFunction (fun) {\n    this.pushMap();\n    this.currentFunction = fun;\n    fun.formalParameters.forEach((formalParam) => {\n      if (formalParam.type instanceof ArrayType) {\n        if (formalParam.type.dimensions > 1) {\n          this.insertSymbol(formalParam.id, {\n            id: formalParam.id,\n            lines: -1,\n            columns: -1,\n            type: formalParam.type,\n          });\n        } else {\n          this.insertSymbol(formalParam.id, {\n            id: formalParam.id,\n            lines: -1,\n            columns: null,\n            type: formalParam.type,\n          });\n        }\n      } else {\n        this.insertSymbol(formalParam.id, {\n          id: formalParam.id,\n          type: formalParam.type,\n        });\n      }\n    });\n    this.assertDeclarations(fun.variablesDeclarations);\n    const optional = fun.returnType.isCompatible(Types.VOID);\n    const valid = this.assertReturn(fun, optional);\n    if (!valid) {\n      throw ProcessorErrorFactory.function_no_return(fun.name);\n    }\n    this.popMap();\n  }\n\n  assertReturn (fun, optional) {\n    return fun.commands.reduce(\n      (last, next) => this.checkCommand(fun.returnType, next, optional) || last,\n      optional\n    );\n  }\n\n  checkCommand (type, cmd, optional) {\n    if (cmd instanceof While) {\n      const resultType = this.evaluateExpressionType(cmd.expression);\n      if (!resultType.isCompatible(Types.BOOLEAN)) {\n        throw ProcessorErrorFactory.loop_condition_type_full(\n          cmd.expression.toString(),\n          cmd.sourceInfo\n        );\n      }\n      this.checkCommands(type, cmd.commands, optional);\n      return false;\n    } else if (cmd instanceof For) {\n      const var_type = this.evaluateExpressionType(cmd.for_id);\n      if (!var_type.isCompatible(Types.INTEGER)) {\n        throw ProcessorErrorFactory.invalid_for_variable(\n          cmd.for_id,\n          cmd.sourceInfo\n        );\n      }\n      const from_type = this.evaluateExpressionType(cmd.for_from);\n      if (!from_type.isCompatible(Types.INTEGER)) {\n        throw ProcessorErrorFactory.invalid_for_from(\n          cmd.for_from,\n          cmd.sourceInfo\n        );\n      }\n      const to_type = this.evaluateExpressionType(cmd.for_to);\n      if (!to_type.isCompatible(Types.INTEGER)) {\n        throw ProcessorErrorFactory.invalid_for_to(cmd.for_to, cmd.sourceInfo);\n      }\n      if (cmd.for_pass != null) {\n        const pass_type = this.evaluateExpressionType(cmd.for_pass);\n        if (!pass_type.isCompatible(Types.INTEGER)) {\n          throw ProcessorErrorFactory.invalid_for_pass(\n            cmd.for_pass,\n            cmd.sourceInfo\n          );\n        }\n      }\n      this.checkCommands(type, cmd.commands, optional);\n      return false;\n    } else if (cmd instanceof Switch) {\n      const sType = this.evaluateExpressionType(cmd.expression);\n      let result = optional;\n      let hasDefault = false;\n      for (let i = 0; i < cmd.cases.length; i++) {\n        const aCase = cmd.cases[i];\n        if (aCase.expression !== null) {\n          const caseType = this.evaluateExpressionType(aCase.expression);\n          if (!sType.isCompatible(caseType)) {\n            const strInfo = sType.stringInfo();\n            const info = strInfo[0];\n            const strExp = aCase.expression.toString();\n            throw ProcessorErrorFactory.invalid_case_type_full(\n              strExp,\n              info.type,\n              info.dim,\n              aCase.sourceInfo\n            );\n          }\n        } else {\n          hasDefault = true;\n        }\n        result = result && this.checkCommands(type, aCase.commands, result);\n      }\n      return result && hasDefault;\n    } else if (cmd instanceof ArrayIndexAssign) {\n      // TODO - rework!!!!!\n      let used_dims = 0;\n      const typeInfo = this.findSymbol(cmd.id, this.symbolMap);\n      if (typeInfo === null) {\n        throw ProcessorErrorFactory.symbol_not_found_full(\n          cmd.id,\n          cmd.sourceInfo\n        );\n      }\n      if (typeInfo.isConst) {\n        throw ProcessorErrorFactory.invalid_const_assignment_full(\n          cmd.id,\n          cmd.sourceInfo\n        );\n      }\n      if (!(typeInfo.type instanceof ArrayType)) {\n        throw ProcessorErrorFactory.invalid_array_access_full(\n          cmd.id,\n          cmd.sourceInfo\n        );\n      }\n      const exp = cmd.expression;\n      const lineExp = cmd.line;\n      const lineType = this.evaluateExpressionType(lineExp);\n      if (!lineType.isCompatible(Types.INTEGER)) {\n        throw ProcessorErrorFactory.array_dimension_not_int_full(\n          cmd.sourceInfo\n        );\n      }\n      used_dims += 1;\n      const columnExp = cmd.column;\n      if (typeInfo.columns === null && columnExp !== null) {\n        throw ProcessorErrorFactory.invalid_matrix_access_full(\n          cmd.id,\n          cmd.sourceInfo\n        );\n      } else if (columnExp !== null) {\n        const columnType = this.evaluateExpressionType(columnExp);\n        if (!columnType.isCompatible(Types.INTEGER)) {\n          throw ProcessorErrorFactory.array_dimension_not_int_full(\n            cmd.sourceInfo\n          );\n        }\n        used_dims += 1;\n      }\n      // exp a single value exp or an array access\n      const exp_type = this.evaluateExpressionType(exp);\n      const access_type = typeInfo.type;\n\n      let compatible = false;\n      let type = access_type;\n      if (exp_type instanceof MultiType) {\n        if (access_type.dimensions - used_dims == 0) {\n          type = access_type.innerType;\n        } else {\n          type = new ArrayType(\n            access_type.innerType,\n            Math.max(0, access_type.dimensions - used_dims)\n          );\n        }\n        compatible = exp_type.isCompatible(type);\n      } else {\n        compatible = access_type.canAccept(exp_type, used_dims);\n      }\n      if (!compatible) {\n        if (0 === access_type.dimensions - used_dims) {\n          type = access_type.innerType; // enable a valid attempt to cast real <--> integer\n        }\n        if (\n          !Config.enable_type_casting ||\n          !Store.canImplicitTypeCast(type, exp_type)\n        ) {\n          const access_type_string_info = access_type.stringInfo();\n          const access_type_info = access_type_string_info[0];\n          const exp_type_string_info = exp_type.stringInfo();\n          const exp_type_info = exp_type_string_info[0];\n          throw ProcessorErrorFactory.incompatible_types_full(\n            access_type_info.type,\n            access_type_info.dim - used_dims,\n            exp_type_info.type,\n            exp_type_info.dim,\n            exp.toString(),\n            cmd.sourceInfo\n          );\n        }\n      }\n      return optional;\n    } else if (cmd instanceof Assign) {\n      // TODO - rework since there is no literal array assignment\n      const typeInfo = this.findSymbol(cmd.id, this.symbolMap);\n      if (typeInfo === null) {\n        throw ProcessorErrorFactory.symbol_not_found_full(\n          cmd.id,\n          cmd.sourceInfo\n        );\n      }\n      if (typeInfo.isConst) {\n        throw ProcessorErrorFactory.invalid_const_assignment_full(\n          cmd.id,\n          cmd.sourceInfo\n        );\n      }\n      const exp = cmd.expression;\n      const exp_type = this.evaluateExpressionType(exp);\n      if (exp_type instanceof ArrayType) {\n        if (!(typeInfo.type instanceof ArrayType)) {\n          // TODO better error message\n          throw new Error(\"Cannot assign an array to a non-array variable \");\n        }\n        // Both are arrays...\n        // if both don't have same dimensions and type, cannot perform assignment\n        if (!exp_type.isCompatible(typeInfo.type)) {\n          if (\n            exp_type.dimensions === typeInfo.type.dimensions &&\n            !exp_type.innerType.isCompatible(typeInfo.type.innerType)\n          ) {\n            if (\n              !Config.enable_type_casting ||\n              !Store.canImplicitTypeCast(\n                typeInfo.type.innerType,\n                exp_type.innerType\n              )\n            ) {\n              const stringInfo = typeInfo.type.stringInfo();\n              const info = stringInfo[0];\n              const exp_type_string_info = exp_type.stringInfo();\n              const exp_type_info = exp_type_string_info[0];\n              throw ProcessorErrorFactory.incompatible_types_full(\n                info.type,\n                info.dim,\n                exp_type_info.type,\n                exp_type_info.dim,\n                exp.toString(),\n                cmd.sourceInfo\n              );\n            }\n          } else {\n            switch (exp_type.dimensions) {\n              case 1: {\n                throw ProcessorErrorFactory.vector_to_matrix_attr(\n                  cmd.id,\n                  exp.toString(),\n                  cmd.sourceInfo\n                );\n              }\n              case 2: {\n                throw ProcessorErrorFactory.matrix_to_vector_attr(\n                  cmd.id,\n                  exp.toString(),\n                  cmd.sourceInfo\n                );\n              }\n            }\n          }\n        }\n      } else if (!exp_type.isCompatible(typeInfo.type)) {\n        if (\n          !Config.enable_type_casting ||\n          !Store.canImplicitTypeCast(typeInfo.type, exp_type)\n        ) {\n          const stringInfo = typeInfo.type.stringInfo();\n          const info = stringInfo[0];\n          const exp_type_string_info = exp_type.stringInfo();\n          const exp_type_info = exp_type_string_info[0];\n          throw ProcessorErrorFactory.incompatible_types_full(\n            info.type,\n            info.dim,\n            exp_type_info.type,\n            exp_type_info.dim,\n            exp.toString(),\n            cmd.sourceInfo\n          );\n        }\n      }\n      return optional;\n    } else if (cmd instanceof Break) {\n      return optional;\n    } else if (cmd instanceof IfThenElse) {\n      const resultType = this.evaluateExpressionType(cmd.condition);\n      if (!resultType.isCompatible(Types.BOOLEAN)) {\n        throw ProcessorErrorFactory.if_condition_type_full(\n          cmd.condition.toString(),\n          cmd.sourceInfo\n        );\n      }\n      if (cmd.ifFalse instanceof IfThenElse) {\n        return (\n          this.checkCommands(type, cmd.ifTrue.commands, optional) &&\n          this.checkCommand(type, cmd.ifFalse, optional)\n        );\n      } else if (cmd.ifFalse != null) {\n        return (\n          this.checkCommands(type, cmd.ifTrue.commands, optional) &&\n          this.checkCommands(type, cmd.ifFalse.commands, optional)\n        );\n      } else {\n        return this.checkCommands(type, cmd.ifTrue.commands, optional);\n      }\n    } else if (cmd instanceof FunctionCall) {\n      let fun = null;\n      if (cmd.isMainCall) {\n        fun = this.getMainFunction();\n      } else {\n        fun = this.findFunction(cmd.id);\n      }\n      if (fun === null) {\n        throw ProcessorErrorFactory.function_missing_full(\n          cmd.id,\n          cmd.sourceInfo\n        );\n      }\n      this.assertParameters(fun, cmd.actualParameters);\n      return optional;\n    } else if (cmd instanceof Return) {\n      const funcName = this.currentFunction.isMain\n        ? LanguageDefinedFunction.getMainFunctionName()\n        : this.currentFunction.name;\n      if (cmd.expression === null && !type.isCompatible(Types.VOID)) {\n        const stringInfo = type.stringInfo();\n        const info = stringInfo[0];\n        throw ProcessorErrorFactory.invalid_void_return_full(\n          funcName,\n          info.type,\n          info.dim,\n          cmd.sourceInfo\n        );\n      } else if (cmd.expression !== null) {\n        const resultType = this.evaluateExpressionType(cmd.expression);\n        if (!type.isCompatible(resultType)) {\n          if (\n            !Config.enable_type_casting ||\n            !Store.canImplicitTypeCast(type, resultType)\n          ) {\n            const stringInfo = type.stringInfo();\n            const info = stringInfo[0];\n            throw ProcessorErrorFactory.invalid_return_type_full(\n              funcName,\n              info.type,\n              info.dim,\n              cmd.sourceInfo\n            );\n          }\n        }\n        return true;\n      } else {\n        return true;\n      }\n    }\n  }\n\n  checkCommands (type, cmds, optional) {\n    return cmds.reduce(\n      (last, next) => this.checkCommand(type, next, optional) || last,\n      optional\n    );\n  }\n\n  /**\n   *\n   * @param {import('./../../ast/commands/function').Function} fun\n   * @param {Expression[]} actualParametersList\n   */\n  assertParameters (fun, actualParametersList) {\n    const parameterList = fun.formalParameters;\n    if (\n      parameterList.length > actualParametersList.length ||\n      (parameterList.length !== actualParametersList.length &&\n        !fun.hasVariadic())\n    ) {\n      throw ProcessorErrorFactory.invalid_parameters_size_full(\n        fun.name,\n        actualParametersList.length,\n        fun.formalParameters.length,\n        null\n      );\n    }\n\n    for (\n      let i = 0, j = 0;\n      i < parameterList.length && j < actualParametersList.length;\n      i += 1, j += 1\n    ) {\n      const formalParam = parameterList[i];\n      if (formalParam.variadic && i + 1 !== parameterList.length) {\n        throw \"A function variadic parameter must be its last parameter!\";\n      }\n      if (formalParam.variadic) {\n        j = this.assertVariadicParameter(\n          fun,\n          formalParam,\n          j,\n          actualParametersList\n        );\n      } else {\n        const param = actualParametersList[j];\n        this.assertParameter(fun, formalParam, param);\n      }\n    }\n  }\n\n  evaluateVectorLiteralType (literal, type) {\n    // console.log(literal);\n    for (let i = 0; i < literal.value.length; i += 1) {\n      const exp = literal.value[i];\n      const expType = this.evaluateExpressionType(exp);\n      let compatible = false;\n      if (expType instanceof MultiType) {\n        compatible = expType.isCompatible(type.innerType);\n      } else {\n        compatible = type.canAccept(expType, 1);\n      }\n      if (!compatible) {\n        if (\n          !Config.enable_type_casting ||\n          !Store.canImplicitTypeCast(type.innerType, expType)\n        ) {\n          const stringInfo = type.stringInfo();\n          const info = stringInfo[0];\n          const result_string_info = expType.stringInfo();\n          const result_info = result_string_info[0];\n          throw ProcessorErrorFactory.incompatible_types_full(\n            info.type,\n            0,\n            result_info.type,\n            result_info.dim,\n            exp.toString(),\n            literal.sourceInfo\n          );\n        }\n      }\n    }\n    return type;\n  }\n\n  /**\n   *\n   * @param {import('./../../ast/commands/function').Function} fun\n   * @param {import('./../../ast/commands/formalParameter').FormalParameter} formalParam\n   * @param {number} index\n   * @param {Expression[]} actualParametersList\n   */\n  assertVariadicParameter (fun, formalParam, index, actualParametersList) {\n    let i;\n    for (i = index; i < actualParametersList.length; i += 1) {\n      this.assertParameter(fun, formalParam, actualParametersList[i]);\n    }\n    return i - 1;\n  }\n\n  /**\n   *\n   * @param {import('./../../ast/commands/function').Function} fun\n   * @param {import('./../../ast/commands/formalParameter').FormalParameter} formalParam\n   * @param {Expression} actualParameter\n   */\n  assertParameter (fun, formalParam, actualParameter) {\n    // const id = formalParam.id;\n    if (formalParam.byRef) {\n      if (actualParameter instanceof VariableLiteral) {\n        const variable = this.findSymbol(actualParameter.id, this.symbolMap);\n        if (variable.isConst) {\n          throw ProcessorErrorFactory.invalid_const_ref_full(\n            fun.name,\n            actualParameter.toString(),\n            actualParameter.sourceInfo\n          );\n        }\n      } else if (\n        !(\n          actualParameter instanceof VariableLiteral ||\n          actualParameter instanceof ArrayAccess\n        )\n      ) {\n        throw ProcessorErrorFactory.invalid_parameter_type_full(\n          fun.name,\n          actualParameter.toString(),\n          actualParameter.sourceInfo\n        );\n      }\n    }\n    const resultType = this.evaluateExpressionType(actualParameter);\n    if (\n      resultType instanceof MultiType &&\n      formalParam.type instanceof MultiType\n    ) {\n      let shared = 0;\n      for (let j = 0; j < resultType.types.length; ++j) {\n        const element = resultType.types[j];\n        if (formalParam.type.types.indexOf(element) !== -1) {\n          shared += 1;\n        }\n      }\n      if (shared <= 0) {\n        if (Config.enable_type_casting && !formalParam.byRef) {\n          if (\n            (!resultType.isCompatible(Types.INTEGER) &&\n              !resultType.isCompatible(Types.REAL)) ||\n            formalParam.type.isCompatible(Types.INTEGER) ||\n            formalParam.type.isCompatible(Types.REAL)\n          ) {\n            throw ProcessorErrorFactory.invalid_parameter_type_full(\n              fun.name,\n              actualParameter.toString(),\n              actualParameter.sourceInfo\n            );\n          }\n        }\n      }\n    } else if (resultType instanceof MultiType) {\n      if (!resultType.isCompatible(formalParam.type)) {\n        if (Config.enable_type_casting && !formalParam.byRef) {\n          if (\n            (!resultType.isCompatible(Types.INTEGER) &&\n              !resultType.isCompatible(Types.REAL)) ||\n            formalParam.type.isCompatible(Types.INTEGER) ||\n            formalParam.type.isCompatible(Types.REAL)\n          ) {\n            throw ProcessorErrorFactory.invalid_parameter_type_full(\n              fun.name,\n              actualParameter.toString(),\n              actualParameter.sourceInfo\n            );\n          }\n        }\n      }\n    } else if (!formalParam.type.isCompatible(resultType)) {\n      if (Config.enable_type_casting && !formalParam.byRef) {\n        if (!Store.canImplicitTypeCast(formalParam.type, resultType)) {\n          throw ProcessorErrorFactory.invalid_parameter_type_full(\n            fun.name,\n            actualParameter.toString(),\n            actualParameter.sourceInfo\n          );\n        }\n      }\n    }\n  }\n}\n","export const Context = Object.freeze({\n  BASE: Symbol('context:base'),\n  BREAKABLE: Symbol('context:breakable'),\n  FUNCTION: Symbol('context:function')\n});","import { Store } from \"./store/store\";\nimport { Modes } from \"./modes\";\nimport { Context } from \"./context\";\nimport { Types } from \"./../typeSystem/types\";\nimport { Operators } from \"./../ast/operators\";\nimport { LanguageDefinedFunction } from \"./definedFunctions\";\nimport {\n  resultTypeAfterInfixOp,\n  resultTypeAfterUnaryOp,\n} from \"./compatibilityTable\";\nimport * as Commands from \"./../ast/commands/\";\n// eslint-disable-next-line @typescript-eslint/no-unused-vars\nimport { Command } from \"./../ast/commands/command\";\nimport * as Expressions from \"./../ast/expressions/\";\n// eslint-disable-next-line @typescript-eslint/no-unused-vars\nimport { Expression } from \"./../ast/expressions/expression\";\nimport * as Utils from \"./../util/utils\";\nimport { ArrayType } from \"./../typeSystem/array_type\";\nimport { convertToString, toInt } from \"../typeSystem/parsers\";\nimport { Config } from \"../util/config\";\nimport { ProcessorErrorFactory } from \"./error/processorErrorFactory\";\nimport { RuntimeError } from \"./error/runtimeError\";\nimport { Location } from \"../memory/location\";\nimport { StoreValue } from \"./store/value/store_value\";\nimport { StoreValueRef } from \"./store/value/store_value_ref\";\nimport { ArrayStoreValue } from \"./store/value/array_store_value\";\nimport { ArrayStoreValueRef } from \"./store/value/array_store_value_ref\";\nimport { StoreValueAddress } from \"./store/value/store_value_address\";\nimport {getInstance as LocalizedStrings} from \"../services/localizedStringsService\";\n\nexport class IVProgProcessor {\n  static get MAIN_INTERNAL_ID () {\n    return \"$main\";\n  }\n\n  constructor (ast) {\n    this.ast = ast;\n    this.globalStore = new Store(\"$global\");\n    this.stores = [this.globalStore];\n    this.context = [Context.BASE];\n    this.input = null;\n    this.forceKill = false;\n    this.output = null;\n    this.mode = Modes.RUN;\n    /**\n     * Stores the sourceInfo of every function call, command or expression\n     */\n    this.function_call_stack = [];\n    this.instruction_count = 0;\n    this.function_call_count = 0;\n  }\n\n  registerInput (input) {\n    if (this.input !== null) this.input = null;\n    this.input = input;\n  }\n\n  registerOutput (output) {\n    if (this.output !== null) this.output = null;\n    this.output = output;\n  }\n\n  checkContext (context) {\n    return this.context[this.context.length - 1] === context;\n  }\n\n  ignoreSwitchCases (store) {\n    if (store.mode === Modes.RETURN) {\n      return true;\n    } else if (store.mode === Modes.BREAK) {\n      return true;\n    } else {\n      return false;\n    }\n  }\n\n  prepareState () {\n    if (this.stores !== null) {\n      for (let i = 0; i < this.stores.length; i++) {\n        delete this.stores[i];\n      }\n      this.stores = null;\n    }\n    if (this.globalStore !== null) this.globalStore = null;\n    this.globalStore = new Store(\"$global\");\n    this.stores = [this.globalStore];\n    this.context = [Context.BASE];\n    this.instruction_count = 0;\n    this.mode = Modes.RUN;\n  }\n\n  async interpretAST () {\n    this.prepareState();\n    Location.clear();\n    await this.initGlobal();\n    const mainFunc = this.findMainFunction();\n    if (mainFunc === null) {\n      throw ProcessorErrorFactory.main_missing();\n    }\n    return this.runFunction(mainFunc, [], this.globalStore);\n  }\n\n  async initGlobal () {\n    if (!this.checkContext(Context.BASE)) {\n      return ProcessorErrorFactory.invalid_global_var();\n    }\n    return this.executeCommands(this.globalStore, this.ast.global);\n  }\n\n  findMainFunction () {\n    return this.ast.functions.find((v) => v.isMain);\n  }\n\n  findFunction (name) {\n    if (name.match(/^\\$.+$/)) {\n      if (name === IVProgProcessor.MAIN_INTERNAL_ID) {\n        return this.findMainFunction();\n      }\n      const fun = LanguageDefinedFunction.getFunction(name);\n      if (!fun) {\n        throw ProcessorErrorFactory.not_implemented(name);\n      }\n      return fun;\n    } else {\n      const val = this.ast.functions.find((v) => v.name === name);\n      if (!val) {\n        throw ProcessorErrorFactory.function_missing(name);\n      }\n      return val;\n    }\n  }\n\n  async runFunction (func, actualParameters, store) {\n    const funcName = func.isMain ? IVProgProcessor.MAIN_INTERNAL_ID : func.name;\n    const funcStore = new Store(funcName);\n    funcStore.extendStore(this.globalStore);\n    await this.associateParameters(\n      func.formalParameters,\n      actualParameters,\n      store,\n      funcStore\n    );\n    this.context.push(Context.FUNCTION);\n    this.stores.push(funcStore);\n    const stoWithVars = await this.executeCommands(\n      funcStore,\n      func.variablesDeclarations\n    );\n    const finalSto = await this.executeCommands(stoWithVars, func.commands);\n    this.stores.pop();\n    this.context.pop();\n    return finalSto;\n  }\n\n  /**\n   *\n   * @param {import('./../ast/commands/formalParameter').FormalParameter[]} formal_params\n   * @param {Expression[]} effective_params\n   * @param {Store} caller_store\n   * @param {Store} callee_store\n   */\n  async associateParameters (\n    formal_params,\n    effective_params,\n    caller_store,\n    callee_store\n  ) {\n    const funcName =\n      callee_store.name === IVProgProcessor.MAIN_INTERNAL_ID\n        ? LanguageDefinedFunction.getMainFunctionName()\n        : callee_store.name;\n\n    const hasVariadic = formal_params.some((p) => p.variadic);\n\n    if (\n      (formal_params.length != effective_params.length && !hasVariadic) ||\n      formal_params.length > effective_params.length\n    ) {\n      throw ProcessorErrorFactory.invalid_parameters_size(\n        funcName,\n        formal_params.length,\n        effective_params.length\n      );\n    }\n    for (\n      let i = 0, j = 0;\n      i < formal_params.length && j < effective_params.length;\n      i += 1, j += 1\n    ) {\n      const formalParameter = formal_params[i];\n      if (formalParameter.variadic) {\n        [j, callee_store] = await this.associateVariadicParameter(\n          funcName,\n          formalParameter,\n          j,\n          effective_params,\n          caller_store,\n          callee_store\n        );\n      } else {\n        const actualParam = effective_params[i];\n        callee_store = await this.associateParameter(\n          funcName,\n          formalParameter,\n          actualParam,\n          caller_store,\n          callee_store\n        );\n      }\n    }\n    return callee_store;\n  }\n\n  /**\n   *\n   * @param {string} funcName\n   * @param {import('./../ast/commands/formalParameter').FormalParameter} formalParameter\n   * @param {number} index\n   * @param {Expression[]} effective_params\n   * @param {Store} caller_store\n   * @param {Store} callee_store\n   */\n  async associateVariadicParameter (\n    funcName,\n    formalParameter,\n    index,\n    effective_params,\n    caller_store,\n    callee_store\n  ) {\n    let i;\n    let count = 1;\n    for (i = index; i < effective_params.length; i += 1) {\n      const actualParam = effective_params[i];\n      callee_store = await this.associateParameter(\n        funcName,\n        formalParameter,\n        actualParam,\n        caller_store,\n        callee_store,\n        count\n      );\n      count += 1;\n    }\n    const variadicCount = new StoreValue(Types.INTEGER, count, undefined, true);\n    callee_store.insertStore(`${formalParameter.id}.0`, variadicCount);\n    return [i - 1, callee_store];\n  }\n\n  /**\n   *\n   * @param {string} funcName\n   * @param {import('./../ast/commands/formalParameter').FormalParameter} formalParameter\n   * @param {Expression} actualParameter\n   * @param {Store} callerStore\n   * @param {Store} calleeStore\n   * @param {number} variadicCount The number of the current value being assigned to the variadic parameter, default 0\n   */\n  async associateParameter (\n    funcName,\n    formalParameter,\n    actualParameter,\n    callerStore,\n    calleeStore,\n    variadicCount = 0\n  ) {\n    const actualValue = await this.evaluateExpression(\n      callerStore,\n      actualParameter\n    );\n\n    let shouldTypeCast = false;\n\n    if (!formalParameter.type.isCompatible(actualValue.type)) {\n      if (\n        Config.enable_type_casting &&\n        !formalParameter.byRef &&\n        Store.canImplicitTypeCast(formalParameter.type, actualValue.type)\n      ) {\n        shouldTypeCast = true;\n      } else {\n        throw ProcessorErrorFactory.invalid_parameter_type(\n          funcName,\n          actualParameter.toString()\n        );\n      }\n    }\n\n    if (formalParameter.byRef && !actualValue.inStore()) {\n      throw ProcessorErrorFactory.invalid_ref(\n        funcName,\n        actualParameter.toString()\n      );\n    }\n\n    if (formalParameter.byRef) {\n      const realObj = callerStore.getStoreObject(actualValue.id);\n      let ref = null;\n      if (actualValue instanceof ArrayStoreValue) {\n        // it's a vector or matrix...\n        const values = actualValue.get();\n        const array_type = actualValue.type;\n        const addresses = values.map((v) =>\n          realObj.getLocAddressOf(v.line, v.column)\n        );\n        const columns = actualValue.isVector() ? 0 : actualValue.columns;\n        ref = new ArrayStoreValueRef(\n          array_type,\n          values,\n          addresses,\n          actualValue.lines,\n          columns,\n          realObj.id\n        );\n      } else {\n        if (actualValue instanceof StoreValueAddress) {\n          const line = actualValue.line;\n          const column = actualValue.column;\n          ref = new StoreValueRef(\n            actualValue.type,\n            actualValue.get(),\n            realObj.getLocAddressOf(line, column),\n            realObj.id\n          );\n          ref.setReferenceDimension(realObj.type.dimensions);\n        } else {\n          ref = new StoreValueRef(\n            actualValue.type,\n            actualValue.get(),\n            realObj.locAddress,\n            realObj.id\n          );\n        }\n      }\n      let varID = formalParameter.id;\n      if (formalParameter.variadic) varID = `${varID}.${variadicCount}`;\n      calleeStore.insertStore(varID, ref);\n    } else {\n      let realValue = actualValue;\n      if (shouldTypeCast) {\n        realValue = Store.doImplicitCasting(formalParameter.type, realValue);\n      }\n      let varID = formalParameter.id;\n      if (formalParameter.variadic) varID = `${varID}.${variadicCount}`;\n      calleeStore.insertStore(varID, realValue);\n    }\n    return calleeStore;\n  }\n\n  /**\n   *\n   * @param {Store} store\n   * @param {Command[]} cmds\n   *\n   * @returns {Promise<Store>}\n   */\n  async executeCommands (store, cmds) {\n    // helper to partially apply a function, in this case executeCommand\n    let sto = store;\n    for (let i = 0; i < cmds.length; i += 1) {\n      sto = await this.executeCommand(sto, cmds[i]);\n    }\n    return sto;\n  }\n\n  /**\n   *\n   * @param {Store} store\n   * @param {Command} cmd\n   *\n   * @returns {Promise<Store>}\n   */\n  async executeCommand (store, cmd) {\n    this.instruction_count += 1;\n    if (this.instruction_count % Config.suspend_threshold == 0) {\n      //every Config.suspend_threshold instruction should briefly delay its execution in order to allow the browser to process other things\n      await Utils.sleep(3);\n    }\n\n    // Checks if it must interrupt the execution for some reason\n    if (this.instruction_count >= Config.max_instruction_count) {\n      throw ProcessorErrorFactory.exceed_max_instructions();\n    } else if (this.forceKill) {\n      throw \"FORCED_KILL!\";\n    } else if (store.mode === Modes.PAUSE) {\n      return this.executeCommand(store, cmd);\n    } else if (store.mode === Modes.RETURN) {\n      return store;\n    } else if (\n      this.checkContext(Context.BREAKABLE) &&\n      store.mode === Modes.BREAK\n    ) {\n      return store;\n    } else if (this.mode === Modes.ABORT) {\n      throw LocalizedStrings().getMessage(\"aborted_execution\");\n    }\n\n    if (cmd instanceof Commands.Declaration) {\n      return this.executeDeclaration(store, cmd);\n    } else if (cmd instanceof Commands.ArrayIndexAssign) {\n      return this.executeArrayIndexAssign(store, cmd);\n    } else if (cmd instanceof Commands.Assign) {\n      return this.executeAssign(store, cmd);\n    } else if (cmd instanceof Commands.Break) {\n      return this.executeBreak(store, cmd);\n    } else if (cmd instanceof Commands.Return) {\n      return this.executeReturn(store, cmd);\n    } else if (cmd instanceof Commands.IfThenElse) {\n      return this.executeIfThenElse(store, cmd);\n    } else if (cmd instanceof Commands.RepeatUntil) {\n      return this.executeRepeatUntil(store, cmd);\n    } else if (cmd instanceof Commands.While) {\n      return this.executeWhile(store, cmd);\n    } else if (cmd instanceof Commands.For) {\n      return this.executeFor(store, cmd);\n    } else if (cmd instanceof Commands.Switch) {\n      return this.executeSwitch(store, cmd);\n    } else if (cmd instanceof Expressions.FunctionCall) {\n      return this.executeFunctionCall(store, cmd);\n    } else if (cmd instanceof Commands.SysCall) {\n      return this.executeSysCall(store, cmd);\n    } else {\n      throw ProcessorErrorFactory.unknown_command(cmd.sourceInfo);\n    }\n  }\n\n  /**\n   *\n   * @param {Store} store\n   * @param {Commands.SysCall} cmd\n   *\n   * @returns {Promise<Store>}\n   */\n  async executeSysCall (store, cmd) {\n    const func = cmd.langFunc.bind(this);\n    return func(store, cmd);\n  }\n\n  /**\n   *\n   * @param {Store} store\n   * @param {Commands.FunctionCall} cmd\n   *\n   * @returns {Promise<Store>}\n   */\n  async executeFunctionCall (store, cmd) {\n    let func = null;\n    if (cmd.isMainCall) {\n      func = this.findMainFunction();\n    } else {\n      func = this.findFunction(cmd.id);\n    }\n    this.function_call_stack.push(cmd.sourceInfo);\n    const sto = await this.runFunction(func, cmd.actualParameters, store);\n    sto.destroy();\n    if (\n      !Types.VOID.isCompatible(func.returnType) &&\n      sto.mode !== Modes.RETURN\n    ) {\n      const funcName =\n        func.name === IVProgProcessor.MAIN_INTERNAL_ID\n          ? LanguageDefinedFunction.getMainFunctionName()\n          : func.name;\n      throw ProcessorErrorFactory.function_no_return(funcName);\n    } else {\n      this.function_call_stack.pop();\n      return store;\n    }\n  }\n\n  /**\n   *\n   * @param {Store} store\n   * @param {Commands.Switch} cmd\n   *\n   * @returns {Promise<Store>}\n   */\n  async executeSwitch (store, cmd) {\n    this.context.push(Context.BREAKABLE);\n    const switchCases = cmd.cases;\n    let lastStore = store;\n    let lastCaseCheckResult = false;\n    for (\n      let i = 0;\n      i < switchCases.length && !this.ignoreSwitchCases(lastStore);\n      i += 1\n    ) {\n      const switchCase = switchCases[i];\n      if (lastCaseCheckResult || switchCase.isDefault) {\n        lastStore = await this.executeCommands(lastStore, switchCase.commands);\n      } else {\n        const equalityInfixApp = new Expressions.InfixApp(\n          Operators.EQ,\n          cmd.expression,\n          switchCase.expression\n        );\n        equalityInfixApp.sourceInfo = switchCase.sourceInfo;\n        const result = await this.evaluateExpression(\n          lastStore,\n          equalityInfixApp\n        );\n        if (result.get()) {\n          lastStore = await this.executeCommands(\n            lastStore,\n            switchCase.commands\n          );\n        }\n        lastCaseCheckResult = result.get();\n      }\n    }\n    this.context.pop();\n    if (lastStore.mode === Modes.BREAK) {\n      lastStore.mode = Modes.RUN;\n    }\n    return lastStore;\n  }\n\n  /**\n   *\n   * @param {Store} store\n   * @param {Commands.For} cmd\n   *\n   * @returns {Promise<Store>}\n   */\n  async executeFor (store, cmd) {\n    //BEGIN for -> while rewrite\n    const initCmd = new Commands.Assign(cmd.for_id.id, cmd.for_from);\n    initCmd.sourceInfo = cmd.sourceInfo;\n    // Assume for is iterating forward and that pass is not missing\n    let passValue = cmd.for_pass;\n    let condition = new Expressions.InfixApp(\n      Operators.LT,\n      cmd.for_id,\n      cmd.for_to\n    );\n\n    if (cmd.for_pass == null) {\n      passValue = new Expressions.IntLiteral(toInt(1));\n      const checkEndGTBegin = await this.evaluateExpression(\n        store,\n        new Expressions.InfixApp(Operators.GE, cmd.for_to, cmd.for_from)\n      );\n      if (!checkEndGTBegin.get()) {\n        passValue = new Expressions.IntLiteral(toInt(-1));\n        condition = new Expressions.InfixApp(\n          Operators.GT,\n          cmd.for_id,\n          cmd.for_to\n        );\n      }\n    } else {\n      const isForward = await this.evaluateExpression(\n        store,\n        new Expressions.InfixApp(\n          Operators.GE,\n          cmd.for_pass,\n          new Expressions.IntLiteral(toInt(0))\n        )\n      );\n      if (!isForward.get()) {\n        condition = new Expressions.InfixApp(\n          Operators.GT,\n          cmd.for_id,\n          cmd.for_to\n        );\n      }\n    }\n\n    condition.sourceInfo = cmd.sourceInfo;\n    const increment = new Commands.Assign(\n      cmd.for_id.id,\n      new Expressions.InfixApp(Operators.ADD, cmd.for_id, passValue)\n    );\n    increment.sourceInfo = cmd.sourceInfo;\n    const whileBlock = new Commands.CommandBlock(\n      [],\n      cmd.commands.concat(increment)\n    );\n    const forAsWhile = new Commands.While(condition, whileBlock);\n    forAsWhile.sourceInfo = cmd.sourceInfo;\n    //END for -> while rewrite\n    const newCmdList = [initCmd, forAsWhile];\n    return this.executeCommands(store, newCmdList);\n  }\n\n  /**\n   *\n   * @param {Store} store\n   * @param {Commands.RepeatUntil} cmd\n   *\n   * @returns {Promise<Store>}\n   */\n  async executeRepeatUntil (store, cmd) {\n    this.context.push(Context.BREAKABLE);\n    const sto = await this.executeCommands(store, cmd.commands);\n    if (sto.mode === Modes.BREAK) {\n      this.context.pop();\n      sto.mode = Modes.RUN;\n      return sto;\n    }\n    const checkCondition = await this.evaluateExpression(sto, cmd.expression);\n    if (!checkCondition.type.isCompatible(Types.BOOLEAN)) {\n      throw ProcessorErrorFactory.loop_condition_type_full(cmd.sourceInfo);\n    }\n    this.context.pop();\n    if (checkCondition.get()) {\n      return sto;\n    } else {\n      return this.executeCommand(sto, cmd);\n    }\n  }\n\n  /**\n   *\n   * @param {Store} store\n   * @param {Commands.While} cmd\n   *\n   * @returns {Promise<Store>}\n   */\n  async executeWhile (store, cmd) {\n    this.context.push(Context.BREAKABLE);\n    const checkCondition = await this.evaluateExpression(store, cmd.expression);\n    if (!checkCondition.type.isCompatible(Types.BOOLEAN)) {\n      throw ProcessorErrorFactory.loop_condition_type_full(\n        cmd.expression.toString(),\n        cmd.sourceInfo\n      );\n    }\n    if (checkCondition.get()) {\n      const sto = await this.executeCommands(store, cmd.commands);\n      this.context.pop();\n      if (sto.mode === Modes.BREAK) {\n        sto.mode = Modes.RUN;\n        return sto;\n      }\n      return this.executeCommand(sto, cmd);\n    } else {\n      this.context.pop();\n      return store;\n    }\n  }\n\n  /**\n   *\n   * @param {Store} store\n   * @param {Commands.IfThenElse} cmd\n   *\n   * @returns {Promise<Store>}\n   */\n  async executeIfThenElse (store, cmd) {\n    const isTrue = await this.evaluateExpression(store, cmd.condition);\n    if (!isTrue.type.isCompatible(Types.BOOLEAN)) {\n      throw ProcessorErrorFactory.if_condition_type_full(\n        cmd.condition.toString(),\n        cmd.sourceInfo\n      );\n    }\n    if (isTrue.get()) {\n      return this.executeCommands(store, cmd.ifTrue.commands);\n    } else if (cmd.ifFalse !== null) {\n      if (cmd.ifFalse instanceof Commands.IfThenElse) {\n        return this.executeCommand(store, cmd.ifFalse);\n      } else {\n        return this.executeCommands(store, cmd.ifFalse.commands);\n      }\n    } else {\n      return store;\n    }\n  }\n\n  /**\n   *\n   * @param {Store} store\n   * @param {Commands.Return} cmd\n   *\n   * @returns {Promise<Store>}\n   */\n  async executeReturn (store, cmd) {\n    const funcName =\n      store.name === IVProgProcessor.MAIN_INTERNAL_ID\n        ? LanguageDefinedFunction.getMainFunctionName()\n        : store.name;\n    // console.log(funcName,  store.name === IVProgProcessor.MAIN_INTERNAL_ID);\n    const func = this.findFunction(store.name);\n    const funcType = func.returnType;\n    const value = await this.evaluateExpression(store, cmd.expression);\n    if (value === null && funcType.isCompatible(Types.VOID)) {\n      store.mode = Modes.RETURN;\n      return store;\n    }\n\n    let real_value = value;\n    if (value === null || !funcType.isCompatible(value.type)) {\n      if (\n        !Config.enable_type_casting ||\n        !Store.canImplicitTypeCast(funcType, value.type)\n      ) {\n        const stringInfo = funcType.stringInfo();\n        const info = stringInfo[0];\n        throw ProcessorErrorFactory.invalid_return_type_full(\n          funcName,\n          info.type,\n          info.dim,\n          cmd.sourceInfo\n        );\n      }\n      real_value = Store.doImplicitCasting(funcType, value);\n    }\n\n    store.insertStore(\"$\", real_value);\n    store.mode = Modes.RETURN;\n    return store;\n  }\n\n  /**\n   *\n   * @param {Store} store\n   * @param {Commands.Break} cmd\n   *\n   * @returns {Promise<Store>}\n   */\n  async executeBreak (store, cmd) {\n    if (this.checkContext(Context.BREAKABLE)) {\n      store.mode = Modes.BREAK;\n      return store;\n    } else {\n      throw ProcessorErrorFactory.unexpected_break_command_full(cmd.sourceInfo);\n    }\n  }\n\n  /**\n   *\n   * @param {Store} store\n   * @param {Commands.Assign} cmd\n   *\n   * @returns {Promise<Store>}\n   */\n  async executeAssign (store, cmd) {\n    const inStore = store.applyStore(cmd.id);\n    if (inStore.isConst) {\n      throw ProcessorErrorFactory.invalid_const_assignment_full(\n        cmd.id,\n        cmd.sourceInfo\n      );\n    }\n    const value = await this.evaluateExpression(store, cmd.expression);\n    let realValue = value;\n    if (!inStore.type.isCompatible(realValue.type)) {\n      if (\n        Config.enable_type_casting &&\n        Store.canImplicitTypeCast(inStore.type, value.type)\n      ) {\n        realValue = Store.doImplicitCasting(inStore.type, realValue);\n      } else {\n        const stringInfo = inStore.type.stringInfo();\n        const info = stringInfo[0];\n        const exp_type_string_info = value.type.stringInfo();\n        const exp_type_info = exp_type_string_info[0];\n        const exp = cmd.expression.toString();\n        throw ProcessorErrorFactory.incompatible_types_full(\n          info.type,\n          info.dim,\n          exp_type_info.type,\n          exp_type_info.dim,\n          exp,\n          cmd.sourceInfo\n        );\n      }\n    }\n\n    if (inStore instanceof ArrayStoreValue) {\n      const columns = realValue.columns == null ? 0 : realValue.columns;\n      if (inStore.lines !== realValue.lines || inStore.columns !== columns) {\n        const exp = cmd.expression.toString();\n        if (inStore.isVector()) {\n          throw ProcessorErrorFactory.invalid_vector_assignment_full(\n            cmd.id,\n            inStore.lines,\n            exp,\n            realValue.lines,\n            cmd.sourceInfo\n          );\n        } else {\n          throw ProcessorErrorFactory.invalid_matrix_assignment_full(\n            cmd.id,\n            inStore.lines,\n            inStore.columns,\n            exp,\n            realValue.lines,\n            realValue.columns,\n            cmd.sourceInfo\n          );\n        }\n      }\n    }\n\n    store.updateStore(cmd.id, realValue);\n    return store;\n  }\n\n  /**\n   *\n   * @param {Store} store\n   * @param {Commands.ArrayIndexAssign} cmd\n   *\n   * @returns {Promise<Store>}\n   */\n  async executeArrayIndexAssign (store, cmd) {\n    const mustBeArray = store.applyStore(cmd.id);\n    let used_dims = 0;\n    if (mustBeArray.isConst) {\n      throw ProcessorErrorFactory.invalid_const_assignment_full(\n        cmd.id,\n        cmd.sourceInfo\n      );\n    }\n    if (!(mustBeArray.type instanceof ArrayType)) {\n      throw ProcessorErrorFactory.invalid_array_access_full(\n        cmd.id,\n        cmd.sourceInfo\n      );\n    }\n    const lineSV = await this.evaluateExpression(store, cmd.line);\n    if (!Types.INTEGER.isCompatible(lineSV.type)) {\n      throw ProcessorErrorFactory.array_dimension_not_int_full(cmd.sourceInfo);\n    }\n    used_dims += 1;\n    const line = lineSV.get().toNumber();\n    const columnSV = await this.evaluateExpression(store, cmd.column);\n    let column = null;\n    if (columnSV != null) {\n      if (!Types.INTEGER.isCompatible(columnSV.type)) {\n        throw ProcessorErrorFactory.array_dimension_not_int_full(\n          cmd.sourceInfo\n        );\n      }\n      column = columnSV.get().toNumber();\n      used_dims += 1;\n    }\n    const value = await this.evaluateExpression(store, cmd.expression);\n    let actualValue = value;\n    if (line >= mustBeArray.lines) {\n      if (mustBeArray.isVector) {\n        throw ProcessorErrorFactory.vector_line_outbounds_full(\n          cmd.id,\n          line,\n          mustBeArray.lines,\n          cmd.sourceInfo\n        );\n      } else {\n        throw ProcessorErrorFactory.matrix_line_outbounds_full(\n          cmd.id,\n          line,\n          mustBeArray.lines,\n          cmd.sourceInfo\n        );\n      }\n    } else if (line < 0) {\n      throw ProcessorErrorFactory.array_dimension_not_positive_full(\n        cmd.sourceInfo\n      );\n    }\n    if (column != null && mustBeArray.columns === 0) {\n      throw ProcessorErrorFactory.vector_not_matrix_full(\n        cmd.id,\n        cmd.sourceInfo\n      );\n    }\n    if (column != null) {\n      if (column >= mustBeArray.columns) {\n        throw ProcessorErrorFactory.matrix_column_outbounds_full(\n          cmd.id,\n          column,\n          mustBeArray.columns,\n          cmd.sourceInfo\n        );\n      } else if (column < 0) {\n        throw ProcessorErrorFactory.array_dimension_not_positive_full(\n          cmd.sourceInfo\n        );\n      }\n    }\n\n    if (!mustBeArray.type.canAccept(value.type, used_dims)) {\n      if (\n        !Config.enable_type_casting ||\n        !Store.canImplicitTypeCast(mustBeArray.type.innerType, value.type)\n      ) {\n        const type = mustBeArray.type.innerType;\n        const stringInfo = type.stringInfo();\n        const info = stringInfo[0];\n        const exp_type_string_info = value.type.stringInfo();\n        const exp_type_info = exp_type_string_info[0];\n        const exp = cmd.expression.toString();\n        throw ProcessorErrorFactory.incompatible_types_full(\n          info.type,\n          info.dim,\n          exp_type_info.type,\n          exp_type_info.dim,\n          exp,\n          cmd.sourceInfo\n        );\n      }\n      actualValue = Store.doImplicitCasting(mustBeArray.type.innerType, value);\n    }\n\n    const current_value = mustBeArray.getAt(line, column);\n    if (current_value instanceof ArrayStoreValue) {\n      if (\n        current_value.lines !== actualValue.lines ||\n        current_value.columns !== actualValue.columns\n      ) {\n        const exp = cmd.expression.toString();\n        throw ProcessorErrorFactory.invalid_matrix_index_assign_full(\n          cmd.id,\n          line,\n          current_value.lines,\n          exp,\n          actualValue.lines,\n          cmd.sourceInfo\n        );\n      }\n    }\n\n    return store.updateStoreArray(cmd.id, actualValue, line, column);\n  }\n\n  /**\n   *\n   * @param {Store} store\n   * @param {Commands.Declaration} cmd\n   *\n   * @returns {Promise<Store>}\n   */\n  async executeDeclaration (store, cmd) {\n    if (cmd instanceof Commands.ArrayDeclaration) {\n      return this.executeArrayDeclaration(store, cmd);\n    } else {\n      let temp = new StoreValue(cmd.type, null, null, cmd.isConst);\n      if (cmd.initial !== null) {\n        const value = await this.evaluateExpression(store, cmd.initial);\n        let realValue = value;\n        if (!value.type.isCompatible(cmd.type)) {\n          if (\n            Config.enable_type_casting &&\n            Store.canImplicitTypeCast(cmd.type, value.type)\n          ) {\n            realValue = Store.doImplicitCasting(cmd.type, realValue);\n          } else {\n            const stringInfo = value.type.stringInfo();\n            const info = stringInfo[0];\n            const exp_type_string_info = value.type.stringInfo();\n            const exp_type_info = exp_type_string_info[0];\n            const exp = cmd.expression.toString();\n            throw ProcessorErrorFactory.incompatible_types_full(\n              info.type,\n              info.dim,\n              exp_type_info.type,\n              exp_type_info.dim,\n              exp,\n              cmd.sourceInfo\n            );\n          }\n        }\n        temp = new StoreValue(cmd.type, realValue.get(), null, cmd.isConst);\n      }\n      store.insertStore(cmd.id, temp);\n      return store;\n    }\n  }\n\n  /**\n   *\n   * @param {Store} store\n   * @param {Commands.ArrayDeclaration} cmd\n   *\n   * @returns {Promise<Store>}\n   */\n  async executeArrayDeclaration (store, cmd) {\n    const linesSV = await this.evaluateExpression(store, cmd.lines);\n    if (!Types.INTEGER.isCompatible(linesSV.type)) {\n      throw ProcessorErrorFactory.array_dimension_not_int_full(cmd.sourceInfo);\n    }\n    const line = linesSV.get().toNumber();\n    const columnsSV = await this.evaluateExpression(store, cmd.columns);\n    let column = null;\n    if (columnsSV !== null) {\n      if (!Types.INTEGER.isCompatible(columnsSV.type)) {\n        throw ProcessorErrorFactory.array_dimension_not_int_full(\n          cmd.sourceInfo\n        );\n      }\n      column = columnsSV.get().toNumber();\n      if (column < 0) {\n        throw ProcessorErrorFactory.array_dimension_not_positive_full(\n          cmd.sourceInfo\n        );\n      }\n    }\n    let temp = new ArrayStoreValue(\n      cmd.type,\n      [],\n      line,\n      column,\n      null,\n      cmd.isConst\n    );\n    if (cmd.initial !== null) {\n      // array can only be initialized by a literal....\n      const valueList = await this.evaluateArrayLiteral(\n        store,\n        cmd.initial,\n        cmd.type,\n        line,\n        column\n      );\n      temp = new ArrayStoreValue(\n        cmd.type,\n        valueList,\n        line,\n        column,\n        null,\n        cmd.isConst\n      );\n    }\n    store.insertStore(cmd.id, temp);\n    return store;\n  }\n\n  /**\n   *\n   * @param {Store} store\n   * @param {Expression} exp\n   *\n   * @returns {Promise<import('./store/value/istore_value').IStoreValue>}\n   */\n  async evaluateExpression (store, exp) {\n    this.instruction_count += 1;\n    if (this.instruction_count % Config.suspend_threshold == 0) {\n      //every Config.suspend_threshold instruction should briefly delay its execution in order to allow the browser to process other things\n      await Utils.sleep(3);\n    }\n    if (this.mode === Modes.ABORT) {\n      throw LocalizedStrings().getMessage(\"aborted_execution\");\n    }\n    if (this.instruction_count >= Config.max_instruction_count) {\n      throw new Error(\n        \"Número de instruções excedeu o limite definido. Verifique se seu código não possui laços infinitos ou muitas chamadas de funções recursivas.\"\n      );\n    }\n    if (exp instanceof Expressions.UnaryApp) {\n      return this.evaluateUnaryApp(store, exp);\n    } else if (exp instanceof Expressions.InfixApp) {\n      return this.evaluateInfixApp(store, exp);\n    } else if (exp instanceof Expressions.ArrayAccess) {\n      return this.evaluateArrayAccess(store, exp);\n    } else if (exp instanceof Expressions.VariableLiteral) {\n      return this.evaluateVariableLiteral(store, exp);\n    } else if (exp instanceof Expressions.IntLiteral) {\n      return this.evaluateLiteral(store, exp);\n    } else if (exp instanceof Expressions.RealLiteral) {\n      return this.evaluateLiteral(store, exp);\n    } else if (exp instanceof Expressions.BoolLiteral) {\n      return this.evaluateLiteral(store, exp);\n    } else if (exp instanceof Expressions.StringLiteral) {\n      return this.evaluateLiteral(store, exp);\n    } else if (exp instanceof Expressions.CharLiteral) {\n      return this.evaluateLiteral(store, exp);\n    } else if (exp instanceof Expressions.ArrayLiteral) {\n      throw new Error(\n        \"Internal Error: The system should not eval an array literal.\"\n      );\n    } else if (exp instanceof Expressions.FunctionCall) {\n      return this.evaluateFunctionCall(store, exp);\n    }\n    return null;\n  }\n\n  async evaluateFunctionCall (store, exp) {\n    if (exp.isMainCall) {\n      throw ProcessorErrorFactory.void_in_expression_full(\n        LanguageDefinedFunction.getMainFunctionName(),\n        exp.sourceInfo\n      );\n    }\n    const func = this.findFunction(exp.id);\n    if (Types.VOID.isCompatible(func.returnType)) {\n      throw ProcessorErrorFactory.void_in_expression_full(\n        exp.id,\n        exp.sourceInfo\n      );\n    }\n    if (this.function_call_stack.length >= Config.max_call_stack) {\n      throw ProcessorErrorFactory.exceeded_recursive_calls(exp.sourceInfo);\n    }\n    this.function_call_stack.push(exp.sourceInfo);\n    const sto = await this.runFunction(func, exp.actualParameters, store);\n    if (sto.mode !== Modes.RETURN) {\n      throw new Error(\n        \"!!!Internal error: the function that was called did not have a return command or did not set the store mode properly -> \" +\n          exp.id\n      );\n    }\n    const val = sto.applyStore(\"$\");\n    sto.destroy();\n    this.function_call_stack.pop();\n    return val;\n  }\n\n  /**\n   *\n   * @param {Store} store\n   * @param {Expressions.ArrayLiteral} exp\n   * @param {ArrayType} type\n   *\n   * @returns {Promise<StoreValue[]>}\n   */\n  async evaluateArrayLiteral (store, exp, type, lines, columns) {\n    if (!exp.isVector) {\n      if (columns == null) {\n        throw new Error(\n          \"This should never happen: Vector cannot be initialized by a matrix\"\n        );\n      }\n      const storeValueMatrix = await this.evaluateMatrix(\n        store,\n        exp,\n        type,\n        lines,\n        columns\n      );\n      return storeValueMatrix.reduce((prev, next) => prev.concat(next), []);\n    } else {\n      if (columns != null) {\n        throw new Error(\n          \"This should never happen: Matrix cannot be initialized by a vector\"\n        );\n      }\n      return this.evaluateVector(store, exp, type, lines);\n    }\n  }\n\n  /**\n   * Evalautes a list of literals and expression composing the vector\n   * @param {Store} store\n   * @param {Expressions.ArrayLiteral} exps\n   * @param {ArrayType} type\n   * @param {number} n_elements\n   *\n   * @returns {Promise<StoreValue[]>} store object list\n   */\n  async evaluateVector (store, exps, type, n_elements) {\n    const values = exps.value;\n    if (n_elements !== values.length) {\n      throw ProcessorErrorFactory.invalid_number_elements_vector(\n        n_elements,\n        exps.toString(),\n        values.length,\n        exps.sourceInfo\n      );\n    }\n    const actualValues = await Promise.all(\n      values.map((exp) => this.evaluateExpression(store, exp))\n    );\n    return actualValues.map((v, index) => {\n      if (!type.canAccept(v.type, 1)) {\n        if (\n          !Config.enable_type_casting ||\n          !Store.canImplicitTypeCast(type.innerType, v.type)\n        ) {\n          // const stringInfo = v.type.stringInfo();\n          // const info = stringInfo[0];\n          const exp_str = values[index].toString();\n          // TODO - fix error message\n          throw ProcessorErrorFactory.invalid_array_literal_type_full(\n            exp_str,\n            values[index].sourceInfo\n          );\n        }\n        const newValue = Store.doImplicitCasting(type.innerType, v);\n        return newValue;\n      }\n      return v;\n    });\n  }\n\n  /**\n   * Evaluates a list of array literals composing the matrix\n   * @param {Store} store\n   * @param {Expressions.ArrayLiteral} exps\n   * @param {ArrayType} type\n   *\n   * @returns {Promise<StoreValue[][]>}\n   */\n  async evaluateMatrix (store, exps, type, lines, columns) {\n    const values = exps.value;\n    if (values.length !== lines) {\n      throw ProcessorErrorFactory.invalid_number_lines_matrix(\n        lines,\n        exps.toString(),\n        values.length,\n        exps.sourceInfo\n      );\n    }\n    const vectors = values.map((vector) => {\n      const vec_type = new ArrayType(type.innerType, 1);\n      return this.evaluateVector(store, vector, vec_type, columns);\n    });\n    return await Promise.all(vectors);\n  }\n\n  /**\n   *\n   * @param {Store} _\n   * @param {import('../ast/expressions/literal').Literal} exp\n   *\n   * @returns {import('./store/value/istore_value').IStoreValue}\n   */\n  async evaluateLiteral (_, exp) {\n    return new StoreValue(exp.type, exp.value);\n  }\n\n  /**\n   *\n   * @param {Store} store\n   * @param {Expressions.VariableLiteral} exp\n   *\n   * @returns {import('./store/value/istore_value').IStoreValue}\n   */\n  async evaluateVariableLiteral (store, exp) {\n    const val = store.applyStore(exp.id);\n    return val;\n  }\n\n  /**\n   *\n   * @param {Store} store\n   * @param {Expressions.ArrayAccess} exp\n   *\n   * @returns {import('./store/value/istore_value').IStoreValue}\n   */\n  async evaluateArrayAccess (store, exp) {\n    const mustBeArray = store.getStoreObject(exp.id);\n    if (!(mustBeArray.type instanceof ArrayType)) {\n      throw ProcessorErrorFactory.invalid_array_access_full(\n        exp.id,\n        exp.sourceInfo\n      );\n    }\n    const lineSV = await this.evaluateExpression(store, exp.line);\n    if (!Types.INTEGER.isCompatible(lineSV.type)) {\n      throw ProcessorErrorFactory.array_dimension_not_int_full(exp.sourceInfo);\n    }\n    const line = lineSV.get().toNumber();\n    const columnSV = await this.evaluateExpression(store, exp.column);\n    let column = null;\n    if (columnSV !== null) {\n      if (!Types.INTEGER.isCompatible(columnSV.type)) {\n        throw ProcessorErrorFactory.array_dimension_not_int_full(\n          exp.sourceInfo\n        );\n      }\n      column = columnSV.get().toNumber();\n    }\n    if (line >= mustBeArray.lines) {\n      if (mustBeArray.isVector) {\n        throw ProcessorErrorFactory.vector_line_outbounds_full(\n          exp.id,\n          line,\n          mustBeArray.lines,\n          exp.sourceInfo\n        );\n      } else {\n        throw ProcessorErrorFactory.matrix_line_outbounds_full(\n          exp.id,\n          line,\n          mustBeArray.lines,\n          exp.sourceInfo\n        );\n      }\n    } else if (line < 0) {\n      throw ProcessorErrorFactory.array_dimension_not_positive_full(\n        exp.sourceInfo\n      );\n    }\n    if (column !== null && mustBeArray.columns === 0) {\n      throw ProcessorErrorFactory.vector_not_matrix_full(\n        exp.id,\n        exp.sourceInfo\n      );\n    }\n    if (column !== null) {\n      if (column >= mustBeArray.columns) {\n        throw ProcessorErrorFactory.matrix_column_outbounds_full(\n          exp.id,\n          column,\n          mustBeArray.columns,\n          exp.sourceInfo\n        );\n      } else if (column < 0) {\n        throw ProcessorErrorFactory.array_dimension_not_positive_full(\n          exp.sourceInfo\n        );\n      }\n    }\n    const result = mustBeArray.getAt(line, column);\n    const type = mustBeArray.type.innerType;\n    if (Array.isArray(result)) {\n      const values = result.map((val, col) => {\n        return new StoreValueAddress(\n          type,\n          val,\n          line,\n          col,\n          mustBeArray.id,\n          mustBeArray.readOnly\n        );\n      });\n      return new ArrayStoreValue(\n        new ArrayType(type, 1),\n        values,\n        mustBeArray.columns,\n        null,\n        mustBeArray.id,\n        mustBeArray.readOnly\n      );\n    } else {\n      return new StoreValueAddress(\n        type,\n        result,\n        line,\n        column,\n        mustBeArray.id,\n        mustBeArray.readOnly\n      );\n    }\n  }\n\n  /**\n   *\n   * @param {Store} store\n   * @param {Expressions.UnaryApp} unaryApp\n   *\n   * @returns {import('./store/value/istore_value').IStoreValue}\n   */\n  async evaluateUnaryApp (store, unaryApp) {\n    const left = await this.evaluateExpression(store, unaryApp.left);\n    const resultType = resultTypeAfterUnaryOp(unaryApp.op, left.type);\n    if (Types.UNDEFINED.isCompatible(resultType)) {\n      const stringInfo = left.type.stringInfo();\n      const info = stringInfo[0];\n      throw ProcessorErrorFactory.invalid_unary_op_full(\n        unaryApp.op,\n        info.type,\n        info.dim,\n        unaryApp.sourceInfo\n      );\n    }\n    switch (unaryApp.op.ord) {\n      case Operators.ADD.ord:\n        return new StoreValue(resultType, left.get());\n      case Operators.SUB.ord:\n        return new StoreValue(resultType, left.get().negated());\n      case Operators.NOT.ord:\n        return new StoreValue(resultType, !left.get());\n      default:\n        throw new RuntimeError(\"!!!Critical Invalid UnaryApp \" + unaryApp.op);\n    }\n  }\n\n  /**\n   *\n   * @param {Store} store\n   * @param {Expressions.InfixApp} infixApp\n   *\n   * @returns {import('./store/value/istore_value').IStoreValue}\n   */\n  async evaluateInfixApp (store, infixApp) {\n    const left = await this.evaluateExpression(store, infixApp.left);\n    const right = await this.evaluateExpression(store, infixApp.right);\n    let shouldImplicitCast = false;\n    let resultType = resultTypeAfterInfixOp(infixApp.op, left.type, right.type);\n    if (Types.UNDEFINED.isCompatible(resultType)) {\n      if (\n        Config.enable_type_casting &&\n        Store.canImplicitTypeCast(left.type, right.type)\n      ) {\n        shouldImplicitCast = true;\n      } else {\n        const stringInfoLeft = left.type.stringInfo();\n        const infoLeft = stringInfoLeft[0];\n        const stringInfoRight = right.type.stringInfo();\n        const infoRight = stringInfoRight[0];\n        throw ProcessorErrorFactory.invalid_infix_op_full(\n          infixApp.op,\n          infoLeft.type,\n          infoLeft.dim,\n          infoRight.type,\n          infoRight.dim,\n          infixApp.sourceInfo\n        );\n      }\n    }\n    let result = null;\n    switch (infixApp.op.ord) {\n      case Operators.ADD.ord: {\n        if (Types.STRING.isCompatible(left.type)) {\n          const rightStr = convertToString(right.get(), right.type);\n          return new StoreValue(resultType, left.get() + rightStr);\n        } else if (Types.STRING.isCompatible(right.type)) {\n          const leftStr = convertToString(left.get(), left.type);\n          return new StoreValue(resultType, leftStr + right.get());\n        } else if (Types.CHAR.isCompatible(left.type)) {\n          const strLeft = convertToString(left.get(), left.type);\n          const strRight = convertToString(right.get(), right.type);\n          return new StoreValue(resultType, strLeft + strRight);\n        } else {\n          return new StoreValue(resultType, left.get().plus(right.get()));\n        }\n      }\n      case Operators.SUB.ord:\n        return new StoreValue(resultType, left.get().minus(right.get()));\n      case Operators.MULT.ord: {\n        result = left.get().times(right.get());\n        return new StoreValue(resultType, result);\n      }\n      case Operators.DIV.ord: {\n        if (right.get() == 0) {\n          throw ProcessorErrorFactory.divsion_by_zero_full(\n            infixApp.toString(),\n            infixApp.sourceInfo\n          );\n        }\n        if (Types.INTEGER.isCompatible(resultType))\n          result = left.get().divToInt(right.get());\n        else result = left.get().div(right.get());\n        return new StoreValue(resultType, result);\n      }\n      case Operators.MOD.ord: {\n        let leftValue = left.get();\n        let rightValue = right.get();\n        if (shouldImplicitCast) {\n          resultType = Types.INTEGER;\n          leftValue = leftValue.trunc();\n          rightValue = rightValue.trunc();\n        }\n        result = leftValue.modulo(rightValue);\n        return new StoreValue(resultType, result);\n      }\n      case Operators.GT.ord: {\n        let leftValue = left.get();\n        let rightValue = right.get();\n        if (Types.STRING.isCompatible(left.type)) {\n          result = leftValue.length > rightValue.length;\n        } else if (Types.CHAR.isCompatible(left.type)) {\n          result = leftValue.charCodeAt(0) > rightValue.charCodeAt(0);\n        } else {\n          if (shouldImplicitCast) {\n            resultType = Types.BOOLEAN;\n            leftValue = leftValue.trunc();\n            rightValue = rightValue.trunc();\n          }\n          result = leftValue.gt(rightValue);\n        }\n        return new StoreValue(resultType, result);\n      }\n      case Operators.GE.ord: {\n        let leftValue = left.get();\n        let rightValue = right.get();\n        if (Types.STRING.isCompatible(left.type)) {\n          result = leftValue.length >= rightValue.length;\n        } else if (Types.CHAR.isCompatible(left.type)) {\n          result = leftValue.charCodeAt(0) >= rightValue.charCodeAt(0);\n        } else {\n          if (shouldImplicitCast) {\n            resultType = Types.BOOLEAN;\n            leftValue = leftValue.trunc();\n            rightValue = rightValue.trunc();\n          }\n          result = leftValue.gte(rightValue);\n        }\n        return new StoreValue(resultType, result);\n      }\n      case Operators.LT.ord: {\n        let leftValue = left.get();\n        let rightValue = right.get();\n        if (Types.STRING.isCompatible(left.type)) {\n          result = leftValue.length < rightValue.length;\n        } else if (Types.CHAR.isCompatible(left.type)) {\n          result = leftValue.charCodeAt(0) < rightValue.charCodeAt(0);\n        } else {\n          if (shouldImplicitCast) {\n            resultType = Types.BOOLEAN;\n            leftValue = leftValue.trunc();\n            rightValue = rightValue.trunc();\n          }\n          result = leftValue.lt(rightValue);\n        }\n        return new StoreValue(resultType, result);\n      }\n      case Operators.LE.ord: {\n        let leftValue = left.get();\n        let rightValue = right.get();\n        if (Types.STRING.isCompatible(left.type)) {\n          result = leftValue.length <= rightValue.length;\n        } else if (Types.CHAR.isCompatible(left.type)) {\n          result = leftValue.charCodeAt(0) <= rightValue.charCodeAt(0);\n        } else {\n          if (shouldImplicitCast) {\n            resultType = Types.BOOLEAN;\n            leftValue = leftValue.trunc();\n            rightValue = rightValue.trunc();\n          }\n          result = leftValue.lte(rightValue);\n        }\n        return new StoreValue(resultType, result);\n      }\n      case Operators.EQ.ord: {\n        let leftValue = left.get();\n        let rightValue = right.get();\n        if (\n          Types.INTEGER.isCompatible(left.type) ||\n          Types.REAL.isCompatible(left.type)\n        ) {\n          if (shouldImplicitCast) {\n            resultType = Types.BOOLEAN;\n            leftValue = leftValue.trunc();\n            rightValue = rightValue.trunc();\n          }\n          result = leftValue.eq(rightValue);\n        } else {\n          result = leftValue === rightValue;\n        }\n        return new StoreValue(resultType, result);\n      }\n      case Operators.NEQ.ord: {\n        let leftValue = left.get();\n        let rightValue = right.get();\n        if (\n          Types.INTEGER.isCompatible(left.type) ||\n          Types.REAL.isCompatible(left.type)\n        ) {\n          if (shouldImplicitCast) {\n            resultType = Types.BOOLEAN;\n            leftValue = leftValue.trunc();\n            rightValue = rightValue.trunc();\n          }\n          result = !leftValue.eq(rightValue);\n        } else {\n          result = leftValue !== rightValue;\n        }\n        return new StoreValue(resultType, result);\n      }\n      case Operators.AND.ord:\n        return new StoreValue(resultType, left.get() && right.get());\n      case Operators.OR.ord:\n        return new StoreValue(resultType, left.get() || right.get());\n      default:\n        throw new RuntimeError(\"!!!Critical Invalid InfixApp \" + infixApp.op);\n    }\n  }\n}\n","import { Input } from './../io/input';\nimport { getInstance as LocalizedStrings} from '../services/localizedStringsService';\n\nexport class InputTest extends Input {\n\n  constructor (inputList) {\n    super();\n    this.index = 0;\n    this.inputList = inputList;\n  }\n\n  requestInput () {\n    const promise = new Promise( (resolve, reject) => {\n      if(this.index < this.inputList.length) {      \n        resolve(this.inputList[this.index]);\n        this.index++;\n      } else {\n        reject(new Error(LocalizedStrings().getError(\"exceeded_input_request\")));\n      }\n    });\n    return promise\n  }\n}","export class Input {\n\n  /**\n   * This function should return a promise which will resolve with the text provided by user.\n   * The promise should usually resolves when the ENTER key is pressed, \n   * but if the parameter anyKey is true, any key press should make the promise immediatlly resolve\n   * \n   * @param {boolean} anyKey if true any key pressed should be immediatly sent to the processor, defaults false \n   * @returns Promise<string>\n   */\n  requestInput (anyKey = false) {\n    throw new Error(\"Must be implemented\");\n  }\n\n}","import { Output } from \"./../io/output\";\n\nexport class OutputTest extends Output {\n  constructor () {\n    super();\n    this.list = [];\n    this.currentLine = null;\n  }\n\n  write (text, newLine = false) {\n    if (this.currentLine == null) {\n      this.currentLine = this.list.push(\"\") - 1;\n    }\n\n    this.list[this.currentLine] += text;\n    if (newLine) {\n      this.currentLine = null;\n    }\n  }\n\n  sendOutput (text) {\n    const output = \"\" + text;\n    if (output.indexOf(\"\\n\") !== -1) {\n      const outputList = output.split(\"\\n\");\n      const last = outputList.pop();\n      outputList.forEach((t) => {\n        //t = t.replace(/\\t/g, '&#x0020;&#x0020;');\n        //t = t.replace(/\\s/g, \"&#x0020;\");\n        if (t.length == 0) this.currentLine = null;\n        else this.write(t, true);\n      });\n      //last = last.replace(/\\t/g, '&#x0020;&#x0020;');\n      //last = last.replace(/\\s/g, \"&#x0020;\");\n      if (last.length != 0) this.write(last);\n    } else {\n      //output = output.replace(/\\t/g, '&#x0020;&#x0020;');\n      //output = output.replace(/\\s/g, \"&#x0020;\");\n      this.write(output);\n    }\n  }\n}\n","export class Output {\n\n  // Channels used to indicate the nature of the output for formatting purposes(raw HTML only)\n  static get USER () {\n    return 0;\n  }\n\n  static get INFO () {\n    return 1;\n  }\n\n  static get ERR () {\n    return 2;\n  }\n\n  static get INPUT () {\n    return 3;\n  }\n  // </ END Channels>\n\n  /**\n   * sendOutput is the function used by the code processor to send output from the program to the user\n   * From the functions presented in this file this is only function that MUST BE provided by the instance passed to\n   * the processor using IVProgProcessor.registerOutput\n   * \n   * @param {string|number|boolean} text text to be present as an output \n   */\n  sendOutput (text) {\n    throw new Error(\"Must be implemented\");\n  }\n\n  /**\n   * Function used by the assessment tool to present the assessment results which can be raw HTML text and should not be sanitized\n   * @param {string|number|boolean} text text to be presented to the user\n   * @param {number} channel channel that should be used to send this output\n   */\n  writeRawHTML (text, channel) {\n    throw new Error(\"Must be implemented\");\n  }\n\n  /**\n   * Function used by the assessment tool to generate logs and notifications\n   * @param {string|number|boolean} text the output\n   * @param {boolean} newLine if true a line break will be added after the text\n   */\n  write (text, newLine = false) {\n    throw new Error(\"Must be implemented\");\n  }\n\n  /**\n   * Function used by the assessment tool to generate logs and notifications in the INFO channel\n   * @param {string|number|boolean} text the output\n   */\n  info (text) {\n    throw new Error(\"Must be implemented\");\n  }\n\n  /**\n   * Function used by the assessment tool to generate logs and notifications in the ERROR channel\n   * @param {string|number|boolean} text the output\n   */\n  err (text) {\n    throw new Error(\"Must be implemented\");\n  }\n\n}","import {SemanticAnalyser} from './../processor/semantic/semanticAnalyser';\nimport {IVProgProcessor} from './../processor/ivprogProcessor';\nimport { InputTest } from './inputTest';\nimport { OutputTest } from './outputTest';\nimport { getInstance as LocalizedStrings } from './../services/localizedStringsService'\n\nexport async function autoGenerateTestCaseOutput (program_text, testCases, callback) {\n  let copyTestCases = testCases.map((test) => Object.assign({}, test));\n  try {\n    const program = SemanticAnalyser.analyseFromSource(program_text);\n    const resultList = testCases.map(async (test, id) => {\n      const input = new InputTest(test.input);\n      const output = new OutputTest();\n      const exec =  new IVProgProcessor(program);\n      exec.registerInput(input);\n      exec.registerOutput(output);\n      await exec.interpretAST();\n      return { id: id, program: exec };\n    });\n    const result_final = await Promise.all(resultList);\n    for (let i = 0; i < result_final.length; ++i) {\n      const result_1 = result_final[i];\n      const output_2 = result_1.program.output.list;\n      const input_2 = result_1.program.input;\n      if (input_2.index != input_2.inputList.length) {\n        window.showAlert(LocalizedStrings().getMessage(\"testcase_autogen_unused_input\", [result_1.id + 1]));\n        return false;\n      }\n      if (output_2.length == 0) {\n        window.showAlert(LocalizedStrings().getMessage(\"testcase_autogen_empty\", [result_1.id + 1]));\n      }\n      copyTestCases[result_1.id].output = output_2;\n    }\n    callback(copyTestCases);\n    return true;\n  }catch (error) {\n    return Promise.reject(error)\n  }\n}","import line_i18n from \"line-i18n\";\nimport { getInstance as LocalizedStrings} from \"./localizedStringsService\";\n\nconst StringTypes = line_i18n.StringTypes;\n\nexport const i18nHelper = Object.freeze({\n  i18n: (identifier) => {\n    var opts = identifier.split(':');\n    var type = opts[0].toLowerCase();\n    var id = opts[1];\n    if (StringTypes.ERROR === type) {\n      return LocalizedStrings().getError(id);\n    } else if (StringTypes.MESSAGE === type) {\n      return LocalizedStrings().getMessage(id); \n    } else if (StringTypes.UI === type) {\n      return LocalizedStrings().getUI(id);\n    } else {\n      console.warn(\"A string has been passed to the i18n helper function that was not in the form type:id -> \" + identifier);\n      return LocalizedStrings().getString(identifier, type);\n    }\n  }\n});","import { openAssessmentDetail, levenshteinDistance } from \"./src/util/utils\";\nimport { processData } from \"./src/util/dataProcess\";\nimport { parseExpression, parseCode } from \"./src/util/parseFromVisual\";\nimport { autoGenerateTestCaseOutput } from \"./src/util/auto_gen_output\";\nimport { IVProgProcessor } from \"./src/processor/ivprogProcessor\";\nimport { SemanticAnalyser } from \"./src/processor/semantic/semanticAnalyser\";\nimport { Modes } from \"./src/processor/modes\";\nimport { Location } from \"./src/memory/location\";\nimport { Config } from \"./src/util/config\";\nimport { i18nHelper } from \"./src/services/i18nHelper\";\nimport {getInstance as LocalizedStrings} from \"./src/services/localizedStringsService\";\nimport {LanguageService} from \"./src/services/languageService\";\n\nconst Settings = {\n  programming: [],\n  functions: [],\n  datatypes: [],\n  commands: [],\n  filter: []\n}\n\nconst i18n = i18nHelper.i18n;\n\nexport {\n  i18n,\n  Settings,\n  Config,\n  LocalizedStrings,\n  LanguageService,\n  SemanticAnalyser,\n  IVProgProcessor,\n  Modes,\n  Location,\n  openAssessmentDetail,\n  autoGenerateTestCaseOutput,\n  parseExpression,\n  parseCode,\n  levenshteinDistance,\n  processData,\n};\n"],"names":["root","factory","exports","module","define","amd","this","hasOwnProperty","Object","prototype","toString","hasSticky","RegExp","sticky","isRegExp","o","call","isObject","Array","isArray","reCapture","s","reUnion","regexps","length","map","join","regexpOrLiteral","obj","replace","ignoreCase","Error","global","multiline","source","pad","ruleOptions","type","match","include","options","defaultType","lineBreaks","error","fallback","pop","next","push","value","shouldThrow","key","sort","a","b","toRules","spec","array","result","i","concat","j","JSON","stringify","arrayToRules","object","keys","getOwnPropertyNames","thing","rules","forEach","rule","objectToRules","defaultErrorRule","compileRules","hasStates","errorRule","fast","create","fastAllowed","unicodeFlag","groups","parts","slice","shift","charCodeAt","unicode","pat","regexp","test","exec","fallbackRule","flags","suffix","checkStateGroup","g","name","state","Lexer","states","startState","buffer","stack","reset","data","info","index","line","col","queuedToken","queuedText","queuedThrow","setState","save","re","popState","pushState","eat","tokenToString","_getGroup","groupCount","undefined","queuedGroup","token","_token","group","charAt","lastIndex","text","offset","matchNL","nl","size","formatError","Symbol","iterator","LexerIterator","lexer","done","message","indexOf","firstDisplayedLine","Math","max","lastDisplayedLine","lastLineDigits","String","displayedLines","string","numLines","position","idx","lastIndexOf","startPosition","substring","split","lastNLines","errorLines","lineNo","clone","has","tokenType","compile","start","all","$all","ruleMap","included","splice","newRules","k","newRule","apply","fastKeys","freeze","keywords","isMap","Map","reverseMap","types","item","keyword","set","get","_typeof","_regeneratorRuntime","__esModule","Op","hasOwn","defineProperty","desc","$Symbol","iteratorSymbol","asyncIteratorSymbol","asyncIterator","toStringTagSymbol","toStringTag","enumerable","configurable","writable","err","wrap","innerFn","outerFn","self","tryLocsList","protoGenerator","Generator","generator","context","Context","makeInvokeMethod","tryCatch","fn","arg","ContinueSentinel","GeneratorFunction","GeneratorFunctionPrototype","IteratorPrototype","getProto","getPrototypeOf","NativeIteratorPrototype","values","Gp","defineIteratorMethods","method","_invoke","AsyncIterator","PromiseImpl","invoke","resolve","reject","record","__await","then","unwrapped","previousPromise","callInvokeWithMethodAndArg","delegate","delegateResult","maybeInvokeDelegate","sent","_sent","dispatchException","abrupt","methodName","TypeError","resultName","nextLoc","pushTryEntry","locs","entry","tryLoc","catchLoc","finallyLoc","afterLoc","tryEntries","resetTryEntry","completion","iterable","iteratorMethod","isNaN","doneResult","displayName","isGeneratorFunction","genFun","ctor","constructor","mark","setPrototypeOf","__proto__","awrap","async","Promise","iter","val","reverse","skipTempReset","prev","stop","rootRecord","rval","exception","handle","loc","caught","hasCatch","hasFinally","finallyEntry","complete","finish","thrown","delegateYield","runtime","regeneratorRuntime","accidentalStrictMode","globalThis","Function","__webpack_module_cache__","__webpack_require__","moduleId","cachedModule","__webpack_modules__","n","getter","d","definition","prop","r","asyncGeneratorStep","gen","_next","_throw","args","arguments","_classCallCheck","instance","Constructor","_toPropertyKey","input","hint","prim","toPrimitive","res","_defineProperties","target","props","descriptor","_createClass","protoProps","staticProps","_setPrototypeOf","p","bind","_inherits","subClass","superClass","_assertThisInitialized","ReferenceError","_possibleConstructorReturn","_getPrototypeOf","_arrayLikeToArray","arr","len","arr2","_unsupportedIterableToArray","minLen","from","_slicedToArray","_i","_s","_e","_x","_r","_arr","_n","_d","_taggedTemplateLiteral","strings","raw","defineProperties","combineRegex","pieces","IVProgLexer","RKs","i18nLexer","langLibs","langFuncs","HEX_DIGIT","OCTAL_DIGIT","ESC_OCTAL","ESC_UNICODE","ESC_SEQ","STRING_CHARACTER","makeLexer","entries","boolVal","commands","logicOp","RK_LOGICAL_AND","RK_LOGICAL_OR","RK_LOGICAL_NOT","RESERVED_KEYS","moo","lexerRules","COMMENTS","OPEN_BRACE","CLOSE_BRACE","OPEN_PARENTHESIS","CLOSE_PARENTHESIS","OPEN_CURLY","CLOSE_CURLY","COMMA","ASSIGNMENT","REAL","INTEGER","SUM_OP","MULTI_OP","RELATIONAL_OPERATOR","COLON","STRING","CHARACTER","EOS","WHITESPACE","RK_REFERENCE","ID","DOT","ERROR","moolexer","ptLexer","RK_VOID","RK_PROGRAM","RK_SWITCH","RK_CASE","RK_DEFAULT","RK_CONST","RK_FUNCTION","RK_RETURN","RK_FOR","RK_FOR_ALT","RK_FOR_FROM","RK_FOR_TO","RK_FOR_PASS","RK_BREAK","RK_DO","RK_DO_UNTIL","RK_WHILE","RK_WHILE_ALT","RK_IF","RK_ELSE","RK_FALSE","RK_TRUE","RK_REAL","RK_INTEGER","RK_BOOLEAN","RK_CHARACTER","RK_STRING","$mathLib","$ioLib","$strLib","$arrayLib","$langLib","main_function","$read","$write","$numElements","$matrixLines","$matrixColumns","$substring","$length","$uppercase","$lowercase","$charAt","$isReal","$isInt","$isBool","$castReal","$castInt","$castBool","$castString","$castChar","$sin","$cos","$tan","$sqrt","$pow","$log","$abs","$negate","$invert","$max","$min","$rand","enLexer","lexers","pt","en","StringTypes","LanguageService","lsKey","defaultLang","listeners","document","setupListener","_this","addEventListener","event","l","getLang","lang","localStorage","getItem","console","warn","getDefaultLang","registerLanguageChangeListener","listener","LocalizedStrings","service","i18nData","listenToChange","updateTagText","getString","id","i18nObj","getDefaultString","getOR","getUI","getError","processString","getMessage","MESSAGE","UI","v","func","querySelectorAll","node","innerHTML","processTagTex","getAttribute","opts","toLowerCase","LanguageServiceNoLS","notifyChange","setLang","_defineProperty","ConfigObject","decimalPlaces","intConvertRoundMode","default_lang","enable_type_casting","idle_input_interval","suspend_threshold","max_instruction_count","Number","MAX_SAFE_INTEGER","activity_programming_type","activity_functions","activity_datatypes","activity_commands","activity_filter","otherConfig","Config","iLMparameters","langLexer","Lexers","langInfo","getLangFuncs","getLangLibs","line_i18n","MessagesObj","UIObj","ErrorsObj","i18n_data","Command","_sourceInfo","sourceInfo","Break","Return","expression","Assign","ArrayIndexAssign","lineExpression","columnExpression","column","Declaration","initial","isConst","ArrayDeclaration","lines","columns","While","commandBlock","For","for_id","for_from","for_to","for_pass","Type","ord","dim","another","MultiType","list","t","stringInfo","isCompatible","BOOLEAN","CHAR","VOID","UNDEFINED","ALL","Types","returnType","formalParameters","variables","some","variadic","IfThenElse","condition","ifTrue","ifFalse","CommandBlock","RepeatUntil","Switch","cases","Case","SysCall","langFunc","FormalParameter","byRef","Expression","_parenthesis","flag","inexact","quadrant","FunctionCall","actualParameters","isMainCall","LanguageDefinedFunction","getMainFunctionName","getLocalName","params","parenthesis","Modes","RETURN","BREAK","PAUSE","RUN","ABORT","EXP_LIMIT","MAX_DIGITS","NUMERALS","LN10","PI","DEFAULTS","precision","rounding","modulo","toExpNeg","toExpPos","minE","maxE","crypto","external","decimalError","invalidArgument","precisionLimitExceeded","cryptoUnavailable","tag","mathfloor","floor","mathpow","pow","isBinary","isHex","isOctal","isDecimal","BASE","LN10_PRECISION","PI_PRECISION","P","digitsToString","ws","indexOfLastWord","str","w","getZeroString","checkInt32","min","checkRoundingDigits","rm","repeating","di","rd","ceil","convertBase","baseIn","baseOut","arrL","strL","absoluteValue","abs","x","finalise","e","clampedTo","clamp","Ctor","NaN","gt","cmp","comparedTo","y","xdL","ydL","xd","yd","xs","ys","cosine","cos","pr","sd","isZero","tinyPow","taylorSeries","times","cos2x","minus","plus","toLessThanHalfPi","neg","cubeRoot","cbrt","m","rep","t3","t3plusx","isFinite","toExponential","divide","eq","dp","dividedBy","div","dividedToIntegerBy","divToInt","equals","greaterThan","greaterThanOrEqualTo","gte","hyperbolicCosine","cosh","one","cosh2_x","d8","hyperbolicSine","sinh","sqrt","sinh2_x","d5","d16","d20","hyperbolicTangent","tanh","inverseCosine","acos","halfPi","isNeg","getPi","asin","inverseHyperbolicCosine","acosh","lte","ln","inverseHyperbolicSine","asinh","inverseHyperbolicTangent","atanh","wpr","xsd","inverseSine","atan","inverseTangent","px","x2","isInteger","isInt","isNegative","isPositive","isPos","lessThan","lt","lessThanOrEqualTo","logarithm","log","base","isBase10","denominator","inf","num","naturalLogarithm","getLn10","sub","xe","xLTy","getBase10Exponent","mod","q","naturalExponential","exp","negated","add","carry","unshift","z","getPrecision","round","sine","sin","sin2_x","squareRoot","tangent","tan","mul","rL","toBinary","toStringBinary","toDecimalPlaces","toDP","finiteToString","toFixed","toFraction","maxD","d0","d1","d2","n0","n1","toHexadecimal","toHex","toNearest","toNumber","toOctal","toPower","yn","intPow","toPrecision","toSignificantDigits","toSD","truncated","trunc","valueOf","toJSON","multiplyInteger","temp","compare","aL","bL","subtract","logBase","more","prod","prodL","qd","rem","remL","rem0","xi","xL","yd0","yL","yz","sign","isTruncated","digits","roundUp","xdi","out","isExp","nonFiniteToString","zs","truncate","isOdd","maxOrMin","ltgt","guard","sum","c","c0","numerator","x1","parseDecimal","search","parseOther","divisor","isFloat","Decimal","isHyperbolic","u","pi","atan2","useDefaults","defaults","ps","getRandomValues","randomBytes","hypot","isDecimalInstance","log2","log10","random","Uint32Array","copy","for","ROUND_UP","ROUND_DOWN","ROUND_CEIL","ROUND_FLOOR","ROUND_HALF_UP","ROUND_HALF_DOWN","ROUND_HALF_EVEN","ROUND_HALF_CEIL","ROUND_HALF_FLOOR","EUCLID","config","toInt","toChar","toReal","toBool","getReservedKeys","getRules","convertBoolToString","bool","convertToString","Reflect","construct","sham","Proxy","Boolean","_construct","Parent","Class","_wrapNativeSuper","_cache","Wrapper","RuntimeError","msg","_context","captureStackTrace","contextObj","SemanticError","createRuntimeError","i18n_id","LocalizedStringsService","createSemanticError","ProcessorErrorFactory","symbol_not_found_full","symbol_not_found","function_missing_full","function_missing","main_missing","array_dimension_not_int_full","array_dimension_not_int","unknown_command_full","unknown_command","incompatible_types_full","left_type","left_dim","right_type","right_dim","source_info","translateType","incompatible_types","incompatible_types_array_full","incompatible_types_array","loop_condition_type_full","loop_condition_type","endless_loop_full","endless_loop","if_condition_type_full","if_condition_type","invalid_global_var","not_implemented","invalid_case_type_full","invalid_case_type","void_in_expression_full","void_in_expression","invalid_array_access_full","invalid_array_access","invalid_matrix_access_full","invalid_matrix_access","matrix_column_outbounds_full","matrix_column_outbounds","matrix_line_outbounds_full","matrix_line_outbounds","vector_line_outbounds_full","vector_line_outbounds","vector_not_matrix_full","vector_not_matrix","function_no_return","invalid_void_return_full","invalid_void_return","invalid_return_type_full","invalid_return_type","invalid_parameters_size_full","expected","actual","invalid_parameters_size","invalid_parameter_type_full","fun_name","invalid_parameter_type","invalid_ref_full","invalid_ref","unexpected_break_command_full","unexpected_break_command","invalid_array_literal_type_full","invalid_array_literal_type","invalid_array_literal_line_full","invalid_array_literal_line","invalid_array_literal_column_full","invalid_array_literal_column","invalid_unary_op_full","expString","opName","translateOp","invalid_unary_op","invalid_infix_op_full","typeLeft","dimLeft","typeRight","dimRight","invalid_infix_op","array_dimension_not_positive_full","array_dimension_not_positive","invalid_type_conversion","invalid_read_type","invalid_read_type_array","typePos","dimPos","typeArray","dimArray","invalid_const_ref_full","invalid_const_ref","invalid_const_assignment_full","var_id","invalid_const_assignment","invalid_vector_assignment_full","left_id","left_size","right_id","right_size","invalid_vector_assignment","invalid_matrix_assignment_full","left_line","left_column","right_line","right_column","invalid_matrix_assignment","matrix_to_vector_attr","vector_to_matrix_attr","invalid_matrix_index_assign_full","mat_id","mat_line","mat_size","exp_size","invalid_matrix_index_assign","invalid_number_elements_vector","expected_num","actual_num","invalid_number_lines_matrix","divsion_by_zero_full","divsion_by_zero","undefined_tanget_value","negative_log_value","invalid_string_index","local_fun_name","negative_sqrt_value","exceeded_recursive_calls","invalid_for_variable","invalid_for_from","invalid_for_to","invalid_for_pass","exceed_max_instructions","StoreValue","ArrayType","dimensions","innerType","used_dims","free_dims","ArrayAccess","strLine","strColumn","Literal","IntLiteral","RealLiteral","BoolLiteral","CharLiteral","StringLiteral","ArrayLiteral","element","validateSize","validateType","arrayLiteral","VariableLiteral","InfixApp","op","left","right","UnaryApp","SourceInfo","tokenA","tokenB","Operators","ADD","SUB","MULT","DIV","MOD","GT","GE","LT","LE","EQ","NEQ","AND","OR","NOT","convertFromString","SyntaxError","createError","message_id","error_message","SyntaxErrorFactory","extra_lines","token_missing_one","token_missing_list","expectedList","id_missing","eos_missing","invalid_array_dimension","typeName","invalid_array_size","invalid_main_return","invalid_var_declaration","invalid_break_command","cmdName","invalid_terminal","invalid_type","const_not_init","invalid_id_format","duplicate_function","main_parameters","duplicate_variable","invalid_character","annonymous_array_literal","invalid_matrix_literal_line","cannot_infer_matrix_line","cannot_infer_matrix_column","cannot_infer_vector_size","matrix_to_vector_literal_attr","vector_to_matrix_literal_attr","array_init_not_literal","array_exceeds_2d","invalid_matrix_id_dimension","invalid_vector_init","invalid_matrix_init","invalid_syntax","IVProgParser","ivprogLexer","inputStream","tokenStream","pos","ruleNames","variableTypes","getTypeKeys","functionTypes","parsingArrayDimension","scope","definedFuncsNameList","definedVariablesStack","stream","filter","parseProgram","EOF_TOKEN","getToken","consumeNewLines","globalVars","functions","checkOpenCurly","pushVariableStack","isVariableType","parseGlobalVariables","parseFunction","popVariableStack","checkCloseCurly","isEOF","attempt","eosToken","functionID","funcIDToken","variableID","getCurrentVariableStack","decl","parseMaybeConst","checkEOS","constToken","typeString","parseType","parseDeclaration","getTypeArray","dim1","dim2","createSourceInfo","idString","parseID","checkVariableDuplicate","checkOpenBrace","parseArrayDimension","checkCloseBrace","parseArrayDeclaration","assignmentToken","parseExpressionOR","declaration","Commands","commaToken","n_lines","n_columns","dim_is_id","Expressions","parseArrayLiteral","isVector","Parsers","find","dimToken","getIntLiteral","parseVariable","invalid_token","beginArray","parseVectorList","parseExpressionList","endArray","createSourceInfoFromList","dataDim","lastSize","pushScope","FUNCTION","formalParams","funType","checkFunctionDuplicate","checkOpenParenthesis","checkCloseParenthesis","parseFormalParameters","commandsBlock","parseCommandBlock","isMain","popScope","reference","maybeIDToken","parameter","insideScope","anotherID","optionalCurly","variablesDecl","hasOpen","parsedCommand","cmd","parseCommand","lastToken","varType","parseIDCommand","parseReturn","parseWhile","parseFor","BREAKABLE","parseBreak","parseSwitchCase","parseRepeatUntil","parseIfThenElse","casesList","parseCases","command","whileToken","COMMAND","logicalExpression","cmdBlocks","maybeIf","elseBlock","for_token","id_token","parseForParameters","maybePass","returnCommand","refToken","parseMaybeLibID","isID","parseExpression","assignmentOrParenthesis","funcCall","parseFunctionCallCommand","keyword_code","from_token","int_or_id","is_unary_op","colonToken","block","defaultCase","setCommands","aCase","exp1","parseExpressionAND","opToken","or","exp2","finalExp","parseExpressionNot","and","not","parseExpressionRel","relToken","rel","factor","parseFactor","sumOpToken","factor2","term","parseTerm","multOpToken","term2","getRealLiteral","getStringLiteral","getCharLiteral","getBoolLiteral","parseIDTerm","parseParenthesisExp","firstIndex","secondIndex","parseFunctionCallExpression","getInternalName","stepBack","parseActualParameters","funcName","getFunctionName","literalNames","fill","parser","convertToRadians","degrees","seed","Date","now","valueToKey","libsObject","sto","_","applyStore","angle","insertStore","mode","createCosFun","function_call_stack","createTanFun","createSqrtFun","createPowFun","createLogFun","createAbsFun","createNegateFun","createInvertFun","maxFun","numbers","sto_addrs","paramType","createMaxFun","minFun","createMinFun","createRandFun","store","requestInput","typeToConvert","trim","realObject","getStoreObject","getReferenceDimension","arrayInfo","getRefObj","stoValue","updateStore","createInputFun","totalSV","total","output","sendOutput","createOutputFun","end","createSubstringFun","createLengthFun","toUpperCase","createUppercaseFun","createLowercaseFun","createrCharAtFun","vector","createNumElementsFun","matrix","createMatrixLinesFun","createMatrixColumnsFun","createParser","createIsRealFun","createIsIntFun","createIsBoolFun","typeStringInfoArray","typeInfo","createCastRealFun","createCastIntFun","createCastBoolFun","createCastStringFun","fromCharCode","createCastCharFun","funcsObject","concatObjects","localName","names","lib","internalName","getFunction","libName","funName","_instance","langService","langsJsons","shouldListenToChange","type_string","category","Langs","getInstance","levenshteinDistance","win","openAssessmentDetail","preventDefault","page_code","currentTarget","dataset","page","close","window","open","write","sleep","ms","setTimeout","processData","folderInput","querySelector","header","generateSubCode","algorithmInIlm","program_obj","parse","globals","ivprogCore","generateCode","prepareData","submission","exercID","studentID","exercMap","download","getExercHeader","reduce","acc","file","createElement","setAttribute","encodeURIComponent","classList","appendChild","files","f","folderName","webkitRelativePath","csvEntries","vec","blockExercMap","getFilePath","path","counter","studentsMap","submissions","parseInt","student","parseFloat","previousCode","previousFile","previous","prepareActivityToStudentHelper","getOrElse","currentFile","current","currentCode","logs","ratio","setInterval","clearInterval","csv","firstLine","TYPES","getOpType","switchCaseWalker","switchCase","commandWalker","isDefault","expressionWalker","ifThenElseWalker","ifthenelse","forLoop","switchCommand","whileLoop","functionCall","parameters","lastInput","newLine","content","variable","parameters_list","functionCallWalker","assingment","arrayClass","class","assignmentWalker","testFirst","var_attribution","var_initial","step_expression","functionWalker","funcDeclaration","return_type","return_dimensions","variables_list","functionParameterWalker","variablesDeclarations","variableDeclarationWalker","formalParameter","rows","dimension","is_const","variableInitialWalker","funcObj","paramsList","opType","opValue","parseCode","codeLinesMap","program","parseTree","buildInfixMultiDivSubTable","table","buildInfixEqualityInequalityTable","buildInfixRelationalTable","buildInfixAndOrTable","buildUnarySumSubList","compatibilityMap","infixMap","WeakMap","buildInfixModTable","unaryMap","buildUnaryCompatibilityTable","resultTypeAfterInfixOp","operator","leftExpressionType","rightExpressionType","newMulti","typeA","typeB","resultType","resultTypeAfterUnaryOp","Address","inner_ref","address_id","address","findIndex","beg","med","getAddressAt","Location","allocate","deallocate","updateAddress","clear","StoreObject","loc_address","readOnly","_loc_address","_type","_readOnly","_id","locAddress","StoreObjectRef","getRefAddress","refObj","reference_dimension","StoreValueAddress","ArrayStoreValue","array_type","actual_line","actual_column","canAccept","actual_values","_superPropBase","property","_get","receiver","getOwnPropertyDescriptor","StoreObjectArray","_lines","_columns","loc_addresses","cols","addresses","getIndexOf","StoreValueRef","reference_dimesion","ArrayStoreValueRef","StoreObjectArrayRef","getAddresses","Store","nextStore","oldObj","array_value","setAt","oldType","stoType","sto_value","updateStoreArray","newObj","all_values","setID","destroy","isDefined","castType","sourceType","stoObj","canImplicitTypeCast","SemanticAnalyser","ast","symbolMap","currentFunction","symbol_map","findSymbol","fun","pushMap","assertDeclarations","assertFunction","assertDeclaration","assertArrayDeclaration","insertSymbol","evaluateExpressionType","result_info","evaluateArrayLiteral","finalResult","resultTypeLeft","resultTypeRight","infoLeft","infoRight","evaluateLiteralType","findFunction","assertParameters","arrayTypeInfo","arrType","literal","last","strExp","arrayDeclaration","evaluateVectorLiteralType","line_literal","formalParam","optional","assertReturn","popMap","checkCommand","checkCommands","sType","hasDefault","caseType","lineExp","columnExp","exp_type","access_type","compatible","access_type_info","exp_type_info","getMainFunction","cmds","actualParametersList","parameterList","hasVariadic","assertVariadicParameter","param","assertParameter","expType","actualParameter","shared","stringCode","analyseTree","IVProgProcessor","globalStore","stores","forceKill","instruction_count","function_call_count","prepareState","initGlobal","mainFunc","findMainFunction","runFunction","checkContext","executeCommands","MAIN_INTERNAL_ID","funcStore","extendStore","associateParameters","stoWithVars","finalSto","formal_params","effective_params","caller_store","callee_store","associateVariadicParameter","actualParam","associateParameter","count","variadicCount","callerStore","calleeStore","evaluateExpression","actualValue","shouldTypeCast","inStore","realObj","ref","getLocAddressOf","setReferenceDimension","varID","realValue","doImplicitCasting","executeCommand","Utils","executeDeclaration","executeArrayIndexAssign","executeAssign","executeBreak","executeReturn","executeIfThenElse","executeRepeatUntil","executeWhile","executeFor","executeSwitch","executeFunctionCall","executeSysCall","switchCases","lastStore","lastCaseCheckResult","ignoreSwitchCases","equalityInfixApp","initCmd","passValue","increment","whileBlock","forAsWhile","newCmdList","checkCondition","isTrue","funcType","real_value","exp_type_string_info","mustBeArray","lineSV","columnSV","current_value","getAt","executeArrayDeclaration","linesSV","columnsSV","valueList","evaluateUnaryApp","evaluateInfixApp","evaluateArrayAccess","evaluateVariableLiteral","evaluateLiteral","evaluateFunctionCall","max_call_stack","evaluateMatrix","storeValueMatrix","evaluateVector","exps","n_elements","actualValues","exp_str","vectors","vec_type","unaryApp","infixApp","shouldImplicitCast","stringInfoLeft","stringInfoRight","rightStr","leftStr","strLeft","strRight","leftValue","rightValue","InputTest","inputList","OutputTest","currentLine","outputList","channel","autoGenerateTestCaseOutput","program_text","testCases","callback","copyTestCases","assign","analyseFromSource","resultList","registerInput","registerOutput","interpretAST","result_final","result_1","output_2","input_2","showAlert","i18nHelper","i18n","identifier","Settings","programming","datatypes"],"sourceRoot":""}