Repository: DesignLiquido/delegua
Pull request #166 (2022-11-14 16:53:23)

Dialeto birl: Lexador
Fiz uma melhora no lexador do dialeto birl.
Falta algumas coisas pra implementar mais já da pra fazer o código mínimo da linguagem com ele.

github-actions[bot]: <!-- jest coverage report action for options with hash 825fd481788efa7282e8569b20438413 -->

## Coverage report 



| <div title="Status of coverage:&#10; 🟢 - ok&#10; 🟡 - slightly more than threshold&#10; 🔴 - under the threshold">St.<sup>:grey_question:</sup></div> | Category   | Percentage                                                     | Covered / Total |
| :----------------------------------------------------------------------------------------------------------------------------------------------------: | :--------- | :------------------------------------------------------------- | :-------------: |
|                                                                           🟡                                                                           | Statements | <div title="Base coverage is: 72.15%">71.44% (-0.7% 🔻)</div>  |    3958/5540    |
|                                                                           🔴                                                                           | Branches   | <div title="Base coverage is: 60.08%">59.46% (-0.63% 🔻)</div> |    1009/1697    |
|                                                                           🟡                                                                           | Functions  | <div title="Base coverage is: 70.6%">69.15% (-1.46% 🔻)</div>  |     520/752     |
|                                                                           🟡                                                                           | Lines      | <div title="Base coverage is: 72.36%">71.65% (-0.71% 🔻)</div> |    3586/5005    |

<details><summary>Show new covered files 🐣</summary>
<br/>

| <div title="Status of coverage:&#10; 🟢 - ok&#10; 🟡 - slightly more than threshold&#10; 🔴 - under the threshold">St.<sup>:grey_question:</sup></div> | File                                                                                                            | Statements | Branches | Functions | Lines  |
| :----------------------------------------------------------------------------------------------------------------------------------------------------: | :-------------------------------------------------------------------------------------------------------------- | :--------- | :------- | :-------- | :----- |
|                                                                           🔴                                                                           | <div title="lexador/dialetos/lexador-birl.ts">`...` / lexador-birl.ts</div>                                     | 42.16%     | 28.95%   | 50%       | 40.21% |
|                                                                           🟢                                                                           | <div title="tipos-de-simbolos/birl.ts">`...` / birl.ts</div>                                                    | 100%       | 100%     | 100%      | 100%   |
|                                                                           🔴                                                                           | <div title="avaliador-sintatico/dialetos/avaliador-sintatico-birl.ts">`...` / avaliador-sintatico-birl.ts</div> | 44.9%      | 0%       | 6.25%     | 42.55% |

</details>


## Test suite run success
168 tests passing in 17 suites.

<p align="right">Report generated by <a href="https://github.com/ArtiomTr/jest-coverage-report-action">🧪jest coverage report action</a> from 118ff2954fa2cc9de0a3297abfb25355fc6c8bd7</p>
<!-- Sticky Pull Request Comment -->

Patch:
diff --git a/.editorconfig b/.editorconfig
index 7c12ab28..debc1c85 100644
--- a/.editorconfig
+++ b/.editorconfig
@@ -11,4 +11,4 @@ indent_size = 4
 # end_of_line = lf
 charset = utf-8
 trim_trailing_whitespace = true
-insert_final_newline = true
+insert_final_newline = false
diff --git a/.eslintrc b/.eslintrc
index a6bd2278..f3be4aa4 100644
--- a/.eslintrc
+++ b/.eslintrc
@@ -24,6 +24,7 @@
         "no-unsafe-finally": "off",
         "no-fallthrough": "off",
         "@typescript-eslint/no-this-alias": "off",
-        "@typescript-eslint/no-inferrable-types": "off"
+        "@typescript-eslint/no-inferrable-types": "off",
+        "prefer-const": "off"
     }
 }
diff --git a/.vscode/launch.json b/.vscode/launch.json
index 1f5167da..056d0f4c 100644
--- a/.vscode/launch.json
+++ b/.vscode/launch.json
@@ -7,13 +7,15 @@
         {
             "type": "node",
             "request": "launch",
-            "name": "Delégua > Bhaskara",
+            "name": "Birl > Teste",
             "skipFiles": ["<node_internals>/**", "node_modules/**"],
             "cwd": "${workspaceRoot}",
             "console": "integratedTerminal",
             "args": [
                 "${workspaceFolder}${pathSeparator}index.ts",
-                "./testes/exemplos/dialetos/egua-classico/bhaskara.egua"
+                "--dialeto",
+                "birl",
+                "./testes/exemplos/birl/teste1.birl"
             ],
             "runtimeExecutable": "node",
             "runtimeArgs": ["--nolazy", "-r", "ts-node/register/transpile-only"]
@@ -21,17 +23,28 @@
         {
             "type": "node",
             "request": "launch",
-            "name": "Delégua > Classes > Construtor",
+            "name": "Delégua > Bhaskara",
             "skipFiles": ["<node_internals>/**", "node_modules/**"],
             "cwd": "${workspaceRoot}",
             "console": "integratedTerminal",
             "args": [
                 "${workspaceFolder}${pathSeparator}index.ts",
-                "./testes/exemplos/classes/construtor-classe.egua"
+                "./testes/exemplos/dialetos/egua-classico/bhaskara.egua"
             ],
             "runtimeExecutable": "node",
             "runtimeArgs": ["--nolazy", "-r", "ts-node/register/transpile-only"]
         },
+        {
+            "type": "node",
+            "request": "launch",
+            "name": "Delégua > Classes > Construtor",
+            "skipFiles": ["<node_internals>/**", "node_modules/**"],
+            "cwd": "${workspaceRoot}",
+            "console": "integratedTerminal",
+            "args": ["${workspaceFolder}${pathSeparator}index.ts", "./testes/exemplos/classes/construtor-classe.egua"],
+            "runtimeExecutable": "node",
+            "runtimeArgs": ["--nolazy", "-r", "ts-node/register/transpile-only"]
+        },
         {
             "type": "node",
             "request": "launch",
@@ -39,10 +52,7 @@
             "skipFiles": ["<node_internals>/**", "node_modules/**"],
             "cwd": "${workspaceRoot}",
             "console": "integratedTerminal",
-            "args": [
-                "${workspaceFolder}${pathSeparator}index.ts",
-                "./testes/exemplos/condicionais/escolha.delegua"
-            ],
+            "args": ["${workspaceFolder}${pathSeparator}index.ts", "./testes/exemplos/condicionais/escolha.delegua"],
             "runtimeExecutable": "node",
             "runtimeArgs": ["--nolazy", "-r", "ts-node/register/transpile-only"]
         },
@@ -53,10 +63,7 @@
             "skipFiles": ["<node_internals>/**", "node_modules/**"],
             "cwd": "${workspaceRoot}",
             "console": "integratedTerminal",
-            "args": [
-                "${workspaceFolder}${pathSeparator}index.ts",
-                "./testes/exemplos/fibonacci.delegua"
-            ],
+            "args": ["${workspaceFolder}${pathSeparator}index.ts", "./testes/exemplos/fibonacci.delegua"],
             "runtimeExecutable": "node",
             "runtimeArgs": ["--nolazy", "-r", "ts-node/register/transpile-only"]
         },
@@ -95,10 +102,7 @@
             "skipFiles": ["<node_internals>/**", "node_modules/**"],
             "cwd": "${workspaceRoot}",
             "console": "integratedTerminal",
-            "args": [
-                "${workspaceFolder}${pathSeparator}index.ts",
-                "./testes/exemplos/media.delegua"
-            ],
+            "args": ["${workspaceFolder}${pathSeparator}index.ts", "./testes/exemplos/media.delegua"],
             "runtimeExecutable": "node",
             "runtimeArgs": ["--nolazy", "-r", "ts-node/register/transpile-only"]
         },
@@ -137,10 +141,7 @@
             "skipFiles": ["<node_internals>/**", "node_modules/**"],
             "cwd": "${workspaceRoot}",
             "console": "integratedTerminal",
-            "args": [
-                "${workspaceFolder}${pathSeparator}index.ts",
-                "./testes/exemplos/primitivas/lista/inclui.delegua"
-            ],
+            "args": ["${workspaceFolder}${pathSeparator}index.ts", "./testes/exemplos/primitivas/lista/inclui.delegua"],
             "runtimeExecutable": "node",
             "runtimeArgs": ["--nolazy", "-r", "ts-node/register/transpile-only"]
         },
@@ -162,10 +163,7 @@
             "skipFiles": ["<node_internals>/**", "node_modules/**"],
             "cwd": "${workspaceRoot}",
             "console": "integratedTerminal",
-            "args": [
-                "${workspaceFolder}${pathSeparator}index.ts",
-                "./testes/exemplos/classes/teste-classe.egua"
-            ],
+            "args": ["${workspaceFolder}${pathSeparator}index.ts", "./testes/exemplos/classes/teste-classe.egua"],
             "runtimeExecutable": "node",
             "runtimeArgs": ["--nolazy", "-r", "ts-node/register/transpile-only"]
         },
@@ -176,11 +174,7 @@
             "skipFiles": ["<node_internals>/**", "node_modules/**"],
             "cwd": "${workspaceRoot}",
             "console": "integratedTerminal",
-            "args": [
-                "${workspaceFolder}${pathSeparator}index.ts",
-                "-p",
-                "./testes/exemplos/testes.egua"
-            ],
+            "args": ["${workspaceFolder}${pathSeparator}index.ts", "-p", "./testes/exemplos/testes.egua"],
             "runtimeExecutable": "node",
             "runtimeArgs": ["--nolazy", "-r", "ts-node/register/transpile-only"]
         },
@@ -217,7 +211,21 @@
                 "--runInBand"
             ],
             "console": "integratedTerminal",
-            "internalConsoleOptions": "neverOpen",
+            "internalConsoleOptions": "neverOpen"
+        },
+        {
+            "name": "Testes unitários > BIRL",
+            "type": "node",
+            "request": "launch",
+            "runtimeArgs": [
+                "--inspect-brk",
+                "${workspaceRoot}/node_modules/jest/bin/jest.js",
+                // "interpretador.test.ts",
+                "birl",
+                "--runInBand"
+            ],
+            "console": "integratedTerminal",
+            "internalConsoleOptions": "neverOpen"
         },
         {
             "type": "node",
@@ -414,10 +422,7 @@
             "skipFiles": ["<node_internals>/**", "node_modules/**"],
             "cwd": "${workspaceRoot}",
             "console": "integratedTerminal",
-            "args": [
-                "${workspaceFolder}${pathSeparator}index.ts",
-                "./testes/exemplos/fizzbuzz.egua"
-            ],
+            "args": ["${workspaceFolder}${pathSeparator}index.ts", "./testes/exemplos/fizzbuzz.egua"],
             "runtimeExecutable": "node",
             "runtimeArgs": ["--nolazy", "-r", "ts-node/register/transpile-only"]
         },
@@ -502,10 +507,7 @@
             "skipFiles": ["<node_internals>/**", "node_modules/**"],
             "cwd": "${workspaceRoot}",
             "console": "integratedTerminal",
-            "args": [
-                "${workspaceFolder}${pathSeparator}index.ts",
-                "./testes/exemplos/condicionais/se.egua"
-            ],
+            "args": ["${workspaceFolder}${pathSeparator}index.ts", "./testes/exemplos/condicionais/se.egua"],
             "runtimeExecutable": "node",
             "runtimeArgs": ["--nolazy", "-r", "ts-node/register/transpile-only"]
         },
diff --git a/.vscode/settings.json b/.vscode/settings.json
index 6f3a2913..a43b6db0 100644
--- a/.vscode/settings.json
+++ b/.vscode/settings.json
@@ -1,3 +1,23 @@
 {
-    "liveServer.settings.port": 5501
-}
\ No newline at end of file
+    "liveServer.settings.port": 5501,
+    "workbench.colorCustomizations": {
+        "activityBar.activeBackground": "#1a1a1a",
+        "activityBar.background": "#1a1a1a",
+        "activityBar.foreground": "#e7e7e7",
+        "activityBar.inactiveForeground": "#e7e7e799",
+        "activityBarBadge.background": "#606020",
+        "activityBarBadge.foreground": "#e7e7e7",
+        "commandCenter.border": "#e7e7e799",
+        "sash.hoverBorder": "#1a1a1a",
+        "statusBar.background": "#000000",
+        "statusBar.foreground": "#e7e7e7",
+        "statusBarItem.hoverBackground": "#1a1a1a",
+        "statusBarItem.remoteBackground": "#000000",
+        "statusBarItem.remoteForeground": "#e7e7e7",
+        "titleBar.activeBackground": "#000000",
+        "titleBar.activeForeground": "#e7e7e7",
+        "titleBar.inactiveBackground": "#00000099",
+        "titleBar.inactiveForeground": "#e7e7e799"
+    },
+    "peacock.color": "#000000"
+}
diff --git a/fontes/avaliador-sintatico/avaliador-sintatico-base.ts b/fontes/avaliador-sintatico/avaliador-sintatico-base.ts
index 597255a9..b0d77262 100644
--- a/fontes/avaliador-sintatico/avaliador-sintatico-base.ts
+++ b/fontes/avaliador-sintatico/avaliador-sintatico-base.ts
@@ -19,10 +19,7 @@ import {
     Leia,
 } from '../declaracoes';
 import { AvaliadorSintaticoInterface, SimboloInterface } from '../interfaces';
-import {
-    RetornoLexador,
-    RetornoAvaliadorSintatico,
-} from '../interfaces/retornos';
+import { RetornoLexador, RetornoAvaliadorSintatico } from '../interfaces/retornos';
 import { ErroAvaliadorSintatico } from './erro-avaliador-sintatico';
 
 import tiposDeSimbolos from '../tipos-de-simbolos/comum';
@@ -32,24 +29,18 @@ import tiposDeSimbolos from '../tipos-de-simbolos/comum';
  * entre todos os outros Avaliadores Sintáticos. Depende de um dicionário
  * de tipos de símbolos comuns entre todos os dialetos.
  */
-export abstract class AvaliadorSintaticoBase
-    implements AvaliadorSintaticoInterface
-{
+export abstract class AvaliadorSintaticoBase implements AvaliadorSintaticoInterface {
     simbolos: SimboloInterface[];
     erros: ErroAvaliadorSintatico[];
     atual: number;
-    ciclos: number;
+    blocos: number;
 
     consumir(tipo: string, mensagemDeErro: string): SimboloInterface {
-        if (this.verificarTipoSimboloAtual(tipo))
-            return this.avancarEDevolverAnterior();
+        if (this.verificarTipoSimboloAtual(tipo)) return this.avancarEDevolverAnterior();
         throw this.erro(this.simbolos[this.atual], mensagemDeErro);
     }
 
-    erro(
-        simbolo: SimboloInterface,
-        mensagemDeErro: string
-    ): ErroAvaliadorSintatico {
+    erro(simbolo: SimboloInterface, mensagemDeErro: string): ErroAvaliadorSintatico {
         const excecao = new ErroAvaliadorSintatico(simbolo, mensagemDeErro);
         this.erros.push(excecao);
         return excecao;
@@ -98,12 +89,7 @@ export abstract class AvaliadorSintaticoBase
     abstract chamar(): Construto;
 
     unario(): Construto {
-        if (
-            this.verificarSeSimboloAtualEIgualA(
-                tiposDeSimbolos.NEGACAO,
-                tiposDeSimbolos.SUBTRACAO
-            )
-        ) {
+        if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.NEGACAO, tiposDeSimbolos.SUBTRACAO)) {
             const operador = this.simbolos[this.atual - 1];
             const direito = this.unario();
             return new Unario(-1, operador, direito);
@@ -137,12 +123,7 @@ export abstract class AvaliadorSintaticoBase
     adicaoOuSubtracao(): Construto {
         let expressao = this.multiplicar();
 
-        while (
-            this.verificarSeSimboloAtualEIgualA(
-                tiposDeSimbolos.SUBTRACAO,
-                tiposDeSimbolos.ADICAO
-            )
-        ) {
+        while (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.SUBTRACAO, tiposDeSimbolos.ADICAO)) {
             const operador = this.simbolos[this.atual - 1];
             const direito = this.multiplicar();
             expressao = new Binario(-1, expressao, operador, direito);
@@ -185,12 +166,7 @@ export abstract class AvaliadorSintaticoBase
     comparacaoIgualdade(): Construto {
         let expressao = this.comparar();
 
-        while (
-            this.verificarSeSimboloAtualEIgualA(
-                tiposDeSimbolos.DIFERENTE,
-                tiposDeSimbolos.IGUAL
-            )
-        ) {
+        while (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.DIFERENTE, tiposDeSimbolos.IGUAL)) {
             const operador = this.simbolos[this.atual - 1];
             const direito = this.comparar();
             expressao = new Binario(-1, expressao, operador, direito);
@@ -287,10 +263,7 @@ export abstract class AvaliadorSintaticoBase
     funcao(tipo: string): FuncaoDeclaracao {
         const simboloFuncao: SimboloInterface = this.avancarEDevolverAnterior();
 
-        const nomeFuncao: SimboloInterface = this.consumir(
-            tiposDeSimbolos.IDENTIFICADOR,
-            `Esperado nome ${tipo}.`
-        );
+        const nomeFuncao: SimboloInterface = this.consumir(tiposDeSimbolos.IDENTIFICADOR, `Esperado nome ${tipo}.`);
         return new FuncaoDeclaracao(nomeFuncao, this.corpoDaFuncao(tipo));
     }
 
@@ -302,8 +275,5 @@ export abstract class AvaliadorSintaticoBase
 
     abstract declaracao(): Declaracao;
 
-    abstract analisar(
-        retornoLexador: RetornoLexador,
-        hashArquivo?: number
-    ): RetornoAvaliadorSintatico;
+    abstract analisar(retornoLexador: RetornoLexador, hashArquivo?: number): RetornoAvaliadorSintatico;
 }
diff --git a/fontes/avaliador-sintatico/avaliador-sintatico.ts b/fontes/avaliador-sintatico/avaliador-sintatico.ts
index 47ec27bb..305ae604 100644
--- a/fontes/avaliador-sintatico/avaliador-sintatico.ts
+++ b/fontes/avaliador-sintatico/avaliador-sintatico.ts
@@ -1,10 +1,6 @@
 import tiposDeSimbolos from '../tipos-de-simbolos/delegua';
 import hrtime from 'browser-process-hrtime';
-import {
-    AvaliadorSintaticoInterface,
-    ParametroInterface,
-    SimboloInterface,
-} from '../interfaces';
+import { AvaliadorSintaticoInterface, ParametroInterface, SimboloInterface } from '../interfaces';
 import {
     AtribuicaoSobrescrita,
     Atribuir,
@@ -63,29 +59,25 @@ export class AvaliadorSintatico implements AvaliadorSintaticoInterface {
 
     hashArquivo: number;
     atual: number;
-    ciclos: number;
+    blocos: number;
     performance: boolean;
 
     constructor(performance = false) {
         this.hashArquivo = 0;
         this.atual = 0;
-        this.ciclos = 0;
+        this.blocos = 0;
         this.erros = [];
         this.performance = performance;
     }
 
-    erro(
-        simbolo: SimboloInterface,
-        mensagemDeErro: string
-    ): ErroAvaliadorSintatico {
+    erro(simbolo: SimboloInterface, mensagemDeErro: string): ErroAvaliadorSintatico {
         const excecao = new ErroAvaliadorSintatico(simbolo, mensagemDeErro);
         this.erros.push(excecao);
         return excecao;
     }
 
     consumir(tipo: string, mensagemDeErro: string): SimboloInterface {
-        if (this.verificarTipoSimboloAtual(tipo))
-            return this.avancarEDevolverAnterior();
+        if (this.verificarTipoSimboloAtual(tipo)) return this.avancarEDevolverAnterior();
         throw this.erro(this.simbolos[this.atual], mensagemDeErro);
     }
 
@@ -132,186 +124,80 @@ export class AvaliadorSintatico implements AvaliadorSintaticoInterface {
         if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.SUPER)) {
             const simboloChave = this.simbolos[this.atual - 1];
             this.consumir(tiposDeSimbolos.PONTO, "Esperado '.' após 'super'.");
-            const metodo = this.consumir(
-                tiposDeSimbolos.IDENTIFICADOR,
-                'Esperado nome do método da SuperClasse.'
-            );
+            const metodo = this.consumir(tiposDeSimbolos.IDENTIFICADOR, 'Esperado nome do método da SuperClasse.');
             return new Super(this.hashArquivo, simboloChave, metodo);
         }
 
-        if (
-            this.verificarSeSimboloAtualEIgualA(
-                tiposDeSimbolos.COLCHETE_ESQUERDO
-            )
-        ) {
+        if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.COLCHETE_ESQUERDO)) {
             const valores = [];
 
-            if (
-                this.verificarSeSimboloAtualEIgualA(
-                    tiposDeSimbolos.COLCHETE_DIREITO
-                )
-            ) {
-                return new Vetor(
-                    this.hashArquivo,
-                    Number(simboloAtual.linha),
-                    []
-                );
+            if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.COLCHETE_DIREITO)) {
+                return new Vetor(this.hashArquivo, Number(simboloAtual.linha), []);
             }
 
-            while (
-                !this.verificarSeSimboloAtualEIgualA(
-                    tiposDeSimbolos.COLCHETE_DIREITO
-                )
-            ) {
+            while (!this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.COLCHETE_DIREITO)) {
                 const valor = this.atribuir();
                 valores.push(valor);
-                if (
-                    this.simbolos[this.atual].tipo !==
-                    tiposDeSimbolos.COLCHETE_DIREITO
-                ) {
-                    this.consumir(
-                        tiposDeSimbolos.VIRGULA,
-                        'Esperado vírgula antes da próxima expressão.'
-                    );
+                if (this.simbolos[this.atual].tipo !== tiposDeSimbolos.COLCHETE_DIREITO) {
+                    this.consumir(tiposDeSimbolos.VIRGULA, 'Esperado vírgula antes da próxima expressão.');
                 }
             }
 
-            return new Vetor(
-                this.hashArquivo,
-                Number(simboloAtual.linha),
-                valores
-            );
+            return new Vetor(this.hashArquivo, Number(simboloAtual.linha), valores);
         }
 
-        if (
-            this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.CHAVE_ESQUERDA)
-        ) {
+        if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.CHAVE_ESQUERDA)) {
             const chaves = [];
             const valores = [];
 
-            if (
-                this.verificarSeSimboloAtualEIgualA(
-                    tiposDeSimbolos.CHAVE_DIREITA
-                )
-            ) {
-                return new Dicionario(
-                    this.hashArquivo,
-                    Number(simboloAtual.linha),
-                    [],
-                    []
-                );
+            if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.CHAVE_DIREITA)) {
+                return new Dicionario(this.hashArquivo, Number(simboloAtual.linha), [], []);
             }
 
-            while (
-                !this.verificarSeSimboloAtualEIgualA(
-                    tiposDeSimbolos.CHAVE_DIREITA
-                )
-            ) {
+            while (!this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.CHAVE_DIREITA)) {
                 const chave = this.atribuir();
-                this.consumir(
-                    tiposDeSimbolos.DOIS_PONTOS,
-                    "Esperado ':' entre chave e valor."
-                );
+                this.consumir(tiposDeSimbolos.DOIS_PONTOS, "Esperado ':' entre chave e valor.");
                 const valor = this.atribuir();
 
                 chaves.push(chave);
                 valores.push(valor);
 
-                if (
-                    this.simbolos[this.atual].tipo !==
-                    tiposDeSimbolos.CHAVE_DIREITA
-                ) {
-                    this.consumir(
-                        tiposDeSimbolos.VIRGULA,
-                        'Esperado vírgula antes da próxima expressão.'
-                    );
+                if (this.simbolos[this.atual].tipo !== tiposDeSimbolos.CHAVE_DIREITA) {
+                    this.consumir(tiposDeSimbolos.VIRGULA, 'Esperado vírgula antes da próxima expressão.');
                 }
             }
 
-            return new Dicionario(
-                this.hashArquivo,
-                Number(simboloAtual.linha),
-                chaves,
-                valores
-            );
+            return new Dicionario(this.hashArquivo, Number(simboloAtual.linha), chaves, valores);
         }
 
-        if (
-            this.verificarSeSimboloAtualEIgualA(
-                tiposDeSimbolos.FUNÇÃO,
-                tiposDeSimbolos.FUNCAO
-            )
-        )
+        if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.FUNÇÃO, tiposDeSimbolos.FUNCAO))
             return this.corpoDaFuncao(this.simbolos[this.atual - 1].lexema);
         if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.FALSO))
-            return new Literal(
-                this.hashArquivo,
-                Number(simboloAtual.linha),
-                false
-            );
+            return new Literal(this.hashArquivo, Number(simboloAtual.linha), false);
         if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.VERDADEIRO))
-            return new Literal(
-                this.hashArquivo,
-                Number(simboloAtual.linha),
-                true
-            );
+            return new Literal(this.hashArquivo, Number(simboloAtual.linha), true);
         if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.NULO))
-            return new Literal(
-                this.hashArquivo,
-                Number(simboloAtual.linha),
-                null
-            );
+            return new Literal(this.hashArquivo, Number(simboloAtual.linha), null);
         if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.ISTO))
-            return new Isto(
-                this.hashArquivo,
-                Number(simboloAtual.linha),
-                this.simbolos[this.atual - 1]
-            );
+            return new Isto(this.hashArquivo, Number(simboloAtual.linha), this.simbolos[this.atual - 1]);
 
-        if (
-            this.verificarSeSimboloAtualEIgualA(
-                tiposDeSimbolos.NUMERO,
-                tiposDeSimbolos.TEXTO
-            )
-        ) {
-            const simboloAnterior: SimboloInterface =
-                this.simbolos[this.atual - 1];
-            return new Literal(
-                this.hashArquivo,
-                Number(simboloAnterior.linha),
-                simboloAnterior.literal
-            );
+        if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.NUMERO, tiposDeSimbolos.TEXTO)) {
+            const simboloAnterior: SimboloInterface = this.simbolos[this.atual - 1];
+            return new Literal(this.hashArquivo, Number(simboloAnterior.linha), simboloAnterior.literal);
         }
 
