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/@babel/runtime/helpers/arrayLikeToArray.js","webpack://vcat/./node_modules/@babel/runtime/helpers/arrayWithHoles.js","webpack://vcat/./node_modules/@babel/runtime/helpers/arrayWithoutHoles.js","webpack://vcat/./node_modules/@babel/runtime/helpers/assertThisInitialized.js","webpack://vcat/./node_modules/@babel/runtime/helpers/asyncToGenerator.js","webpack://vcat/./node_modules/@babel/runtime/helpers/classCallCheck.js","webpack://vcat/./node_modules/@babel/runtime/helpers/construct.js","webpack://vcat/./node_modules/@babel/runtime/helpers/createClass.js","webpack://vcat/./node_modules/@babel/runtime/helpers/defineProperty.js","webpack://vcat/./node_modules/@babel/runtime/helpers/get.js","webpack://vcat/./node_modules/@babel/runtime/helpers/getPrototypeOf.js","webpack://vcat/./node_modules/@babel/runtime/helpers/inherits.js","webpack://vcat/./node_modules/@babel/runtime/helpers/isNativeFunction.js","webpack://vcat/./node_modules/@babel/runtime/helpers/isNativeReflectConstruct.js","webpack://vcat/./node_modules/@babel/runtime/helpers/iterableToArray.js","webpack://vcat/./node_modules/@babel/runtime/helpers/iterableToArrayLimit.js","webpack://vcat/./node_modules/@babel/runtime/helpers/nonIterableRest.js","webpack://vcat/./node_modules/@babel/runtime/helpers/nonIterableSpread.js","webpack://vcat/./node_modules/@babel/runtime/helpers/possibleConstructorReturn.js","webpack://vcat/./node_modules/@babel/runtime/helpers/setPrototypeOf.js","webpack://vcat/./node_modules/@babel/runtime/helpers/slicedToArray.js","webpack://vcat/./node_modules/@babel/runtime/helpers/superPropBase.js","webpack://vcat/./node_modules/@babel/runtime/helpers/taggedTemplateLiteral.js","webpack://vcat/./node_modules/@babel/runtime/helpers/toConsumableArray.js","webpack://vcat/./node_modules/@babel/runtime/helpers/typeof.js","webpack://vcat/./node_modules/@babel/runtime/helpers/unsupportedIterableToArray.js","webpack://vcat/./node_modules/@babel/runtime/helpers/wrapNativeSuper.js","webpack://vcat/./node_modules/@babel/runtime/regenerator/index.js","webpack://vcat/./node_modules/decimal.js/decimal.js","webpack://vcat/./node_modules/moo/moo.js","webpack://vcat/./node_modules/regenerator-runtime/runtime.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/line-i18n/dist/StringTypes.js","webpack://vcat/./src/util/config.ts","webpack://vcat/./node_modules/line-i18n/dist/LanguageService.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/./i18n/index.ts","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/./src/services/languageService.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/expressions/expression.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/functionCall.js","webpack://vcat/./src/processor/modes.ts","webpack://vcat/./src/typeSystem/parsers.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/./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/services/i18nHelper.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/./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/./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, function() {\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 _arrayLikeToArray(arr, len) {\n  if (len == null || len > arr.length) len = arr.length;\n\n  for (var i = 0, arr2 = new Array(len); i < len; i++) {\n    arr2[i] = arr[i];\n  }\n\n  return arr2;\n}\n\nmodule.exports = _arrayLikeToArray;","function _arrayWithHoles(arr) {\n  if (Array.isArray(arr)) return arr;\n}\n\nmodule.exports = _arrayWithHoles;","var arrayLikeToArray = require(\"./arrayLikeToArray\");\n\nfunction _arrayWithoutHoles(arr) {\n  if (Array.isArray(arr)) return arrayLikeToArray(arr);\n}\n\nmodule.exports = _arrayWithoutHoles;","function _assertThisInitialized(self) {\n  if (self === void 0) {\n    throw new ReferenceError(\"this hasn't been initialised - super() hasn't been called\");\n  }\n\n  return self;\n}\n\nmodule.exports = _assertThisInitialized;","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\n  if (info.done) {\n    resolve(value);\n  } else {\n    Promise.resolve(value).then(_next, _throw);\n  }\n}\n\nfunction _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\n      function _next(value) {\n        asyncGeneratorStep(gen, resolve, reject, _next, _throw, \"next\", value);\n      }\n\n      function _throw(err) {\n        asyncGeneratorStep(gen, resolve, reject, _next, _throw, \"throw\", err);\n      }\n\n      _next(undefined);\n    });\n  };\n}\n\nmodule.exports = _asyncToGenerator;","function _classCallCheck(instance, Constructor) {\n  if (!(instance instanceof Constructor)) {\n    throw new TypeError(\"Cannot call a class as a function\");\n  }\n}\n\nmodule.exports = _classCallCheck;","var setPrototypeOf = require(\"./setPrototypeOf\");\n\nvar isNativeReflectConstruct = require(\"./isNativeReflectConstruct\");\n\nfunction _construct(Parent, args, Class) {\n  if (isNativeReflectConstruct()) {\n    module.exports = _construct = Reflect.construct;\n  } else {\n    module.exports = _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\n  return _construct.apply(null, arguments);\n}\n\nmodule.exports = _construct;","function _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, descriptor.key, descriptor);\n  }\n}\n\nfunction _createClass(Constructor, protoProps, staticProps) {\n  if (protoProps) _defineProperties(Constructor.prototype, protoProps);\n  if (staticProps) _defineProperties(Constructor, staticProps);\n  return Constructor;\n}\n\nmodule.exports = _createClass;","function _defineProperty(obj, key, value) {\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\n  return obj;\n}\n\nmodule.exports = _defineProperty;","var superPropBase = require(\"./superPropBase\");\n\nfunction _get(target, property, receiver) {\n  if (typeof Reflect !== \"undefined\" && Reflect.get) {\n    module.exports = _get = Reflect.get;\n  } else {\n    module.exports = _get = function _get(target, property, receiver) {\n      var base = superPropBase(target, property);\n      if (!base) return;\n      var desc = Object.getOwnPropertyDescriptor(base, property);\n\n      if (desc.get) {\n        return desc.get.call(receiver);\n      }\n\n      return desc.value;\n    };\n  }\n\n  return _get(target, property, receiver || target);\n}\n\nmodule.exports = _get;","function _getPrototypeOf(o) {\n  module.exports = _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) {\n    return o.__proto__ || Object.getPrototypeOf(o);\n  };\n  return _getPrototypeOf(o);\n}\n\nmodule.exports = _getPrototypeOf;","var setPrototypeOf = require(\"./setPrototypeOf\");\n\nfunction _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\n  subClass.prototype = Object.create(superClass && superClass.prototype, {\n    constructor: {\n      value: subClass,\n      writable: true,\n      configurable: true\n    }\n  });\n  if (superClass) setPrototypeOf(subClass, superClass);\n}\n\nmodule.exports = _inherits;","function _isNativeFunction(fn) {\n  return Function.toString.call(fn).indexOf(\"[native code]\") !== -1;\n}\n\nmodule.exports = _isNativeFunction;","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\n  try {\n    Date.prototype.toString.call(Reflect.construct(Date, [], function () {}));\n    return true;\n  } catch (e) {\n    return false;\n  }\n}\n\nmodule.exports = _isNativeReflectConstruct;","function _iterableToArray(iter) {\n  if (typeof Symbol !== \"undefined\" && Symbol.iterator in Object(iter)) return Array.from(iter);\n}\n\nmodule.exports = _iterableToArray;","function _iterableToArrayLimit(arr, i) {\n  if (typeof Symbol === \"undefined\" || !(Symbol.iterator in Object(arr))) return;\n  var _arr = [];\n  var _n = true;\n  var _d = false;\n  var _e = undefined;\n\n  try {\n    for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) {\n      _arr.push(_s.value);\n\n      if (i && _arr.length === i) break;\n    }\n  } catch (err) {\n    _d = true;\n    _e = err;\n  } finally {\n    try {\n      if (!_n && _i[\"return\"] != null) _i[\"return\"]();\n    } finally {\n      if (_d) throw _e;\n    }\n  }\n\n  return _arr;\n}\n\nmodule.exports = _iterableToArrayLimit;","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}\n\nmodule.exports = _nonIterableRest;","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}\n\nmodule.exports = _nonIterableSpread;","var _typeof = require(\"../helpers/typeof\");\n\nvar assertThisInitialized = require(\"./assertThisInitialized\");\n\nfunction _possibleConstructorReturn(self, call) {\n  if (call && (_typeof(call) === \"object\" || typeof call === \"function\")) {\n    return call;\n  }\n\n  return assertThisInitialized(self);\n}\n\nmodule.exports = _possibleConstructorReturn;","function _setPrototypeOf(o, p) {\n  module.exports = _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) {\n    o.__proto__ = p;\n    return o;\n  };\n\n  return _setPrototypeOf(o, p);\n}\n\nmodule.exports = _setPrototypeOf;","var arrayWithHoles = require(\"./arrayWithHoles\");\n\nvar iterableToArrayLimit = require(\"./iterableToArrayLimit\");\n\nvar unsupportedIterableToArray = require(\"./unsupportedIterableToArray\");\n\nvar nonIterableRest = require(\"./nonIterableRest\");\n\nfunction _slicedToArray(arr, i) {\n  return arrayWithHoles(arr) || iterableToArrayLimit(arr, i) || unsupportedIterableToArray(arr, i) || nonIterableRest();\n}\n\nmodule.exports = _slicedToArray;","var getPrototypeOf = require(\"./getPrototypeOf\");\n\nfunction _superPropBase(object, property) {\n  while (!Object.prototype.hasOwnProperty.call(object, property)) {\n    object = getPrototypeOf(object);\n    if (object === null) break;\n  }\n\n  return object;\n}\n\nmodule.exports = _superPropBase;","function _taggedTemplateLiteral(strings, raw) {\n  if (!raw) {\n    raw = strings.slice(0);\n  }\n\n  return Object.freeze(Object.defineProperties(strings, {\n    raw: {\n      value: Object.freeze(raw)\n    }\n  }));\n}\n\nmodule.exports = _taggedTemplateLiteral;","var arrayWithoutHoles = require(\"./arrayWithoutHoles\");\n\nvar iterableToArray = require(\"./iterableToArray\");\n\nvar unsupportedIterableToArray = require(\"./unsupportedIterableToArray\");\n\nvar nonIterableSpread = require(\"./nonIterableSpread\");\n\nfunction _toConsumableArray(arr) {\n  return arrayWithoutHoles(arr) || iterableToArray(arr) || unsupportedIterableToArray(arr) || nonIterableSpread();\n}\n\nmodule.exports = _toConsumableArray;","function _typeof(obj) {\n  \"@babel/helpers - typeof\";\n\n  if (typeof Symbol === \"function\" && typeof Symbol.iterator === \"symbol\") {\n    module.exports = _typeof = function _typeof(obj) {\n      return typeof obj;\n    };\n  } else {\n    module.exports = _typeof = function _typeof(obj) {\n      return obj && typeof Symbol === \"function\" && obj.constructor === Symbol && obj !== Symbol.prototype ? \"symbol\" : typeof obj;\n    };\n  }\n\n  return _typeof(obj);\n}\n\nmodule.exports = _typeof;","var arrayLikeToArray = require(\"./arrayLikeToArray\");\n\nfunction _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}\n\nmodule.exports = _unsupportedIterableToArray;","var getPrototypeOf = require(\"./getPrototypeOf\");\n\nvar setPrototypeOf = require(\"./setPrototypeOf\");\n\nvar isNativeFunction = require(\"./isNativeFunction\");\n\nvar construct = require(\"./construct\");\n\nfunction _wrapNativeSuper(Class) {\n  var _cache = typeof Map === \"function\" ? new Map() : undefined;\n\n  module.exports = _wrapNativeSuper = function _wrapNativeSuper(Class) {\n    if (Class === null || !isNativeFunction(Class)) return Class;\n\n    if (typeof Class !== \"function\") {\n      throw new TypeError(\"Super expression must either be null or a function\");\n    }\n\n    if (typeof _cache !== \"undefined\") {\n      if (_cache.has(Class)) return _cache.get(Class);\n\n      _cache.set(Class, Wrapper);\n    }\n\n    function Wrapper() {\n      return construct(Class, arguments, getPrototypeOf(this).constructor);\n    }\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\n  return _wrapNativeSuper(Class);\n}\n\nmodule.exports = _wrapNativeSuper;","module.exports = require(\"regenerator-runtime\");\n",";(function (globalScope) {\r\n  'use strict';\r\n\r\n\r\n  /*\r\n   *  decimal.js v10.2.0\r\n   *  An arbitrary-precision Decimal type for JavaScript.\r\n   *  https://github.com/MikeMcl/decimal.js\r\n   *  Copyright (c) 2019 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\n  var 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    Decimal, inexact, noConflict, 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\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 = { name: '[object Decimal]' };\r\n\r\n\r\n  // Decimal prototype methods\r\n\r\n\r\n  /*\r\n   *  absoluteValue             abs\r\n   *  ceil\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\n  P.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\n  P.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\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\n  P.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\n  P.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\n  P.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\n  P.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\n  P.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\n  P.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\n  P.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\n  P.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\n  P.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\n  P.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\n  P.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\n  P.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\n  P.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\n  P.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\n  P.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\n  P.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\n  P.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\n  P.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\n  P.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\n  P.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\n  P.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\n  P.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\n  P.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\n  P.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\n  P.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\n  P.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\n  P.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\n  P.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\n  P.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\n  P.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\n  P.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\n  P.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\n  P.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\n  P.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\n  P.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\n  P.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\n  P.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\n  P.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\n  P.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\n  P.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 = '1e' + 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\n  P.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\n  P.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\n  P.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\n  P.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\n  P.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\n  P.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\n  P.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\n  P.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\n  P.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\n  P.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\n  P.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\n  P.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\n  P.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\n  P.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\n  P.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\n  P.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\n  P.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  /*\r\n  // Add aliases to match BigDecimal method names.\r\n  // P.add = P.plus;\r\n  P.subtract = P.minus;\r\n  P.multiply = P.times;\r\n  P.divide = P.div;\r\n  P.remainder = P.mod;\r\n  P.compareTo = P.cmp;\r\n  P.negate = P.neg;\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\n  function 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\n  function 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\n  function 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\n  function 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\n  function cosine(Ctor, x) {\r\n    var k, y,\r\n      len = x.d.length;\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    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\n  var 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\n  function 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\n  function 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\n  function 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\n  function 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\n  function 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\n  function 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\n  function 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\n  function 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\n  function 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\n  function 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\n  function 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\n  function 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\n  function 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\n  function parseOther(x, str) {\r\n    var base, Ctor, divisor, i, isFloat, len, p, xd, xe;\r\n\r\n    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\n  function sine(Ctor, x) {\r\n    var k,\r\n      len = x.d.length;\r\n\r\n    if (len < 3) return taylorSeries(Ctor, 2, x, x);\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\n  function 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\n  function 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\n  function 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\n  function 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\n  function 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   *  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   *  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\n  function 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\n  function 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\n  function 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\n  function 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\n  function 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\n  function 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\n  function 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\n  function 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\n  function 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\n  function 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\n  function ceil(x) {\r\n    return finalise(x = new this(x), x.e + 1, 2);\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\n  function 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\n  function 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\n  function 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\n  function 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 (v instanceof Decimal) {\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.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.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\n  function 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\n  function 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\n  function 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\n  function 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\n  function isDecimalInstance(obj) {\r\n    return obj instanceof Decimal || obj && obj.name === '[object Decimal]' || 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\n  function 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\n  function 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\n  function 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\n  function 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\n  function 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\n  function 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\n  function 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\n  function 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\n  function 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\n  function 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\n  function 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\n  function 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\n  function 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\n  function 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\n  function 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\n  function 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 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\n  function 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\n  function 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\n  function trunc(x) {\r\n    return finalise(x = new this(x), x.e + 1, 1);\r\n  }\r\n\r\n\r\n  // Create and configure initial Decimal constructor.\r\n  Decimal = clone(DEFAULTS);\r\n\r\n  Decimal['default'] = Decimal.Decimal = Decimal;\r\n\r\n  // Create the internal constants from their string values.\r\n  LN10 = new Decimal(LN10);\r\n  PI = new Decimal(PI);\r\n\r\n\r\n  // Export.\r\n\r\n\r\n  // AMD.\r\n  if (typeof define == 'function' && define.amd) {\r\n    define(function () {\r\n      return Decimal;\r\n    });\r\n\r\n  // Node and other environments that support module.exports.\r\n  } else if (typeof module != 'undefined' && module.exports) {\r\n    if (typeof Symbol == 'function' && typeof Symbol.iterator == 'symbol') {\r\n      P[Symbol.for('nodejs.util.inspect.custom')] = P.toString;\r\n      P[Symbol.toStringTag] = 'Decimal';\r\n    }\r\n\r\n    module.exports = Decimal;\r\n\r\n  // Browser.\r\n  } else {\r\n    if (!globalScope) {\r\n      globalScope = typeof self != 'undefined' && self && self.self == self ? self : window;\r\n    }\r\n\r\n    noConflict = globalScope.Decimal;\r\n    Decimal.noConflict = function () {\r\n      globalScope.Decimal = noConflict;\r\n      return Decimal;\r\n    };\r\n\r\n    globalScope.Decimal = Decimal;\r\n  }\r\n})(this);\r\n","(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 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    var reverseMap = Object.create(null)\n    var byLength = Object.create(null)\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        (byLength[keyword.length] = byLength[keyword.length] || []).push(keyword)\n        if (typeof keyword !== 'string') {\n          throw new Error(\"keyword must be string (in keyword '\" + tokenType + \"')\")\n        }\n        reverseMap[keyword] = tokenType\n      })\n    }\n\n    // fast string lookup\n    // https://jsperf.com/string-lookups\n    function str(x) { return JSON.stringify(x) }\n    var source = ''\n    source += 'switch (value.length) {\\n'\n    for (var length in byLength) {\n      var keywords = byLength[length]\n      source += 'case ' + length + ':\\n'\n      source += 'switch (value) {\\n'\n      keywords.forEach(function(keyword) {\n        var tokenType = reverseMap[keyword]\n        source += 'case ' + str(keyword) + ': return ' + str(tokenType) + '\\n'\n      })\n      source += '}\\n'\n    }\n    source += '}\\n'\n    return Function('value', source) // type\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.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      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      throw new Error(this.formatError(token, \"invalid syntax\"))\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    var start = Math.max(0, token.offset - token.col + 1)\n    var eol = token.lineBreaks ? token.text.indexOf('\\n') : token.text.length\n    var firstLine = this.buffer.substring(start, token.offset + eol)\n    message += \" at line \" + token.line + \" col \" + token.col + \":\\n\\n\"\n    message += \"  \" + firstLine + \"\\n\"\n    message += \"  \" + Array(token.col).join(\" \") + \"^\"\n    return message\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","/**\n * Copyright (c) 2014-present, Facebook, Inc.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n */\n\nvar runtime = (function (exports) {\n  \"use strict\";\n\n  var Op = Object.prototype;\n  var hasOwn = Op.hasOwnProperty;\n  var undefined; // More compressible than void 0.\n  var $Symbol = typeof Symbol === \"function\" ? Symbol : {};\n  var iteratorSymbol = $Symbol.iterator || \"@@iterator\";\n  var asyncIteratorSymbol = $Symbol.asyncIterator || \"@@asyncIterator\";\n  var toStringTagSymbol = $Symbol.toStringTag || \"@@toStringTag\";\n\n  function wrap(innerFn, outerFn, self, tryLocsList) {\n    // If outerFn provided and outerFn.prototype is a Generator, then outerFn.prototype instanceof Generator.\n    var protoGenerator = outerFn && outerFn.prototype instanceof Generator ? outerFn : Generator;\n    var generator = Object.create(protoGenerator.prototype);\n    var context = new Context(tryLocsList || []);\n\n    // The ._invoke method unifies the implementations of the .next,\n    // .throw, and .return methods.\n    generator._invoke = makeInvokeMethod(innerFn, self, context);\n\n    return generator;\n  }\n  exports.wrap = wrap;\n\n  // Try/catch helper to minimize deoptimizations. Returns a completion\n  // record like context.tryEntries[i].completion. This interface could\n  // have been (and was previously) designed to take a closure to be\n  // invoked without arguments, but in all the cases we care about we\n  // already have an existing method we want to call, so there's no need\n  // to create a new function object. We can even get away with assuming\n  // the method takes exactly one argument, since that happens to be true\n  // in every case, so we don't have to touch the arguments object. The\n  // only additional allocation required is the completion record, which\n  // has a stable shape and so hopefully should be cheap to allocate.\n  function tryCatch(fn, obj, arg) {\n    try {\n      return { type: \"normal\", arg: fn.call(obj, arg) };\n    } catch (err) {\n      return { type: \"throw\", arg: err };\n    }\n  }\n\n  var GenStateSuspendedStart = \"suspendedStart\";\n  var GenStateSuspendedYield = \"suspendedYield\";\n  var GenStateExecuting = \"executing\";\n  var GenStateCompleted = \"completed\";\n\n  // Returning this object from the innerFn has the same effect as\n  // breaking out of the dispatch switch statement.\n  var ContinueSentinel = {};\n\n  // Dummy constructor functions that we use as the .constructor and\n  // .constructor.prototype properties for functions that return Generator\n  // objects. For full spec compliance, you may wish to configure your\n  // minifier not to mangle the names of these two functions.\n  function Generator() {}\n  function GeneratorFunction() {}\n  function GeneratorFunctionPrototype() {}\n\n  // This is a polyfill for %IteratorPrototype% for environments that\n  // don't natively support it.\n  var IteratorPrototype = {};\n  IteratorPrototype[iteratorSymbol] = function () {\n    return this;\n  };\n\n  var getProto = Object.getPrototypeOf;\n  var NativeIteratorPrototype = getProto && getProto(getProto(values([])));\n  if (NativeIteratorPrototype &&\n      NativeIteratorPrototype !== Op &&\n      hasOwn.call(NativeIteratorPrototype, iteratorSymbol)) {\n    // This environment has a native %IteratorPrototype%; use it instead\n    // of the polyfill.\n    IteratorPrototype = NativeIteratorPrototype;\n  }\n\n  var Gp = GeneratorFunctionPrototype.prototype =\n    Generator.prototype = Object.create(IteratorPrototype);\n  GeneratorFunction.prototype = Gp.constructor = GeneratorFunctionPrototype;\n  GeneratorFunctionPrototype.constructor = GeneratorFunction;\n  GeneratorFunctionPrototype[toStringTagSymbol] =\n    GeneratorFunction.displayName = \"GeneratorFunction\";\n\n  // Helper for defining the .next, .throw, and .return methods of the\n  // Iterator interface in terms of a single ._invoke method.\n  function defineIteratorMethods(prototype) {\n    [\"next\", \"throw\", \"return\"].forEach(function(method) {\n      prototype[method] = function(arg) {\n        return this._invoke(method, arg);\n      };\n    });\n  }\n\n  exports.isGeneratorFunction = function(genFun) {\n    var ctor = typeof genFun === \"function\" && genFun.constructor;\n    return ctor\n      ? ctor === GeneratorFunction ||\n        // For the native GeneratorFunction constructor, the best we can\n        // do is to check its .name property.\n        (ctor.displayName || ctor.name) === \"GeneratorFunction\"\n      : false;\n  };\n\n  exports.mark = function(genFun) {\n    if (Object.setPrototypeOf) {\n      Object.setPrototypeOf(genFun, GeneratorFunctionPrototype);\n    } else {\n      genFun.__proto__ = GeneratorFunctionPrototype;\n      if (!(toStringTagSymbol in genFun)) {\n        genFun[toStringTagSymbol] = \"GeneratorFunction\";\n      }\n    }\n    genFun.prototype = Object.create(Gp);\n    return genFun;\n  };\n\n  // Within the body of any async function, `await x` is transformed to\n  // `yield regeneratorRuntime.awrap(x)`, so that the runtime can test\n  // `hasOwn.call(value, \"__await\")` to determine if the yielded value is\n  // meant to be awaited.\n  exports.awrap = function(arg) {\n    return { __await: arg };\n  };\n\n  function AsyncIterator(generator, PromiseImpl) {\n    function invoke(method, arg, resolve, reject) {\n      var record = tryCatch(generator[method], generator, arg);\n      if (record.type === \"throw\") {\n        reject(record.arg);\n      } else {\n        var result = record.arg;\n        var value = result.value;\n        if (value &&\n            typeof value === \"object\" &&\n            hasOwn.call(value, \"__await\")) {\n          return PromiseImpl.resolve(value.__await).then(function(value) {\n            invoke(\"next\", value, resolve, reject);\n          }, function(err) {\n            invoke(\"throw\", err, resolve, reject);\n          });\n        }\n\n        return PromiseImpl.resolve(value).then(function(unwrapped) {\n          // When a yielded Promise is resolved, its final value becomes\n          // the .value of the Promise<{value,done}> result for the\n          // current iteration.\n          result.value = unwrapped;\n          resolve(result);\n        }, function(error) {\n          // If a rejected Promise was yielded, throw the rejection back\n          // into the async generator function so it can be handled there.\n          return invoke(\"throw\", error, resolve, reject);\n        });\n      }\n    }\n\n    var previousPromise;\n\n    function enqueue(method, arg) {\n      function callInvokeWithMethodAndArg() {\n        return new PromiseImpl(function(resolve, reject) {\n          invoke(method, arg, resolve, reject);\n        });\n      }\n\n      return previousPromise =\n        // If enqueue has been called before, then we want to wait until\n        // all previous Promises have been resolved before calling invoke,\n        // so that results are always delivered in the correct order. If\n        // enqueue has not been called before, then it is important to\n        // call invoke immediately, without waiting on a callback to fire,\n        // so that the async generator function has the opportunity to do\n        // any necessary setup in a predictable way. This predictability\n        // is why the Promise constructor synchronously invokes its\n        // executor callback, and why async functions synchronously\n        // execute code before the first await. Since we implement simple\n        // async functions in terms of async generators, it is especially\n        // important to get this right, even though it requires care.\n        previousPromise ? previousPromise.then(\n          callInvokeWithMethodAndArg,\n          // Avoid propagating failures to Promises returned by later\n          // invocations of the iterator.\n          callInvokeWithMethodAndArg\n        ) : callInvokeWithMethodAndArg();\n    }\n\n    // Define the unified helper method that is used to implement .next,\n    // .throw, and .return (see defineIteratorMethods).\n    this._invoke = enqueue;\n  }\n\n  defineIteratorMethods(AsyncIterator.prototype);\n  AsyncIterator.prototype[asyncIteratorSymbol] = function () {\n    return this;\n  };\n  exports.AsyncIterator = AsyncIterator;\n\n  // Note that simple async functions are implemented on top of\n  // AsyncIterator objects; they just return a Promise for the value of\n  // the final result produced by the iterator.\n  exports.async = function(innerFn, outerFn, self, tryLocsList, PromiseImpl) {\n    if (PromiseImpl === void 0) PromiseImpl = Promise;\n\n    var iter = new AsyncIterator(\n      wrap(innerFn, outerFn, self, tryLocsList),\n      PromiseImpl\n    );\n\n    return exports.isGeneratorFunction(outerFn)\n      ? iter // If outerFn is a generator, return the full iterator.\n      : iter.next().then(function(result) {\n          return result.done ? result.value : iter.next();\n        });\n  };\n\n  function makeInvokeMethod(innerFn, self, context) {\n    var state = GenStateSuspendedStart;\n\n    return function invoke(method, arg) {\n      if (state === GenStateExecuting) {\n        throw new Error(\"Generator is already running\");\n      }\n\n      if (state === GenStateCompleted) {\n        if (method === \"throw\") {\n          throw arg;\n        }\n\n        // Be forgiving, per 25.3.3.3.3 of the spec:\n        // https://people.mozilla.org/~jorendorff/es6-draft.html#sec-generatorresume\n        return doneResult();\n      }\n\n      context.method = method;\n      context.arg = arg;\n\n      while (true) {\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\n        if (context.method === \"next\") {\n          // Setting context._sent for legacy support of Babel's\n          // function.sent implementation.\n          context.sent = context._sent = context.arg;\n\n        } else if (context.method === \"throw\") {\n          if (state === GenStateSuspendedStart) {\n            state = GenStateCompleted;\n            throw context.arg;\n          }\n\n          context.dispatchException(context.arg);\n\n        } else if (context.method === \"return\") {\n          context.abrupt(\"return\", context.arg);\n        }\n\n        state = GenStateExecuting;\n\n        var record = tryCatch(innerFn, self, context);\n        if (record.type === \"normal\") {\n          // If an exception is thrown from innerFn, we leave state ===\n          // GenStateExecuting and loop back for another invocation.\n          state = context.done\n            ? GenStateCompleted\n            : GenStateSuspendedYield;\n\n          if (record.arg === ContinueSentinel) {\n            continue;\n          }\n\n          return {\n            value: record.arg,\n            done: context.done\n          };\n\n        } else if (record.type === \"throw\") {\n          state = GenStateCompleted;\n          // Dispatch the exception by looping back around to the\n          // context.dispatchException(context.arg) call above.\n          context.method = \"throw\";\n          context.arg = record.arg;\n        }\n      }\n    };\n  }\n\n  // Call delegate.iterator[context.method](context.arg) and handle the\n  // result, either by returning a { value, done } result from the\n  // delegate iterator, or by modifying context.method and context.arg,\n  // setting context.delegate to null, and returning the ContinueSentinel.\n  function maybeInvokeDelegate(delegate, context) {\n    var method = delegate.iterator[context.method];\n    if (method === undefined) {\n      // A .throw or .return when the delegate iterator has no .throw\n      // method always terminates the yield* loop.\n      context.delegate = null;\n\n      if (context.method === \"throw\") {\n        // Note: [\"return\"] must be used for ES3 parsing compatibility.\n        if (delegate.iterator[\"return\"]) {\n          // If the delegate iterator has a return method, give it a\n          // chance to clean up.\n          context.method = \"return\";\n          context.arg = undefined;\n          maybeInvokeDelegate(delegate, context);\n\n          if (context.method === \"throw\") {\n            // If maybeInvokeDelegate(context) changed context.method from\n            // \"return\" to \"throw\", let that override the TypeError below.\n            return ContinueSentinel;\n          }\n        }\n\n        context.method = \"throw\";\n        context.arg = new TypeError(\n          \"The iterator does not provide a 'throw' method\");\n      }\n\n      return ContinueSentinel;\n    }\n\n    var record = tryCatch(method, delegate.iterator, context.arg);\n\n    if (record.type === \"throw\") {\n      context.method = \"throw\";\n      context.arg = record.arg;\n      context.delegate = null;\n      return ContinueSentinel;\n    }\n\n    var info = record.arg;\n\n    if (! info) {\n      context.method = \"throw\";\n      context.arg = new TypeError(\"iterator result is not an object\");\n      context.delegate = null;\n      return ContinueSentinel;\n    }\n\n    if (info.done) {\n      // Assign the result of the finished delegate to the temporary\n      // variable specified by delegate.resultName (see delegateYield).\n      context[delegate.resultName] = info.value;\n\n      // Resume execution at the desired location (see delegateYield).\n      context.next = delegate.nextLoc;\n\n      // If context.method was \"throw\" but the delegate handled the\n      // exception, let the outer generator proceed normally. If\n      // context.method was \"next\", forget context.arg since it has been\n      // \"consumed\" by the delegate iterator. If context.method was\n      // \"return\", allow the original .return call to continue in the\n      // outer generator.\n      if (context.method !== \"return\") {\n        context.method = \"next\";\n        context.arg = undefined;\n      }\n\n    } else {\n      // Re-yield the result returned by the delegate method.\n      return info;\n    }\n\n    // The delegate iterator is finished, so forget it and continue with\n    // the outer generator.\n    context.delegate = null;\n    return ContinueSentinel;\n  }\n\n  // Define Generator.prototype.{next,throw,return} in terms of the\n  // unified ._invoke helper method.\n  defineIteratorMethods(Gp);\n\n  Gp[toStringTagSymbol] = \"Generator\";\n\n  // A Generator should always return itself as the iterator object when the\n  // @@iterator function is called on it. Some browsers' implementations of the\n  // iterator prototype chain incorrectly implement this, causing the Generator\n  // object to not be returned from this call. This ensures that doesn't happen.\n  // See https://github.com/facebook/regenerator/issues/274 for more details.\n  Gp[iteratorSymbol] = function() {\n    return this;\n  };\n\n  Gp.toString = function() {\n    return \"[object Generator]\";\n  };\n\n  function pushTryEntry(locs) {\n    var entry = { tryLoc: locs[0] };\n\n    if (1 in locs) {\n      entry.catchLoc = locs[1];\n    }\n\n    if (2 in locs) {\n      entry.finallyLoc = locs[2];\n      entry.afterLoc = locs[3];\n    }\n\n    this.tryEntries.push(entry);\n  }\n\n  function resetTryEntry(entry) {\n    var record = entry.completion || {};\n    record.type = \"normal\";\n    delete record.arg;\n    entry.completion = record;\n  }\n\n  function Context(tryLocsList) {\n    // The root entry object (effectively a try statement without a catch\n    // or a finally block) gives us a place to store values thrown from\n    // locations where there is no enclosing try statement.\n    this.tryEntries = [{ tryLoc: \"root\" }];\n    tryLocsList.forEach(pushTryEntry, this);\n    this.reset(true);\n  }\n\n  exports.keys = function(object) {\n    var keys = [];\n    for (var key in object) {\n      keys.push(key);\n    }\n    keys.reverse();\n\n    // Rather than returning an object with a next method, we keep\n    // things simple and return the next function itself.\n    return function next() {\n      while (keys.length) {\n        var key = keys.pop();\n        if (key in object) {\n          next.value = key;\n          next.done = false;\n          return next;\n        }\n      }\n\n      // To avoid creating an additional object, we just hang the .value\n      // and .done properties off the next function object itself. This\n      // also ensures that the minifier will not anonymize the function.\n      next.done = true;\n      return next;\n    };\n  };\n\n  function values(iterable) {\n    if (iterable) {\n      var iteratorMethod = iterable[iteratorSymbol];\n      if (iteratorMethod) {\n        return iteratorMethod.call(iterable);\n      }\n\n      if (typeof iterable.next === \"function\") {\n        return iterable;\n      }\n\n      if (!isNaN(iterable.length)) {\n        var i = -1, next = function next() {\n          while (++i < iterable.length) {\n            if (hasOwn.call(iterable, i)) {\n              next.value = iterable[i];\n              next.done = false;\n              return next;\n            }\n          }\n\n          next.value = undefined;\n          next.done = true;\n\n          return next;\n        };\n\n        return next.next = next;\n      }\n    }\n\n    // Return an iterator with no values.\n    return { next: doneResult };\n  }\n  exports.values = values;\n\n  function doneResult() {\n    return { value: undefined, done: true };\n  }\n\n  Context.prototype = {\n    constructor: Context,\n\n    reset: function(skipTempReset) {\n      this.prev = 0;\n      this.next = 0;\n      // Resetting context._sent for legacy support of Babel's\n      // function.sent implementation.\n      this.sent = this._sent = undefined;\n      this.done = false;\n      this.delegate = null;\n\n      this.method = \"next\";\n      this.arg = undefined;\n\n      this.tryEntries.forEach(resetTryEntry);\n\n      if (!skipTempReset) {\n        for (var name in this) {\n          // Not sure about the optimal order of these conditions:\n          if (name.charAt(0) === \"t\" &&\n              hasOwn.call(this, name) &&\n              !isNaN(+name.slice(1))) {\n            this[name] = undefined;\n          }\n        }\n      }\n    },\n\n    stop: function() {\n      this.done = true;\n\n      var rootEntry = this.tryEntries[0];\n      var rootRecord = rootEntry.completion;\n      if (rootRecord.type === \"throw\") {\n        throw rootRecord.arg;\n      }\n\n      return this.rval;\n    },\n\n    dispatchException: function(exception) {\n      if (this.done) {\n        throw exception;\n      }\n\n      var context = this;\n      function handle(loc, caught) {\n        record.type = \"throw\";\n        record.arg = exception;\n        context.next = loc;\n\n        if (caught) {\n          // If the dispatched exception was caught by a catch block,\n          // then let that catch block handle the exception normally.\n          context.method = \"next\";\n          context.arg = undefined;\n        }\n\n        return !! caught;\n      }\n\n      for (var i = this.tryEntries.length - 1; i >= 0; --i) {\n        var entry = this.tryEntries[i];\n        var record = entry.completion;\n\n        if (entry.tryLoc === \"root\") {\n          // Exception thrown outside of any try block that could handle\n          // it, so set the completion value of the entire function to\n          // throw the exception.\n          return handle(\"end\");\n        }\n\n        if (entry.tryLoc <= this.prev) {\n          var hasCatch = hasOwn.call(entry, \"catchLoc\");\n          var hasFinally = hasOwn.call(entry, \"finallyLoc\");\n\n          if (hasCatch && hasFinally) {\n            if (this.prev < entry.catchLoc) {\n              return handle(entry.catchLoc, true);\n            } else if (this.prev < entry.finallyLoc) {\n              return handle(entry.finallyLoc);\n            }\n\n          } else if (hasCatch) {\n            if (this.prev < entry.catchLoc) {\n              return handle(entry.catchLoc, true);\n            }\n\n          } else if (hasFinally) {\n            if (this.prev < entry.finallyLoc) {\n              return handle(entry.finallyLoc);\n            }\n\n          } else {\n            throw new Error(\"try statement without catch or finally\");\n          }\n        }\n      }\n    },\n\n    abrupt: function(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 &&\n            hasOwn.call(entry, \"finallyLoc\") &&\n            this.prev < entry.finallyLoc) {\n          var finallyEntry = entry;\n          break;\n        }\n      }\n\n      if (finallyEntry &&\n          (type === \"break\" ||\n           type === \"continue\") &&\n          finallyEntry.tryLoc <= arg &&\n          arg <= finallyEntry.finallyLoc) {\n        // Ignore the finally entry if control is not jumping to a\n        // location outside the try/catch block.\n        finallyEntry = null;\n      }\n\n      var record = finallyEntry ? finallyEntry.completion : {};\n      record.type = type;\n      record.arg = arg;\n\n      if (finallyEntry) {\n        this.method = \"next\";\n        this.next = finallyEntry.finallyLoc;\n        return ContinueSentinel;\n      }\n\n      return this.complete(record);\n    },\n\n    complete: function(record, afterLoc) {\n      if (record.type === \"throw\") {\n        throw record.arg;\n      }\n\n      if (record.type === \"break\" ||\n          record.type === \"continue\") {\n        this.next = record.arg;\n      } else if (record.type === \"return\") {\n        this.rval = this.arg = record.arg;\n        this.method = \"return\";\n        this.next = \"end\";\n      } else if (record.type === \"normal\" && afterLoc) {\n        this.next = afterLoc;\n      }\n\n      return ContinueSentinel;\n    },\n\n    finish: function(finallyLoc) {\n      for (var i = this.tryEntries.length - 1; i >= 0; --i) {\n        var entry = this.tryEntries[i];\n        if (entry.finallyLoc === finallyLoc) {\n          this.complete(entry.completion, entry.afterLoc);\n          resetTryEntry(entry);\n          return ContinueSentinel;\n        }\n      }\n    },\n\n    \"catch\": function(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 (record.type === \"throw\") {\n            var thrown = record.arg;\n            resetTryEntry(entry);\n          }\n          return thrown;\n        }\n      }\n\n      // The context.catch method must only be called with a location\n      // argument that corresponds to a known catch block.\n      throw new Error(\"illegal catch attempt\");\n    },\n\n    delegateYield: function(iterable, resultName, nextLoc) {\n      this.delegate = {\n        iterator: values(iterable),\n        resultName: resultName,\n        nextLoc: nextLoc\n      };\n\n      if (this.method === \"next\") {\n        // Deliberately forget the last sent value so that we don't\n        // accidentally pass it on to the delegate.\n        this.arg = undefined;\n      }\n\n      return ContinueSentinel;\n    }\n  };\n\n  // Regardless of whether this script is executing as a CommonJS module\n  // or not, return the runtime object so that we can declare the variable\n  // regeneratorRuntime in the outer scope, which allows this module to be\n  // injected easily by `bin/regenerator --include-runtime script.js`.\n  return exports;\n\n}(\n  // If this script is executing as a CommonJS module, use module.exports\n  // as the regeneratorRuntime namespace. Otherwise create a new empty\n  // object. Either way, the resulting object will be used to initialize\n  // the regeneratorRuntime variable at the top of this file.\n  typeof module === \"object\" ? module.exports : {}\n));\n\ntry {\n  regeneratorRuntime = runtime;\n} catch (accidentalStrictMode) {\n  // This module should not be running in strict mode, so the above\n  // assignment should always work unless something is misconfigured. Just\n  // in case runtime.js accidentally runs in strict mode, we can escape\n  // strict mode using a global Function call. This could conceivably fail\n  // if a Content Security Policy forbids using Function, but in that case\n  // the proper solution is to fix the accidental strict mode problem. If\n  // you've misconfigured your bundler to force strict mode and applied a\n  // CSP to forbid Function, and you're not willing to fix either of those\n  // problems, please detail your unique predicament in a GitHub issue.\n  Function(\"r\", \"regeneratorRuntime = r\")(runtime);\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};","export var StringTypes;\n(function (StringTypes) {\n    StringTypes[\"ERROR\"] = \"error\";\n    StringTypes[\"MESSAGE\"] = \"message\";\n    StringTypes[\"UI\"] = \"ui\";\n})(StringTypes || (StringTypes = {}));\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","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","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 * 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 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: \"vazio\",\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","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","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}","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 { 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}","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}","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 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 * as LocalizedStringsService from \"./../../services/localizedStringsService\";\nimport { SyntaxError } from \"./syntaxError\";\n\nconst LocalizedStrings = LocalizedStringsService.getInstance();\n\nfunction createError (message_id, context = []) {\n  return new SyntaxError(\n    LocalizedStrings.getError(message_id, context),\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 * 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\nexport const LocalizedStrings = Object.freeze(\n  new IVProgLocalizedStrings(LanguageService, Langs)\n);\n\nconst _instance = new IVProgLocalizedStrings(LanguageService, Langs);\n\nexport function getInstance () {\n  return _instance;\n}\n","import line_i18n from \"line-i18n\";\nimport { 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 { LanguageService } from \"./../services/languageService\";\nimport { LocalizedStrings } from \"./../services/localizedStringsService\";\nimport { Operators } from \"./../ast/operators\";\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 { 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 { 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 { 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 { 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 { Config } from \"./src/util/config\";\nimport { i18nHelper } from \"./src/services/i18nHelper\";\nimport * as LocalizedStringsService from \"./src/services/localizedStringsService\";\nimport { 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.js\";\nimport { SemanticAnalyser } from \"./src/processor/semantic/semanticAnalyser.js\";\nimport { Modes } from \"./src/processor/modes\";\nimport { Location } from \"./src/memory/location\";\n\nconst Settings = {\n  programming: [],\n  functions: [],\n  datatypes: [],\n  commands: [],\n  filter: []\n}\n\nconst i18n = i18nHelper.i18n;\nconst LocalizedStrings = LocalizedStringsService.getInstance();\n\nexport {\n  i18n,\n  Settings,\n  Config,\n  LocalizedStrings,\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","arr","len","length","i","arr2","Array","isArray","arrayLikeToArray","self","ReferenceError","asyncGeneratorStep","gen","resolve","reject","_next","_throw","key","arg","info","value","error","done","Promise","then","fn","args","arguments","apply","err","undefined","instance","Constructor","TypeError","setPrototypeOf","isNativeReflectConstruct","_construct","Parent","Class","Reflect","construct","a","push","Function","bind","prototype","_defineProperties","target","props","descriptor","enumerable","configurable","writable","Object","defineProperty","protoProps","staticProps","obj","superPropBase","_get","property","receiver","get","base","desc","getOwnPropertyDescriptor","call","_getPrototypeOf","o","getPrototypeOf","__proto__","subClass","superClass","create","constructor","toString","indexOf","sham","Proxy","Date","e","iter","Symbol","iterator","from","_arr","_n","_d","_e","_s","_i","next","_typeof","assertThisInitialized","_setPrototypeOf","p","arrayWithHoles","iterableToArrayLimit","unsupportedIterableToArray","nonIterableRest","object","hasOwnProperty","strings","raw","slice","freeze","defineProperties","arrayWithoutHoles","iterableToArray","nonIterableSpread","minLen","n","name","test","isNativeFunction","_wrapNativeSuper","_cache","Map","has","set","Wrapper","globalScope","Decimal","inexact","quadrant","EXP_LIMIT","MAX_DIGITS","NUMERALS","LN10","PI","DEFAULTS","precision","rounding","modulo","toExpNeg","toExpPos","minE","maxE","crypto","external","decimalError","invalidArgument","precisionLimitExceeded","cryptoUnavailable","mathfloor","Math","floor","mathpow","pow","isBinary","isHex","isOctal","isDecimal","BASE","LN10_PRECISION","PI_PRECISION","P","digitsToString","d","k","ws","indexOfLastWord","str","w","getZeroString","checkInt32","min","max","Error","checkRoundingDigits","rm","repeating","di","r","rd","ceil","convertBase","baseIn","baseOut","j","arrL","strL","charAt","reverse","absoluteValue","abs","x","s","finalise","comparedTo","cmp","y","xdL","ydL","xd","yd","xs","ys","NaN","cosine","cos","pr","Ctor","sd","tinyPow","taylorSeries","times","cos2x","minus","plus","toLessThanHalfPi","neg","cubeRoot","cbrt","m","rep","t","t3","t3plusx","isFinite","isZero","toExponential","divide","eq","decimalPlaces","dp","dividedBy","div","dividedToIntegerBy","divToInt","equals","greaterThan","gt","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","isNaN","isNegative","isPositive","isPos","lessThan","lt","lessThanOrEqualTo","logarithm","log","isBase10","denominator","inf","num","naturalLogarithm","getLn10","sub","xe","xLTy","pop","shift","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","b","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","String","parseDecimal","replace","search","substring","charCodeAt","parseOther","divisor","isFloat","toLowerCase","isHyperbolic","u","pi","atan2","config","v","useDefaults","defaults","ps","getRandomValues","randomBytes","hypot","isDecimalInstance","log2","log10","random","Uint32Array","copy","clone","ROUND_UP","ROUND_DOWN","ROUND_CEIL","ROUND_FLOOR","ROUND_HALF_UP","ROUND_HALF_DOWN","ROUND_HALF_EVEN","ROUND_HALF_CEIL","ROUND_HALF_FLOOR","EUCLID","hasSticky","RegExp","sticky","isRegExp","isObject","reCapture","reUnion","regexps","map","join","regexpOrLiteral","ignoreCase","global","multiline","source","ruleOptions","type","match","include","options","defaultType","lineBreaks","fallback","shouldThrow","sort","toRules","spec","array","result","concat","JSON","stringify","arrayToRules","keys","getOwnPropertyNames","thing","rules","forEach","rule","objectToRules","defaultErrorRule","compileRules","hasStates","errorRule","fast","fastAllowed","unicodeFlag","groups","parts","unicode","pat","regexp","exec","fallbackRule","flags","suffix","checkStateGroup","g","state","Lexer","states","startState","buffer","stack","reset","data","index","line","col","queuedToken","queuedThrow","setState","save","re","popState","pushState","eat","tokenToString","_getGroup","groupCount","queuedGroup","token","_token","queuedText","group","lastIndex","text","offset","matchNL","nl","size","formatError","LexerIterator","lexer","message","start","eol","firstLine","tokenType","compile","all","$all","ruleMap","included","splice","newRules","newRule","fastKeys","keywords","reverseMap","byLength","types","item","keyword","runtime","Op","hasOwn","$Symbol","iteratorSymbol","asyncIteratorSymbol","asyncIterator","toStringTagSymbol","toStringTag","wrap","innerFn","outerFn","tryLocsList","protoGenerator","Generator","generator","context","Context","_invoke","GenStateSuspendedStart","method","GenStateExecuting","GenStateCompleted","doneResult","delegate","delegateResult","maybeInvokeDelegate","ContinueSentinel","sent","_sent","dispatchException","abrupt","record","tryCatch","GenStateSuspendedYield","makeInvokeMethod","GeneratorFunction","GeneratorFunctionPrototype","IteratorPrototype","getProto","NativeIteratorPrototype","values","Gp","defineIteratorMethods","AsyncIterator","PromiseImpl","invoke","__await","unwrapped","previousPromise","callInvokeWithMethodAndArg","resultName","nextLoc","pushTryEntry","locs","entry","tryLoc","catchLoc","finallyLoc","afterLoc","tryEntries","resetTryEntry","completion","iterable","iteratorMethod","displayName","isGeneratorFunction","genFun","ctor","mark","awrap","async","skipTempReset","prev","stop","rootRecord","rval","exception","handle","loc","caught","hasCatch","hasFinally","finallyEntry","complete","finish","thrown","delegateYield","regeneratorRuntime","accidentalStrictMode","__webpack_module_cache__","__webpack_require__","moduleId","cachedModule","__webpack_modules__","getter","__esModule","definition","prop","StringTypes","ConfigObject","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","opts","otherConfig","Config","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","ERROR","processString","getMessage","MESSAGE","UI","func","querySelectorAll","node","innerHTML","processTagTex","getAttribute","split","LanguageServiceNoLS","notifyChange","setLang","MessagesObj","UIObj","ErrorsObj","i18n_data","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","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","iLMparameters","langLexer","Lexers","langInfo","getLangFuncs","getLangLibs","line_i18n","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","stringInfo","isCompatible","BOOLEAN","CHAR","VOID","UNDEFINED","ALL","Types","returnType","formalParameters","some","variadic","variables","IfThenElse","condition","ifTrue","ifFalse","CommandBlock","RepeatUntil","Expression","_parenthesis","flag","Switch","cases","Case","SysCall","langFunc","FormalParameter","byRef","FunctionCall","actualParameters","isMainCall","LanguageDefinedFunction","getMainFunctionName","getLocalName","params","parenthesis","Modes","RETURN","BREAK","PAUSE","RUN","ABORT","toInt","toChar","toReal","toBool","val","getReservedKeys","getRules","convertBoolToString","bool","convertToString","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","arrayLiteral","element","validateSize","validateType","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","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","input","ivprogLexer","inputStream","tokenStream","pos","ruleNames","variableTypes","getTypeKeys","functionTypes","parsingArrayDimension","scope","definedFuncsNameList","definedVariablesStack","fill","parser","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","convertToRadians","degrees","seed","now","valueToKey","sinFun","libsObject","sto","_","applyStore","angle","insertStore","mode","cosFun","createCosFun","tanFun","function_call_stack","createTanFun","sqrtFun","createSqrtFun","powFun","createPowFun","logFun","createLogFun","absFun","createAbsFun","negateFun","createNegateFun","invertFun","createInvertFun","maxFun","numbers","sto_addrs","paramType","createMaxFun","minFun","createMinFun","randFun","createRandFun","readFunction","store","requestInput","typeToConvert","trim","realObject","getStoreObject","getReferenceDimension","arrayInfo","getRefObj","stoValue","updateStore","createInputFun","writeFunction","totalSV","total","output","sendOutput","createOutputFun","substringFun","end","createSubstringFun","lengthFun","createLengthFun","uppercaseFun","toUpperCase","createUppercaseFun","lowercaseFun","createLowercaseFun","charAtFun","idx","createrCharAtFun","numElementsFun","vector","createNumElementsFun","matrixLinesFun","matrix","createMatrixLinesFun","matrixColumnsFun","createMatrixColumnsFun","isRealFun","createParser","createIsRealFun","isIntFun","createIsIntFun","createIsBoolFun","castRealFun","typeStringInfoArray","typeInfo","createCastRealFun","castIntFun","createCastIntFun","castBoolFun","createCastBoolFun","castStringFun","createCastStringFun","fromCharCode","createCastCharFun","funcsObject","concatObjects","localName","names","lib","internalName","getFunction","libName","funName","IVProgLocalizedStrings","langService","langsJsons","shouldListenToChange","type_string","category","Langs","_instance","getInstance","i18nHelper","i18n","identifier","levenshteinDistance","win","openAssessmentDetail","preventDefault","page_code","currentTarget","dataset","page","close","window","open","write","sleep","ms","res","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","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","StoreObjectArray","_lines","_columns","loc_addresses","cols","addresses","getIndexOf","StoreValueRef","reference_dimesion","ArrayStoreValueRef","StoreObjectArrayRef","getAddresses","Store","castType","sourceType","stoObj","canImplicitTypeCast","nextStore","oldObj","array_value","setAt","oldType","stoType","sto_value","updateStoreArray","newObj","all_values","setID","destroy","isDefined","SemanticAnalyser","ast","symbolMap","currentFunction","stringCode","analyseTree","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","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","Settings","programming","datatypes"],"sourceRoot":""}