-        if (
-            this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.IDENTIFICADOR)
-        ) {
-            return new Variavel(
-                this.hashArquivo,
-                this.simbolos[this.atual - 1]
-            );
+        if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.IDENTIFICADOR)) {
+            return new Variavel(this.hashArquivo, this.simbolos[this.atual - 1]);
         }
 
-        if (
-            this.verificarSeSimboloAtualEIgualA(
-                tiposDeSimbolos.PARENTESE_ESQUERDO
-            )
-        ) {
+        if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.PARENTESE_ESQUERDO)) {
             const expressao = this.expressao();
-            this.consumir(
-                tiposDeSimbolos.PARENTESE_DIREITO,
-                "Esperado ')' após a expressão."
-            );
-
-            return new Agrupamento(
-                this.hashArquivo,
-                Number(simboloAtual.linha),
-                expressao
-            );
+            this.consumir(tiposDeSimbolos.PARENTESE_DIREITO, "Esperado ')' após a expressão.");
+
+            return new Agrupamento(this.hashArquivo, Number(simboloAtual.linha), expressao);
         }
 
-        if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.IMPORTAR))
-            return this.declaracaoImportar();
+        if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.IMPORTAR)) return this.declaracaoImportar();
 
         throw this.erro(this.simbolos[this.atual], 'Esperado expressão.');
     }
@@ -319,69 +205,36 @@ export class AvaliadorSintatico implements AvaliadorSintaticoInterface {
     finalizarChamada(entidadeChamada: Construto): Construto {
         const argumentos: Array<Construto> = [];
 
-        if (
-            !this.verificarTipoSimboloAtual(tiposDeSimbolos.PARENTESE_DIREITO)
-        ) {
+        if (!this.verificarTipoSimboloAtual(tiposDeSimbolos.PARENTESE_DIREITO)) {
             do {
                 if (argumentos.length >= 255) {
-                    throw this.erro(
-                        this.simbolos[this.atual],
-                        'Não pode haver mais de 255 argumentos.'
-                    );
+                    throw this.erro(this.simbolos[this.atual], 'Não pode haver mais de 255 argumentos.');
                 }
                 argumentos.push(this.expressao());
-            } while (
-                this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.VIRGULA)
-            );
+            } while (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.VIRGULA));
         }
 
-        const parenteseDireito = this.consumir(
-            tiposDeSimbolos.PARENTESE_DIREITO,
-            "Esperado ')' após os argumentos."
-        );
+        const parenteseDireito = this.consumir(tiposDeSimbolos.PARENTESE_DIREITO, "Esperado ')' após os argumentos.");
 
-        return new Chamada(
-            this.hashArquivo,
-            entidadeChamada,
-            parenteseDireito,
-            argumentos
-        );
+        return new Chamada(this.hashArquivo, entidadeChamada, parenteseDireito, argumentos);
     }
 
     chamar(): Construto {
         let expressao = this.primario();
 
         while (true) {
-            if (
-                this.verificarSeSimboloAtualEIgualA(
-                    tiposDeSimbolos.PARENTESE_ESQUERDO
-                )
-            ) {
+            if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.PARENTESE_ESQUERDO)) {
                 expressao = this.finalizarChamada(expressao);
-            } else if (
-                this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.PONTO)
-            ) {
-                const nome = this.consumir(
-                    tiposDeSimbolos.IDENTIFICADOR,
-                    "Esperado nome do método após '.'."
-                );
+            } else if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.PONTO)) {
+                const nome = this.consumir(tiposDeSimbolos.IDENTIFICADOR, "Esperado nome do método após '.'.");
                 expressao = new AcessoMetodo(this.hashArquivo, expressao, nome);
-            } else if (
-                this.verificarSeSimboloAtualEIgualA(
-                    tiposDeSimbolos.COLCHETE_ESQUERDO
-                )
-            ) {
+            } else if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.COLCHETE_ESQUERDO)) {
                 const indice = this.expressao();
                 const simboloFechamento = this.consumir(
                     tiposDeSimbolos.COLCHETE_DIREITO,
                     "Esperado ']' após escrita do indice."
                 );
-                expressao = new AcessoIndiceVariavel(
-                    this.hashArquivo,
-                    expressao,
-                    indice,
-                    simboloFechamento
-                );
+                expressao = new AcessoIndiceVariavel(this.hashArquivo, expressao, indice, simboloFechamento);
             } else {
                 break;
             }
@@ -409,17 +262,10 @@ export class AvaliadorSintatico implements AvaliadorSintaticoInterface {
     exponenciacao(): Construto {
         let expressao = this.unario();
 
-        while (
-            this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.EXPONENCIACAO)
-        ) {
+        while (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.EXPONENCIACAO)) {
             const operador = this.simbolos[this.atual - 1];
             const direito = this.unario();
-            expressao = new Binario(
-                this.hashArquivo,
-                expressao,
-                operador,
-                direito
-            );
+            expressao = new Binario(this.hashArquivo, expressao, operador, direito);
         }
 
         return expressao;
@@ -440,12 +286,7 @@ export class AvaliadorSintatico implements AvaliadorSintaticoInterface {
         ) {
             const operador = this.simbolos[this.atual - 1];
             const direito = this.exponenciacao();
-            expressao = new Binario(
-                this.hashArquivo,
-                expressao,
-                operador,
-                direito
-            );
+            expressao = new Binario(this.hashArquivo, expressao, operador, direito);
         }
 
         return expressao;
@@ -469,12 +310,7 @@ export class AvaliadorSintatico implements AvaliadorSintaticoInterface {
         ) {
             const operador = this.simbolos[this.atual - 1];
             const direito = this.multiplicar();
-            expressao = new Binario(
-                this.hashArquivo,
-                expressao,
-                operador,
-                direito
-            );
+            expressao = new Binario(this.hashArquivo, expressao, operador, direito);
         }
 
         return expressao;
@@ -483,20 +319,10 @@ export class AvaliadorSintatico implements AvaliadorSintaticoInterface {
     bitFill(): Construto {
         let expressao = this.adicaoOuSubtracao();
 
-        while (
-            this.verificarSeSimboloAtualEIgualA(
-                tiposDeSimbolos.MENOR_MENOR,
-                tiposDeSimbolos.MAIOR_MAIOR
-            )
-        ) {
+        while (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.MENOR_MENOR, tiposDeSimbolos.MAIOR_MAIOR)) {
             const operador = this.simbolos[this.atual - 1];
             const direito = this.adicaoOuSubtracao();
-            expressao = new Binario(
-                this.hashArquivo,
-                expressao,
-                operador,
-                direito
-            );
+            expressao = new Binario(this.hashArquivo, expressao, operador, direito);
         }
 
         return expressao;
@@ -508,12 +334,7 @@ export class AvaliadorSintatico implements AvaliadorSintaticoInterface {
         while (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.BIT_AND)) {
             const operador = this.simbolos[this.atual - 1];
             const direito = this.bitFill();
-            expressao = new Binario(
-                this.hashArquivo,
-                expressao,
-                operador,
-                direito
-            );
+            expressao = new Binario(this.hashArquivo, expressao, operador, direito);
         }
 
         return expressao;
@@ -522,20 +343,10 @@ export class AvaliadorSintatico implements AvaliadorSintaticoInterface {
     bitOu(): Construto {
         let expressao = this.bitE();
 
-        while (
-            this.verificarSeSimboloAtualEIgualA(
-                tiposDeSimbolos.BIT_OR,
-                tiposDeSimbolos.BIT_XOR
-            )
-        ) {
+        while (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.BIT_OR, tiposDeSimbolos.BIT_XOR)) {
             const operador = this.simbolos[this.atual - 1];
             const direito = this.bitE();
-            expressao = new Binario(
-                this.hashArquivo,
-                expressao,
-                operador,
-                direito
-            );
+            expressao = new Binario(this.hashArquivo, expressao, operador, direito);
         }
 
         return expressao;
@@ -554,12 +365,7 @@ export class AvaliadorSintatico implements AvaliadorSintaticoInterface {
         ) {
             const operador = this.simbolos[this.atual - 1];
             const direito = this.bitOu();
-            expressao = new Binario(
-                this.hashArquivo,
-                expressao,
-                operador,
-                direito
-            );
+            expressao = new Binario(this.hashArquivo, expressao, operador, direito);
         }
 
         return expressao;
@@ -568,20 +374,10 @@ export class AvaliadorSintatico implements AvaliadorSintaticoInterface {
     comparacaoIgualdade(): Construto {
         let expressao = this.comparar();
 
-        while (
-            this.verificarSeSimboloAtualEIgualA(
-                tiposDeSimbolos.DIFERENTE,
-                tiposDeSimbolos.IGUAL_IGUAL
-            )
-        ) {
+        while (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.DIFERENTE, tiposDeSimbolos.IGUAL_IGUAL)) {
             const operador = this.simbolos[this.atual - 1];
             const direito = this.comparar();
-            expressao = new Binario(
-                this.hashArquivo,
-                expressao,
-                operador,
-                direito
-            );
+            expressao = new Binario(this.hashArquivo, expressao, operador, direito);
         }
 
         return expressao;
@@ -593,12 +389,7 @@ export class AvaliadorSintatico implements AvaliadorSintaticoInterface {
         while (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.EM)) {
             const operador = this.simbolos[this.atual - 1];
             const direito = this.comparacaoIgualdade();
-            expressao = new Logico(
-                this.hashArquivo,
-                expressao,
-                operador,
-                direito
-            );
+            expressao = new Logico(this.hashArquivo, expressao, operador, direito);
         }
 
         return expressao;
@@ -610,12 +401,7 @@ export class AvaliadorSintatico implements AvaliadorSintaticoInterface {
         while (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.E)) {
             const operador = this.simbolos[this.atual - 1];
             const direito = this.em();
-            expressao = new Logico(
-                this.hashArquivo,
-                expressao,
-                operador,
-                direito
-            );
+            expressao = new Logico(this.hashArquivo, expressao, operador, direito);
         }
 
         return expressao;
@@ -627,12 +413,7 @@ export class AvaliadorSintatico implements AvaliadorSintaticoInterface {
         while (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.OU)) {
             const operador = this.simbolos[this.atual - 1];
             const direito = this.e();
-            expressao = new Logico(
-                this.hashArquivo,
-                expressao,
-                operador,
-                direito
-            );
+            expressao = new Logico(this.hashArquivo, expressao, operador, direito);
         }
 
         return expressao;
@@ -655,11 +436,7 @@ export class AvaliadorSintatico implements AvaliadorSintaticoInterface {
                 tiposDeSimbolos.MODULO_IGUAL,
             ].includes(expressao.operador.tipo)
         ) {
-            return new Atribuir(
-                this.hashArquivo,
-                expressao.esquerda.simbolo,
-                expressao
-            );
+            return new Atribuir(this.hashArquivo, expressao.esquerda.simbolo, expressao);
         } else if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.IGUAL)) {
             const igual = this.simbolos[this.atual - 1];
             const valor = this.atribuir();
@@ -669,13 +446,8 @@ export class AvaliadorSintatico implements AvaliadorSintaticoInterface {
                 return new Atribuir(this.hashArquivo, simbolo, valor);
             } else if (expressao instanceof AcessoMetodo) {
                 const get = expressao;
-                return new DefinirValor(
-                    this.hashArquivo,
-                    0,
-                    get.objeto,
-                    get.simbolo,
-                    valor
-                );
+                // return new Conjunto(this.hashArquivo, 0, get.objeto, get.simbolo, valor);
+                return new DefinirValor(this.hashArquivo, 0, get.objeto, get.simbolo, valor);
             } else if (expressao instanceof AcessoIndiceVariavel) {
                 return new AtribuicaoSobrescrita(
                     this.hashArquivo,
@@ -692,18 +464,14 @@ export class AvaliadorSintatico implements AvaliadorSintaticoInterface {
     }
 
     expressao(): Construto {
-        if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.LEIA))
-            return this.declaracaoLeia();
+        if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.LEIA)) return this.declaracaoLeia();
         return this.atribuir();
     }
 
     declaracaoEscreva(): Escreva {
         const simboloAtual = this.simbolos[this.atual];
 
-        this.consumir(
-            tiposDeSimbolos.PARENTESE_ESQUERDO,
-            "Esperado '(' antes dos valores em escreva."
-        );
+        this.consumir(tiposDeSimbolos.PARENTESE_ESQUERDO, "Esperado '(' antes dos valores em escreva.");
 
         const argumentos: Construto[] = [];
 
@@ -711,16 +479,9 @@ export class AvaliadorSintatico implements AvaliadorSintaticoInterface {
             argumentos.push(this.expressao());
         } while (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.VIRGULA));
 
-        this.consumir(
-            tiposDeSimbolos.PARENTESE_DIREITO,
-            "Esperado ')' após os valores em escreva."
-        );
+        this.consumir(tiposDeSimbolos.PARENTESE_DIREITO, "Esperado ')' após os valores em escreva.");
 
-        return new Escreva(
-            Number(simboloAtual.linha),
-            simboloAtual.hashArquivo,
-            argumentos
-        );
+        return new Escreva(Number(simboloAtual.linha), simboloAtual.hashArquivo, argumentos);
     }
 
     declaracaoExpressao(): Expressao {
@@ -731,10 +492,7 @@ export class AvaliadorSintatico implements AvaliadorSintaticoInterface {
     declaracaoLeia(): Leia {
         const simboloAtual = this.simbolos[this.atual];
 
-        this.consumir(
-            tiposDeSimbolos.PARENTESE_ESQUERDO,
-            "Esperado '(' antes dos valores em leia."
-        );
+        this.consumir(tiposDeSimbolos.PARENTESE_ESQUERDO, "Esperado '(' antes dos valores em leia.");
 
         const argumentos: Construto[] = [];
 
@@ -742,10 +500,7 @@ export class AvaliadorSintatico implements AvaliadorSintaticoInterface {
             argumentos.push(this.expressao());
         } while (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.VIRGULA));
 
-        this.consumir(
-            tiposDeSimbolos.PARENTESE_DIREITO,
-            "Esperado ')' após os valores em leia."
-        );
+        this.consumir(tiposDeSimbolos.PARENTESE_DIREITO, "Esperado ')' após os valores em leia.");
 
         return new Leia(simboloAtual.hashArquivo, Number(simboloAtual.linha), argumentos);
     }
@@ -753,49 +508,26 @@ export class AvaliadorSintatico implements AvaliadorSintaticoInterface {
     blocoEscopo(): Array<RetornoDeclaracao> {
         const declaracoes: Array<RetornoDeclaracao> = [];
 
-        while (
-            !this.verificarTipoSimboloAtual(tiposDeSimbolos.CHAVE_DIREITA) &&
-            !this.estaNoFinal()
-        ) {
+        while (!this.verificarTipoSimboloAtual(tiposDeSimbolos.CHAVE_DIREITA) && !this.estaNoFinal()) {
             declaracoes.push(this.declaracao());
         }
 
-        this.consumir(
-            tiposDeSimbolos.CHAVE_DIREITA,
-            "Esperado '}' após o bloco."
-        );
+        this.consumir(tiposDeSimbolos.CHAVE_DIREITA, "Esperado '}' após o bloco.");
         return declaracoes;
     }
 
     declaracaoSe(): Se {
-        this.consumir(
-            tiposDeSimbolos.PARENTESE_ESQUERDO,
-            "Esperado '(' após 'se'."
-        );
+        this.consumir(tiposDeSimbolos.PARENTESE_ESQUERDO, "Esperado '(' após 'se'.");
         const condicao = this.expressao();
-        this.consumir(
-            tiposDeSimbolos.PARENTESE_DIREITO,
-            "Esperado ')' após condição do se."
-        );
+        this.consumir(tiposDeSimbolos.PARENTESE_DIREITO, "Esperado ')' após condição do se.");
 
         const caminhoEntao = this.resolverDeclaracao();
 
         const caminhosSeSenao = [];
-        while (
-            this.verificarSeSimboloAtualEIgualA(
-                tiposDeSimbolos.SENAOSE,
-                tiposDeSimbolos.SENÃOSE
-            )
-        ) {
-            this.consumir(
-                tiposDeSimbolos.PARENTESE_ESQUERDO,
-                "Esperado '(' após 'senaose' ou 'senãose'."
-            );
+        while (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.SENAOSE, tiposDeSimbolos.SENÃOSE)) {
+            this.consumir(tiposDeSimbolos.PARENTESE_ESQUERDO, "Esperado '(' após 'senaose' ou 'senãose'.");
             const condicaoSeSenao = this.expressao();
-            this.consumir(
-                tiposDeSimbolos.PARENTESE_DIREITO,
-                "Esperado ')' após codição do 'senaose' ou 'senãose'."
-            );
+            this.consumir(tiposDeSimbolos.PARENTESE_DIREITO, "Esperado ')' após codição do 'senaose' ou 'senãose'.");
 
             const caminho = this.resolverDeclaracao();
 
@@ -806,12 +538,7 @@ export class AvaliadorSintatico implements AvaliadorSintaticoInterface {
         }
 
         let caminhoSenao = null;
-        if (
-            this.verificarSeSimboloAtualEIgualA(
-                tiposDeSimbolos.SENAO,
-                tiposDeSimbolos.SENÃO
-            )
-        ) {
+        if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.SENAO, tiposDeSimbolos.SENÃO)) {
             caminhoSenao = this.resolverDeclaracao();
         }
 
@@ -820,103 +547,66 @@ export class AvaliadorSintatico implements AvaliadorSintaticoInterface {
 
     declaracaoEnquanto(): Enquanto {
         try {
-            this.ciclos += 1;
+            this.blocos += 1;
 
-            this.consumir(
-                tiposDeSimbolos.PARENTESE_ESQUERDO,
-                "Esperado '(' após 'enquanto'."
-            );
+            this.consumir(tiposDeSimbolos.PARENTESE_ESQUERDO, "Esperado '(' após 'enquanto'.");
             const condicao = this.expressao();
-            this.consumir(
-                tiposDeSimbolos.PARENTESE_DIREITO,
-                "Esperado ')' após condicional."
-            );
+            this.consumir(tiposDeSimbolos.PARENTESE_DIREITO, "Esperado ')' após condicional.");
             const corpo = this.resolverDeclaracao();
 
             return new Enquanto(condicao, corpo);
         } finally {
-            this.ciclos -= 1;
+            this.blocos -= 1;
         }
     }
 
     declaracaoPara(): Para {
         try {
             const simboloPara: SimboloInterface = this.simbolos[this.atual - 1];
-            this.ciclos += 1;
+            this.blocos += 1;
 
-            this.consumir(
-                tiposDeSimbolos.PARENTESE_ESQUERDO,
-                "Esperado '(' após 'para'."
-            );
+            this.consumir(tiposDeSimbolos.PARENTESE_ESQUERDO, "Esperado '(' após 'para'.");
 
             let inicializador: Var | Expressao;
-            if (
-                this.verificarSeSimboloAtualEIgualA(
-                    tiposDeSimbolos.PONTO_E_VIRGULA
-                )
-            ) {
+            if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.PONTO_E_VIRGULA)) {
                 inicializador = null;
-            } else if (
-                this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.VARIAVEL)
-            ) {
+            } else if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.VARIAVEL)) {
                 inicializador = this.declaracaoDeVariavel();
             } else {
                 inicializador = this.declaracaoExpressao();
             }
 
             let condicao = null;
-            if (
-                !this.verificarTipoSimboloAtual(tiposDeSimbolos.PONTO_E_VIRGULA)
-            ) {
+            if (!this.verificarTipoSimboloAtual(tiposDeSimbolos.PONTO_E_VIRGULA)) {
                 condicao = this.expressao();
             }
 
             let incrementar = null;
-            if (
-                !this.verificarTipoSimboloAtual(
-                    tiposDeSimbolos.PARENTESE_DIREITO
-                )
-            ) {
+            if (!this.verificarTipoSimboloAtual(tiposDeSimbolos.PARENTESE_DIREITO)) {
                 incrementar = this.expressao();
             }
 
-            this.consumir(
-                tiposDeSimbolos.PARENTESE_DIREITO,
-                "Esperado ')' após cláusulas"
-            );
+            this.consumir(tiposDeSimbolos.PARENTESE_DIREITO, "Esperado ')' após cláusulas");
 
             const corpo = this.resolverDeclaracao();
 
-            return new Para(
-                this.hashArquivo,
-                Number(simboloPara.linha),
-                inicializador,
-                condicao,
-                incrementar,
-                corpo
-            );
+            return new Para(this.hashArquivo, Number(simboloPara.linha), inicializador, condicao, incrementar, corpo);
         } finally {
-            this.ciclos -= 1;
+            this.blocos -= 1;
         }
     }
 
     declaracaoSustar(): Sustar {
-        if (this.ciclos < 1) {
-            this.erro(
-                this.simbolos[this.atual - 1],
-                "'sustar' ou 'pausa' deve estar dentro de um laço de repetição."
-            );
+        if (this.blocos < 1) {
+            this.erro(this.simbolos[this.atual - 1], "'sustar' ou 'pausa' deve estar dentro de um laço de repetição.");
         }
 
         return new Sustar(this.simbolos[this.atual]);
     }
 
     declaracaoContinua(): Continua {
-        if (this.ciclos < 1) {
-            this.erro(
-                this.simbolos[this.atual - 1],
-                "'continua' precisa estar em um laço de repetição."
-            );
+        if (this.blocos < 1) {
+            this.erro(this.simbolos[this.atual - 1], "'continua' precisa estar em um laço de repetição.");
         }
 
         return new Continua(this.simbolos[this.atual]);
@@ -935,46 +625,24 @@ export class AvaliadorSintatico implements AvaliadorSintaticoInterface {
 
     declaracaoEscolha(): Escolha {
         try {
-            this.ciclos += 1;
+            this.blocos += 1;
 
-            this.consumir(
-                tiposDeSimbolos.PARENTESE_ESQUERDO,
-                "Esperado '{' após 'escolha'."
-            );
+            this.consumir(tiposDeSimbolos.PARENTESE_ESQUERDO, "Esperado '{' após 'escolha'.");
             const condicao = this.expressao();
-            this.consumir(
-                tiposDeSimbolos.PARENTESE_DIREITO,
-                "Esperado '}' após a condição de 'escolha'."
-            );
-            this.consumir(
-                tiposDeSimbolos.CHAVE_ESQUERDA,
-                "Esperado '{' antes do escopo do 'escolha'."
-            );
+            this.consumir(tiposDeSimbolos.PARENTESE_DIREITO, "Esperado '}' após a condição de 'escolha'.");
+            this.consumir(tiposDeSimbolos.CHAVE_ESQUERDA, "Esperado '{' antes do escopo do 'escolha'.");
 
             const caminhos = [];
             let caminhoPadrao = null;
-            while (
-                !this.verificarSeSimboloAtualEIgualA(
-                    tiposDeSimbolos.CHAVE_DIREITA
-                ) &&
-                !this.estaNoFinal()
-            ) {
+            while (!this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.CHAVE_DIREITA) && !this.estaNoFinal()) {
                 if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.CASO)) {
                     const caminhoCondicoes = [this.expressao()];
-                    this.consumir(
-                        tiposDeSimbolos.DOIS_PONTOS,
-                        "Esperado ':' após o 'caso'."
-                    );
+                    this.consumir(tiposDeSimbolos.DOIS_PONTOS, "Esperado ':' após o 'caso'.");
 
-                    while (
-                        this.verificarTipoSimboloAtual(tiposDeSimbolos.CASO)
-                    ) {
+                    while (this.verificarTipoSimboloAtual(tiposDeSimbolos.CASO)) {
                         this.consumir(tiposDeSimbolos.CASO, null);
                         caminhoCondicoes.push(this.expressao());
-                        this.consumir(
-                            tiposDeSimbolos.DOIS_PONTOS,
-                            "Esperado ':' após declaração do 'caso'."
-                        );
+                        this.consumir(tiposDeSimbolos.DOIS_PONTOS, "Esperado ':' após declaração do 'caso'.");
                     }
 
                     const declaracoes = [];
@@ -982,21 +650,15 @@ export class AvaliadorSintatico implements AvaliadorSintaticoInterface {
                         declaracoes.push(this.resolverDeclaracao());
                     } while (
                         !this.verificarTipoSimboloAtual(tiposDeSimbolos.CASO) &&
-                        !this.verificarTipoSimboloAtual(
-                            tiposDeSimbolos.PADRAO
-                        ) &&
-                        !this.verificarTipoSimboloAtual(
-                            tiposDeSimbolos.CHAVE_DIREITA
-                        )
+                        !this.verificarTipoSimboloAtual(tiposDeSimbolos.PADRAO) &&
+                        !this.verificarTipoSimboloAtual(tiposDeSimbolos.CHAVE_DIREITA)
                     );
 
                     caminhos.push({
                         condicoes: caminhoCondicoes,
                         declaracoes,
                     });
-                } else if (
-                    this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.PADRAO)
-                ) {
+                } else if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.PADRAO)) {
                     if (caminhoPadrao !== null) {
                         const excecao = new ErroAvaliadorSintatico(
                             this.simbolos[this.atual],
@@ -1006,22 +668,15 @@ export class AvaliadorSintatico implements AvaliadorSintaticoInterface {
                         throw excecao;
                     }
 
-                    this.consumir(
-                        tiposDeSimbolos.DOIS_PONTOS,
-                        "Esperado ':' após declaração do 'padrao'."
-                    );
+                    this.consumir(tiposDeSimbolos.DOIS_PONTOS, "Esperado ':' após declaração do 'padrao'.");
 
                     const declaracoes = [];
                     do {
                         declaracoes.push(this.resolverDeclaracao());
                     } while (
                         !this.verificarTipoSimboloAtual(tiposDeSimbolos.CASO) &&
-                        !this.verificarTipoSimboloAtual(
-                            tiposDeSimbolos.PADRAO
-                        ) &&
-                        !this.verificarTipoSimboloAtual(
-                            tiposDeSimbolos.CHAVE_DIREITA
-                        )
+                        !this.verificarTipoSimboloAtual(tiposDeSimbolos.PADRAO) &&
+                        !this.verificarTipoSimboloAtual(tiposDeSimbolos.CHAVE_DIREITA)
                     );
 
                     caminhoPadrao = {
@@ -1032,66 +687,43 @@ export class AvaliadorSintatico implements AvaliadorSintaticoInterface {
 
             return new Escolha(condicao, caminhos, caminhoPadrao);
         } finally {
-            this.ciclos -= 1;
+            this.blocos -= 1;
         }
     }
 
     declaracaoImportar(): Importar {
-        this.consumir(
-            tiposDeSimbolos.PARENTESE_ESQUERDO,
-            "Esperado '(' após declaração."
-        );
+        this.consumir(tiposDeSimbolos.PARENTESE_ESQUERDO, "Esperado '(' após declaração.");
 
         const caminho = this.expressao();
 
-        const simboloFechamento = this.consumir(
-            tiposDeSimbolos.PARENTESE_DIREITO,
-            "Esperado ')' após declaração."
-        );
+        const simboloFechamento = this.consumir(tiposDeSimbolos.PARENTESE_DIREITO, "Esperado ')' após declaração.");
 
         return new Importar(caminho as Literal, simboloFechamento);
     }
 
     declaracaoTente(): Tente {
         const simboloTente: SimboloInterface = this.simbolos[this.atual - 1];
-        this.consumir(
-            tiposDeSimbolos.CHAVE_ESQUERDA,
-            "Esperado '{' após a declaração 'tente'."
-        );
+        this.consumir(tiposDeSimbolos.CHAVE_ESQUERDA, "Esperado '{' após a declaração 'tente'.");
 
         const blocoTente = this.blocoEscopo();
 
         let blocoPegue = null;
         if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.PEGUE)) {
-            this.consumir(
-                tiposDeSimbolos.CHAVE_ESQUERDA,
-                "Esperado '{' após a declaração 'pegue'."
-            );
+            this.consumir(tiposDeSimbolos.CHAVE_ESQUERDA, "Esperado '{' após a declaração 'pegue'.");
 
             blocoPegue = this.blocoEscopo();
         }
 
         let blocoSenao = null;
-        if (
-            this.verificarSeSimboloAtualEIgualA(
-                tiposDeSimbolos.SENAO,
-                tiposDeSimbolos.SENÃO
-            )
-        ) {
-            this.consumir(
-                tiposDeSimbolos.CHAVE_ESQUERDA,
-                "Esperado '{' após a declaração 'pegue'."
-            );
+        if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.SENAO, tiposDeSimbolos.SENÃO)) {
+            this.consumir(tiposDeSimbolos.CHAVE_ESQUERDA, "Esperado '{' após a declaração 'pegue'.");
 
             blocoSenao = this.blocoEscopo();
         }
 
         let blocoFinalmente = null;
         if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.FINALMENTE)) {
-            this.consumir(
-                tiposDeSimbolos.CHAVE_ESQUERDA,
-                "Esperado '{' após a declaração 'pegue'."
-            );
+            this.consumir(tiposDeSimbolos.CHAVE_ESQUERDA, "Esperado '{' após a declaração 'pegue'.");
 
             blocoFinalmente = this.blocoEscopo();
         }
@@ -1109,70 +741,37 @@ export class AvaliadorSintatico implements AvaliadorSintaticoInterface {
     declaracaoFazer(): Fazer {
         const simboloFazer: SimboloInterface = this.simbolos[this.atual - 1];
         try {
-            this.ciclos += 1;
+            this.blocos += 1;
 
             const caminhoFazer = this.resolverDeclaracao();
 
-            this.consumir(
-                tiposDeSimbolos.ENQUANTO,
-                "Esperado declaração do 'enquanto' após o escopo do 'fazer'."
-            );
-            this.consumir(
-                tiposDeSimbolos.PARENTESE_ESQUERDO,
-                "Esperado '(' após declaração 'enquanto'."
-            );
+            this.consumir(tiposDeSimbolos.ENQUANTO, "Esperado declaração do 'enquanto' após o escopo do 'fazer'.");
+            this.consumir(tiposDeSimbolos.PARENTESE_ESQUERDO, "Esperado '(' após declaração 'enquanto'.");
 
             const condicaoEnquanto = this.expressao();
 
-            this.consumir(
-                tiposDeSimbolos.PARENTESE_DIREITO,
-                "Esperado ')' após declaração do 'enquanto'."
-            );
-
-            return new Fazer(
-                simboloFazer.hashArquivo,
-                Number(simboloFazer.linha),
-                caminhoFazer,
-                condicaoEnquanto
-            );
+            this.consumir(tiposDeSimbolos.PARENTESE_DIREITO, "Esperado ')' após declaração do 'enquanto'.");
+
+            return new Fazer(simboloFazer.hashArquivo, Number(simboloFazer.linha), caminhoFazer, condicaoEnquanto);
         } finally {
-            this.ciclos -= 1;
+            this.blocos -= 1;
         }
     }
 
     resolverDeclaracao(): RetornoResolverDeclaracao {
-        if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.FAZER))
-            return this.declaracaoFazer();
-        if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.TENTE))
-            return this.declaracaoTente();
-        if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.ESCOLHA))
-            return this.declaracaoEscolha();
-        if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.RETORNA))
-            return this.declaracaoRetorna();
-        if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.CONTINUA))
-            return this.declaracaoContinua();
-        if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.PAUSA))
-            return this.declaracaoSustar();
-        if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.PARA))
-            return this.declaracaoPara();
-        if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.ENQUANTO))
-            return this.declaracaoEnquanto();
-        if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.SE))
-            return this.declaracaoSe();
-        if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.ESCREVA))
-            return this.declaracaoEscreva();
-        if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.LEIA))
-            return this.declaracaoLeia();
-        if (
-            this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.CHAVE_ESQUERDA)
-        ) {
-            const simboloInicioBloco: SimboloInterface =
-                this.simbolos[this.atual - 1];
-            return new Bloco(
-                simboloInicioBloco.hashArquivo,
-                Number(simboloInicioBloco.linha),
-                this.blocoEscopo()
-            );
+        if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.FAZER)) return this.declaracaoFazer();
+        if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.TENTE)) return this.declaracaoTente();
+        if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.ESCOLHA)) return this.declaracaoEscolha();
+        if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.RETORNA)) return this.declaracaoRetorna();
+        if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.CONTINUA)) return this.declaracaoContinua();
+        if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.PAUSA)) return this.declaracaoSustar();
+        if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.PARA)) return this.declaracaoPara();
+        if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.ENQUANTO)) return this.declaracaoEnquanto();
+        if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.SE)) return this.declaracaoSe();
+        if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.ESCREVA)) return this.declaracaoEscreva();
+        if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.CHAVE_ESQUERDA)) {
+            const simboloInicioBloco: SimboloInterface = this.simbolos[this.atual - 1];
+            return new Bloco(simboloInicioBloco.hashArquivo, Number(simboloInicioBloco.linha), this.blocoEscopo());
         }
 
         const simboloAtual = this.simbolos[this.atual];
@@ -1202,10 +801,7 @@ export class AvaliadorSintatico implements AvaliadorSintaticoInterface {
      * @returns Um Construto do tipo Var.
      */
     declaracaoDeVariavel(): Var {
-        const simbolo: SimboloInterface = this.consumir(
-            tiposDeSimbolos.IDENTIFICADOR,
-            'Esperado nome de variável.'
-        );
+        const simbolo: SimboloInterface = this.consumir(tiposDeSimbolos.IDENTIFICADOR, 'Esperado nome de variável.');
         let inicializador = null;
         if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.IGUAL)) {
             inicializador = this.expressao();
@@ -1215,10 +811,7 @@ export class AvaliadorSintatico implements AvaliadorSintaticoInterface {
     }
 
     funcao(tipo: string): FuncaoDeclaracao {
-        const simbolo: SimboloInterface = this.consumir(
-            tiposDeSimbolos.IDENTIFICADOR,
-            `Esperado nome ${tipo}.`
-        );
+        const simbolo: SimboloInterface = this.consumir(tiposDeSimbolos.IDENTIFICADOR, `Esperado nome ${tipo}.`);
         return new FuncaoDeclaracao(simbolo, this.corpoDaFuncao(tipo));
     }
 
@@ -1227,27 +820,19 @@ export class AvaliadorSintatico implements AvaliadorSintaticoInterface {
 
         do {
             if (parametros.length >= 255) {
-                this.erro(
-                    this.simbolos[this.atual],
-                    'Não pode haver mais de 255 parâmetros'
-                );
+                this.erro(this.simbolos[this.atual], 'Não pode haver mais de 255 parâmetros');
             }
 
             const parametro: Partial<ParametroInterface> = {};
 
-            if (
-                this.simbolos[this.atual].tipo === tiposDeSimbolos.MULTIPLICACAO
-            ) {
+            if (this.simbolos[this.atual].tipo === tiposDeSimbolos.MULTIPLICACAO) {
                 this.consumir(tiposDeSimbolos.MULTIPLICACAO, null);
                 parametro.tipo = 'estrela';
             } else {
                 parametro.tipo = 'padrao';
             }
 
-            parametro.nome = this.consumir(
-                tiposDeSimbolos.IDENTIFICADOR,
-                'Esperado nome do parâmetro.'
-            );
+            parametro.nome = this.consumir(tiposDeSimbolos.IDENTIFICADOR, 'Esperado nome do parâmetro.');
 
             if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.IGUAL)) {
                 parametro.valorPadrao = this.primario();
@@ -1269,66 +854,35 @@ export class AvaliadorSintatico implements AvaliadorSintaticoInterface {
         );
 
         let parametros = [];
-        if (
-            !this.verificarTipoSimboloAtual(tiposDeSimbolos.PARENTESE_DIREITO)
-        ) {
+        if (!this.verificarTipoSimboloAtual(tiposDeSimbolos.PARENTESE_DIREITO)) {
             parametros = this.logicaComumParametros();
         }
 
-        this.consumir(
-            tiposDeSimbolos.PARENTESE_DIREITO,
-            "Esperado ')' após parâmetros."
-        );
-        this.consumir(
-            tiposDeSimbolos.CHAVE_ESQUERDA,
-            `Esperado '{' antes do escopo do ${tipo}.`
-        );
+        this.consumir(tiposDeSimbolos.PARENTESE_DIREITO, "Esperado ')' após parâmetros.");
+        this.consumir(tiposDeSimbolos.CHAVE_ESQUERDA, `Esperado '{' antes do escopo do ${tipo}.`);
 
         const corpo = this.blocoEscopo();
 
-        return new FuncaoConstruto(
-            this.hashArquivo,
-            Number(parenteseEsquerdo.linha),
-            parametros,
-            corpo
-        );
+        return new FuncaoConstruto(this.hashArquivo, Number(parenteseEsquerdo.linha), parametros, corpo);
     }
 
     declaracaoDeClasse(): Classe {
-        const simbolo: SimboloInterface = this.consumir(
-            tiposDeSimbolos.IDENTIFICADOR,
-            'Esperado nome da classe.'
-        );
+        const simbolo: SimboloInterface = this.consumir(tiposDeSimbolos.IDENTIFICADOR, 'Esperado nome da classe.');
 
         let superClasse = null;
         if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.HERDA)) {
-            this.consumir(
-                tiposDeSimbolos.IDENTIFICADOR,
-                'Esperado nome da SuperClasse.'
-            );
-            superClasse = new Variavel(
-                this.hashArquivo,
-                this.simbolos[this.atual - 1]
-            );
+            this.consumir(tiposDeSimbolos.IDENTIFICADOR, 'Esperado nome da SuperClasse.');
+            superClasse = new Variavel(this.hashArquivo, this.simbolos[this.atual - 1]);
         }
 
-        this.consumir(
-            tiposDeSimbolos.CHAVE_ESQUERDA,
-            "Esperado '{' antes do escopo da classe."
-        );
+        this.consumir(tiposDeSimbolos.CHAVE_ESQUERDA, "Esperado '{' antes do escopo da classe.");
 
         const metodos = [];
-        while (
-            !this.verificarTipoSimboloAtual(tiposDeSimbolos.CHAVE_DIREITA) &&
-            !this.estaNoFinal()
-        ) {
+        while (!this.verificarTipoSimboloAtual(tiposDeSimbolos.CHAVE_DIREITA) && !this.estaNoFinal()) {
             metodos.push(this.funcao('método'));
         }
 
-        this.consumir(
-            tiposDeSimbolos.CHAVE_DIREITA,
-            "Esperado '}' após o escopo da classe."
-        );
+        this.consumir(tiposDeSimbolos.CHAVE_DIREITA, "Esperado '}' após o escopo da classe.");
         return new Classe(simbolo, superClasse, metodos);
     }
 
@@ -1342,10 +896,8 @@ export class AvaliadorSintatico implements AvaliadorSintaticoInterface {
                 this.avancarEDevolverAnterior();
                 return this.funcao('funcao');
             }
-            if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.VARIAVEL))
-                return this.declaracaoDeVariavel();
-            if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.CLASSE))
-                return this.declaracaoDeClasse();
+            if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.VARIAVEL)) return this.declaracaoDeVariavel();
+            if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.CLASSE)) return this.declaracaoDeClasse();
 
             return this.resolverDeclaracao();
         } catch (erro: any) {
@@ -1383,14 +935,11 @@ export class AvaliadorSintatico implements AvaliadorSintaticoInterface {
         }
     }
 
-    analisar(
-        retornoLexador: RetornoLexador,
-        hashArquivo?: number
-    ): RetornoAvaliadorSintatico {
+    analisar(retornoLexador: RetornoLexador, hashArquivo?: number): RetornoAvaliadorSintatico {
         const inicioAnalise: [number, number] = hrtime();
         this.erros = [];
         this.atual = 0;
-        this.ciclos = 0;
+        this.blocos = 0;
 
         this.hashArquivo = hashArquivo || 0;
         this.simbolos = retornoLexador?.simbolos || [];
@@ -1402,11 +951,7 @@ export class AvaliadorSintatico implements AvaliadorSintaticoInterface {
 
         if (this.performance) {
             const deltaAnalise: [number, number] = hrtime(inicioAnalise);
-            console.log(
-                `[Avaliador Sintático] Tempo para análise: ${
-                    deltaAnalise[0] * 1e9 + deltaAnalise[1]
-                }ns`
-            );
+            console.log(`[Avaliador Sintático] Tempo para análise: ${deltaAnalise[0] * 1e9 + deltaAnalise[1]}ns`);
         }
 
         return {
diff --git a/fontes/avaliador-sintatico/dialetos/avaliador-sintatico-birl.ts b/fontes/avaliador-sintatico/dialetos/avaliador-sintatico-birl.ts
new file mode 100644
index 00000000..9d80a142
--- /dev/null
+++ b/fontes/avaliador-sintatico/dialetos/avaliador-sintatico-birl.ts
@@ -0,0 +1,75 @@
+import { Construto, FuncaoConstruto, Literal, Variavel } from '../../construtos';
+import { Escreva, Declaracao, Enquanto, Para, Escolha, Fazer } from '../../declaracoes';
+import { RetornoLexador, RetornoAvaliadorSintatico } from '../../interfaces/retornos';
+import { AvaliadorSintaticoBase } from '../avaliador-sintatico-base';
+import tiposDeSimbolos from '../../tipos-de-simbolos/birl';
+import { SimboloInterface } from '../../interfaces';
+import { ErroAvaliadorSintatico } from '../erro-avaliador-sintatico';
+
+export class AvaliadorSintaticoBirl extends AvaliadorSintaticoBase {
+    validarSegmentoHoraDoShow(): void {
+        this.consumir(tiposDeSimbolos.HORA_DO_SHOW, 'Esperado expressão `HORA DO SHOW` para iniciar o programa');
+        this.blocos += 1;
+    }
+
+    validarSegmentoBirlFinal(): void {
+        this.consumir(tiposDeSimbolos.BIRL, 'Esperado expressão `BIRL` para fechamento do programa');
+        this.blocos -= 1;
+    }
+
+    primario(): Construto {
+        throw new Error('Method not implemented');
+    }
+    chamar(): Construto {
+        return this.primario();
+    }
+    atribuir(): Construto {
+        throw new Error('Method not implemented.');
+    }
+    declaracaoEscreva(): Escreva {
+        throw new Error('Method not implemented.');
+    }
+    blocoEscopo(): Declaracao[] {
+        throw new Error('Method not implemented.');
+    }
+    declaracaoEnquanto(): Enquanto {
+        throw new Error('Method not implemented.');
+    }
+    declaracaoPara(): Para {
+        throw new Error('Method not implemented.');
+    }
+    declaracaoEscolha(): Escolha {
+        throw new Error('Method not implemented.');
+    }
+    declaracaoFazer(): Fazer {
+        throw new Error('Method not implemented.');
+    }
+    corpoDaFuncao(tipo: string): FuncaoConstruto {
+        throw new Error('Method not implemented.');
+    }
+    declaracao(): Declaracao {
+        throw new Error('Method not implemented.');
+    }
+    analisar(retornoLexador: RetornoLexador, hashArquivo?: number): RetornoAvaliadorSintatico {
+        this.blocos = 0;
+
+        // 1 validação
+        if (this.blocos > 0) {
+            throw new ErroAvaliadorSintatico(
+                null,
+                'Quantidade de blocos abertos não corresponde com a quantidade de blocos fechados'
+            );
+        }
+
+        const declaracoes = [];
+
+        this.validarSegmentoHoraDoShow();
+
+        this.validarSegmentoBirlFinal();
+
+        return {
+            declaracoes: declaracoes.filter((d) => d),
+            erros: this.erros,
+        } as RetornoAvaliadorSintatico;
+    }
+}
diff --git a/fontes/avaliador-sintatico/dialetos/avaliador-sintatico-egua-classico.ts b/fontes/avaliador-sintatico/dialetos/avaliador-sintatico-egua-classico.ts
index d112b958..fd05049d 100644
--- a/fontes/avaliador-sintatico/dialetos/avaliador-sintatico-egua-classico.ts
+++ b/fontes/avaliador-sintatico/dialetos/avaliador-sintatico-egua-classico.ts
@@ -1,7 +1,4 @@
-import {
-    AvaliadorSintaticoInterface,
-    SimboloInterface,
-} from '../../interfaces';
+import { AvaliadorSintaticoInterface, SimboloInterface } from '../../interfaces';
 import {
     AtribuicaoSobrescrita,
     Atribuir,
@@ -54,21 +51,19 @@ import tiposDeSimbolos from '../../tipos-de-simbolos/egua-classico';
  * O avaliador sintático (Parser) é responsável por transformar os símbolos do Lexador em estruturas de alto nível.
  * Essas estruturas de alto nível são as partes que executam lógica de programação de fato.
  */
-export class AvaliadorSintaticoEguaClassico
-    implements AvaliadorSintaticoInterface
-{
+export class AvaliadorSintaticoEguaClassico implements AvaliadorSintaticoInterface {
     simbolos: SimboloInterface[];
     erros: ErroAvaliadorSintatico[];
 
     hashArquivo: number;
     atual: number;
-    ciclos: number;
+    blocos: number;
 
     constructor(simbolos?: SimboloInterface[]) {
         this.simbolos = simbolos;
 
         this.atual = 0;
-        this.ciclos = 0;
+        this.blocos = 0;
     }
 
     declaracaoLeia(): Leia {
@@ -79,8 +74,7 @@ export class AvaliadorSintaticoEguaClassico
         this.avancarEDevolverAnterior();
 
         while (!this.estaNoFinal()) {
-            if (this.simboloAnterior().tipo === tiposDeSimbolos.PONTO_E_VIRGULA)
-                return;
+            if (this.simboloAnterior().tipo === tiposDeSimbolos.PONTO_E_VIRGULA) return;
 
             switch (this.simboloAtual().tipo) {
                 case tiposDeSimbolos.CLASSE:
@@ -98,18 +92,14 @@ export class AvaliadorSintaticoEguaClassico
         }
     }
 
-    erro(
-        simbolo: SimboloInterface,
-        mensagemDeErro: string
-    ): ErroAvaliadorSintatico {
+    erro(simbolo: SimboloInterface, mensagemDeErro: string): ErroAvaliadorSintatico {
         const excecao = new ErroAvaliadorSintatico(simbolo, mensagemDeErro);
         this.erros.push(excecao);
         return excecao;
     }
 
     consumir(tipo: string, mensagemDeErro: string): SimboloInterface {
-        if (this.verificarTipoSimboloAtual(tipo))
-            return this.avancarEDevolverAnterior();
+        if (this.verificarTipoSimboloAtual(tipo)) return this.avancarEDevolverAnterior();
         else throw this.erro(this.simboloAtual(), mensagemDeErro);
     }
 
@@ -160,193 +150,99 @@ export class AvaliadorSintaticoEguaClassico
         if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.SUPER)) {
             const simboloChave = this.simboloAnterior();
             this.consumir(tiposDeSimbolos.PONTO, "Esperado '.' após 'super'.");
-            const metodo = this.consumir(
-                tiposDeSimbolos.IDENTIFICADOR,
-                'Esperado nome do método da SuperClasse.'
-            );
+            const metodo = this.consumir(tiposDeSimbolos.IDENTIFICADOR, 'Esperado nome do método da SuperClasse.');
             return new Super(this.hashArquivo, simboloChave, metodo);
         }
-        if (
-            this.verificarSeSimboloAtualEIgualA(
-                tiposDeSimbolos.COLCHETE_ESQUERDO
-            )
-        ) {
+        if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.COLCHETE_ESQUERDO)) {
             const valores = [];
-            if (
-                this.verificarSeSimboloAtualEIgualA(
-                    tiposDeSimbolos.COLCHETE_DIREITO
-                )
-            ) {
+            if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.COLCHETE_DIREITO)) {
                 return new Vetor(this.hashArquivo, 0, []);
             }
-            while (
-                !this.verificarSeSimboloAtualEIgualA(
-                    tiposDeSimbolos.COLCHETE_DIREITO
-                )
-            ) {
+            while (!this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.COLCHETE_DIREITO)) {
                 const valor = this.atribuir();
                 valores.push(valor);
-                if (
-                    this.simboloAtual().tipo !==
-                    tiposDeSimbolos.COLCHETE_DIREITO
-                ) {
-                    this.consumir(
-                        tiposDeSimbolos.VIRGULA,
-                        'Esperado vírgula antes da próxima expressão.'
-                    );
+                if (this.simboloAtual().tipo !== tiposDeSimbolos.COLCHETE_DIREITO) {
+                    this.consumir(tiposDeSimbolos.VIRGULA, 'Esperado vírgula antes da próxima expressão.');
                 }
             }
             return new Vetor(this.hashArquivo, 0, valores);
         }
-        if (
-            this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.CHAVE_ESQUERDA)
-        ) {
+        if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.CHAVE_ESQUERDA)) {
             const chaves = [];
             const valores = [];
-            if (
-                this.verificarSeSimboloAtualEIgualA(
-                    tiposDeSimbolos.CHAVE_DIREITA
-                )
-            ) {
+            if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.CHAVE_DIREITA)) {
                 return new Dicionario(this.hashArquivo, 0, [], []);
             }
-            while (
-                !this.verificarSeSimboloAtualEIgualA(
-                    tiposDeSimbolos.CHAVE_DIREITA
-                )
-            ) {
+            while (!this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.CHAVE_DIREITA)) {
                 const chave = this.atribuir();
-                this.consumir(
-                    tiposDeSimbolos.DOIS_PONTOS,
-                    "Esperado ':' entre chave e valor."
-                );
+                this.consumir(tiposDeSimbolos.DOIS_PONTOS, "Esperado ':' entre chave e valor.");
                 const valor = this.atribuir();
 
                 chaves.push(chave);
                 valores.push(valor);
 
-                if (
-                    this.simboloAtual().tipo !== tiposDeSimbolos.CHAVE_DIREITA
-                ) {
-                    this.consumir(
-                        tiposDeSimbolos.VIRGULA,
-                        'Esperado vírgula antes da próxima expressão.'
-                    );
+                if (this.simboloAtual().tipo !== tiposDeSimbolos.CHAVE_DIREITA) {
+                    this.consumir(tiposDeSimbolos.VIRGULA, 'Esperado vírgula antes da próxima expressão.');
                 }
             }
             return new Dicionario(this.hashArquivo, 0, chaves, valores);
         }
-        if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.FUNÇÃO))
-            return this.corpoDaFuncao('função');
-        if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.FALSO))
-            return new Literal(this.hashArquivo, 0, false);
+        if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.FUNÇÃO)) return this.corpoDaFuncao('função');
+        if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.FALSO)) return new Literal(this.hashArquivo, 0, false);
         if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.VERDADEIRO))
             return new Literal(this.hashArquivo, 0, true);
-        if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.NULO))
-            return new Literal(this.hashArquivo, 0, null);
+        if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.NULO)) return new Literal(this.hashArquivo, 0, null);
         if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.ISTO))
             return new Isto(this.hashArquivo, Number(this.simboloAnterior()));
-        if (
-            this.verificarSeSimboloAtualEIgualA(
-                tiposDeSimbolos.NUMERO,
-                tiposDeSimbolos.TEXTO
-            )
-        ) {
-            return new Literal(
-                this.hashArquivo,
-                0,
-                this.simboloAnterior().literal
-            );
+        if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.NUMERO, tiposDeSimbolos.TEXTO)) {
+            return new Literal(this.hashArquivo, 0, this.simboloAnterior().literal);
         }
-        if (
-            this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.IDENTIFICADOR)
-        ) {
+        if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.IDENTIFICADOR)) {
             return new Variavel(this.hashArquivo, this.simboloAnterior());
         }
-        if (
-            this.verificarSeSimboloAtualEIgualA(
-                tiposDeSimbolos.PARENTESE_ESQUERDO
-            )
-        ) {
+        if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.PARENTESE_ESQUERDO)) {
             const expressao = this.expressao();
-            this.consumir(
-                tiposDeSimbolos.PARENTESE_DIREITO,
-                "Esperado ')' após a expressão."
-            );
+            this.consumir(tiposDeSimbolos.PARENTESE_DIREITO, "Esperado ')' após a expressão.");
 
             return new Agrupamento(this.hashArquivo, 0, expressao);
         }
-        if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.IMPORTAR))
-            return this.declaracaoImportar();
+        if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.IMPORTAR)) return this.declaracaoImportar();
 
         throw this.erro(this.simboloAtual(), 'Esperado expressão.');
     }
 
     finalizarChamada(entidadeChamada: RetornoPrimario): Chamada {
         const argumentos = [];
-        if (
-            !this.verificarTipoSimboloAtual(tiposDeSimbolos.PARENTESE_DIREITO)
-        ) {
+        if (!this.verificarTipoSimboloAtual(tiposDeSimbolos.PARENTESE_DIREITO)) {
             do {
                 if (argumentos.length >= 255) {
-                    throw this.erro(
-                        this.simboloAtual(),
-                        'Não pode haver mais de 255 argumentos.'
-                    );
+                    throw this.erro(this.simboloAtual(), 'Não pode haver mais de 255 argumentos.');
                 }
                 argumentos.push(this.expressao());
-            } while (
-                this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.VIRGULA)
-            );
+            } while (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.VIRGULA));
         }
 
-        const parenteseDireito = this.consumir(
-            tiposDeSimbolos.PARENTESE_DIREITO,
-            "Esperado ')' após os argumentos."
-        );
-
-        return new Chamada(
-            this.hashArquivo,
-            entidadeChamada,
-            parenteseDireito,
-            argumentos
-        );
+        const parenteseDireito = this.consumir(tiposDeSimbolos.PARENTESE_DIREITO, "Esperado ')' após os argumentos.");
+
+        return new Chamada(this.hashArquivo, entidadeChamada, parenteseDireito, argumentos);
     }
 
     chamar(): Construto {
         let expressao = this.primario();
 
         while (true) {
-            if (
-                this.verificarSeSimboloAtualEIgualA(
-                    tiposDeSimbolos.PARENTESE_ESQUERDO
-                )
-            ) {
+            if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.PARENTESE_ESQUERDO)) {
                 expressao = this.finalizarChamada(expressao);
-            } else if (
-                this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.PONTO)
-            ) {
-                const nome = this.consumir(
-                    tiposDeSimbolos.IDENTIFICADOR,
-                    "Esperado nome do método após '.'."
-                );
+            } else if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.PONTO)) {
+                const nome = this.consumir(tiposDeSimbolos.IDENTIFICADOR, "Esperado nome do método após '.'.");
                 expressao = new AcessoMetodo(this.hashArquivo, expressao, nome);
-            } else if (
-                this.verificarSeSimboloAtualEIgualA(
-                    tiposDeSimbolos.COLCHETE_ESQUERDO
-                )
-            ) {
+            } else if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.COLCHETE_ESQUERDO)) {
                 const indice = this.expressao();
                 const simboloFechamento = this.consumir(
                     tiposDeSimbolos.COLCHETE_DIREITO,
                     "Esperado ']' após escrita do indice."
                 );
-                expressao = new AcessoIndiceVariavel(
-                    this.hashArquivo,
-                    expressao,
-                    indice,
-                    simboloFechamento
-                );
+                expressao = new AcessoIndiceVariavel(this.hashArquivo, expressao, indice, simboloFechamento);
             } else {
                 break;
             }
@@ -374,17 +270,10 @@ export class AvaliadorSintaticoEguaClassico
     exponenciacao(): Construto {
         let expressao = this.unario();
 
-        while (
-            this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.EXPONENCIACAO)
-        ) {
+        while (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.EXPONENCIACAO)) {
             const operador = this.simboloAnterior();
             const direito = this.unario();
-            expressao = new Binario(
-                this.hashArquivo,
-                expressao,
-                operador,
-                direito
-            );
+            expressao = new Binario(this.hashArquivo, expressao, operador, direito);
         }
 
         return expressao;
@@ -402,12 +291,7 @@ export class AvaliadorSintaticoEguaClassico
         ) {
             const operador = this.simboloAnterior();
             const direito = this.exponenciacao();
-            expressao = new Binario(
-                this.hashArquivo,
-                expressao,
-                operador,
-                direito
-            );
+            expressao = new Binario(this.hashArquivo, expressao, operador, direito);
         }
 
         return expressao;
@@ -416,20 +300,10 @@ export class AvaliadorSintaticoEguaClassico
     adicionar(): Construto {
         let expressao = this.multiplicar();
 
-        while (
-            this.verificarSeSimboloAtualEIgualA(
-                tiposDeSimbolos.SUBTRACAO,
-                tiposDeSimbolos.ADICAO
-            )
-        ) {
+        while (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.SUBTRACAO, tiposDeSimbolos.ADICAO)) {
             const operador = this.simboloAnterior();
             const direito = this.multiplicar();
-            expressao = new Binario(
-                this.hashArquivo,
-                expressao,
-                operador,
-                direito
-            );
+            expressao = new Binario(this.hashArquivo, expressao, operador, direito);
         }
 
         return expressao;
@@ -438,20 +312,10 @@ export class AvaliadorSintaticoEguaClassico
     bitFill(): Construto {
         let expressao = this.adicionar();
 
-        while (
-            this.verificarSeSimboloAtualEIgualA(
-                tiposDeSimbolos.MENOR_MENOR,
-                tiposDeSimbolos.MAIOR_MAIOR
-            )
-        ) {
+        while (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.MENOR_MENOR, tiposDeSimbolos.MAIOR_MAIOR)) {
             const operador = this.simboloAnterior();
             const direito = this.adicionar();
-            expressao = new Binario(
-                this.hashArquivo,
-                expressao,
-                operador,
-                direito
-            );
+            expressao = new Binario(this.hashArquivo, expressao, operador, direito);
         }
 
         return expressao;
@@ -463,12 +327,7 @@ export class AvaliadorSintaticoEguaClassico
         while (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.BIT_AND)) {
             const operador = this.simboloAnterior();
             const direito = this.bitFill();
-            expressao = new Binario(
-                this.hashArquivo,
-                expressao,
-                operador,
-                direito
-            );
+            expressao = new Binario(this.hashArquivo, expressao, operador, direito);
         }
 
         return expressao;
@@ -477,20 +336,10 @@ export class AvaliadorSintaticoEguaClassico
     bitOu(): Construto {
         let expressao = this.bitE();
 
-        while (
-            this.verificarSeSimboloAtualEIgualA(
-                tiposDeSimbolos.BIT_OR,
-                tiposDeSimbolos.BIT_XOR
-            )
-        ) {
+        while (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.BIT_OR, tiposDeSimbolos.BIT_XOR)) {
             const operador = this.simboloAnterior();
             const direito = this.bitE();
-            expressao = new Binario(
-                this.hashArquivo,
-                expressao,
-                operador,
-                direito
-            );
+            expressao = new Binario(this.hashArquivo, expressao, operador, direito);
         }
 
         return expressao;
@@ -509,12 +358,7 @@ export class AvaliadorSintaticoEguaClassico
         ) {
             const operador = this.simboloAnterior();
             const direito = this.bitOu();
-            expressao = new Binario(
-                this.hashArquivo,
-                expressao,
-                operador,
-                direito
-            );
+            expressao = new Binario(this.hashArquivo, expressao, operador, direito);
         }
 
         return expressao;
@@ -523,20 +367,10 @@ export class AvaliadorSintaticoEguaClassico
     comparacaoIgualdade(): Construto {
         let expressao = this.comparar();
 
-        while (
-            this.verificarSeSimboloAtualEIgualA(
-                tiposDeSimbolos.DIFERENTE,
-                tiposDeSimbolos.IGUAL_IGUAL
-            )
-        ) {
+        while (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.DIFERENTE, tiposDeSimbolos.IGUAL_IGUAL)) {
             const operador = this.simboloAnterior();
             const direito = this.comparar();
-            expressao = new Binario(
-                this.hashArquivo,
-                expressao,
-                operador,
-                direito
-            );
+            expressao = new Binario(this.hashArquivo, expressao, operador, direito);
         }
 
         return expressao;
@@ -548,12 +382,7 @@ export class AvaliadorSintaticoEguaClassico
         while (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.EM)) {
             const operador = this.simboloAnterior();
             const direito = this.comparacaoIgualdade();
-            expressao = new Logico(
-                this.hashArquivo,
-                expressao,
-                operador,
-                direito
-            );
+            expressao = new Logico(this.hashArquivo, expressao, operador, direito);
         }
 
         return expressao;
@@ -565,12 +394,7 @@ export class AvaliadorSintaticoEguaClassico
         while (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.E)) {
             const operador = this.simboloAnterior();
             const direito = this.em();
-            expressao = new Logico(
-                this.hashArquivo,
-                expressao,
-                operador,
-                direito
-            );
+            expressao = new Logico(this.hashArquivo, expressao, operador, direito);
         }
 
         return expressao;
@@ -582,12 +406,7 @@ export class AvaliadorSintaticoEguaClassico
         while (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.OU)) {
             const operador = this.simboloAnterior();
             const direito = this.e();
-            expressao = new Logico(
-                this.hashArquivo,
-                expressao,
-                operador,
-                direito
-            );
+            expressao = new Logico(this.hashArquivo, expressao, operador, direito);
         }
 
         return expressao;
@@ -605,13 +424,7 @@ export class AvaliadorSintaticoEguaClassico
                 return new Atribuir(this.hashArquivo, simbolo, valor);
             } else if (expressao instanceof AcessoMetodo) {
                 const get = expressao;
-                return new DefinirValor(
-                    this.hashArquivo,
-                    0,
-                    get.objeto,
-                    get.simbolo,
-                    valor
-                );
+                return new DefinirValor(this.hashArquivo, 0, get.objeto, get.simbolo, valor);
             } else if (expressao instanceof AcessoIndiceVariavel) {
                 return new AtribuicaoSobrescrita(
                     this.hashArquivo,
@@ -634,80 +447,46 @@ export class AvaliadorSintaticoEguaClassico
     declaracaoEscreva(): Escreva {
         const simboloAtual = this.simboloAtual();
 
-        this.consumir(
-            tiposDeSimbolos.PARENTESE_ESQUERDO,
-            "Esperado '(' antes dos valores em escreva."
-        );
+        this.consumir(tiposDeSimbolos.PARENTESE_ESQUERDO, "Esperado '(' antes dos valores em escreva.");
 
         const valor = this.expressao();
 
-        this.consumir(
-            tiposDeSimbolos.PARENTESE_DIREITO,
-            "Esperado ')' após os valores em escreva."
-        );
-
-        this.consumir(
-            tiposDeSimbolos.PONTO_E_VIRGULA,
-            "Esperado ';' após o valor."
-        );
-
-        return new Escreva(
-            Number(simboloAtual.linha),
-            simboloAtual.hashArquivo,
-            [valor]
-        );
+        this.consumir(tiposDeSimbolos.PARENTESE_DIREITO, "Esperado ')' após os valores em escreva.");
+
+        this.consumir(tiposDeSimbolos.PONTO_E_VIRGULA, "Esperado ';' após o valor.");
+
+        return new Escreva(Number(simboloAtual.linha), simboloAtual.hashArquivo, [valor]);
     }
 
     declaracaoExpressao(): Expressao {
         const expressao = this.expressao();
-        this.consumir(
-            tiposDeSimbolos.PONTO_E_VIRGULA,
-            "Esperado ';' após expressão."
-        );
+        this.consumir(tiposDeSimbolos.PONTO_E_VIRGULA, "Esperado ';' após expressão.");
         return new Expressao(expressao);
     }
 
     blocoEscopo(): RetornoDeclaracao[] {
         const declaracoes: Array<RetornoDeclaracao> = [];
 
-        while (
-            !this.verificarTipoSimboloAtual(tiposDeSimbolos.CHAVE_DIREITA) &&
-            !this.estaNoFinal()
-        ) {
+        while (!this.verificarTipoSimboloAtual(tiposDeSimbolos.CHAVE_DIREITA) && !this.estaNoFinal()) {
             declaracoes.push(this.declaracao());
         }
 
-        this.consumir(
-            tiposDeSimbolos.CHAVE_DIREITA,
-            "Esperado '}' após o bloco."
-        );
+        this.consumir(tiposDeSimbolos.CHAVE_DIREITA, "Esperado '}' após o bloco.");
         return declaracoes;
     }
 
     declaracaoSe(): Se {
-        this.consumir(
-            tiposDeSimbolos.PARENTESE_ESQUERDO,
-            "Esperado '(' após 'se'."
-        );
+        this.consumir(tiposDeSimbolos.PARENTESE_ESQUERDO, "Esperado '(' após 'se'.");
         const condicao = this.expressao();
-        this.consumir(
-            tiposDeSimbolos.PARENTESE_DIREITO,
-            "Esperado ')' após condição do se."
-        );
+        this.consumir(tiposDeSimbolos.PARENTESE_DIREITO, "Esperado ')' após condição do se.");
 
         const caminhoEntao = this.resolverDeclaracao();
 
         const caminhosSeSenao = [];
         while (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.SENÃOSE)) {
-            this.consumir(
-                tiposDeSimbolos.PARENTESE_ESQUERDO,
-                "Esperado '(' após 'senãose'."
-            );
+            this.consumir(tiposDeSimbolos.PARENTESE_ESQUERDO, "Esperado '(' após 'senãose'.");
             const condicaoSeSenao = this.expressao();
-            this.consumir(
-                tiposDeSimbolos.PARENTESE_DIREITO,
-                "Esperado ')' apóes codição do 'senãose."
-            );
+            this.consumir(tiposDeSimbolos.PARENTESE_DIREITO, "Esperado ')' apóes codição do 'senãose.");
 
             const caminho = this.resolverDeclaracao();
 
@@ -727,118 +506,72 @@ export class AvaliadorSintaticoEguaClassico
 
     declaracaoEnquanto(): Enquanto {
         try {
-            this.ciclos += 1;
+            this.blocos += 1;
 
-            this.consumir(
-                tiposDeSimbolos.PARENTESE_ESQUERDO,
-                "Esperado '(' após 'enquanto'."
-            );
+            this.consumir(tiposDeSimbolos.PARENTESE_ESQUERDO, "Esperado '(' após 'enquanto'.");
             const condicao = this.expressao();
-            this.consumir(
-                tiposDeSimbolos.PARENTESE_DIREITO,
-                "Esperado ')' após condicional."
-            );
+            this.consumir(tiposDeSimbolos.PARENTESE_DIREITO, "Esperado ')' após condicional.");
             const corpo = this.resolverDeclaracao();
 
             return new Enquanto(condicao, corpo);
         } finally {
-            this.ciclos -= 1;
+            this.blocos -= 1;
         }
     }
 
     declaracaoPara(): Para {
         try {
             const simboloPara: SimboloInterface = this.simboloAnterior();
-            this.ciclos += 1;
+            this.blocos += 1;
 
-            this.consumir(
-                tiposDeSimbolos.PARENTESE_ESQUERDO,
-                "Esperado '(' após 'para'."
-            );
+            this.consumir(tiposDeSimbolos.PARENTESE_ESQUERDO, "Esperado '(' após 'para'.");
 
             let inicializador;
-            if (
-                this.verificarSeSimboloAtualEIgualA(
-                    tiposDeSimbolos.PONTO_E_VIRGULA
-                )
-            ) {
+            if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.PONTO_E_VIRGULA)) {
                 inicializador = null;
-            } else if (
-                this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.VARIAVEL)
-            ) {
+            } else if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.VARIAVEL)) {
                 inicializador = this.declaracaoDeVariavel();
             } else {
                 inicializador = this.declaracaoExpressao();
             }
 
             let condicao = null;
-            if (
-                !this.verificarTipoSimboloAtual(tiposDeSimbolos.PONTO_E_VIRGULA)
-            ) {
+            if (!this.verificarTipoSimboloAtual(tiposDeSimbolos.PONTO_E_VIRGULA)) {
                 condicao = this.expressao();
             }
 
-            this.consumir(
-                tiposDeSimbolos.PONTO_E_VIRGULA,
-                "Esperado ';' após valores da condicional"
-            );
+            this.consumir(tiposDeSimbolos.PONTO_E_VIRGULA, "Esperado ';' após valores da condicional");
 
             let incrementar = null;
-            if (
-                !this.verificarTipoSimboloAtual(
-                    tiposDeSimbolos.PARENTESE_DIREITO
-                )
-            ) {
+            if (!this.verificarTipoSimboloAtual(tiposDeSimbolos.PARENTESE_DIREITO)) {
                 incrementar = this.expressao();
             }
 
-            this.consumir(
-                tiposDeSimbolos.PARENTESE_DIREITO,
-                "Esperado ')' após cláusulas"
-            );
+            this.consumir(tiposDeSimbolos.PARENTESE_DIREITO, "Esperado ')' após cláusulas");
 
             const corpo = this.resolverDeclaracao();
 
-            return new Para(
-                this.hashArquivo,
-                Number(simboloPara.linha),
-                inicializador,
-                condicao,
-                incrementar,
-                corpo
-            );
+            return new Para(this.hashArquivo, Number(simboloPara.linha), inicializador, condicao, incrementar, corpo);
         } finally {
-            this.ciclos -= 1;
+            this.blocos -= 1;
         }
     }
 
     declaracaoSustar(): Sustar {
-        if (this.ciclos < 1) {
-            this.erro(
-                this.simboloAnterior(),
-                "'pausa' deve estar dentro de um loop."
-            );
+        if (this.blocos < 1) {
+            this.erro(this.simboloAnterior(), "'pausa' deve estar dentro de um loop.");
         }
 
-        this.consumir(
-            tiposDeSimbolos.PONTO_E_VIRGULA,
-            "Esperado ';' após 'pausa'."
-        );
+        this.consumir(tiposDeSimbolos.PONTO_E_VIRGULA, "Esperado ';' após 'pausa'.");
         return new Sustar(this.simboloAtual());
     }
 
     declaracaoContinua(): Continua {
-        if (this.ciclos < 1) {
-            this.erro(
-                this.simboloAnterior(),
-                "'continua' precisa estar em um laço de repetição."
-            );
+        if (this.blocos < 1) {
+            this.erro(this.simboloAnterior(), "'continua' precisa estar em um laço de repetição.");
         }
 
-        this.consumir(
-            tiposDeSimbolos.PONTO_E_VIRGULA,
-            "Esperado ';' após 'continua'."
-        );
+        this.consumir(tiposDeSimbolos.PONTO_E_VIRGULA, "Esperado ';' após 'continua'.");
         return new Continua(this.simboloAtual());
     }
 
@@ -850,57 +583,32 @@ export class AvaliadorSintaticoEguaClassico
             valor = this.expressao();
         }
 
-        this.consumir(
-            tiposDeSimbolos.PONTO_E_VIRGULA,
-            "Esperado ';' após o retorno."
-        );
+        this.consumir(tiposDeSimbolos.PONTO_E_VIRGULA, "Esperado ';' após o retorno.");
         return new Retorna(palavraChave, valor);
     }
 
     declaracaoEscolha(): Escolha {
         try {
-            this.ciclos += 1;
+            this.blocos += 1;
 
-            this.consumir(
-                tiposDeSimbolos.PARENTESE_ESQUERDO,
-                "Esperado '{' após 'escolha'."
-            );
+            this.consumir(tiposDeSimbolos.PARENTESE_ESQUERDO, "Esperado '{' após 'escolha'.");
 
             const condicao = this.expressao();
 
-            this.consumir(
-                tiposDeSimbolos.PARENTESE_DIREITO,
-                "Esperado '}' após a condição de 'escolha'."
-            );
-            this.consumir(
-                tiposDeSimbolos.CHAVE_ESQUERDA,
-                "Esperado '{' antes do escopo do 'escolha'."
-            );
+            this.consumir(tiposDeSimbolos.PARENTESE_DIREITO, "Esperado '}' após a condição de 'escolha'.");
+            this.consumir(tiposDeSimbolos.CHAVE_ESQUERDA, "Esperado '{' antes do escopo do 'escolha'.");
 
             const caminhos = [];
             let caminhoPadrao = null;
-            while (
-                !this.verificarSeSimboloAtualEIgualA(
-                    tiposDeSimbolos.CHAVE_DIREITA
-                ) &&
-                !this.estaNoFinal()
-            ) {
+            while (!this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.CHAVE_DIREITA) && !this.estaNoFinal()) {
                 if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.CASO)) {
                     const caminhoCondicoes = [this.expressao()];
-                    this.consumir(
-                        tiposDeSimbolos.DOIS_PONTOS,
-                        "Esperado ':' após o 'caso'."
-                    );
+                    this.consumir(tiposDeSimbolos.DOIS_PONTOS, "Esperado ':' após o 'caso'.");
 
-                    while (
-                        this.verificarTipoSimboloAtual(tiposDeSimbolos.CASO)
-                    ) {
+                    while (this.verificarTipoSimboloAtual(tiposDeSimbolos.CASO)) {
                         this.consumir(tiposDeSimbolos.CASO, null);
                         caminhoCondicoes.push(this.expressao());
-                        this.consumir(
-                            tiposDeSimbolos.DOIS_PONTOS,
-                            "Esperado ':' após declaração do 'caso'."
-                        );
+                        this.consumir(tiposDeSimbolos.DOIS_PONTOS, "Esperado ':' após declaração do 'caso'.");
                     }
 
                     const declaracoes = [];
@@ -908,21 +616,15 @@ export class AvaliadorSintaticoEguaClassico
                         declaracoes.push(this.resolverDeclaracao());
                     } while (
                         !this.verificarTipoSimboloAtual(tiposDeSimbolos.CASO) &&
-                        !this.verificarTipoSimboloAtual(
-                            tiposDeSimbolos.PADRAO
-                        ) &&
-                        !this.verificarTipoSimboloAtual(
-                            tiposDeSimbolos.CHAVE_DIREITA
-                        )
+                        !this.verificarTipoSimboloAtual(tiposDeSimbolos.PADRAO) &&
+                        !this.verificarTipoSimboloAtual(tiposDeSimbolos.CHAVE_DIREITA)
                     );
 
                     caminhos.push({
                         condicoes: caminhoCondicoes,
                         declaracoes,
                     });
-                } else if (
-                    this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.PADRAO)
-                ) {
+                } else if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.PADRAO)) {
                     if (caminhoPadrao !== null) {
                         const excecao = new ErroAvaliadorSintatico(
                             this.simboloAtual(),
@@ -932,22 +634,15 @@ export class AvaliadorSintaticoEguaClassico
                         throw excecao;
                     }
 
-                    this.consumir(
-                        tiposDeSimbolos.DOIS_PONTOS,
-                        "Esperado ':' após declaração do 'padrao'."
-                    );
+                    this.consumir(tiposDeSimbolos.DOIS_PONTOS, "Esperado ':' após declaração do 'padrao'.");
 
                     const declaracoes = [];
                     do {
                         declaracoes.push(this.resolverDeclaracao());
                     } while (
                         !this.verificarTipoSimboloAtual(tiposDeSimbolos.CASO) &&
-                        !this.verificarTipoSimboloAtual(
-                            tiposDeSimbolos.PADRAO
-                        ) &&
-                        !this.verificarTipoSimboloAtual(
-                            tiposDeSimbolos.CHAVE_DIREITA
-                        )
+                        !this.verificarTipoSimboloAtual(tiposDeSimbolos.PADRAO) &&
+                        !this.verificarTipoSimboloAtual(tiposDeSimbolos.CHAVE_DIREITA)
                     );
 
                     caminhoPadrao = {
@@ -958,22 +653,16 @@ export class AvaliadorSintaticoEguaClassico
 
             return new Escolha(condicao, caminhos, caminhoPadrao);
         } finally {
-            this.ciclos -= 1;
+            this.blocos -= 1;
         }
     }
 
     declaracaoImportar(): Importar {
-        this.consumir(
-            tiposDeSimbolos.PARENTESE_ESQUERDO,
-            "Esperado '(' após declaração."
-        );
+        this.consumir(tiposDeSimbolos.PARENTESE_ESQUERDO, "Esperado '(' após declaração.");
 
         const caminho = this.expressao();
 
-        const simboloFechamento = this.consumir(
-            tiposDeSimbolos.PARENTESE_DIREITO,
-            "Esperado ')' após declaração."
-        );
+        const simboloFechamento = this.consumir(tiposDeSimbolos.PARENTESE_DIREITO, "Esperado ')' após declaração.");
 
         // tive que fazer isso para poder tipar a func expressão
         // não sei isso e certo provavelmente não.
@@ -985,39 +674,27 @@ export class AvaliadorSintaticoEguaClassico
     }
 
     declaracaoTente(): Tente {
-        this.consumir(
-            tiposDeSimbolos.CHAVE_ESQUERDA,
-            "Esperado '{' após a declaração 'tente'."
-        );
+        this.consumir(tiposDeSimbolos.CHAVE_ESQUERDA, "Esperado '{' após a declaração 'tente'.");
 
         const tryBlock = this.blocoEscopo();
 
         let catchBlock = null;
         if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.PEGUE)) {
-            this.consumir(
-                tiposDeSimbolos.CHAVE_ESQUERDA,
-                "Esperado '{' após a declaração 'pegue'."
-            );
+            this.consumir(tiposDeSimbolos.CHAVE_ESQUERDA, "Esperado '{' após a declaração 'pegue'.");
 
             catchBlock = this.blocoEscopo();
         }
 
         let elseBlock = null;
         if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.SENÃO)) {
-            this.consumir(
-                tiposDeSimbolos.CHAVE_ESQUERDA,
-                "Esperado '{' após a declaração 'pegue'."
-            );
+            this.consumir(tiposDeSimbolos.CHAVE_ESQUERDA, "Esperado '{' após a declaração 'pegue'.");
 
             elseBlock = this.blocoEscopo();
         }
 
         let finallyBlock = null;
         if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.FINALMENTE)) {
-            this.consumir(
-                tiposDeSimbolos.CHAVE_ESQUERDA,
-                "Esperado '{' após a declaração 'pegue'."
-            );
+            this.consumir(tiposDeSimbolos.CHAVE_ESQUERDA, "Esperado '{' após a declaração 'pegue'.");
 
             finallyBlock = this.blocoEscopo();
         }
@@ -1027,53 +704,34 @@ export class AvaliadorSintaticoEguaClassico
 
     declaracaoFazer(): Fazer {
         try {
-            this.ciclos += 1;
+            this.blocos += 1;
 
             const caminhoFazer = this.resolverDeclaracao();
 
-            this.consumir(
-                tiposDeSimbolos.ENQUANTO,
-                "Esperado declaração do 'enquanto' após o escopo do 'fazer'."
-            );
-            this.consumir(
-                tiposDeSimbolos.PARENTESE_ESQUERDO,
-                "Esperado '(' após declaração 'enquanto'."
-            );
+            this.consumir(tiposDeSimbolos.ENQUANTO, "Esperado declaração do 'enquanto' após o escopo do 'fazer'.");
+            this.consumir(tiposDeSimbolos.PARENTESE_ESQUERDO, "Esperado '(' após declaração 'enquanto'.");
 
             const condicaoEnquanto = this.expressao();
 
-            this.consumir(
-                tiposDeSimbolos.PARENTESE_DIREITO,
-                "Esperado ')' após declaração do 'enquanto'."
-            );
+            this.consumir(tiposDeSimbolos.PARENTESE_DIREITO, "Esperado ')' após declaração do 'enquanto'.");
 
             return new Fazer(0, 0, caminhoFazer, condicaoEnquanto);
         } finally {
-            this.ciclos -= 1;
+            this.blocos -= 1;
         }
     }
 
     resolverDeclaracao(): RetornoResolverDeclaracao {
-        if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.FAZER))
-            return this.declaracaoFazer();
-        if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.TENTE))
-            return this.declaracaoTente();
-        if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.ESCOLHA))
-            return this.declaracaoEscolha();
-        if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.RETORNA))
-            return this.declaracaoRetorna();
-        if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.CONTINUA))
-            return this.declaracaoContinua();
-        if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.PAUSA))
-            return this.declaracaoSustar();
-        if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.PARA))
-            return this.declaracaoPara();
-        if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.ENQUANTO))
-            return this.declaracaoEnquanto();
-        if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.SE))
-            return this.declaracaoSe();
-        if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.ESCREVA))
-            return this.declaracaoEscreva();
+        if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.FAZER)) return this.declaracaoFazer();
+        if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.TENTE)) return this.declaracaoTente();
+        if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.ESCOLHA)) return this.declaracaoEscolha();
+        if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.RETORNA)) return this.declaracaoRetorna();
+        if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.CONTINUA)) return this.declaracaoContinua();
+        if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.PAUSA)) return this.declaracaoSustar();
+        if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.PARA)) return this.declaracaoPara();
+        if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.ENQUANTO)) return this.declaracaoEnquanto();
+        if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.SE)) return this.declaracaoSe();
+        if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.ESCREVA)) return this.declaracaoEscreva();
         if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.CHAVE_ESQUERDA))
             return new Bloco(0, 0, this.blocoEscopo());
 
@@ -1081,87 +739,55 @@ export class AvaliadorSintaticoEguaClassico
     }
 
     declaracaoDeVariavel(): Var {
-        const nome = this.consumir(
-            tiposDeSimbolos.IDENTIFICADOR,
-            'Esperado nome de variável.'
-        );
+        const nome = this.consumir(tiposDeSimbolos.IDENTIFICADOR, 'Esperado nome de variável.');
         let inicializador = null;
         if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.IGUAL)) {
             inicializador = this.expressao();
         }
 
-        this.consumir(
-            tiposDeSimbolos.PONTO_E_VIRGULA,
-            "Esperado ';' após a declaração da variável."
-        );
+        this.consumir(tiposDeSimbolos.PONTO_E_VIRGULA, "Esperado ';' após a declaração da variável.");
 
         return new Var(nome, inicializador);
     }
 
     funcao(kind: string): FuncaoDeclaracao {
-        const nome = this.consumir(
-            tiposDeSimbolos.IDENTIFICADOR,
-            `Esperado nome ${kind}.`
-        );
+        const nome = this.consumir(tiposDeSimbolos.IDENTIFICADOR, `Esperado nome ${kind}.`);
         return new FuncaoDeclaracao(nome, this.corpoDaFuncao(kind));
     }
 
     corpoDaFuncao(kind: string): FuncaoConstruto {
-        this.consumir(
-            tiposDeSimbolos.PARENTESE_ESQUERDO,
-            `Esperado '(' após o nome ${kind}.`
-        );
+        this.consumir(tiposDeSimbolos.PARENTESE_ESQUERDO, `Esperado '(' após o nome ${kind}.`);
 
         const parametros = [];
-        if (
-            !this.verificarTipoSimboloAtual(tiposDeSimbolos.PARENTESE_DIREITO)
-        ) {
+        if (!this.verificarTipoSimboloAtual(tiposDeSimbolos.PARENTESE_DIREITO)) {
             do {
                 if (parametros.length >= 255) {
-                    this.erro(
-                        this.simboloAtual(),
-                        'Não pode haver mais de 255 parâmetros'
-                    );
+                    this.erro(this.simboloAtual(), 'Não pode haver mais de 255 parâmetros');
                 }
 
                 const parametro = {};
 
-                if (
-                    this.simboloAtual().tipo === tiposDeSimbolos.MULTIPLICACAO
-                ) {
+                if (this.simboloAtual().tipo === tiposDeSimbolos.MULTIPLICACAO) {
                     this.consumir(tiposDeSimbolos.MULTIPLICACAO, null);
                     parametro['tipo'] = 'estrela';
                 } else {
                     parametro['tipo'] = 'padrao';
                 }
 
-                parametro['nome'] = this.consumir(
-                    tiposDeSimbolos.IDENTIFICADOR,
-                    'Esperado nome do parâmetro.'
-                );
+                parametro['nome'] = this.consumir(tiposDeSimbolos.IDENTIFICADOR, 'Esperado nome do parâmetro.');
 
-                if (
-                    this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.IGUAL)
-                ) {
+                if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.IGUAL)) {
                     parametro['padrao'] = this.primario();
                 }
 
                 parametros.push(parametro);
 
                 if (parametro['tipo'] === 'estrela') break;
-            } while (
-                this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.VIRGULA)
-            );
+            } while (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.VIRGULA));
         }
 
-        this.consumir(
-            tiposDeSimbolos.PARENTESE_DIREITO,
-            "Esperado ')' após parâmetros."
-        );
-        this.consumir(
-            tiposDeSimbolos.CHAVE_ESQUERDA,
-            `Esperado '{' antes do escopo do ${kind}.`
-        );
+        this.consumir(tiposDeSimbolos.PARENTESE_DIREITO, "Esperado ')' após parâmetros.");
+        this.consumir(tiposDeSimbolos.CHAVE_ESQUERDA, `Esperado '{' antes do escopo do ${kind}.`);
 
         const corpo = this.blocoEscopo();
 
@@ -1169,40 +795,22 @@ export class AvaliadorSintaticoEguaClassico
     }
 
     declaracaoDeClasse(): Classe {
-        const nome = this.consumir(
-            tiposDeSimbolos.IDENTIFICADOR,
-            'Esperado nome da classe.'
-        );
+        const nome = this.consumir(tiposDeSimbolos.IDENTIFICADOR, 'Esperado nome da classe.');
 
         let superClasse = null;
         if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.HERDA)) {
-            this.consumir(
-                tiposDeSimbolos.IDENTIFICADOR,
-                'Esperado nome da SuperClasse.'
-            );
-            superClasse = new Variavel(
-                this.hashArquivo,
-                this.simboloAnterior()
-            );
+            this.consumir(tiposDeSimbolos.IDENTIFICADOR, 'Esperado nome da SuperClasse.');
+            superClasse = new Variavel(this.hashArquivo, this.simboloAnterior());
         }
 
-        this.consumir(
-            tiposDeSimbolos.CHAVE_ESQUERDA,
-            "Esperado '{' antes do escopo da classe."
-        );
+        this.consumir(tiposDeSimbolos.CHAVE_ESQUERDA, "Esperado '{' antes do escopo da classe.");
 
         const metodos = [];
-        while (
-            !this.verificarTipoSimboloAtual(tiposDeSimbolos.CHAVE_DIREITA) &&
-            !this.estaNoFinal()
-        ) {
+        while (!this.verificarTipoSimboloAtual(tiposDeSimbolos.CHAVE_DIREITA) && !this.estaNoFinal()) {
             metodos.push(this.funcao('método'));
         }
 
-        this.consumir(
-            tiposDeSimbolos.CHAVE_DIREITA,
-            "Esperado '}' após o escopo da classe."
-        );
+        this.consumir(tiposDeSimbolos.CHAVE_DIREITA, "Esperado '}' após o escopo da classe.");
         return new Classe(nome, superClasse, metodos);
     }
 
@@ -1215,10 +823,8 @@ export class AvaliadorSintaticoEguaClassico
                 this.consumir(tiposDeSimbolos.FUNÇÃO, null);
                 return this.funcao('função');
             }
-            if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.VARIAVEL))
-                return this.declaracaoDeVariavel();
-            if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.CLASSE))
-                return this.declaracaoDeClasse();
+            if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.VARIAVEL)) return this.declaracaoDeVariavel();
+            if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.CLASSE)) return this.declaracaoDeClasse();
 
             return this.resolverDeclaracao();
         } catch (erro) {
@@ -1227,13 +833,10 @@ export class AvaliadorSintaticoEguaClassico
         }
     }
 
-    analisar(
-        retornoLexador: RetornoLexador,
-        hashArquivo?: number
-    ): RetornoAvaliadorSintatico {
+    analisar(retornoLexador: RetornoLexador, hashArquivo?: number): RetornoAvaliadorSintatico {
         this.erros = [];
         this.atual = 0;
-        this.ciclos = 0;
+        this.blocos = 0;
 
         this.hashArquivo = hashArquivo || 0;
         this.simbolos = retornoLexador?.simbolos || [];
diff --git a/fontes/avaliador-sintatico/dialetos/avaliador-sintatico-eguap.ts b/fontes/avaliador-sintatico/dialetos/avaliador-sintatico-eguap.ts
index 501a94d1..018cc445 100644
--- a/fontes/avaliador-sintatico/dialetos/avaliador-sintatico-eguap.ts
+++ b/fontes/avaliador-sintatico/dialetos/avaliador-sintatico-eguap.ts
@@ -41,10 +41,7 @@ import {
     Leia,
 } from '../../declaracoes';
 
-import {
-    AvaliadorSintaticoInterface,
-    SimboloInterface,
-} from '../../interfaces';
+import { AvaliadorSintaticoInterface, SimboloInterface } from '../../interfaces';
 import { Pragma } from '../../lexador/dialetos/pragma';
 import tiposDeSimbolos from '../../tipos-de-simbolos/eguap';
 import { RetornoLexador } from '../../interfaces/retornos/retorno-lexador';
@@ -67,13 +64,13 @@ export class AvaliadorSintaticoEguaP implements AvaliadorSintaticoInterface {
 
     hashArquivo: number;
     atual: number;
-    ciclos: number;
+    blocos: number;
     escopos: number[];
     performance: boolean;
 
     constructor(performance = false) {
         this.atual = 0;
-        this.ciclos = 0;
+        this.blocos = 0;
         this.performance = performance;
         this.escopos = [];
     }
@@ -99,18 +96,14 @@ export class AvaliadorSintaticoEguaP implements AvaliadorSintaticoInterface {
         }
     }
 
-    erro(
-        simbolo: SimboloInterface,
-        mensagemDeErro: string
-    ): ErroAvaliadorSintatico {
+    erro(simbolo: SimboloInterface, mensagemDeErro: string): ErroAvaliadorSintatico {
         const excecao = new ErroAvaliadorSintatico(simbolo, mensagemDeErro);
         this.erros.push(excecao);
         return excecao;
     }
 
     consumir(tipo: string, mensagemDeErro: string) {
-        if (this.verificarTipoSimboloAtual(tipo))
-            return this.avancarEDevolverAnterior();
+        if (this.verificarTipoSimboloAtual(tipo)) return this.avancarEDevolverAnterior();
         throw this.erro(this.simboloAtual(), mensagemDeErro);
     }
 
@@ -161,136 +154,76 @@ export class AvaliadorSintaticoEguaP implements AvaliadorSintaticoInterface {
         if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.SUPER)) {
             const simboloChave = this.simboloAnterior();
             this.consumir(tiposDeSimbolos.PONTO, "Esperado '.' após 'super'.");
-            const metodo = this.consumir(
-                tiposDeSimbolos.IDENTIFICADOR,
-                'Esperado nome do método da SuperClasse.'
-            );
+            const metodo = this.consumir(tiposDeSimbolos.IDENTIFICADOR, 'Esperado nome do método da SuperClasse.');
             return new Super(this.hashArquivo, simboloChave, metodo);
         }
 
-        if (
-            this.verificarSeSimboloAtualEIgualA(
-                tiposDeSimbolos.COLCHETE_ESQUERDO
-            )
-        ) {
+        if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.COLCHETE_ESQUERDO)) {
             const valores = [];
 
-            if (
-                this.verificarSeSimboloAtualEIgualA(
-                    tiposDeSimbolos.COLCHETE_DIREITO
-                )
-            ) {
+            if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.COLCHETE_DIREITO)) {
                 return new Vetor(this.hashArquivo, 0, []);
             }
 
-            while (
-                !this.verificarSeSimboloAtualEIgualA(
-                    tiposDeSimbolos.COLCHETE_DIREITO
-                )
-            ) {
+            while (!this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.COLCHETE_DIREITO)) {
                 const valor = this.atribuir();
                 valores.push(valor);
-                if (
-                    this.simboloAtual().tipo !==
-                    tiposDeSimbolos.COLCHETE_DIREITO
-                ) {
-                    this.consumir(
-                        tiposDeSimbolos.VIRGULA,
-                        'Esperado vírgula antes da próxima expressão.'
-                    );
+                if (this.simboloAtual().tipo !== tiposDeSimbolos.COLCHETE_DIREITO) {
+                    this.consumir(tiposDeSimbolos.VIRGULA, 'Esperado vírgula antes da próxima expressão.');
                 }
             }
 
             return new Vetor(this.hashArquivo, 0, valores);
         }
 
-        if (
-            this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.CHAVE_ESQUERDA)
-        ) {
+        if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.CHAVE_ESQUERDA)) {
             const chaves = [];
             const valores = [];
 
-            if (
-                this.verificarSeSimboloAtualEIgualA(
-                    tiposDeSimbolos.CHAVE_DIREITA
-                )
-            ) {
+            if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.CHAVE_DIREITA)) {
                 return new Dicionario(this.hashArquivo, 0, [], []);
             }
 
-            while (
-                !this.verificarSeSimboloAtualEIgualA(
-                    tiposDeSimbolos.CHAVE_DIREITA
-                )
-            ) {
+            while (!this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.CHAVE_DIREITA)) {
                 const chave = this.atribuir();
-                this.consumir(
-                    tiposDeSimbolos.DOIS_PONTOS,
-                    "Esperado ':' entre chave e valor."
-                );
+                this.consumir(tiposDeSimbolos.DOIS_PONTOS, "Esperado ':' entre chave e valor.");
                 const valor = this.atribuir();
 
                 chaves.push(chave);
                 valores.push(valor);
 
-                if (
-                    this.simboloAtual().tipo !== tiposDeSimbolos.CHAVE_DIREITA
-                ) {
-                    this.consumir(
-                        tiposDeSimbolos.VIRGULA,
-                        'Esperado vírgula antes da próxima expressão.'
-                    );
+                if (this.simboloAtual().tipo !== tiposDeSimbolos.CHAVE_DIREITA) {
+                    this.consumir(tiposDeSimbolos.VIRGULA, 'Esperado vírgula antes da próxima expressão.');
                 }
             }
 
             return new Dicionario(this.hashArquivo, 0, chaves, valores);
         }
 
-        if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.FALSO))
-            return new Literal(this.hashArquivo, 0, false);
+        if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.FALSO)) return new Literal(this.hashArquivo, 0, false);
         if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.VERDADEIRO))
             return new Literal(this.hashArquivo, 0, true);
-        if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.NULO))
-            return new Literal(this.hashArquivo, 0, null);
+        if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.NULO)) return new Literal(this.hashArquivo, 0, null);
         if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.ISTO))
             return new Isto(this.hashArquivo, 0, this.simboloAnterior());
 
-        if (
-            this.verificarSeSimboloAtualEIgualA(
-                tiposDeSimbolos.NUMERO,
-                tiposDeSimbolos.TEXTO
-            )
-        ) {
+        if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.NUMERO, tiposDeSimbolos.TEXTO)) {
             const simboloAnterior: SimboloInterface = this.simboloAnterior();
-            return new Literal(
-                this.hashArquivo,
-                Number(simboloAnterior.linha),
-                simboloAnterior.literal
-            );
+            return new Literal(this.hashArquivo, Number(simboloAnterior.linha), simboloAnterior.literal);
         }
 
-        if (
-            this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.IDENTIFICADOR)
-        ) {
+        if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.IDENTIFICADOR)) {
             return new Variavel(this.hashArquivo, this.simboloAnterior());
         }
 
-        if (
-            this.verificarSeSimboloAtualEIgualA(
-                tiposDeSimbolos.PARENTESE_ESQUERDO
-            )
-        ) {
+        if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.PARENTESE_ESQUERDO)) {
             const expressao = this.expressao();
-            this.consumir(
-                tiposDeSimbolos.PARENTESE_DIREITO,
-                "Esperado ')' após a expressão."
-            );
+            this.consumir(tiposDeSimbolos.PARENTESE_DIREITO, "Esperado ')' após a expressão.");
 
             return new Agrupamento(this.hashArquivo, 0, expressao);
         }
 
-        if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.IMPORTAR))
-            return this.declaracaoImportar();
+        if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.IMPORTAR)) return this.declaracaoImportar();
 
         throw this.erro(this.simboloAtual(), 'Esperado expressão.');
     }
@@ -298,71 +231,38 @@ export class AvaliadorSintaticoEguaP implements AvaliadorSintaticoInterface {
     finalizarChamada(entidadeChamada: Construto): Construto {
         const argumentos = [];
 
-        if (
-            !this.verificarTipoSimboloAtual(tiposDeSimbolos.PARENTESE_DIREITO)
-        ) {
+        if (!this.verificarTipoSimboloAtual(tiposDeSimbolos.PARENTESE_DIREITO)) {
             do {
                 if (argumentos.length >= 255) {
-                    throw this.erro(
-                        this.simboloAtual(),
-                        'Não pode haver mais de 255 argumentos.'
-                    );
+                    throw this.erro(this.simboloAtual(), 'Não pode haver mais de 255 argumentos.');
                 }
                 argumentos.push(this.expressao());
-            } while (
-                this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.VIRGULA)
-            );
+            } while (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.VIRGULA));
         }
 
-        const parenteseDireito = this.consumir(
-            tiposDeSimbolos.PARENTESE_DIREITO,
-            "Esperado ')' após os argumentos."
-        );
+        const parenteseDireito = this.consumir(tiposDeSimbolos.PARENTESE_DIREITO, "Esperado ')' após os argumentos.");
 
-        return new Chamada(
-            this.hashArquivo,
-            entidadeChamada,
-            parenteseDireito,
-            argumentos
-        );
+        return new Chamada(this.hashArquivo, entidadeChamada, parenteseDireito, argumentos);
     }
 
     chamar(): Construto | RetornoPrimario {
         let expressao: RetornoPrimario | Construto = this.primario();
 
         while (true) {
-            if (
-                this.verificarSeSimboloAtualEIgualA(
-                    tiposDeSimbolos.PARENTESE_ESQUERDO
-                )
-            ) {
+            if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.PARENTESE_ESQUERDO)) {
                 expressao = this.finalizarChamada(expressao);
-            } else if (
-                this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.PONTO)
-            ) {
-                const nome = this.consumir(
-                    tiposDeSimbolos.IDENTIFICADOR,
-                    "Esperado nome do método após '.'."
-                );
+            } else if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.PONTO)) {
+                const nome = this.consumir(tiposDeSimbolos.IDENTIFICADOR, "Esperado nome do método após '.'.");
 
                 expressao = new AcessoMetodo(this.hashArquivo, expressao, nome);
-            } else if (
-                this.verificarSeSimboloAtualEIgualA(
-                    tiposDeSimbolos.COLCHETE_ESQUERDO
-                )
-            ) {
+            } else if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.COLCHETE_ESQUERDO)) {
                 const indice = this.expressao();
                 const simboloFechamento = this.consumir(
                     tiposDeSimbolos.COLCHETE_DIREITO,
                     "Esperado ']' após escrita do indice."
                 );
 
-                expressao = new AcessoIndiceVariavel(
-                    this.hashArquivo,
-                    expressao,
-                    indice,
-                    simboloFechamento
-                );
+                expressao = new AcessoIndiceVariavel(this.hashArquivo, expressao, indice, simboloFechamento);
             } else {
                 break;
             }
@@ -390,17 +290,10 @@ export class AvaliadorSintaticoEguaP implements AvaliadorSintaticoInterface {
     exponenciacao(): Construto {
         let expressao = this.unario();
 
-        while (
-            this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.EXPONENCIACAO)
-        ) {
+        while (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.EXPONENCIACAO)) {
             const operador = this.simboloAnterior();
             const direito = this.unario();
-            expressao = new Binario(
-                this.hashArquivo,
-                expressao,
-                operador,
-                direito
-            );
+            expressao = new Binario(this.hashArquivo, expressao, operador, direito);
         }
 
         return expressao;
@@ -418,12 +311,7 @@ export class AvaliadorSintaticoEguaP implements AvaliadorSintaticoInterface {
         ) {
             const operador = this.simboloAnterior();
             const direito = this.exponenciacao();
-            expressao = new Binario(
-                this.hashArquivo,
-                expressao,
-                operador,
-                direito
-            );
+            expressao = new Binario(this.hashArquivo, expressao, operador, direito);
         }
 
         return expressao;
@@ -432,20 +320,10 @@ export class AvaliadorSintaticoEguaP implements AvaliadorSintaticoInterface {
     adicaoOuSubtracao(): Construto {
         let expressao = this.multiplicar();
 
-        while (
-            this.verificarSeSimboloAtualEIgualA(
-                tiposDeSimbolos.SUBTRACAO,
-                tiposDeSimbolos.ADICAO
-            )
-        ) {
+        while (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.SUBTRACAO, tiposDeSimbolos.ADICAO)) {
             const operador = this.simboloAnterior();
             const direito = this.multiplicar();
-            expressao = new Binario(
-                this.hashArquivo,
-                expressao,
-                operador,
-                direito
-            );
+            expressao = new Binario(this.hashArquivo, expressao, operador, direito);
         }
 
         return expressao;
@@ -454,20 +332,10 @@ export class AvaliadorSintaticoEguaP implements AvaliadorSintaticoInterface {
     bitFill(): Construto {
         let expressao = this.adicaoOuSubtracao();
 
-        while (
-            this.verificarSeSimboloAtualEIgualA(
-                tiposDeSimbolos.MENOR_MENOR,
-                tiposDeSimbolos.MAIOR_MAIOR
-            )
-        ) {
+        while (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.MENOR_MENOR, tiposDeSimbolos.MAIOR_MAIOR)) {
             const operador = this.simboloAnterior();
             const direito = this.adicaoOuSubtracao();
-            expressao = new Binario(
-                this.hashArquivo,
-                expressao,
-                operador,
-                direito
-            );
+            expressao = new Binario(this.hashArquivo, expressao, operador, direito);
         }
 
         return expressao;
@@ -479,12 +347,7 @@ export class AvaliadorSintaticoEguaP implements AvaliadorSintaticoInterface {
         while (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.BIT_AND)) {
             const operador = this.simboloAnterior();
             const direito = this.bitFill();
-            expressao = new Binario(
-                this.hashArquivo,
-                expressao,
-                operador,
-                direito
-            );
+            expressao = new Binario(this.hashArquivo, expressao, operador, direito);
         }
 
         return expressao;
@@ -493,20 +356,10 @@ export class AvaliadorSintaticoEguaP implements AvaliadorSintaticoInterface {
     bitOu(): Construto {
         let expressao = this.bitE();
 
-        while (
-            this.verificarSeSimboloAtualEIgualA(
-                tiposDeSimbolos.BIT_OR,
-                tiposDeSimbolos.BIT_XOR
-            )
-        ) {
+        while (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.BIT_OR, tiposDeSimbolos.BIT_XOR)) {
             const operador = this.simboloAnterior();
             const direito = this.bitE();
-            expressao = new Binario(
-                this.hashArquivo,
-                expressao,
-                operador,
-                direito
-            );
+            expressao = new Binario(this.hashArquivo, expressao, operador, direito);
         }
 
         return expressao;
@@ -525,12 +378,7 @@ export class AvaliadorSintaticoEguaP implements AvaliadorSintaticoInterface {
         ) {
             const operador = this.simboloAnterior();
             const direito = this.bitOu();
-            expressao = new Binario(
-                this.hashArquivo,
-                expressao,
-                operador,
-                direito
-            );
+            expressao = new Binario(this.hashArquivo, expressao, operador, direito);
         }
 
         return expressao;
@@ -539,20 +387,10 @@ export class AvaliadorSintaticoEguaP implements AvaliadorSintaticoInterface {
     comparacaoIgualdade(): Construto {
         let expressao = this.comparar();
 
-        while (
-            this.verificarSeSimboloAtualEIgualA(
-                tiposDeSimbolos.DIFERENTE,
-                tiposDeSimbolos.IGUAL_IGUAL
-            )
-        ) {
+        while (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.DIFERENTE, tiposDeSimbolos.IGUAL_IGUAL)) {
             const operador = this.simboloAnterior();
             const direito = this.comparar();
-            expressao = new Binario(
-                this.hashArquivo,
-                expressao,
-                operador,
-                direito
-            );
+            expressao = new Binario(this.hashArquivo, expressao, operador, direito);
         }
 
         return expressao;
@@ -564,12 +402,7 @@ export class AvaliadorSintaticoEguaP implements AvaliadorSintaticoInterface {
         while (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.EM)) {
             const operador = this.simboloAnterior();
             const direito = this.comparacaoIgualdade();
-            expressao = new Logico(
-                this.hashArquivo,
-                expressao,
-                operador,
-                direito
-            );
+            expressao = new Logico(this.hashArquivo, expressao, operador, direito);
         }
 
         return expressao;
@@ -581,12 +414,7 @@ export class AvaliadorSintaticoEguaP implements AvaliadorSintaticoInterface {
         while (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.E)) {
             const operador = this.simboloAnterior();
             const direito = this.em();
-            expressao = new Logico(
-                this.hashArquivo,
-                expressao,
-                operador,
-                direito
-            );
+            expressao = new Logico(this.hashArquivo, expressao, operador, direito);
         }
 
         return expressao;
@@ -598,12 +426,7 @@ export class AvaliadorSintaticoEguaP implements AvaliadorSintaticoInterface {
         while (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.OU)) {
             const operador = this.simboloAnterior();
             const direito = this.e();
-            expressao = new Logico(
-                this.hashArquivo,
-                expressao,
-                operador,
-                direito
-            );
+            expressao = new Logico(this.hashArquivo, expressao, operador, direito);
         }
 
         return expressao;
@@ -623,13 +446,7 @@ export class AvaliadorSintaticoEguaP implements AvaliadorSintaticoInterface {
                 const simbolo = expressao.simbolo;
                 return new Atribuir(this.hashArquivo, simbolo, valor);
             } else if (expressao instanceof AcessoMetodo) {
-                return new DefinirValor(
-                    this.hashArquivo,
-                    0,
-                    expressao.objeto,
-                    expressao.simbolo,
-                    valor
-                );
+                return new DefinirValor(this.hashArquivo, 0, expressao.objeto, expressao.simbolo, valor);
             } else if (expressao instanceof AcessoIndiceVariavel) {
                 return new AtribuicaoSobrescrita(
                     this.hashArquivo,
@@ -646,18 +463,14 @@ export class AvaliadorSintaticoEguaP implements AvaliadorSintaticoInterface {
     }
 
     expressao(): Construto {
-        if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.LEIA))
-            return this.declaracaoLeia();
+        if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.LEIA)) return this.declaracaoLeia();
         return this.atribuir();
     }
 
     declaracaoEscreva(): Escreva {
         const simboloAtual = this.simboloAtual();
 
-        this.consumir(
-            tiposDeSimbolos.PARENTESE_ESQUERDO,
-            "Esperado '(' antes dos valores em escreva."
-        );
+        this.consumir(tiposDeSimbolos.PARENTESE_ESQUERDO, "Esperado '(' antes dos valores em escreva.");
 
         const argumentos: Array<Construto> = [];
 
@@ -665,16 +478,9 @@ export class AvaliadorSintaticoEguaP implements AvaliadorSintaticoInterface {
             argumentos.push(this.expressao());
         } while (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.VIRGULA));
 
-        this.consumir(
-            tiposDeSimbolos.PARENTESE_DIREITO,
-            "Esperado ')' após os valores em escreva."
-        );
+        this.consumir(tiposDeSimbolos.PARENTESE_DIREITO, "Esperado ')' após os valores em escreva.");
 
-        return new Escreva(
-            Number(simboloAtual.linha),
-            simboloAtual.hashArquivo,
-            argumentos
-        );
+        return new Escreva(Number(simboloAtual.linha), simboloAtual.hashArquivo, argumentos);
     }
 
     declaracaoExpressao() {
@@ -685,10 +491,7 @@ export class AvaliadorSintaticoEguaP implements AvaliadorSintaticoInterface {
     declaracaoLeia(): Leia {
         const simboloAtual = this.simbolos[this.atual];
 
-        this.consumir(
-            tiposDeSimbolos.PARENTESE_ESQUERDO,
-            "Esperado '(' antes dos valores em leia."
-        );
+        this.consumir(tiposDeSimbolos.PARENTESE_ESQUERDO, "Esperado '(' antes dos valores em leia.");
 
         const argumentos: Construto[] = [];
 
@@ -696,10 +499,7 @@ export class AvaliadorSintaticoEguaP implements AvaliadorSintaticoInterface {
             argumentos.push(this.expressao());
         } while (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.VIRGULA));
 
-        this.consumir(
-            tiposDeSimbolos.PARENTESE_DIREITO,
-            "Esperado ')' após os valores em leia."
-        );
+        this.consumir(tiposDeSimbolos.PARENTESE_DIREITO, "Esperado ')' após os valores em leia.");
 
         return new Leia(simboloAtual.hashArquivo, Number(simboloAtual.linha), argumentos);
     }
@@ -722,10 +522,8 @@ export class AvaliadorSintaticoEguaP implements AvaliadorSintaticoInterface {
             // Verifica-se o número de espaços à esquerda da linha através dos pragmas.
             // Se número de espaços da linha do símbolo atual é menor ou igual ao número de espaços
             // da linha anterior, e bloco ainda não começou, é uma situação de erro.
-            let espacosIndentacaoLinhaAtual =
-                this.pragmas[simboloAtual.linha].espacosIndentacao;
-            const espacosIndentacaoLinhaAnterior =
-                this.pragmas[simboloAnterior.linha].espacosIndentacao;
+            let espacosIndentacaoLinhaAtual = this.pragmas[simboloAtual.linha].espacosIndentacao;
+            const espacosIndentacaoLinhaAnterior = this.pragmas[simboloAnterior.linha].espacosIndentacao;
             if (espacosIndentacaoLinhaAtual <= espacosIndentacaoLinhaAnterior) {
                 this.erro(
                     simboloAtual,
@@ -744,8 +542,7 @@ export class AvaliadorSintaticoEguaP implements AvaliadorSintaticoInterface {
                     declaracoes.push(this.declaracao());
                     simboloAtual = this.simboloAtual();
                     if (!simboloAtual) break;
-                    espacosIndentacaoLinhaAtual =
-                        this.pragmas[simboloAtual.linha].espacosIndentacao;
+                    espacosIndentacaoLinhaAtual = this.pragmas[simboloAtual.linha].espacosIndentacao;
                 }
             }
         }
@@ -754,34 +551,17 @@ export class AvaliadorSintaticoEguaP implements AvaliadorSintaticoInterface {
     }
 
     declaracaoSe(): Se {
-        this.consumir(
-            tiposDeSimbolos.PARENTESE_ESQUERDO,
-            "Esperado '(' após 'se'."
-        );
+        this.consumir(tiposDeSimbolos.PARENTESE_ESQUERDO, "Esperado '(' após 'se'.");
         const condicao = this.expressao();
-        this.consumir(
-            tiposDeSimbolos.PARENTESE_DIREITO,
-            "Esperado ')' após condição do se."
-        );
+        this.consumir(tiposDeSimbolos.PARENTESE_DIREITO, "Esperado ')' após condição do se.");
 
         const caminhoEntao = this.resolverDeclaracao();
 
         const caminhosSeSenao = [];
-        while (
-            this.verificarSeSimboloAtualEIgualA(
-                tiposDeSimbolos.SENAOSE,
-                tiposDeSimbolos.SENÃOSE
-            )
-        ) {
-            this.consumir(
-                tiposDeSimbolos.PARENTESE_ESQUERDO,
-                "Esperado '(' após 'senaose' ou 'senãose'."
-            );
+        while (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.SENAOSE, tiposDeSimbolos.SENÃOSE)) {
+            this.consumir(tiposDeSimbolos.PARENTESE_ESQUERDO, "Esperado '(' após 'senaose' ou 'senãose'.");
             const condicaoSeSenao = this.expressao();
-            this.consumir(
-                tiposDeSimbolos.PARENTESE_DIREITO,
-                "Esperado ')' após codição do 'senaose' ou 'senãose'."
-            );
+            this.consumir(tiposDeSimbolos.PARENTESE_DIREITO, "Esperado ')' após codição do 'senaose' ou 'senãose'.");
 
             const caminho = this.resolverDeclaracao();
 
@@ -798,12 +578,7 @@ export class AvaliadorSintaticoEguaP implements AvaliadorSintaticoInterface {
         } */
 
         let caminhoSenao = null;
-        if (
-            this.verificarSeSimboloAtualEIgualA(
-                tiposDeSimbolos.SENAO,
-                tiposDeSimbolos.SENÃO
-            )
-        ) {
+        if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.SENAO, tiposDeSimbolos.SENÃO)) {
             caminhoSenao = this.resolverDeclaracao();
         }
 
@@ -812,105 +587,68 @@ export class AvaliadorSintaticoEguaP implements AvaliadorSintaticoInterface {
 
     declaracaoEnquanto(): Enquanto {
         try {
-            this.ciclos += 1;
+            this.blocos += 1;
 
-            this.consumir(
-                tiposDeSimbolos.PARENTESE_ESQUERDO,
-                "Esperado '(' após 'enquanto'."
-            );
+            this.consumir(tiposDeSimbolos.PARENTESE_ESQUERDO, "Esperado '(' após 'enquanto'.");
             const condicao = this.expressao();
-            this.consumir(
-                tiposDeSimbolos.PARENTESE_DIREITO,
-                "Esperado ')' após condicional."
-            );
+            this.consumir(tiposDeSimbolos.PARENTESE_DIREITO, "Esperado ')' após condicional.");
             const corpo = this.resolverDeclaracao();
 
             return new Enquanto(condicao, corpo);
         } finally {
-            this.ciclos -= 1;
+            this.blocos -= 1;
         }
     }
 
     declaracaoPara(): Para {
         try {
             const simboloPara: SimboloInterface = this.simboloAnterior();
-            this.ciclos += 1;
+            this.blocos += 1;
 
-            this.consumir(
-                tiposDeSimbolos.PARENTESE_ESQUERDO,
-                "Esperado '(' após 'para'."
-            );
+            this.consumir(tiposDeSimbolos.PARENTESE_ESQUERDO, "Esperado '(' após 'para'.");
 
             let inicializador: Var | Expressao;
-            if (
-                this.verificarSeSimboloAtualEIgualA(
-                    tiposDeSimbolos.PONTO_E_VIRGULA
-                )
-            ) {
+            if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.PONTO_E_VIRGULA)) {
                 inicializador = null;
-            } else if (
-                this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.VARIAVEL)
-            ) {
+            } else if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.VARIAVEL)) {
                 inicializador = this.declaracaoDeVariavel();
             } else {
                 inicializador = this.declaracaoExpressao();
             }
 
             let condicao = null;
-            if (
-                !this.verificarTipoSimboloAtual(tiposDeSimbolos.PONTO_E_VIRGULA)
-            ) {
+            if (!this.verificarTipoSimboloAtual(tiposDeSimbolos.PONTO_E_VIRGULA)) {
                 condicao = this.expressao();
             }
 
             let incrementar = null;
-            if (
-                !this.verificarTipoSimboloAtual(
-                    tiposDeSimbolos.PARENTESE_DIREITO
-                )
-            ) {
+            if (!this.verificarTipoSimboloAtual(tiposDeSimbolos.PARENTESE_DIREITO)) {
                 incrementar = this.expressao();
             }
 
-            this.consumir(
-                tiposDeSimbolos.PARENTESE_DIREITO,
-                "Esperado ')' após cláusulas"
-            );
+            this.consumir(tiposDeSimbolos.PARENTESE_DIREITO, "Esperado ')' após cláusulas");
 
             const corpo = this.resolverDeclaracao();
 
-            return new Para(
-                this.hashArquivo,
-                Number(simboloPara.linha),
-                inicializador,
-                condicao,
-                incrementar,
-                corpo
-            );
+            return new Para(this.hashArquivo, Number(simboloPara.linha), inicializador, condicao, incrementar, corpo);
         } catch (erro) {
             throw erro;
         } finally {
-            this.ciclos -= 1;
+            this.blocos -= 1;
         }
     }
 
     declaracaoSustar() {
-        if (this.ciclos < 1) {
-            this.erro(
-                this.simboloAnterior(),
-                "'sustar' deve estar dentro de um laço de repetição."
-            );
+        if (this.blocos < 1) {
+            this.erro(this.simboloAnterior(), "'sustar' deve estar dentro de um laço de repetição.");
         }
 
         return new Sustar(this.simboloAtual());
     }
 
     declaracaoContinua(): Continua {
-        if (this.ciclos < 1) {
-            this.erro(
-                this.simboloAnterior(),
-                "'continua' precisa estar em um laço de repetição."
-            );
+        if (this.blocos < 1) {
+            this.erro(this.simboloAnterior(), "'continua' precisa estar em um laço de repetição.");
         }
 
         return new Continua(this.simboloAtual());
@@ -929,39 +667,23 @@ export class AvaliadorSintaticoEguaP implements AvaliadorSintaticoInterface {
 
     declaracaoEscolha(): Escolha {
         try {
-            this.ciclos += 1;
+            this.blocos += 1;
 
-            this.consumir(
-                tiposDeSimbolos.DOIS_PONTOS,
-                "Esperado ':' após 'escolha'."
-            );
+            this.consumir(tiposDeSimbolos.DOIS_PONTOS, "Esperado ':' após 'escolha'.");
 
             const condicao = this.expressao();
 
             const caminhos = [];
             let caminhoPadrao = null;
-            while (
-                !this.verificarSeSimboloAtualEIgualA(
-                    tiposDeSimbolos.CHAVE_DIREITA
-                ) &&
-                !this.estaNoFinal()
-            ) {
+            while (!this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.CHAVE_DIREITA) && !this.estaNoFinal()) {
                 if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.CASO)) {
                     const caminhoCondicoes = [this.expressao()];
-                    this.consumir(
-                        tiposDeSimbolos.DOIS_PONTOS,
-                        "Esperado ':' após o 'caso'."
-                    );
+                    this.consumir(tiposDeSimbolos.DOIS_PONTOS, "Esperado ':' após o 'caso'.");
 
-                    while (
-                        this.verificarTipoSimboloAtual(tiposDeSimbolos.CASO)
-                    ) {
+                    while (this.verificarTipoSimboloAtual(tiposDeSimbolos.CASO)) {
                         this.consumir(tiposDeSimbolos.CASO, null);
                         caminhoCondicoes.push(this.expressao());
-                        this.consumir(
-                            tiposDeSimbolos.DOIS_PONTOS,
-                            "Esperado ':' após declaração do 'caso'."
-                        );
+                        this.consumir(tiposDeSimbolos.DOIS_PONTOS, "Esperado ':' após declaração do 'caso'.");
                     }
 
                     const declaracoes = [];
@@ -969,21 +691,15 @@ export class AvaliadorSintaticoEguaP implements AvaliadorSintaticoInterface {
                         declaracoes.push(this.resolverDeclaracao());
                     } while (
                         !this.verificarTipoSimboloAtual(tiposDeSimbolos.CASO) &&
-                        !this.verificarTipoSimboloAtual(
-                            tiposDeSimbolos.PADRAO
-                        ) &&
-                        !this.verificarTipoSimboloAtual(
-                            tiposDeSimbolos.CHAVE_DIREITA
-                        )
+                        !this.verificarTipoSimboloAtual(tiposDeSimbolos.PADRAO) &&
+                        !this.verificarTipoSimboloAtual(tiposDeSimbolos.CHAVE_DIREITA)
                     );
 
                     caminhos.push({
                         condicoes: caminhoCondicoes,
                         declaracoes,
                     });
-                } else if (
-                    this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.PADRAO)
-                ) {
+                } else if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.PADRAO)) {
                     if (caminhoPadrao !== null) {
                         const excecao = new ErroAvaliadorSintatico(
                             this.simboloAtual(),
@@ -993,22 +709,15 @@ export class AvaliadorSintaticoEguaP implements AvaliadorSintaticoInterface {
                         throw excecao;
                     }
 
-                    this.consumir(
-                        tiposDeSimbolos.DOIS_PONTOS,
-                        "Esperado ':' após declaração do 'padrao'."
-                    );
+                    this.consumir(tiposDeSimbolos.DOIS_PONTOS, "Esperado ':' após declaração do 'padrao'.");
 
                     const declaracoes = [];
                     do {
                         declaracoes.push(this.resolverDeclaracao());
                     } while (
                         !this.verificarTipoSimboloAtual(tiposDeSimbolos.CASO) &&
-                        !this.verificarTipoSimboloAtual(
-                            tiposDeSimbolos.PADRAO
-                        ) &&
-                        !this.verificarTipoSimboloAtual(
-                            tiposDeSimbolos.CHAVE_DIREITA
-                        )
+                        !this.verificarTipoSimboloAtual(tiposDeSimbolos.PADRAO) &&
+                        !this.verificarTipoSimboloAtual(tiposDeSimbolos.CHAVE_DIREITA)
                     );
 
                     caminhoPadrao = {
@@ -1019,66 +728,43 @@ export class AvaliadorSintaticoEguaP implements AvaliadorSintaticoInterface {
 
             return new Escolha(condicao, caminhos, caminhoPadrao);
         } finally {
-            this.ciclos -= 1;
+            this.blocos -= 1;
         }
     }
 
     declaracaoImportar(): Importar {
-        this.consumir(
-            tiposDeSimbolos.PARENTESE_ESQUERDO,
-            "Esperado '(' após declaração."
-        );
+        this.consumir(tiposDeSimbolos.PARENTESE_ESQUERDO, "Esperado '(' após declaração.");
 
         const caminho = this.expressao();
 
-        const simboloFechamento = this.consumir(
-            tiposDeSimbolos.PARENTESE_DIREITO,
-            "Esperado ')' após declaração."
-        );
+        const simboloFechamento = this.consumir(tiposDeSimbolos.PARENTESE_DIREITO, "Esperado ')' após declaração.");
 
         return new Importar(caminho as Literal, simboloFechamento);
     }
 
     declaracaoTente(): Tente {
         const simboloTente: SimboloInterface = this.simboloAnterior();
-        this.consumir(
-            tiposDeSimbolos.DOIS_PONTOS,
-            "Esperado ':' após a declaração 'tente'."
-        );
+        this.consumir(tiposDeSimbolos.DOIS_PONTOS, "Esperado ':' após a declaração 'tente'.");
 
         const blocoTente = this.blocoEscopo();
 
         let blocoPegue = null;
         if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.PEGUE)) {
-            this.consumir(
-                tiposDeSimbolos.DOIS_PONTOS,
-                "Esperado ':' após a declaração 'pegue'."
-            );
+            this.consumir(tiposDeSimbolos.DOIS_PONTOS, "Esperado ':' após a declaração 'pegue'.");
 
             blocoPegue = this.blocoEscopo();
         }
 
         let blocoSenao = null;
-        if (
-            this.verificarSeSimboloAtualEIgualA(
-                tiposDeSimbolos.SENAO,
-                tiposDeSimbolos.SENÃO
-            )
-        ) {
-            this.consumir(
-                tiposDeSimbolos.DOIS_PONTOS,
-                "Esperado ':' após a declaração 'pegue'."
-            );
+        if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.SENAO, tiposDeSimbolos.SENÃO)) {
+            this.consumir(tiposDeSimbolos.DOIS_PONTOS, "Esperado ':' após a declaração 'pegue'.");
 
             blocoSenao = this.blocoEscopo();
         }
 
         let blocoFinalmente = null;
         if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.FINALMENTE)) {
-            this.consumir(
-                tiposDeSimbolos.DOIS_PONTOS,
-                "Esperado ':' após a declaração 'pegue'."
-            );
+            this.consumir(tiposDeSimbolos.DOIS_PONTOS, "Esperado ':' após a declaração 'pegue'.");
 
             blocoFinalmente = this.blocoEscopo();
         }
@@ -1096,78 +782,48 @@ export class AvaliadorSintaticoEguaP implements AvaliadorSintaticoInterface {
     declaracaoFazer(): Fazer {
         const simboloFazer: SimboloInterface = this.simboloAnterior();
         try {
-            this.ciclos += 1;
+            this.blocos += 1;
 
             const caminhoFazer = this.resolverDeclaracao();
 
-            this.consumir(
-                tiposDeSimbolos.ENQUANTO,
-                "Esperado declaração do 'enquanto' após o escopo do 'fazer'."
-            );
-            this.consumir(
-                tiposDeSimbolos.PARENTESE_ESQUERDO,
-                "Esperado '(' após declaração 'enquanto'."
-            );
+            this.consumir(tiposDeSimbolos.ENQUANTO, "Esperado declaração do 'enquanto' após o escopo do 'fazer'.");
+            this.consumir(tiposDeSimbolos.PARENTESE_ESQUERDO, "Esperado '(' após declaração 'enquanto'.");
 
             const condicaoEnquanto = this.expressao();
 
-            this.consumir(
-                tiposDeSimbolos.PARENTESE_DIREITO,
-                "Esperado ')' após declaração do 'enquanto'."
-            );
-
-            return new Fazer(
-                simboloFazer.hashArquivo,
-                Number(simboloFazer.linha),
-                caminhoFazer,
-                condicaoEnquanto
-            );
+            this.consumir(tiposDeSimbolos.PARENTESE_DIREITO, "Esperado ')' após declaração do 'enquanto'.");
+
+            return new Fazer(simboloFazer.hashArquivo, Number(simboloFazer.linha), caminhoFazer, condicaoEnquanto);
         } finally {
-            this.ciclos -= 1;
+            this.blocos -= 1;
         }
     }
 
     resolverDeclaracao(): RetornoResolverDeclaracao {
-        if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.FAZER))
-            return this.declaracaoFazer();
-        if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.TENTE))
-            return this.declaracaoTente();
-        if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.ESCOLHA))
-            return this.declaracaoEscolha();
-        if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.RETORNA))
-            return this.declaracaoRetorna();
-        if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.CONTINUA))
-            return this.declaracaoContinua();
+        if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.FAZER)) return this.declaracaoFazer();
+        if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.TENTE)) return this.declaracaoTente();
+        if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.ESCOLHA)) return this.declaracaoEscolha();
+        if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.RETORNA)) return this.declaracaoRetorna();
+        if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.CONTINUA)) return this.declaracaoContinua();
         if (
             this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.SUSTAR) ||
             this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.PAUSA)
         )
             return this.declaracaoSustar();
-        if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.PARA))
-            return this.declaracaoPara();
-        if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.ENQUANTO))
-            return this.declaracaoEnquanto();
-        if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.SE))
-            return this.declaracaoSe();
-        if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.ESCREVA))
-            return this.declaracaoEscreva();
+        if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.PARA)) return this.declaracaoPara();
+        if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.ENQUANTO)) return this.declaracaoEnquanto();
+        if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.SE)) return this.declaracaoSe();
+        if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.ESCREVA)) return this.declaracaoEscreva();
         if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.DOIS_PONTOS)) {
             const simboloInicioBloco: SimboloInterface = this.simboloAnterior();
-            return new Bloco(
-                simboloInicioBloco.hashArquivo,
-                Number(simboloInicioBloco.linha),
-                this.blocoEscopo()
-            );
+            return new Bloco(simboloInicioBloco.hashArquivo, Number(simboloInicioBloco.linha), this.blocoEscopo());
         }
 
         return this.declaracaoExpressao();
     }
 
     declaracaoDeVariavel(): Var {
-        const simbolo: SimboloInterface = this.consumir(
-            tiposDeSimbolos.IDENTIFICADOR,
-            'Esperado nome de variável.'
-        );
+        const simbolo: SimboloInterface = this.consumir(tiposDeSimbolos.IDENTIFICADOR, 'Esperado nome de variável.');
         let inicializador = null;
         if (
             this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.IGUAL) ||
@@ -1180,10 +836,7 @@ export class AvaliadorSintaticoEguaP implements AvaliadorSintaticoInterface {
     }
 
     funcao(tipo: string): FuncaoDeclaracao {
-        const simbolo: SimboloInterface = this.consumir(
-            tiposDeSimbolos.IDENTIFICADOR,
-            `Esperado nome ${tipo}.`
-        );
+        const simbolo: SimboloInterface = this.consumir(tiposDeSimbolos.IDENTIFICADOR, `Esperado nome ${tipo}.`);
         return new FuncaoDeclaracao(simbolo, this.corpoDaFuncao(tipo));
     }
 
@@ -1192,10 +845,7 @@ export class AvaliadorSintaticoEguaP implements AvaliadorSintaticoInterface {
 
         do {
             if (parametros.length >= 255) {
-                this.erro(
-                    this.simboloAtual(),
-                    'Não pode haver mais de 255 parâmetros'
-                );
+                this.erro(this.simboloAtual(), 'Não pode haver mais de 255 parâmetros');
             }
 
             const parametro = {};
@@ -1207,10 +857,7 @@ export class AvaliadorSintaticoEguaP implements AvaliadorSintaticoInterface {
                 parametro['tipo'] = 'padrao';
             }
 
-            parametro['nome'] = this.consumir(
-                tiposDeSimbolos.IDENTIFICADOR,
-                'Esperado nome do parâmetro.'
-            );
+            parametro['nome'] = this.consumir(tiposDeSimbolos.IDENTIFICADOR, 'Esperado nome do parâmetro.');
 
             if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.IGUAL)) {
                 parametro['valorPadrao'] = this.primario();
@@ -1224,27 +871,16 @@ export class AvaliadorSintaticoEguaP implements AvaliadorSintaticoInterface {
     }
 
     corpoDaFuncao(tipo: string): FuncaoConstruto {
-        this.consumir(
-            tiposDeSimbolos.PARENTESE_ESQUERDO,
-            `Esperado '(' após o nome ${tipo}.`
-        );
+        this.consumir(tiposDeSimbolos.PARENTESE_ESQUERDO, `Esperado '(' após o nome ${tipo}.`);
 
         let parametros = [];
-        if (
-            !this.verificarTipoSimboloAtual(tiposDeSimbolos.PARENTESE_DIREITO)
-        ) {
+        if (!this.verificarTipoSimboloAtual(tiposDeSimbolos.PARENTESE_DIREITO)) {
             parametros = this.logicaComumParametros();
         }
 
-        this.consumir(
-            tiposDeSimbolos.PARENTESE_DIREITO,
-            "Esperado ')' após parâmetros."
-        );
+        this.consumir(tiposDeSimbolos.PARENTESE_DIREITO, "Esperado ')' após parâmetros.");
 
-        this.consumir(
-            tiposDeSimbolos.DOIS_PONTOS,
-            `Esperado ':' antes do escopo do ${tipo}.`
-        );
+        this.consumir(tiposDeSimbolos.DOIS_PONTOS, `Esperado ':' antes do escopo do ${tipo}.`);
 
         const corpo = this.blocoEscopo();
 
@@ -1252,33 +888,18 @@ export class AvaliadorSintaticoEguaP implements AvaliadorSintaticoInterface {
     }
 
     declaracaoDeClasse(): Classe {
-        const simbolo: SimboloInterface = this.consumir(
-            tiposDeSimbolos.IDENTIFICADOR,
-            'Esperado nome da classe.'
-        );
+        const simbolo: SimboloInterface = this.consumir(tiposDeSimbolos.IDENTIFICADOR, 'Esperado nome da classe.');
 
         let superClasse = null;
         if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.HERDA)) {
-            this.consumir(
-                tiposDeSimbolos.IDENTIFICADOR,
-                'Esperado nome da SuperClasse.'
-            );
-            superClasse = new Variavel(
-                this.hashArquivo,
-                this.simboloAnterior()
-            );
+            this.consumir(tiposDeSimbolos.IDENTIFICADOR, 'Esperado nome da SuperClasse.');
+            superClasse = new Variavel(this.hashArquivo, this.simboloAnterior());
         }
 
-        this.consumir(
-            tiposDeSimbolos.DOIS_PONTOS,
-            "Esperado ':' antes do escopo da classe."
-        );
+        this.consumir(tiposDeSimbolos.DOIS_PONTOS, "Esperado ':' antes do escopo da classe.");
 
         const metodos = [];
-        while (
-            !this.verificarTipoSimboloAtual(tiposDeSimbolos.CHAVE_DIREITA) &&
-            !this.estaNoFinal()
-        ) {
+        while (!this.verificarTipoSimboloAtual(tiposDeSimbolos.CHAVE_DIREITA) && !this.estaNoFinal()) {
             metodos.push(this.funcao('método'));
         }
 
@@ -1300,10 +921,8 @@ export class AvaliadorSintaticoEguaP implements AvaliadorSintaticoInterface {
                 this.avancarEDevolverAnterior();
                 return this.funcao('funcao');
             }
-            if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.VARIAVEL))
-                return this.declaracaoDeVariavel();
-            if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.CLASSE))
-                return this.declaracaoDeClasse();
+            if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.VARIAVEL)) return this.declaracaoDeVariavel();
+            if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.CLASSE)) return this.declaracaoDeClasse();
 
             return this.resolverDeclaracao();
         } catch (erro) {
@@ -1312,14 +931,11 @@ export class AvaliadorSintaticoEguaP implements AvaliadorSintaticoInterface {
         }
     }
 
-    analisar(
-        retornoLexador: RetornoLexador,
-        hashArquivo?: number
-    ): RetornoAvaliadorSintatico {
+    analisar(retornoLexador: RetornoLexador, hashArquivo?: number): RetornoAvaliadorSintatico {
         const inicioAnalise: [number, number] = hrtime();
         this.erros = [];
         this.atual = 0;
-        this.ciclos = 0;
+        this.blocos = 0;
         this.escopos = [];
 
         this.hashArquivo = hashArquivo || 0;
@@ -1333,11 +949,7 @@ export class AvaliadorSintaticoEguaP implements AvaliadorSintaticoInterface {
 
         if (this.performance) {
             const deltaAnalise: [number, number] = hrtime(inicioAnalise);
-            console.log(
-                `[Avaliador Sintático] Tempo para análise: ${
-                    deltaAnalise[0] * 1e9 + deltaAnalise[1]
-                }ns`
-            );
+            console.log(`[Avaliador Sintático] Tempo para análise: ${deltaAnalise[0] * 1e9 + deltaAnalise[1]}ns`);
         }
 
         return {
diff --git a/fontes/avaliador-sintatico/dialetos/avaliador-sintatico-visualg.ts b/fontes/avaliador-sintatico/dialetos/avaliador-sintatico-visualg.ts
index 43c44052..a5db4d84 100644
--- a/fontes/avaliador-sintatico/dialetos/avaliador-sintatico-visualg.ts
+++ b/fontes/avaliador-sintatico/dialetos/avaliador-sintatico-visualg.ts
@@ -1,27 +1,7 @@
-import {
-    RetornoLexador,
-    RetornoAvaliadorSintatico,
-} from '../../interfaces/retornos';
+import { RetornoLexador, RetornoAvaliadorSintatico } from '../../interfaces/retornos';
 import { AvaliadorSintaticoBase } from '../avaliador-sintatico-base';
-import {
-    Bloco,
-    Declaracao,
-    Enquanto,
-    Escolha,
-    Escreva,
-    Fazer,
-    Leia,
-    Para,
-    Var,
-} from '../../declaracoes';
-import {
-    Atribuir,
-    Binario,
-    Construto,
-    FuncaoConstruto,
-    Literal,
-    Variavel,
-} from '../../construtos';
+import { Bloco, Declaracao, Enquanto, Escolha, Escreva, Fazer, Leia, Para, Var } from '../../declaracoes';
+import { Atribuir, Binario, Construto, FuncaoConstruto, Literal, Variavel } from '../../construtos';
 import { SimboloInterface } from '../../interfaces';
 import { Simbolo } from '../../lexador';
 
@@ -29,20 +9,11 @@ import tiposDeSimbolos from '../../tipos-de-simbolos/visualg';
 
 export class AvaliadorSintaticoVisuAlg extends AvaliadorSintaticoBase {
     validarSegmentoAlgoritmo(): void {
-        this.consumir(
-            tiposDeSimbolos.ALGORITMO,
-            "Esperada expressão 'algoritmo' para inicializar programa."
-        );
+        this.consumir(tiposDeSimbolos.ALGORITMO, "Esperada expressão 'algoritmo' para inicializar programa.");
 
-        this.consumir(
-            tiposDeSimbolos.CARACTERE,
-            "Esperad cadeia de caracteres após palavra-chave 'algoritmo'."
-        );
+        this.consumir(tiposDeSimbolos.CARACTERE, "Esperad cadeia de caracteres após palavra-chave 'algoritmo'.");
 
-        this.consumir(
-            tiposDeSimbolos.QUEBRA_LINHA,
-            "Esperado quebra de linha após definição do segmento 'algoritmo'."
-        );
+        this.consumir(tiposDeSimbolos.QUEBRA_LINHA, "Esperado quebra de linha após definição do segmento 'algoritmo'.");
     }
 
     /**
@@ -60,45 +31,24 @@ export class AvaliadorSintaticoVisuAlg extends AvaliadorSintaticoBase {
         this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.QUEBRA_LINHA);
 
         while (!this.verificarTipoSimboloAtual(tiposDeSimbolos.INICIO)) {
-            const identificador = this.consumir(
-                tiposDeSimbolos.IDENTIFICADOR,
-                'Esperado nome de variável.'
-            );
-            this.consumir(
-                tiposDeSimbolos.DOIS_PONTOS,
-                'Esperado dois-pontos após nome de variável.'
-            );
+            const identificador = this.consumir(tiposDeSimbolos.IDENTIFICADOR, 'Esperado nome de variável.');
+            this.consumir(tiposDeSimbolos.DOIS_PONTOS, 'Esperado dois-pontos após nome de variável.');
 
-            if (
-                !this.verificarSeSimboloAtualEIgualA(
-                    tiposDeSimbolos.INTEIRO,
-                    tiposDeSimbolos.CARACTERE
-                )
-            ) {
-                throw this.erro(
-                    this.simbolos[this.atual],
-                    'Tipo de variável não conhecido.'
-                );
+            if (!this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.INTEIRO, tiposDeSimbolos.CARACTERE)) {
+                throw this.erro(this.simbolos[this.atual], 'Tipo de variável não conhecido.');
             }
 
             const tipoVariavel = this.simbolos[this.atual - 1].tipo;
 
-            this.consumir(
-                tiposDeSimbolos.QUEBRA_LINHA,
-                'Esperado quebra de linha após declaração de variável.'
-            );
+            this.consumir(tiposDeSimbolos.QUEBRA_LINHA, 'Esperado quebra de linha após declaração de variável.');
 
             // Se chegou até aqui, variável é válida.
             switch (tipoVariavel) {
                 case tiposDeSimbolos.INTEIRO:
-                    inicializacoes.push(
-                        new Var(identificador, new Literal(-1, -1, 0))
-                    );
+                    inicializacoes.push(new Var(identificador, new Literal(-1, -1, 0)));
                     break;
                 case tiposDeSimbolos.CARACTERE:
-                    inicializacoes.push(
-                        new Var(identificador, new Literal(-1, -1, ''))
-                    );
+                    inicializacoes.push(new Var(identificador, new Literal(-1, -1, '')));
                     break;
             }
         }
@@ -118,25 +68,13 @@ export class AvaliadorSintaticoVisuAlg extends AvaliadorSintaticoBase {
     }
 
     primario(): Construto {
-        if (
-            this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.IDENTIFICADOR)
-        ) {
+        if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.IDENTIFICADOR)) {
             return new Variavel(-1, this.simbolos[this.atual - 1]);
         }
 
-        if (
-            this.verificarSeSimboloAtualEIgualA(
-                tiposDeSimbolos.NUMERO,
-                tiposDeSimbolos.CARACTERE
-            )
-        ) {
-            const simboloAnterior: SimboloInterface =
-                this.simbolos[this.atual - 1];
-            return new Literal(
-                -1,
-                Number(simboloAnterior.linha),
-                simboloAnterior.literal
-            );
+        if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.NUMERO, tiposDeSimbolos.CARACTERE)) {
+            const simboloAnterior: SimboloInterface = this.simbolos[this.atual - 1];
+            return new Literal(-1, Number(simboloAnterior.linha), simboloAnterior.literal);
         }
     }
 
@@ -147,9 +85,7 @@ export class AvaliadorSintaticoVisuAlg extends AvaliadorSintaticoBase {
     atribuir(): Construto {
         const expressao = this.ou();
 
-        if (
-            this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.SETA_ATRIBUICAO)
-        ) {
+        if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.SETA_ATRIBUICAO)) {
             const igual = this.simbolos[this.atual - 1];
             const valor = this.atribuir();
 
@@ -165,25 +101,18 @@ export class AvaliadorSintaticoVisuAlg extends AvaliadorSintaticoBase {
     }
 
     expressao(): Construto {
-        if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.LEIA))
-            return this.declaracaoLeia();
+        if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.LEIA)) return this.declaracaoLeia();
         return this.atribuir();
     }
 
     blocoEscopo(): any[] {
         const declaracoes = [];
 
-        while (
-            !this.verificarTipoSimboloAtual(tiposDeSimbolos.FIM_FUNCAO) &&
-            !this.estaNoFinal()
-        ) {
+        while (!this.verificarTipoSimboloAtual(tiposDeSimbolos.FIM_FUNCAO) && !this.estaNoFinal()) {
             declaracoes.push(this.declaracao());
         }
 
-        this.consumir(
-            tiposDeSimbolos.FIM_FUNCAO,
-            "Esperado palavra-chave 'fimfuncao' após o bloco."
-        );
+        this.consumir(tiposDeSimbolos.FIM_FUNCAO, "Esperado palavra-chave 'fimfuncao' após o bloco.");
         return declaracoes;
     }
 
@@ -192,28 +121,14 @@ export class AvaliadorSintaticoVisuAlg extends AvaliadorSintaticoBase {
     }
 
     corpoDaFuncao(tipo: any): FuncaoConstruto {
-        this.consumir(
-            tiposDeSimbolos.DOIS_PONTOS,
-            'Esperado dois-pontos após nome de função.'
-        );
+        this.consumir(tiposDeSimbolos.DOIS_PONTOS, 'Esperado dois-pontos após nome de função.');
 
         // Tipo retornado pela função.
-        if (
-            !this.verificarSeSimboloAtualEIgualA(
-                tiposDeSimbolos.INTEIRO,
-                tiposDeSimbolos.CARACTERE
-            )
-        ) {
-            throw this.erro(
-                this.simbolos[this.atual],
-                'Esperado um tipo válido para retorno de função'
-            );
+        if (!this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.INTEIRO, tiposDeSimbolos.CARACTERE)) {
+            throw this.erro(this.simbolos[this.atual], 'Esperado um tipo válido para retorno de função');
         }
 
-        this.consumir(
-            tiposDeSimbolos.QUEBRA_LINHA,
-            "Esperado quebra de linha após tipo retornado por 'funcao'."
-        );
+        this.consumir(tiposDeSimbolos.QUEBRA_LINHA, "Esperado quebra de linha após tipo retornado por 'funcao'.");
 
         this.validarSegmentoVar();
         this.validarSegmentoInicio('função');
@@ -241,29 +156,21 @@ export class AvaliadorSintaticoVisuAlg extends AvaliadorSintaticoBase {
         const declaracoes = [];
         do {
             declaracoes.push(this.declaracao());
-        } while (
-            ![tiposDeSimbolos.FIM_ENQUANTO].includes(
-                this.simbolos[this.atual].tipo
-            )
-        );
+        } while (![tiposDeSimbolos.FIM_ENQUANTO].includes(this.simbolos[this.atual].tipo));
 
         this.consumir(
             tiposDeSimbolos.FIM_ENQUANTO,
             "Esperado palavra-chave 'fimenquanto' para fechamento de declaração 'enquanto'."
         );
 
-        this.consumir(
-            tiposDeSimbolos.QUEBRA_LINHA,
-            "Esperado quebra de linha após palavra-chave 'fimenquanto'."
-        );
+        this.consumir(tiposDeSimbolos.QUEBRA_LINHA, "Esperado quebra de linha após palavra-chave 'fimenquanto'.");
 
         return new Enquanto(condicao, declaracoes);
     }
 
     logicaCasosEscolha(): any {
         const literais = [];
-        let simboloAtualCaso: SimboloInterface =
-            this.avancarEDevolverAnterior();
+        let simboloAtualCaso: SimboloInterface = this.avancarEDevolverAnterior();
         while (simboloAtualCaso.tipo !== tiposDeSimbolos.QUEBRA_LINHA) {
             literais.push(this.primario());
             this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.VIRGULA);
@@ -280,13 +187,8 @@ export class AvaliadorSintaticoVisuAlg extends AvaliadorSintaticoBase {
 
         // Blocos de caso
         const caminhos = [];
-        let simboloAtualBlocoCaso: SimboloInterface =
-            this.avancarEDevolverAnterior();
-        while (
-            ![tiposDeSimbolos.OUTRO_CASO, tiposDeSimbolos.FIM_ESCOLHA].includes(
-                simboloAtualBlocoCaso.tipo
-            )
-        ) {
+        let simboloAtualBlocoCaso: SimboloInterface = this.avancarEDevolverAnterior();
+        while (![tiposDeSimbolos.OUTRO_CASO, tiposDeSimbolos.FIM_ESCOLHA].includes(simboloAtualBlocoCaso.tipo)) {
             const caminhoCondicoes = this.logicaCasosEscolha();
             this.consumir(
                 tiposDeSimbolos.QUEBRA_LINHA,
@@ -297,16 +199,14 @@ export class AvaliadorSintaticoVisuAlg extends AvaliadorSintaticoBase {
             do {
                 declaracoes.push(this.declaracao());
             } while (
-                ![
-                    tiposDeSimbolos.CASO,
-                    tiposDeSimbolos.OUTRO_CASO,
-                    tiposDeSimbolos.FIM_ESCOLHA,
-                ].includes(this.simbolos[this.atual].tipo)
+                ![tiposDeSimbolos.CASO, tiposDeSimbolos.OUTRO_CASO, tiposDeSimbolos.FIM_ESCOLHA].includes(
+                    this.simbolos[this.atual].tipo
+                )
             );
 
             caminhos.push({
                 condicoes: caminhoCondicoes.filter((c: any) => c),
-                declaracoes: declaracoes.filter(d => d),
+                declaracoes: declaracoes.filter((d) => d),
             });
 
             simboloAtualBlocoCaso = this.avancarEDevolverAnterior();
@@ -317,12 +217,10 @@ export class AvaliadorSintaticoVisuAlg extends AvaliadorSintaticoBase {
             const declaracoes = [];
             do {
                 declaracoes.push(this.declaracao());
-            } while (
-                !this.verificarTipoSimboloAtual(tiposDeSimbolos.FIM_ESCOLHA)
-            );
+            } while (!this.verificarTipoSimboloAtual(tiposDeSimbolos.FIM_ESCOLHA));
 
             caminhoPadrao = {
-                declaracoes: declaracoes.filter(d => d),
+                declaracoes: declaracoes.filter((d) => d),
             };
         }
 
@@ -331,10 +229,7 @@ export class AvaliadorSintaticoVisuAlg extends AvaliadorSintaticoBase {
             "Esperado palavra-chave 'fimescolha' para fechamento de declaração 'escolha'."
         );
 
-        this.consumir(
-            tiposDeSimbolos.QUEBRA_LINHA,
-            "Esperado quebra de linha após palavra-chave 'fimescolha'."
-        );
+        this.consumir(tiposDeSimbolos.QUEBRA_LINHA, "Esperado quebra de linha após palavra-chave 'fimescolha'.");
 
         return new Escolha(identificador, caminhos, caminhoPadrao);
     }
@@ -342,17 +237,11 @@ export class AvaliadorSintaticoVisuAlg extends AvaliadorSintaticoBase {
     declaracaoEscreva(): Escreva {
         const simboloAtual = this.avancarEDevolverAnterior();
 
-        this.consumir(
-            tiposDeSimbolos.PARENTESE_ESQUERDO,
-            "Esperado '(' antes dos valores em escreva."
-        );
+        this.consumir(tiposDeSimbolos.PARENTESE_ESQUERDO, "Esperado '(' antes dos valores em escreva.");
 
         const valor = this.declaracao();
 
-        this.consumir(
-            tiposDeSimbolos.PARENTESE_DIREITO,
-            "Esperado ')' após os valores em escreva."
-        );
+        this.consumir(tiposDeSimbolos.PARENTESE_DIREITO, "Esperado ')' após os valores em escreva.");
 
         this.consumir(
             tiposDeSimbolos.QUEBRA_LINHA,
@@ -369,17 +258,12 @@ export class AvaliadorSintaticoVisuAlg extends AvaliadorSintaticoBase {
     declaracaoFazer(): Fazer {
         const simboloAtual = this.avancarEDevolverAnterior();
 
-        this.consumir(
-            tiposDeSimbolos.QUEBRA_LINHA,
-            "Esperado quebra de linha após instrução 'repita'."
-        );
+        this.consumir(tiposDeSimbolos.QUEBRA_LINHA, "Esperado quebra de linha após instrução 'repita'.");
 
         const declaracoes = [];
         do {
             declaracoes.push(this.declaracao());
-        } while (
-            ![tiposDeSimbolos.ATE].includes(this.simbolos[this.atual].tipo)
-        );
+        } while (![tiposDeSimbolos.ATE].includes(this.simbolos[this.atual].tipo));
 
         this.consumir(
             tiposDeSimbolos.ATE,
@@ -399,17 +283,11 @@ export class AvaliadorSintaticoVisuAlg extends AvaliadorSintaticoBase {
     declaracaoLeia(): Leia {
         const simboloAtual = this.avancarEDevolverAnterior();
 
-        this.consumir(
-            tiposDeSimbolos.PARENTESE_ESQUERDO,
-            "Esperado '(' antes dos valores em leia."
-        );
+        this.consumir(tiposDeSimbolos.PARENTESE_ESQUERDO, "Esperado '(' antes dos valores em leia.");
 
         const valor = this.declaracao();
 
-        this.consumir(
-            tiposDeSimbolos.PARENTESE_DIREITO,
-            "Esperado ')' após os valores em leia."
-        );
+        this.consumir(tiposDeSimbolos.PARENTESE_DIREITO, "Esperado ')' após os valores em leia.");
 
         this.consumir(
             tiposDeSimbolos.QUEBRA_LINHA,
@@ -427,10 +305,7 @@ export class AvaliadorSintaticoVisuAlg extends AvaliadorSintaticoBase {
             "Esperado identificador de variável após 'para'."
         );
 
-        this.consumir(
-            tiposDeSimbolos.DE,
-            "Esperado palavra reservada 'de' após variáve de controle de 'para'."
-        );
+        this.consumir(tiposDeSimbolos.DE, "Esperado palavra reservada 'de' após variáve de controle de 'para'.");
 
         const numeroInicio = this.consumir(
             tiposDeSimbolos.NUMERO,
@@ -464,10 +339,7 @@ export class AvaliadorSintaticoVisuAlg extends AvaliadorSintaticoBase {
             simboloAtualBlocoPara = this.avancarEDevolverAnterior();
         }
 
-        this.consumir(
-            tiposDeSimbolos.QUEBRA_LINHA,
-            "Esperado quebra de linha após palavra reservada 'fimpara'."
-        );
+        this.consumir(tiposDeSimbolos.QUEBRA_LINHA, "Esperado quebra de linha após palavra reservada 'fimpara'.");
 
         const corpo = new Bloco(
             -1,
@@ -478,21 +350,11 @@ export class AvaliadorSintaticoVisuAlg extends AvaliadorSintaticoBase {
         return new Para(
             -1,
             Number(simboloPara.linha),
-            new Atribuir(
-                -1,
-                variavelIteracao,
-                new Literal(-1, -1, numeroInicio.literal)
-            ),
+            new Atribuir(-1, variavelIteracao, new Literal(-1, -1, numeroInicio.literal)),
             new Binario(
                 -1,
                 new Variavel(-1, variavelIteracao),
-                new Simbolo(
-                    tiposDeSimbolos.MENOR,
-                    '',
-                    '',
-                    Number(simboloPara.linha),
-                    -1
-                ),
+                new Simbolo(tiposDeSimbolos.MENOR, '', '', Number(simboloPara.linha), -1),
                 new Literal(-1, -1, numeroFim.literal)
             ),
             new Atribuir(
@@ -551,13 +413,10 @@ export class AvaliadorSintaticoVisuAlg extends AvaliadorSintaticoBase {
      * @param retornoLexador Os símbolos entendidos pelo Lexador.
      * @param hashArquivo Obrigatório por interface mas não usado aqui.
      */
-    analisar(
-        retornoLexador: RetornoLexador,
-        hashArquivo?: number
-    ): RetornoAvaliadorSintatico {
+    analisar(retornoLexador: RetornoLexador, hashArquivo?: number): RetornoAvaliadorSintatico {
         this.erros = [];
         this.atual = 0;
-        this.ciclos = 0;
+        this.blocos = 0;
 
         this.simbolos = retornoLexador?.simbolos || [];
 
@@ -566,10 +425,7 @@ export class AvaliadorSintaticoVisuAlg extends AvaliadorSintaticoBase {
         declaracoes = declaracoes.concat(this.validarSegmentoVar());
         this.validarSegmentoInicio('algoritmo');
 
-        while (
-            !this.estaNoFinal() &&
-            this.simbolos[this.atual].tipo !== tiposDeSimbolos.FIM_ALGORITMO
-        ) {
+        while (!this.estaNoFinal() && this.simbolos[this.atual].tipo !== tiposDeSimbolos.FIM_ALGORITMO) {
             declaracoes.push(this.declaracao());
         }
 
diff --git a/fontes/delegua.ts b/fontes/delegua.ts
index ffc3c0a7..2a833378 100644
--- a/fontes/delegua.ts
+++ b/fontes/delegua.ts
@@ -31,6 +31,8 @@ import { InterpretadorComDepuracao } from './interpretador/interpretador-com-dep
 import { ResolvedorEguaClassico } from './resolvedor/dialetos';
 import { LexadorVisuAlg } from './lexador/dialetos/lexador-visualg';
 import { AvaliadorSintaticoVisuAlg } from './avaliador-sintatico/dialetos/avaliador-sintatico-visualg';
+import { LexadorBirl } from './lexador/dialetos/lexador-birl';
+import { AvaliadorSintaticoBirl } from './avaliador-sintatico/dialetos/avaliador-sintatico-birl';
 
 /**
  * O núcleo da linguagem.
@@ -51,12 +53,7 @@ export class Delegua implements DeleguaInterface {
 
     servidorDepuracao: ServidorDepuracao;
 
-    constructor(
-        dialeto = 'delegua',
-        performance = false,
-        depurador = false,
-        funcaoDeRetorno: Function = null
-    ) {
+    constructor(dialeto = 'delegua', performance = false, depurador = false, funcaoDeRetorno: Function = null) {
         this.arquivosAbertos = {};
         this.conteudoArquivosAbertos = {};
 
@@ -67,9 +64,7 @@ export class Delegua implements DeleguaInterface {
         switch (this.dialeto) {
             case 'egua':
                 if (depurador) {
-                    throw new Error(
-                        'Dialeto ' + this.dialeto + ' não suporta depuração.'
-                    );
+                    throw new Error('Dialeto ' + this.dialeto + ' não suporta depuração.');
                 }
 
                 this.lexador = new LexadorEguaClassico();
@@ -81,11 +76,7 @@ export class Delegua implements DeleguaInterface {
                     this.conteudoArquivosAbertos,
                     depurador
                 );
-                this.interpretador = new InterpretadorEguaClassico(
-                    this,
-                    new ResolvedorEguaClassico(),
-                    process.cwd()
-                );
+                this.interpretador = new InterpretadorEguaClassico(this, new ResolvedorEguaClassico(), process.cwd());
 
                 this.funcaoDeRetorno('Usando dialeto: Égua');
                 break;
@@ -100,17 +91,8 @@ export class Delegua implements DeleguaInterface {
                     depurador
                 );
                 this.interpretador = depurador
-                    ? new InterpretadorComDepuracao(
-                          this.importador,
-                          process.cwd(),
-                          funcaoDeRetorno
-                      )
-                    : new Interpretador(
-                          this.importador,
-                          process.cwd(),
-                          performance,
-                          funcaoDeRetorno
-                      );
+                    ? new InterpretadorComDepuracao(this.importador, process.cwd(), funcaoDeRetorno)
+                    : new Interpretador(this.importador, process.cwd(), performance, funcaoDeRetorno);
 
                 this.funcaoDeRetorno('Usando dialeto: ÉguaP');
                 break;
@@ -124,12 +106,20 @@ export class Delegua implements DeleguaInterface {
                     this.conteudoArquivosAbertos,
                     depurador
                 );
-                this.interpretador = new Interpretador(
-                    this.importador,
-                    process.cwd(),
-                    false,
-                    console.log
+                this.interpretador = new Interpretador(this.importador, process.cwd(), false, console.log);
+                break;
+            case 'birl':
+                this.lexador = new LexadorBirl();
+                this.avaliadorSintatico = new AvaliadorSintaticoBirl();
+                this.importador = new Importador(
+                    this.lexador,
+                    this.avaliadorSintatico,
+                    this.arquivosAbertos,
+                    this.conteudoArquivosAbertos,
+                    depurador
                 );
+                this.interpretador = new Interpretador(this.importador, process.cwd(), false, console.log);
+                console.log('Usando dialeto: birl');
                 break;
             default:
                 this.lexador = new Lexador(performance);
@@ -142,17 +132,8 @@ export class Delegua implements DeleguaInterface {
                     depurador
                 );
                 this.interpretador = depurador
-                    ? new InterpretadorComDepuracao(
-                          this.importador,
-                          process.cwd(),
-                          funcaoDeRetorno
-                      )
-                    : new Interpretador(
-                          this.importador,
-                          process.cwd(),
-                          performance,
-                          funcaoDeRetorno
-                      );
+                    ? new InterpretadorComDepuracao(this.importador, process.cwd(), funcaoDeRetorno)
+                    : new Interpretador(this.importador, process.cwd(), performance, funcaoDeRetorno);
 
                 this.funcaoDeRetorno('Usando dialeto: padrão');
                 break;
@@ -166,10 +147,8 @@ export class Delegua implements DeleguaInterface {
     versao(): string {
         try {
             const manifesto = caminho.resolve('package.json');
-            return (
-                JSON.parse(fs.readFileSync(manifesto, { encoding: 'utf8' }))
-                    .version || '0.9'
-            );
+
+            return JSON.parse(fs.readFileSync(manifesto, { encoding: 'utf8' })).version || '0.9';
         } catch (error: any) {
             return '0.9 (desenvolvimento)';
         }
@@ -211,8 +190,7 @@ export class Delegua implements DeleguaInterface {
      */
     async executarUmaLinha(linha: string): Promise<RetornoExecucaoInterface> {
         const retornoLexador = this.lexador.mapear([linha], -1);
-        const retornoAvaliadorSintatico =
-            this.avaliadorSintatico.analisar(retornoLexador);
+        const retornoAvaliadorSintatico = this.avaliadorSintatico.analisar(retornoLexador);
         if (
             this.afericaoErros({
                 retornoLexador,
@@ -237,8 +215,7 @@ export class Delegua implements DeleguaInterface {
     iniciarDepuracao(): void {
         this.servidorDepuracao = new ServidorDepuracao(this);
         this.servidorDepuracao.iniciarServidorDepuracao();
-        (this.interpretador as any).finalizacaoDaExecucao =
-            this.finalizarDepuracao.bind(this);
+        (this.interpretador as any).finalizacaoDaExecucao = this.finalizarDepuracao.bind(this);
     }
 
     /**
@@ -260,22 +237,14 @@ export class Delegua implements DeleguaInterface {
     afericaoErros(retornoImportador: RetornoImportador): boolean {
         if (retornoImportador.retornoLexador.erros.length > 0) {
             for (const erroLexador of retornoImportador.retornoLexador.erros) {
-                this.reportar(
-                    erroLexador.linha,
-                    ` no '${erroLexador.caractere}'`,
-                    erroLexador.mensagem
-                );
+                this.reportar(erroLexador.linha, ` no '${erroLexador.caractere}'`, erroLexador.mensagem);
             }
             return true;
         }
 
         if (retornoImportador.retornoAvaliadorSintatico.erros.length > 0) {
-            for (const erroAvaliadorSintatico of retornoImportador
-                .retornoAvaliadorSintatico.erros) {
-                this.erro(
-                    erroAvaliadorSintatico.simbolo,
-                    erroAvaliadorSintatico.message
-                );
+            for (const erroAvaliadorSintatico of retornoImportador.retornoAvaliadorSintatico.erros) {
+                this.erro(erroAvaliadorSintatico.simbolo, erroAvaliadorSintatico.message);
             }
             return true;
         }
@@ -288,9 +257,7 @@ export class Delegua implements DeleguaInterface {
      * @param caminhoRelativoArquivo O caminho no sistema operacional do arquivo a ser aberto.
      */
     async carregarArquivo(caminhoRelativoArquivo: string): Promise<any> {
-        const retornoImportador = this.importador.importar(
-            caminhoRelativoArquivo
-        );
+        const retornoImportador = this.importador.importar(caminhoRelativoArquivo);
         if (this.afericaoErros(retornoImportador)) {
             process.exit(65); // Código para erro de avaliação antes da execução
         }
@@ -310,9 +277,7 @@ export class Delegua implements DeleguaInterface {
         this.interpretador.interfaceEntradaSaida = interfaceLeitura;
 
         if (this.modoDepuracao) {
-            (
-                this.interpretador as InterpretadorComDepuracaoInterface
-            ).prepararParaDepuracao(
+            (this.interpretador as InterpretadorComDepuracaoInterface).prepararParaDepuracao(
                 retornoImportador.retornoAvaliadorSintatico.declaracoes
             );
         } else {
@@ -332,10 +297,7 @@ export class Delegua implements DeleguaInterface {
      *                       para LAIR, falso para execução por arquivo.
      * @returns Um objeto com o resultado da execução.
      */
-    async executar(
-        retornoImportador: RetornoImportador,
-        manterAmbiente = false
-    ): Promise<RetornoExecucaoInterface> {
+    async executar(retornoImportador: RetornoImportador, manterAmbiente = false): Promise<RetornoExecucaoInterface> {
         const retornoInterpretador = await this.interpretador.interpretar(
             retornoImportador.retornoAvaliadorSintatico.declaracoes,
             manterAmbiente
@@ -347,14 +309,8 @@ export class Delegua implements DeleguaInterface {
                     this.erroEmTempoDeExecucao(erroInterpretador);
                 } else {
                     const erroEmJavaScript: any = erroInterpretador as any;
-                    console.error(
-                        chalk.red(`Erro em JavaScript: `) +
-                            `${erroEmJavaScript.message}`
-                    );
-                    console.error(
-                        chalk.red(`Pilha de execução: `) +
-                            `${erroEmJavaScript.stack}`
-                    );
+                    console.error(chalk.red(`Erro em JavaScript: `) + `${erroEmJavaScript.message}`);
+                    console.error(chalk.red(`Pilha de execução: `) + `${erroEmJavaScript.stack}`);
                 }
             }
         }
@@ -371,20 +327,14 @@ export class Delegua implements DeleguaInterface {
                 chalk.red(`[Arquivo: ${this.nomeArquivo}] [Linha: ${linha}]`) + ` Erro${onde}: ${mensagem}`
             );
         else */
-        console.error(
-            chalk.red(`[Linha: ${linha}]`) + ` Erro${onde}: ${mensagem}`
-        );
+        console.error(chalk.red(`[Linha: ${linha}]`) + ` Erro${onde}: ${mensagem}`);
     }
 
     erro(simbolo: SimboloInterface, mensagemDeErro: string): void {
         if (simbolo.tipo === tiposDeSimbolos.EOF) {
             this.reportar(Number(simbolo.linha), ' no final', mensagemDeErro);
         } else {
-            this.reportar(
-                Number(simbolo.linha),
-                ` no '${simbolo.lexema}'`,
-                mensagemDeErro
-            );
+            this.reportar(Number(simbolo.linha), ` no '${simbolo.lexema}'`, mensagemDeErro);
         }
     }
 
@@ -396,15 +346,9 @@ export class Delegua implements DeleguaInterface {
                     chalk.red(`Erro: [Arquivo: ${this.nomeArquivo}] [Linha: ${erro.simbolo.linha}]`) + ` ${erro.mensagem}`
                 );
             else */
-            console.error(
-                chalk.red(`Erro: [Linha: ${erro.simbolo.linha}]`) +
-                    ` ${erro.mensagem}`
-            );
+            console.error(chalk.red(`Erro: [Linha: ${erro.simbolo.linha}]`) + ` ${erro.mensagem}`);
         } else {
-            console.error(
-                chalk.red(`Erro: [Linha: ${erro.linha || 0}]`) +
-                    ` ${erro.mensagem}`
-            );
+            console.error(chalk.red(`Erro: [Linha: ${erro.linha || 0}]`) + ` ${erro.mensagem}`);
         }
     }
 }
diff --git a/fontes/interfaces/avaliador-sintatico-interface.ts b/fontes/interfaces/avaliador-sintatico-interface.ts
index 7d03ca51..63df6c52 100644
--- a/fontes/interfaces/avaliador-sintatico-interface.ts
+++ b/fontes/interfaces/avaliador-sintatico-interface.ts
@@ -28,14 +28,11 @@ export interface AvaliadorSintaticoInterface {
     erros: ErroAvaliadorSintatico[];
 
     atual: number;
-    ciclos: number;
+    blocos: number;
 
     // sincronizar(): void;
     consumir(tipo: any, mensagemDeErro: string): any;
-    erro(
-        simbolo: SimboloInterface,
-        mensagemDeErro: string
-    ): ErroAvaliadorSintatico;
+    erro(simbolo: SimboloInterface, mensagemDeErro: string): ErroAvaliadorSintatico;
     verificarTipoSimboloAtual(tipo: string): boolean;
     verificarTipoProximoSimbolo(tipo: string): boolean;
     estaNoFinal(): boolean;
@@ -78,8 +75,5 @@ export interface AvaliadorSintaticoInterface {
     corpoDaFuncao(tipo: string): FuncaoConstruto;
     declaracaoDeClasse(): Classe;
     declaracao(): any;
-    analisar(
-        retornoLexador: RetornoLexador,
-        hashArquivo?: number
-    ): RetornoAvaliadorSintatico;
+    analisar(retornoLexador: RetornoLexador, hashArquivo?: number): RetornoAvaliadorSintatico;
 }
diff --git a/fontes/lexador/dialetos/lexador-birl.ts b/fontes/lexador/dialetos/lexador-birl.ts
index 6fa36acb..3763b45b 100644
--- a/fontes/lexador/dialetos/lexador-birl.ts
+++ b/fontes/lexador/dialetos/lexador-birl.ts
@@ -2,74 +2,180 @@ import { LexadorInterface, SimboloInterface } from '../../interfaces';
 import { RetornoLexador } from '../../interfaces/retornos';
 import { ErroLexador } from '../erro-lexador';
 import tiposDeSimbolos from '../../tipos-de-simbolos/birl';
+import { Simbolo } from '../simbolo';
+import { parse } from 'path';
+import palavrasReservadas from '../palavras-reservadas';
+import { LexadorBaseLinhaUnica } from '../lexador-base-linha-unica';
 
-export class LexadorBirl implements LexadorInterface {
-    simbolos: SimboloInterface[];
-    codigo: string | string[];
-    inicioSimbolo: number;
-    atual: number;
-    linha: number;
-    erros: ErroLexador[];
+export class LexadorBirl extends LexadorBaseLinhaUnica {
+    proximoIgualA(esperado: string): boolean {
+        if (this.eFinalDoCodigo()) {
+            return false;
+        }
 
-    eDigito(caractere: string): boolean {
-        throw new Error('Method not implemented.');
-    }
-    eAlfabeto(caractere: string): boolean {
-        throw new Error('Method not implemented.');
-    }
-    eAlfabetoOuDigito(caractere: string): boolean {
-        throw new Error('Method not implemented.');
-    }
-    eFinalDoCodigo(): boolean {
-        throw new Error('Method not implemented.');
-    }
-    avancar(): string | void {
-        throw new Error('Method not implemented.');
-    }
-    adicionarSimbolo(tipo: string, literal?: any): void {
-        throw new Error('Method not implemented.');
-    }
-    simboloAtual(): string {
-        throw new Error('Method not implemented.');
-    }
-    proximoSimbolo(): string {
-        throw new Error('Method not implemented.');
-    }
-    simboloAnterior(): string {
-        throw new Error('Method not implemented.');
+        if (this.codigo[this.atual] !== esperado) {
+            return false;
+        }
+
+        this.atual += 1;
+        return true;
     }
+
     analisarTexto(delimitador: string): void {
-        throw new Error('Method not implemented.');
+        while (this.simboloAtual() !== delimitador && !this.eFinalDoCodigo()) {
+            this.avancar();
+        }
+
+        if (this.eFinalDoCodigo()) {
+            this.erros.push({
+                linha: this.linha + 1,
+                caractere: this.simboloAnterior(),
+                mensagem: 'Caractere não finalizado',
+            } as ErroLexador);
+            return;
+        }
+
+        const valor = this.codigo.substring(this.inicioSimbolo + 1, this.atual);
+        this.adicionarSimbolo(tiposDeSimbolos.FRANGO, valor);
     }
+
     analisarNumero(): void {
-        throw new Error('Method not implemented.');
+        while (this.eDigito(this.simboloAtual())) {
+            this.avancar();
+        }
+        if (this.simboloAtual() == '.' && this.eDigito(this.proximoSimbolo())) {
+            this.avancar();
+
+            while (this.eDigito(this.simboloAtual())) {
+                this.avancar();
+            }
+        }
+        const numeroCompleto = this.codigo.substring(this.inicioSimbolo, this.atual);
+        this.adicionarSimbolo(tiposDeSimbolos.TRAPEZIO, parseFloat(numeroCompleto));
     }
+
     identificarPalavraChave(): void {
-        throw new Error('Method not implemented.');
+        while (this.simboloAtual() !== '\n' && this.simboloAtual() !== '?') {
+            this.avancar();
+        }
+
+        const proximo = this.simboloAtual();
+
+        const valor =
+            proximo !== '?'
+                ? this.codigo.substring(this.inicioSimbolo, this.atual - 1).trim()
+                : this.codigo.substring(this.inicioSimbolo, this.atual + 1).trim();
+
+        switch (valor) {
+            case 'HORA DO SHOW':
+                this.adicionarSimbolo(tiposDeSimbolos.HORA_DO_SHOW);
+                this.avancar();
+                break;
+            case 'BIRL':
+                this.adicionarSimbolo(tiposDeSimbolos.BIRL);
+                this.avancar();
+                break;
+            case 'CE QUER VER ESSA PORRA?':
+                this.adicionarSimbolo(tiposDeSimbolos.CE_QUER_VER_ESSA_PORRA);
+                this.avancar();
+                break;
+            case 'BORA CUMPADE':
+                this.adicionarSimbolo(tiposDeSimbolos.BORA_CUMPADE);
+                this.avancar();
+            default:
+                this.avancar();
+                break;
+        }
     }
+
     analisarToken(): void {
-        const caractere = this.avancar();
+        const caractere = this.simboloAtual();
 
         switch (caractere) {
             case '(':
                 this.adicionarSimbolo(tiposDeSimbolos.PARENTESE_ESQUERDO);
+                this.avancar();
                 break;
             case ')':
                 this.adicionarSimbolo(tiposDeSimbolos.PARENTESE_DIREITO);
+                this.avancar();
+                break;
+            case '=':
+                this.adicionarSimbolo(this.proximoIgualA('=') ? tiposDeSimbolos.IGUAL_IGUAL : tiposDeSimbolos.IGUAL);
+                this.avancar();
+                break;
+            case "'":
+                this.analisarTexto("'");
+                this.avancar();
+                break;
+            case '"':
+                this.avancar();
+                this.analisarTexto('"');
+                this.avancar();
+                break;
+            case ';':
+                this.adicionarSimbolo(tiposDeSimbolos.PONTO_E_VIRGULA);
+                this.avancar();
+                break;
+            case ' ':
+            case '\0':
+            case '\r':
+            case '\t':
+                this.avancar();
                 break;
             default:
-                if (this.eDigito(caractere as string)) this.analisarNumero();
-                else if (this.eAlfabeto(caractere as string))
-                    this.identificarPalavraChave();
+                if (this.eDigito(caractere)) this.analisarNumero();
+                else if (this.eAlfabeto(caractere)) this.identificarPalavraChave();
                 else
                     this.erros.push({
                         linha: this.linha,
                         caractere: caractere,
                         mensagem: 'Caractere inesperado.',
                     } as ErroLexador);
+                this.avancar();
+            // this.analisaPalavraChave();
         }
     }
-    mapear(codigo: string[], hashArquivo: number): RetornoLexador {
-        throw new Error('Method not implemented.');
+
+    // essa funcao não esta sendo usanda por enquanto
+    InjetaUmItemDentroDaLista(item: string, posicao: number): string[] {
+        let codigoComeco: string[];
+        let codigoPosPosição: string[];
+
+        for (let i in this.codigo as any) {
+            if (Number(i) === posicao) {
+                let iterador: number = Number(i);
+                while (iterador <= this.codigo.length) {
+                    codigoPosPosição.push(this.codigo[iterador]);
+                    iterador += 1;
+                }
+                break;
+            }
+            codigoComeco.push(this.codigo[i]);
+        }
+
+        return [...codigoComeco, ...codigoPosPosição];
+    }
+
+    mapear(codigo: string[], hashArquivo: number = -1): RetornoLexador {
+        this.erros = [];
+        this.simbolos = [];
+        this.inicioSimbolo = 0;
+        this.atual = 0;
+        this.linha = 1;
+
+        this.codigo = codigo.join('\n') || '';
+
+        this.codigo += '\n';
+
+        while (!this.eFinalDoCodigo()) {
+            this.inicioSimbolo = this.atual;
+            this.analisarToken();
+        }
+
+        return {
+            simbolos: this.simbolos,
+            erros: this.erros,
+        } as RetornoLexador;
     }
 }
diff --git a/fontes/lexador/dialetos/palavras-reservadas/birl.ts b/fontes/lexador/dialetos/palavras-reservadas/birl.ts
index ff8b4c56..508878de 100644
--- a/fontes/lexador/dialetos/palavras-reservadas/birl.ts
+++ b/fontes/lexador/dialetos/palavras-reservadas/birl.ts
@@ -1,1 +1,16 @@
-export default {};
+import tiposDeSimbolos from '../../../tipos-de-simbolos/birl';
+
+export default {
+    HORA_DO_SHOW: tiposDeSimbolos.HORA_DO_SHOW,
+    BIRL: tiposDeSimbolos.BIRL,
+    QUE_QUE_CE_QUER_MONSTRAO: tiposDeSimbolos.QUE_QUE_CE_QUER_MONSTRAO,
+    ELE_QUE_A_GENTE_QUER: tiposDeSimbolos.ELE_QUE_A_GENTE_QUER,
+    NAO_VAI_DAR_NAO: tiposDeSimbolos.NAO_VAI_DAR_NAO,
+    QUE_NAO_VAI_DAR_O_QUE: tiposDeSimbolos.QUE_NAO_VAI_DAR_O_QUE,
+    NEGATIVA_BAMBAM: tiposDeSimbolos.NEGATIVA_BAMBAM,
+    MAIS_QUERO_MAIS: tiposDeSimbolos.MAIS_QUERO_MAIS,
+    VAMO_MONSTRO: tiposDeSimbolos.VAMO_MONSTRO,
+    SAI_FILHO_DA_PUTA: tiposDeSimbolos.SAI_FILHO_DA_PUTA,
+    OH_O_HOME_AI_PO: tiposDeSimbolos.OH_O_HOME_AI_PO,
+    AJUDA_O_MALUCO_TA_DOENTE: tiposDeSimbolos.AJUDA_O_MALUCO_TA_DOENTE,
+};
diff --git a/fontes/lexador/lexador-base-linha-unica.ts b/fontes/lexador/lexador-base-linha-unica.ts
index 12850819..d252c42a 100644
--- a/fontes/lexador/lexador-base-linha-unica.ts
+++ b/fontes/lexador/lexador-base-linha-unica.ts
@@ -89,14 +89,9 @@ export abstract class LexadorBaseLinhaUnica implements LexadorInterface {
         return this.codigo[this.atual - 1];
     }
 
-    adicionarSimbolo(tipo: any, literal: any): void {
-        const texto: string = this.codigo[this.linha].substring(
-            this.inicioSimbolo,
-            this.atual
-        );
-        this.simbolos.push(
-            new Simbolo(tipo, literal || texto, literal, this.linha + 1, -1)
-        );
+    adicionarSimbolo(tipo: any, literal?: any): void {
+        const texto: string = this.codigo[this.linha].substring(this.inicioSimbolo, this.atual);
+        this.simbolos.push(new Simbolo(tipo, literal || texto, literal, this.linha + 1, -1));
     }
 
     simboloAtual(): string {
diff --git a/fontes/tipos-de-simbolos/birl.ts b/fontes/tipos-de-simbolos/birl.ts
index ac4d2552..58705085 100644
--- a/fontes/tipos-de-simbolos/birl.ts
+++ b/fontes/tipos-de-simbolos/birl.ts
@@ -1,18 +1,32 @@
 export default {
-    HORA_DO_SHOW: 'HORA_DO_SHOW',
+    // Comandos da linguagem do bambam
+    HORA_DO_SHOW: 'HORA DO SHOW',
     BIRL: 'BIRL',
-    CE_QUER_VER_ESSA_PORRA: 'CE_QUER_VER_ESSA_PORRA',
-    QUE_QUE_CE_QUER_MONSTRAO: 'QUE_QUE_CE_QUER_MONSTRAO',
-    ELE_QUE_A_GENTE_QUER: 'ELE_QUE_A_GENTE_QUER',
-    NAO_VAI_DAR_NAO: 'NAO_VAI_DAR_NAO',
-    QUE_NAO_VAI_DAR_O_QUE: 'QUE_NAO_VAI_DAR_O_QUE',
-    NEGATIVA_BAMBAM: 'NEGATIVA_BAMBAM',
-    MAIS_QUERO_MAIS: 'MAIS_QUERO_MAIS',
-    VAMO_MONSTRO: 'VAMO_MONSTRO',
-    SAI_FILHO_DA_PUTA: 'SAI_FILHO_DA_PUTA',
-    OH_O_HOME_AI_PO: 'OH_O_HOME_AI_PO',
-    AJUDA_O_MALUCO_TA_DOENTE: 'AJUDA_O_MALUCO_TA_DOENTE',
+    CE_QUER_VER_ESSA_PORRA: 'CE QUER VER ESSA PORRA?',
+    QUE_QUE_CE_QUER_MONSTRAO: 'QUE QUE CE QUER MONSTRAO?',
+    ELE_QUE_A_GENTE_QUER: 'ELE QUE A GENTE QUER?',
+    NAO_VAI_DAR_NAO: 'NAO VAI DAR NAO',
+    QUE_NAO_VAI_DAR_O_QUE: 'QUE NAO VAI DAR O QUE?',
+    NEGATIVA_BAMBAM: 'NEGATIVA BAMBAM',
+    MAIS_QUERO_MAIS: 'MAIS QUERO MAIS',
+    VAMO_MONSTRO: 'VAMO MONSTRO;',
+    SAI_FILHO_DA_PUTA: 'SAI FILHO DA PUTA;',
+    OH_O_HOME_AI_PO: 'OH O HOME AI PO',
+    AJUDA_O_MALUCO_TA_DOENTE: 'AJUDA O MALUCO TA DOENTE',
+    BORA_CUMPADE: 'BORA CUMPADE',
+
     // simbolos
     PARENTESE_DIREITO: 'PARENTESE_DIREITO',
     PARENTESE_ESQUERDO: 'PARENTESE_ESQUERDO',
+    IGUAL: 'IGUAL',
+    IGUAL_IGUAL: 'IGUAL_IGUAL',
+    PONTO_E_VIRGULA: 'PONTO_E_VIRGULA',
+
+    FRANGO: 'TEXTO',
+    MONSTRINHO: 'INTEIRO',
+    MONSTRO: 'INTEIRO_CURTO',
+    MONSTRAO: 'INTEIRO_LONGO',
+    TRAPEZIO: 'PONTO_FLUTUANTE',
+    TRAPEZIO_DESCENDENTE: 'PONTO_FLUTUANTE_MAIS_PRECISO',
+    BICEPS: 'INTEIRO_NÃO_ASSINADO',
 };


Test patch:
diff --git a/testes/birl/avaliador-sintatico.test.ts b/testes/birl/avaliador-sintatico.test.ts
new file mode 100644
index 00000000..28d72346
--- /dev/null
+++ b/testes/birl/avaliador-sintatico.test.ts
@@ -0,0 +1,23 @@
+import { Delegua } from '../../fontes/delegua';
+
+describe('Avaliador sintático Birl', () => {
+    describe('analisar()', () => {
+        let delegua: Delegua;
+
+        beforeEach(() => {
+            delegua = new Delegua('birl');
+        });
+
+        it.skip('Sucesso - Hello, World! Porra!', () => {
+            const retornoLexador = delegua.lexador.mapear(
+                ['HORA DO SHOW', 'CE QUER VER ESSA PORRA? ("Hello, World! Porra!\n");', 'BORA CUMPADE 0;', 'BIRL'],
+                -1
+            );
+
+            const retornoAvaliadorSintatico = delegua.avaliadorSintatico.analisar(retornoLexador);
+
+            expect(retornoAvaliadorSintatico).toBeTruthy();
+            expect(retornoAvaliadorSintatico.declaracoes).toHaveLength(4);
+        });
+    });
+});
diff --git a/testes/birl/lexador.test.ts b/testes/birl/lexador.test.ts
new file mode 100644
index 00000000..6804a73e
--- /dev/null
+++ b/testes/birl/lexador.test.ts
@@ -0,0 +1,21 @@
+import { Delegua } from '../../fontes/delegua';
+
+describe('Lexador Birl', () => {
+    let delegua: Delegua;
+
+    beforeEach(() => {
+        delegua = new Delegua('birl');
+    });
+    it('Arquivo vazio.', () => {
+        const resultado = delegua.lexador.mapear([''], -1);
+
+        expect(resultado).toBeTruthy();
+        expect(resultado.simbolos).toHaveLength(0);
+    });
+    it('Programa vazio', () => {
+        const resultado = delegua.lexador.mapear(['HORA DO SHOW \n', 'BIRL \n'], -1);
+
+        expect(resultado).toBeTruthy();
+        expect(resultado.simbolos).toHaveLength(2);
+    });
+});
diff --git a/testes/delegua.test.ts b/testes/delegua.test.ts
index 1698dd78..a8c0dfa9 100644
--- a/testes/delegua.test.ts
+++ b/testes/delegua.test.ts
@@ -1,4 +1,4 @@
-import { Delegua } from "../fontes/delegua";
+import { Delegua } from '../fontes/delegua';
 
 describe('Delégua', () => {
     let delegua: Delegua;
@@ -7,12 +7,11 @@ describe('Delégua', () => {
         delegua = new Delegua('delegua');
     });
 
-    describe('Sucesso', () => {        
+    describe('Sucesso', () => {
         it('Obter versão Delégua', () => {
             const versaoDelegua = delegua.versao();
 
             expect(versaoDelegua).toBeTruthy();
         });
     });
-
-});
\ No newline at end of file
+});
diff --git a/testes/exemplos/birl/teste1.birl b/testes/exemplos/birl/teste1.birl
new file mode 100644
index 00000000..a232132a
--- /dev/null
+++ b/testes/exemplos/birl/teste1.birl
@@ -0,0 +1,4 @@
+HORA DO SHOW
+    CE QUER VER ESSA PORRA? ("Hello, World! Porra!\n");
+    BORA CUMPADE 0;
+BIRL
\ No newline at end of file