Repository: DesignLiquido/delegua
Pull request #290 (2023-03-02 16:08:30)

Birl
Implementei declaração de variáveis do tipo caractere e float no avaliador sintático de birl.


Patch:
diff --git a/.vscode/launch.json b/.vscode/launch.json
index 9817b726..5fda7bea 100644
--- a/.vscode/launch.json
+++ b/.vscode/launch.json
@@ -5,20 +5,18 @@
     "version": "0.2.0",
     "configurations": [
         {
+            "name": "BIRL > Testes Lexador",
             "type": "node",
             "request": "launch",
-            "name": "Birl > Hello World",
-            "skipFiles": ["<node_internals>/**", "node_modules/**"],
-            "cwd": "${workspaceRoot}",
-            "console": "integratedTerminal",
-            "args": [
-                "${workspaceFolder}${pathSeparator}execucao.ts",
-                "--dialeto",
-                "birl",
-                "./exemplos/dialetos/birl/hello-world.birl"
+            "runtimeArgs": [
+                "--inspect-brk",
+                "${workspaceRoot}/node_modules/jest/bin/jest.js",
+                // "interpretador.test.ts",
+                "birl/lexador.test.ts",
+                "--runInBand"
             ],
-            "runtimeExecutable": "node",
-            "runtimeArgs": ["--nolazy", "-r", "ts-node/register/transpile-only"]
+            "console": "integratedTerminal",
+            "internalConsoleOptions": "neverOpen"
         },
         {
             "name": "BIRL > Testes unitários",
@@ -38,7 +36,10 @@
             "type": "node",
             "request": "launch",
             "name": "Delégua > Bhaskara",
-            "skipFiles": ["<node_internals>/**", "node_modules/**"],
+            "skipFiles": [
+                "<node_internals>/**",
+                "node_modules/**"
+            ],
             "cwd": "${workspaceRoot}",
             "console": "integratedTerminal",
             "args": [
@@ -46,13 +47,20 @@
                 "./exemplos/dialetos/egua-classico/bhaskara.egua"
             ],
             "runtimeExecutable": "node",
-            "runtimeArgs": ["--nolazy", "-r", "ts-node/register/transpile-only"]
+            "runtimeArgs": [
+                "--nolazy",
+                "-r",
+                "ts-node/register/transpile-only"
+            ]
         },
         {
             "type": "node",
             "request": "launch",
             "name": "Delégua > Bloco Enquanto",
-            "skipFiles": ["<node_internals>/**", "node_modules/**"],
+            "skipFiles": [
+                "<node_internals>/**",
+                "node_modules/**"
+            ],
             "cwd": "${workspaceRoot}",
             "console": "integratedTerminal",
             "args": [
@@ -60,13 +68,20 @@
                 "./exemplos/estruturas-de-repeticao/enquanto.delegua"
             ],
             "runtimeExecutable": "node",
-            "runtimeArgs": ["--nolazy", "-r", "ts-node/register/transpile-only"]
+            "runtimeArgs": [
+                "--nolazy",
+                "-r",
+                "ts-node/register/transpile-only"
+            ]
         },
         {
             "type": "node",
             "request": "launch",
             "name": "Delégua > Bloco Enquanto (com Continua)",
-            "skipFiles": ["<node_internals>/**", "node_modules/**"],
+            "skipFiles": [
+                "<node_internals>/**",
+                "node_modules/**"
+            ],
             "cwd": "${workspaceRoot}",
             "console": "integratedTerminal",
             "args": [
@@ -74,13 +89,20 @@
                 "./exemplos/estruturas-de-repeticao/enquanto-continua.delegua"
             ],
             "runtimeExecutable": "node",
-            "runtimeArgs": ["--nolazy", "-r", "ts-node/register/transpile-only"]
+            "runtimeArgs": [
+                "--nolazy",
+                "-r",
+                "ts-node/register/transpile-only"
+            ]
         },
         {
             "type": "node",
             "request": "launch",
             "name": "Delégua > Bloco Fazer ... Enquanto",
-            "skipFiles": ["<node_internals>/**", "node_modules/**"],
+            "skipFiles": [
+                "<node_internals>/**",
+                "node_modules/**"
+            ],
             "cwd": "${workspaceRoot}",
             "console": "integratedTerminal",
             "args": [
@@ -88,13 +110,20 @@
                 "./exemplos/estruturas-de-repeticao/fazer-enquanto.delegua"
             ],
             "runtimeExecutable": "node",
-            "runtimeArgs": ["--nolazy", "-r", "ts-node/register/transpile-only"]
+            "runtimeArgs": [
+                "--nolazy",
+                "-r",
+                "ts-node/register/transpile-only"
+            ]
         },
         {
             "type": "node",
             "request": "launch",
             "name": "Delégua > Bloco Fazer ... Enquanto (com Continua)",
-            "skipFiles": ["<node_internals>/**", "node_modules/**"],
+            "skipFiles": [
+                "<node_internals>/**",
+                "node_modules/**"
+            ],
             "cwd": "${workspaceRoot}",
             "console": "integratedTerminal",
             "args": [
@@ -102,13 +131,20 @@
                 "./exemplos/estruturas-de-repeticao/fazer-enquanto-continua.delegua"
             ],
             "runtimeExecutable": "node",
-            "runtimeArgs": ["--nolazy", "-r", "ts-node/register/transpile-only"]
+            "runtimeArgs": [
+                "--nolazy",
+                "-r",
+                "ts-node/register/transpile-only"
+            ]
         },
         {
             "type": "node",
             "request": "launch",
             "name": "Delégua > Bloco Para",
-            "skipFiles": ["<node_internals>/**", "node_modules/**"],
+            "skipFiles": [
+                "<node_internals>/**",
+                "node_modules/**"
+            ],
             "cwd": "${workspaceRoot}",
             "console": "integratedTerminal",
             "args": [
@@ -116,13 +152,20 @@
                 "./exemplos/estruturas-de-repeticao/para.delegua"
             ],
             "runtimeExecutable": "node",
-            "runtimeArgs": ["--nolazy", "-r", "ts-node/register/transpile-only"]
+            "runtimeArgs": [
+                "--nolazy",
+                "-r",
+                "ts-node/register/transpile-only"
+            ]
         },
         {
             "type": "node",
             "request": "launch",
             "name": "Delégua > Bloco Para (com Continua)",
-            "skipFiles": ["<node_internals>/**", "node_modules/**"],
+            "skipFiles": [
+                "<node_internals>/**",
+                "node_modules/**"
+            ],
             "cwd": "${workspaceRoot}",
             "console": "integratedTerminal",
             "args": [
@@ -130,46 +173,83 @@
                 "./exemplos/estruturas-de-repeticao/para-continua.delegua"
             ],
             "runtimeExecutable": "node",
-            "runtimeArgs": ["--nolazy", "-r", "ts-node/register/transpile-only"]
+            "runtimeArgs": [
+                "--nolazy",
+                "-r",
+                "ts-node/register/transpile-only"
+            ]
         },
         {
             "type": "node",
             "request": "launch",
             "name": "Delégua > Bloco Se",
-            "skipFiles": ["<node_internals>/**", "node_modules/**"],
+            "skipFiles": [
+                "<node_internals>/**",
+                "node_modules/**"
+            ],
             "cwd": "${workspaceRoot}",
             "console": "integratedTerminal",
-            "args": ["${workspaceFolder}${pathSeparator}execucao.ts", "./exemplos/condicionais/se.delegua"],
+            "args": [
+                "${workspaceFolder}${pathSeparator}execucao.ts",
+                "./exemplos/condicionais/se.delegua"
+            ],
             "runtimeExecutable": "node",
-            "runtimeArgs": ["--nolazy", "-r", "ts-node/register/transpile-only"]
+            "runtimeArgs": [
+                "--nolazy",
+                "-r",
+                "ts-node/register/transpile-only"
+            ]
         },
         {
             "type": "node",
             "request": "launch",
             "name": "Delégua > Classes > Classe vazia",
-            "skipFiles": ["<node_internals>/**", "node_modules/**"],
+            "skipFiles": [
+                "<node_internals>/**",
+                "node_modules/**"
+            ],
             "cwd": "${workspaceRoot}",
             "console": "integratedTerminal",
-            "args": ["${workspaceFolder}${pathSeparator}execucao.ts", "./exemplos/classes/classe-vazia.delegua"],
+            "args": [
+                "${workspaceFolder}${pathSeparator}execucao.ts",
+                "./exemplos/classes/classe-vazia.delegua"
+            ],
             "runtimeExecutable": "node",
-            "runtimeArgs": ["--nolazy", "-r", "ts-node/register/transpile-only"]
+            "runtimeArgs": [
+                "--nolazy",
+                "-r",
+                "ts-node/register/transpile-only"
+            ]
         },
         {
             "type": "node",
             "request": "launch",
             "name": "Delégua > Classes > Construtor",
-            "skipFiles": ["<node_internals>/**", "node_modules/**"],
+            "skipFiles": [
+                "<node_internals>/**",
+                "node_modules/**"
+            ],
             "cwd": "${workspaceRoot}",
             "console": "integratedTerminal",
-            "args": ["${workspaceFolder}${pathSeparator}execucao.ts", "./exemplos/classes/construtor-classe.delegua"],
+            "args": [
+                "${workspaceFolder}${pathSeparator}execucao.ts",
+                "./exemplos/classes/construtor-classe.delegua"
+            ],
             "runtimeExecutable": "node",
-            "runtimeArgs": ["--nolazy", "-r", "ts-node/register/transpile-only"]
+            "runtimeArgs": [
+                "--nolazy",
+                "-r",
+                "ts-node/register/transpile-only"
+            ]
         },
         {
             "type": "node",
             "request": "launch",
             "name": "Delégua > Classes > Herança",
-            "skipFiles": ["<node_internals>/**", "node_modules/**"],
+            "skipFiles": [
+                "<node_internals>/**",
+                "node_modules/**"
+            ],
             "cwd": "${workspaceRoot}",
             "console": "integratedTerminal",
             "args": [
@@ -178,24 +258,41 @@
                 "./exemplos/classes/heranca.delegua"
             ],
             "runtimeExecutable": "node",
-            "runtimeArgs": ["--nolazy", "-r", "ts-node/register/transpile-only"]
+            "runtimeArgs": [
+                "--nolazy",
+                "-r",
+                "ts-node/register/transpile-only"
+            ]
         },
         {
             "type": "node",
             "request": "launch",
             "name": "Delégua > Escolha",
-            "skipFiles": ["<node_internals>/**", "node_modules/**"],
+            "skipFiles": [
+                "<node_internals>/**",
+                "node_modules/**"
+            ],
             "cwd": "${workspaceRoot}",
             "console": "integratedTerminal",
-            "args": ["${workspaceFolder}${pathSeparator}execucao.ts", "./exemplos/condicionais/escolha.delegua"],
+            "args": [
+                "${workspaceFolder}${pathSeparator}execucao.ts",
+                "./exemplos/condicionais/escolha.delegua"
+            ],
             "runtimeExecutable": "node",
-            "runtimeArgs": ["--nolazy", "-r", "ts-node/register/transpile-only"]
+            "runtimeArgs": [
+                "--nolazy",
+                "-r",
+                "ts-node/register/transpile-only"
+            ]
         },
         {
             "type": "node",
             "request": "launch",
             "name": "Delégua > Estruturas de Dados > Inteiros",
-            "skipFiles": ["<node_internals>/**", "node_modules/**"],
+            "skipFiles": [
+                "<node_internals>/**",
+                "node_modules/**"
+            ],
             "cwd": "${workspaceRoot}",
             "console": "integratedTerminal",
             "args": [
@@ -204,13 +301,20 @@
                 "./exemplos/estruturas-de-dados/inteiros.delegua"
             ],
             "runtimeExecutable": "node",
-            "runtimeArgs": ["--nolazy", "-r", "ts-node/register/transpile-only"]
+            "runtimeArgs": [
+                "--nolazy",
+                "-r",
+                "ts-node/register/transpile-only"
+            ]
         },
         {
             "type": "node",
             "request": "launch",
             "name": "Delégua > Estruturas de Repetição > Fazer ... Enquanto",
-            "skipFiles": ["<node_internals>/**", "node_modules/**"],
+            "skipFiles": [
+                "<node_internals>/**",
+                "node_modules/**"
+            ],
             "cwd": "${workspaceRoot}",
             "console": "integratedTerminal",
             "args": [
@@ -218,46 +322,80 @@
                 "./exemplos/estruturas-de-repeticao/fazer-enquanto.delegua"
             ],
             "runtimeExecutable": "node",
-            "runtimeArgs": ["--nolazy", "-r", "ts-node/register/transpile-only"]
+            "runtimeArgs": [
+                "--nolazy",
+                "-r",
+                "ts-node/register/transpile-only"
+            ]
         },
         {
             "type": "node",
             "request": "launch",
             "name": "Delégua > Fibonacci",
-            "skipFiles": ["<node_internals>/**", "node_modules/**"],
+            "skipFiles": [
+                "<node_internals>/**",
+                "node_modules/**"
+            ],
             "cwd": "${workspaceRoot}",
             "console": "integratedTerminal",
-            "args": ["${workspaceFolder}${pathSeparator}execucao.ts", "./exemplos/fibonacci.delegua"],
+            "args": [
+                "${workspaceFolder}${pathSeparator}execucao.ts",
+                "./exemplos/fibonacci.delegua"
+            ],
             "runtimeExecutable": "node",
-            "runtimeArgs": ["--nolazy", "-r", "ts-node/register/transpile-only"]
+            "runtimeArgs": [
+                "--nolazy",
+                "-r",
+                "ts-node/register/transpile-only"
+            ]
         },
         {
             "type": "node",
             "request": "launch",
             "name": "Delégua > Fila estática",
-            "skipFiles": ["<node_internals>/**", "node_modules/**"],
+            "skipFiles": [
+                "<node_internals>/**",
+                "node_modules/**"
+            ],
             "cwd": "${workspaceRoot}",
             "console": "integratedTerminal",
             "args": ["${workspaceFolder}${pathSeparator}execucao.ts", "./exemplos/fila-estatica.delegua"],
             "runtimeExecutable": "node",
-            "runtimeArgs": ["--nolazy", "-r", "ts-node/register/transpile-only"]
+            "runtimeArgs": [
+                "--nolazy",
+                "-r",
+                "ts-node/register/transpile-only"
+            ]
         },
         {
             "type": "node",
             "request": "launch",
             "name": "Delégua > FizzBuzz",
-            "skipFiles": ["<node_internals>/**", "node_modules/**"],
+            "skipFiles": [
+                "<node_internals>/**",
+                "node_modules/**"
+            ],
             "cwd": "${workspaceRoot}",
             "console": "integratedTerminal",
-            "args": ["${workspaceFolder}${pathSeparator}execucao.ts", "./exemplos/fizzbuzz.egua"],
+            "args": [
+                "${workspaceFolder}${pathSeparator}execucao.ts",
+                "./exemplos/fizzbuzz.egua"
+            ],
             "runtimeExecutable": "node",
-            "runtimeArgs": ["--nolazy", "-r", "ts-node/register/transpile-only"]
+            "runtimeArgs": [
+                "--nolazy",
+                "-r",
+                "ts-node/register/transpile-only"
+            ]
         },
         {
             "type": "node",
             "request": "launch",
             "name": "Delégua > Funções Anônimas",
-            "skipFiles": ["<node_internals>/**", "node_modules/**"],
+            "skipFiles": [
+                "<node_internals>/**",
+                "node_modules/**"
+            ],
             "cwd": "${workspaceRoot}",
             "console": "integratedTerminal",
             "args": [
@@ -266,13 +404,20 @@
                 "./exemplos/funcoes/funcoes-anonimas.delegua"
             ],
             "runtimeExecutable": "node",
-            "runtimeArgs": ["--nolazy", "-r", "ts-node/register/transpile-only"]
+            "runtimeArgs": [
+                "--nolazy",
+                "-r",
+                "ts-node/register/transpile-only"
+            ]
         },
         {
             "type": "node",
             "request": "launch",
             "name": "Delégua > Importação",
-            "skipFiles": ["<node_internals>/**", "node_modules/**"],
+            "skipFiles": [
+                "<node_internals>/**",
+                "node_modules/**"
+            ],
             "cwd": "${workspaceRoot}",
             "console": "integratedTerminal",
             "args": [
@@ -281,13 +426,20 @@
                 "./exemplos/importacao/inicial.delegua"
             ],
             "runtimeExecutable": "node",
-            "runtimeArgs": ["--nolazy", "-r", "ts-node/register/transpile-only"]
+            "runtimeArgs": [
+                "--nolazy",
+                "-r",
+                "ts-node/register/transpile-only"
+            ]
         },
         {
             "type": "node",
             "request": "launch",
             "name": "Delégua > Importação > Animais",
-            "skipFiles": ["<node_internals>/**", "node_modules/**"],
+            "skipFiles": [
+                "<node_internals>/**",
+                "node_modules/**"
+            ],
             "cwd": "${workspaceRoot}",
             "console": "integratedTerminal",
             "args": [
@@ -296,13 +448,20 @@
                 "./exemplos/importacao/animais.delegua"
             ],
             "runtimeExecutable": "node",
-            "runtimeArgs": ["--nolazy", "-r", "ts-node/register/transpile-only"]
+            "runtimeArgs": [
+                "--nolazy",
+                "-r",
+                "ts-node/register/transpile-only"
+            ]
         },
         {
             "type": "node",
             "request": "launch",
             "name": "Delégua > Inteiros",
-            "skipFiles": ["<node_internals>/**", "node_modules/**"],
+            "skipFiles": [
+                "<node_internals>/**",
+                "node_modules/**"
+            ],
             "cwd": "${workspaceRoot}",
             "console": "integratedTerminal",
             "args": [
@@ -311,120 +470,185 @@
                 "./exemplos/estruturas-de-dados/inteiros.delegua"
             ],
             "runtimeExecutable": "node",
-            "runtimeArgs": ["--nolazy", "-r", "ts-node/register/transpile-only"]
+            "runtimeArgs": [
+                "--nolazy",
+                "-r",
+                "ts-node/register/transpile-only"
+            ]
         },
         {
             "type": "node",
             "request": "launch",
             "name": "Delégua > Leia",
-            "skipFiles": ["<node_internals>/**", "node_modules/**"],
+            "skipFiles": [
+                "<node_internals>/**",
+                "node_modules/**"
+            ],
             "cwd": "${workspaceRoot}",
             "console": "integratedTerminal",
             "args": ["${workspaceFolder}${pathSeparator}execucao.ts", "./exemplos/leia.delegua"],
             "runtimeExecutable": "node",
-            "runtimeArgs": ["--nolazy", "-r", "ts-node/register/transpile-only"]
+            "runtimeArgs": [
+                "--nolazy",
+                "-r",
+                "ts-node/register/transpile-only"
+            ]
         },
         {
             "type": "node",
             "request": "launch",
             "name": "Delégua > Média",
-            "skipFiles": ["<node_internals>/**", "node_modules/**"],
+            "skipFiles": [
+                "<node_internals>/**",
+                "node_modules/**"
+            ],
             "cwd": "${workspaceRoot}",
             "console": "integratedTerminal",
-            "args": ["${workspaceFolder}${pathSeparator}execucao.ts", "./exemplos/media.delegua"],
+            "args": [
+                "${workspaceFolder}${pathSeparator}execucao.ts",
+                "./exemplos/media.delegua"
+            ],
             "runtimeExecutable": "node",
-            "runtimeArgs": ["--nolazy", "-r", "ts-node/register/transpile-only"]
+            "runtimeArgs": [
+                "--nolazy",
+                "-r",
+                "ts-node/register/transpile-only"
+            ]
         },
         {
             "type": "node",
             "request": "launch",
             "name": "Delégua > Parâmetro -c",
-            "skipFiles": ["<node_internals>/**", "node_modules/**"],
+            "skipFiles": [
+                "<node_internals>/**",
+                "node_modules/**"
+            ],
             "cwd": "${workspaceRoot}",
             "console": "integratedTerminal",
             "args": ["${workspaceFolder}${pathSeparator}execucao.ts", "--codigo", "escreva(2+1)"],
             "runtimeExecutable": "node",
-            "runtimeArgs": ["--nolazy", "-r", "ts-node/register/transpile-only"]
+            "runtimeArgs": [
+                "--nolazy",
+                "-r",
+                "ts-node/register/transpile-only"
+            ]
         },
         {
             "type": "node",
             "request": "launch",
             "name": "Delégua > Perceptron",
-            "skipFiles": ["<node_internals>/**", "node_modules/**"],
+            "skipFiles": [
+                "<node_internals>/**",
+                "node_modules/**"
+            ],
             "cwd": "${workspaceRoot}",
             "console": "integratedTerminal",
             "args": ["${workspaceFolder}${pathSeparator}execucao.ts", "./exemplos/perceptron.delegua"],
             "runtimeExecutable": "node",
-            "runtimeArgs": ["--nolazy", "-r", "ts-node/register/transpile-only"]
+            "runtimeArgs": [
+                "--nolazy",
+                "-r",
+                "ts-node/register/transpile-only"
+            ]
         },
         {
             "type": "node",
             "request": "launch",
             "name": "Delégua > Primitivas > Texto > Minúsculo",
-            "skipFiles": ["<node_internals>/**", "node_modules/**"],
+            "skipFiles": [
+                "<node_internals>/**",
+                "node_modules/**"
+            ],
             "cwd": "${workspaceRoot}",
             "console": "integratedTerminal",
             "args": ["${workspaceFolder}${pathSeparator}execucao.ts", "./exemplos/primitivas/texto/minusculo.delegua"],
             "runtimeExecutable": "node",
-            "runtimeArgs": ["--nolazy", "-r", "ts-node/register/transpile-only"]
+            "runtimeArgs": [
+                "--nolazy",
+                "-r",
+                "ts-node/register/transpile-only"
+            ]
         },
         {
             "type": "node",
             "request": "launch",
             "name": "Delégua > Primitivas > Lista > Inclui",
-            "skipFiles": ["<node_internals>/**", "node_modules/**"],
+            "skipFiles": [
+                "<node_internals>/**",
+                "node_modules/**"
+            ],
             "cwd": "${workspaceRoot}",
             "console": "integratedTerminal",
-            "args": ["${workspaceFolder}${pathSeparator}execucao.ts", "./exemplos/primitivas/lista/inclui.delegua"],
+            "args": [
+                "${workspaceFolder}${pathSeparator}execucao.ts",
+                "./exemplos/primitivas/lista/inclui.delegua"
+            ],
             "runtimeExecutable": "node",
-            "runtimeArgs": ["--nolazy", "-r", "ts-node/register/transpile-only"]
+            "runtimeArgs": [
+                "--nolazy",
+                "-r",
+                "ts-node/register/transpile-only"
+            ]
         },
         {
             "type": "node",
             "request": "launch",
             "name": "Delégua > REPL",
-            "skipFiles": ["<node_internals>/**", "node_modules/**"],
+            "skipFiles": [
+                "<node_internals>/**",
+                "node_modules/**"
+            ],
             "cwd": "${workspaceRoot}",
             "console": "integratedTerminal",
-            "args": ["${workspaceFolder}${pathSeparator}execucao.ts"],
+            "args": [
+                "${workspaceFolder}${pathSeparator}execucao.ts"
+            ],
             "runtimeExecutable": "node",
-            "runtimeArgs": ["--nolazy", "-r", "ts-node/register/transpile-only"]
+            "runtimeArgs": [
+                "--nolazy",
+                "-r",
+                "ts-node/register/transpile-only"
+            ]
         },
         {
             "type": "node",
             "request": "launch",
             "name": "Delégua > Teste de Classe",
-            "skipFiles": ["<node_internals>/**", "node_modules/**"],
+            "skipFiles": [
+                "<node_internals>/**",
+                "node_modules/**"
+            ],
             "cwd": "${workspaceRoot}",
             "console": "integratedTerminal",
             "args": ["${workspaceFolder}${pathSeparator}execucao.ts", "./exemplos/classes/teste-classe.delegua"],
             "runtimeExecutable": "node",
-            "runtimeArgs": ["--nolazy", "-r", "ts-node/register/transpile-only"]
+            "runtimeArgs": [
+                "--nolazy",
+                "-r",
+                "ts-node/register/transpile-only"
+            ]
         },
         {
             "type": "node",
             "request": "launch",
             "name": "Delégua > Todos os Testes de Égua",
-            "skipFiles": ["<node_internals>/**", "node_modules/**"],
+            "skipFiles": [
+                "<node_internals>/**",
+                "node_modules/**"
+            ],
             "cwd": "${workspaceRoot}",
             "console": "integratedTerminal",
-            "args": ["${workspaceFolder}${pathSeparator}execucao.ts", "-p", "./exemplos/testes.egua"],
+            "args": [
+                "${workspaceFolder}${pathSeparator}execucao.ts",
+                "-p",
+                "./exemplos/testes.egua"
+            ],
             "runtimeExecutable": "node",
-            "runtimeArgs": ["--nolazy", "-r", "ts-node/register/transpile-only"]
-        },
-        {
-            "name": "Testes unitários - Delégua",
-            "type": "node",
-            "request": "launch",
             "runtimeArgs": [
-                "--inspect-brk",
-                "${workspaceRoot}/node_modules/jest/bin/jest.js",
-                "interpretador",
-                "--runInBand"
-            ],
-            "skipFiles": ["<node_internals>/**", "node_modules/**"],
-            "console": "integratedTerminal",
-            "internalConsoleOptions": "neverOpen"
+                "--nolazy",
+                "-r",
+                "ts-node/register/transpile-only"
+            ]
         },
         {
             "name": "Testes unitários - VisuAlg",
@@ -450,7 +674,10 @@
                 "portugol-studio/avaliador-sintatico",
                 "--runInBand"
             ],
-            "skipFiles": ["<node_internals>/**", "node_modules/**"],
+            "skipFiles": [
+                "<node_internals>/**",
+                "node_modules/**"
+            ],
             "console": "integratedTerminal",
             "internalConsoleOptions": "neverOpen"
         },
@@ -464,7 +691,10 @@
                 "tradutor-javascript.test.ts",
                 "--runInBand"
             ],
-            "skipFiles": ["<node_internals>/**", "node_modules/**"],
+            "skipFiles": [
+                "<node_internals>/**",
+                "node_modules/**"
+            ],
             "console": "integratedTerminal",
             "internalConsoleOptions": "neverOpen"
         },
@@ -478,7 +708,10 @@
                 "tradutor-reverso-javascript.test.ts",
                 "--runInBand"
             ],
-            "skipFiles": ["<node_internals>/**", "node_modules/**"],
+            "skipFiles": [
+                "<node_internals>/**",
+                "node_modules/**"
+            ],
             "console": "integratedTerminal",
             "internalConsoleOptions": "neverOpen"
         },
@@ -486,7 +719,10 @@
             "type": "node",
             "request": "launch",
             "name": "Tradutores > Delégua > JavaScript > Teste",
-            "skipFiles": ["<node_internals>/**", "node_modules/**"],
+            "skipFiles": [
+                "<node_internals>/**",
+                "node_modules/**"
+            ],
             "cwd": "${workspaceRoot}",
             "console": "integratedTerminal",
             "args": [
@@ -497,13 +733,20 @@
                 "./exemplos/condicionais/se.delegua"
             ],
             "runtimeExecutable": "node",
-            "runtimeArgs": ["--nolazy", "-r", "ts-node/register/transpile-only"]
+            "runtimeArgs": [
+                "--nolazy",
+                "-r",
+                "ts-node/register/transpile-only"
+            ]
         },
         {
             "type": "node",
             "request": "launch",
             "name": "Todos os Testes de Delégua",
-            "skipFiles": ["<node_internals>/**", "node_modules/**"],
+            "skipFiles": [
+                "<node_internals>/**",
+                "node_modules/**"
+            ],
             "cwd": "${workspaceRoot}",
             "console": "integratedTerminal",
             "args": [
@@ -512,13 +755,20 @@
                 "./exemplos/index.delegua"
             ],
             "runtimeExecutable": "node",
-            "runtimeArgs": ["--nolazy", "-r", "ts-node/register/transpile-only"]
+            "runtimeArgs": [
+                "--nolazy",
+                "-r",
+                "ts-node/register/transpile-only"
+            ]
         },
         {
             "type": "node",
             "request": "launch",
             "name": "Égua Clássico > Bhaskara",
-            "skipFiles": ["<node_internals>/**", "node_modules/**"],
+            "skipFiles": [
+                "<node_internals>/**",
+                "node_modules/**"
+            ],
             "cwd": "${workspaceRoot}",
             "console": "integratedTerminal",
             "args": [
@@ -528,13 +778,20 @@
                 "./exemplos/dialetos/egua-classico/bhaskara.egua"
             ],
             "runtimeExecutable": "node",
-            "runtimeArgs": ["--nolazy", "-r", "ts-node/register/transpile-only"]
+            "runtimeArgs": [
+                "--nolazy",
+                "-r",
+                "ts-node/register/transpile-only"
+            ]
         },
         {
             "type": "node",
             "request": "launch",
             "name": "Egua Clássico > Bloco Para (com Continua)",
-            "skipFiles": ["<node_internals>/**", "node_modules/**"],
+            "skipFiles": [
+                "<node_internals>/**",
+                "node_modules/**"
+            ],
             "cwd": "${workspaceRoot}",
             "console": "integratedTerminal",
             "args": [
@@ -544,13 +801,20 @@
                 "./exemplos/dialetos/egua-classico/estruturas-de-repeticao/para-continua.egua"
             ],
             "runtimeExecutable": "node",
-            "runtimeArgs": ["--nolazy", "-r", "ts-node/register/transpile-only"]
+            "runtimeArgs": [
+                "--nolazy",
+                "-r",
+                "ts-node/register/transpile-only"
+            ]
         },
         {
             "type": "node",
             "request": "launch",
             "name": "Égua Clássico > Fibonacci",
-            "skipFiles": ["<node_internals>/**", "node_modules/**"],
+            "skipFiles": [
+                "<node_internals>/**",
+                "node_modules/**"
+            ],
             "cwd": "${workspaceRoot}",
             "console": "integratedTerminal",
             "args": [
@@ -560,13 +824,20 @@
                 "./exemplos/dialetos/egua-classico/fibonacci.egua"
             ],
             "runtimeExecutable": "node",
-            "runtimeArgs": ["--nolazy", "-r", "ts-node/register/transpile-only"]
+            "runtimeArgs": [
+                "--nolazy",
+                "-r",
+                "ts-node/register/transpile-only"
+            ]
         },
         {
             "type": "node",
             "request": "launch",
             "name": "Égua Clássico > Classes > Construtor",
-            "skipFiles": ["<node_internals>/**", "node_modules/**"],
+            "skipFiles": [
+                "<node_internals>/**",
+                "node_modules/**"
+            ],
             "cwd": "${workspaceRoot}",
             "console": "integratedTerminal",
             "args": [
@@ -576,13 +847,20 @@
                 "./exemplos/classes/construtor-classe.egua"
             ],
             "runtimeExecutable": "node",
-            "runtimeArgs": ["--nolazy", "-r", "ts-node/register/transpile-only"]
+            "runtimeArgs": [
+                "--nolazy",
+                "-r",
+                "ts-node/register/transpile-only"
+            ]
         },
         {
             "type": "node",
             "request": "launch",
             "name": "Égua Clássico > Merge Sort",
-            "skipFiles": ["<node_internals>/**", "node_modules/**"],
+            "skipFiles": [
+                "<node_internals>/**",
+                "node_modules/**"
+            ],
             "cwd": "${workspaceRoot}",
             "console": "integratedTerminal",
             "args": [
@@ -592,13 +870,20 @@
                 "./exemplos/dialetos/egua-classico/merge-sort.egua"
             ],
             "runtimeExecutable": "node",
-            "runtimeArgs": ["--nolazy", "-r", "ts-node/register/transpile-only"]
+            "runtimeArgs": [
+                "--nolazy",
+                "-r",
+                "ts-node/register/transpile-only"
+            ]
         },
         {
             "type": "node",
             "request": "launch",
             "name": "Égua Clássico > Fila Estática",
-            "skipFiles": ["<node_internals>/**", "node_modules/**"],
+            "skipFiles": [
+                "<node_internals>/**",
+                "node_modules/**"
+            ],
             "cwd": "${workspaceRoot}",
             "console": "integratedTerminal",
             "args": [
@@ -608,13 +893,20 @@
                 "./exemplos/dialetos/egua-classico/fila-estatica.egua"
             ],
             "runtimeExecutable": "node",
-            "runtimeArgs": ["--nolazy", "-r", "ts-node/register/transpile-only"]
+            "runtimeArgs": [
+                "--nolazy",
+                "-r",
+                "ts-node/register/transpile-only"
+            ]
         },
         {
             "type": "node",
             "request": "launch",
             "name": "Égua Clássico > Funções > Retorna sem valor",
-            "skipFiles": ["<node_internals>/**", "node_modules/**"],
+            "skipFiles": [
+                "<node_internals>/**",
+                "node_modules/**"
+            ],
             "cwd": "${workspaceRoot}",
             "console": "integratedTerminal",
             "args": [
@@ -624,13 +916,20 @@
                 "./exemplos/dialetos/egua-classico/funcoes/retorna-sem-valor.egua"
             ],
             "runtimeExecutable": "node",
-            "runtimeArgs": ["--nolazy", "-r", "ts-node/register/transpile-only"]
+            "runtimeArgs": [
+                "--nolazy",
+                "-r",
+                "ts-node/register/transpile-only"
+            ]
         },
         {
             "type": "node",
             "request": "launch",
             "name": "Égua Clássico > Biblioteca Matemática > Gerar pontos da abscissa",
-            "skipFiles": ["<node_internals>/**", "node_modules/**"],
+            "skipFiles": [
+                "<node_internals>/**",
+                "node_modules/**"
+            ],
             "cwd": "${workspaceRoot}",
             "console": "integratedTerminal",
             "args": [
@@ -640,13 +939,20 @@
                 "./exemplos/dialetos/egua-classico/bibliotecas/matematica/gerar-pontos-abscissa.egua"
             ],
             "runtimeExecutable": "node",
-            "runtimeArgs": ["--nolazy", "-r", "ts-node/register/transpile-only"]
+            "runtimeArgs": [
+                "--nolazy",
+                "-r",
+                "ts-node/register/transpile-only"
+            ]
         },
         {
             "type": "node",
             "request": "launch",
             "name": "Égua Clássico > Perceptron",
-            "skipFiles": ["<node_internals>/**", "node_modules/**"],
+            "skipFiles": [
+                "<node_internals>/**",
+                "node_modules/**"
+            ],
             "cwd": "${workspaceRoot}",
             "console": "integratedTerminal",
             "args": [
@@ -656,35 +962,60 @@
                 "./exemplos/dialetos/egua-classico/perceptron.egua"
             ],
             "runtimeExecutable": "node",
-            "runtimeArgs": ["--nolazy", "-r", "ts-node/register/transpile-only"]
+            "runtimeArgs": [
+                "--nolazy",
+                "-r",
+                "ts-node/register/transpile-only"
+            ]
         },
         {
             "type": "node",
             "request": "launch",
             "name": "Égua Clássico > REPL",
-            "skipFiles": ["<node_internals>/**", "node_modules/**"],
+            "skipFiles": [
+                "<node_internals>/**",
+                "node_modules/**"
+            ],
             "cwd": "${workspaceRoot}",
             "console": "integratedTerminal",
-            "args": ["${workspaceFolder}${pathSeparator}execucao.ts", "--dialeto", "egua"],
+            "args": [
+                "${workspaceFolder}${pathSeparator}execucao.ts",
+                "--dialeto",
+                "egua"
+            ],
             "runtimeExecutable": "node",
-            "runtimeArgs": ["--nolazy", "-r", "ts-node/register/transpile-only"]
+            "runtimeArgs": [
+                "--nolazy",
+                "-r",
+                "ts-node/register/transpile-only"
+            ]
         },
         {
             "type": "node",
             "request": "launch",
             "name": "Égua Clássico > Todos os Testes de Égua",
-            "skipFiles": ["<node_internals>/**", "node_modules/**"],
+            "skipFiles": [
+                "<node_internals>/**",
+                "node_modules/**"
+            ],
             "cwd": "${workspaceRoot}",
             "console": "integratedTerminal",
             "args": ["${workspaceFolder}${pathSeparator}execucao.ts", "--dialeto", "egua", "./exemplos/testes.egua"],
             "runtimeExecutable": "node",
-            "runtimeArgs": ["--nolazy", "-r", "ts-node/register/transpile-only"]
+            "runtimeArgs": [
+                "--nolazy",
+                "-r",
+                "ts-node/register/transpile-only"
+            ]
         },
         {
             "type": "node",
             "request": "launch",
             "name": "Égua Clássico > Teste de Classe",
-            "skipFiles": ["<node_internals>/**", "node_modules/**"],
+            "skipFiles": [
+                "<node_internals>/**",
+                "node_modules/**"
+            ],
             "cwd": "${workspaceRoot}",
             "console": "integratedTerminal",
             "args": [
@@ -694,13 +1025,20 @@
                 "./exemplos/dialetos/egua-classico/teste-classe.egua"
             ],
             "runtimeExecutable": "node",
-            "runtimeArgs": ["--nolazy", "-r", "ts-node/register/transpile-only"]
+            "runtimeArgs": [
+                "--nolazy",
+                "-r",
+                "ts-node/register/transpile-only"
+            ]
         },
         {
             "type": "node",
             "request": "launch",
             "name": "EguaP > Bhaskara",
-            "skipFiles": ["<node_internals>/**", "node_modules/**"],
+            "skipFiles": [
+                "<node_internals>/**",
+                "node_modules/**"
+            ],
             "cwd": "${workspaceRoot}",
             "console": "integratedTerminal",
             "args": [
@@ -710,13 +1048,20 @@
                 "./exemplos/dialetos/eguap/bhaskara.eguap"
             ],
             "runtimeExecutable": "node",
-            "runtimeArgs": ["--nolazy", "-r", "ts-node/register/transpile-only"]
+            "runtimeArgs": [
+                "--nolazy",
+                "-r",
+                "ts-node/register/transpile-only"
+            ]
         },
         {
             "type": "node",
             "request": "launch",
             "name": "EguaP > Bloco Enquanto",
-            "skipFiles": ["<node_internals>/**", "node_modules/**"],
+            "skipFiles": [
+                "<node_internals>/**",
+                "node_modules/**"
+            ],
             "cwd": "${workspaceRoot}",
             "console": "integratedTerminal",
             "args": [
@@ -726,13 +1071,20 @@
                 "./exemplos/dialetos/eguap/estruturas-de-repeticao/enquanto.eguap"
             ],
             "runtimeExecutable": "node",
-            "runtimeArgs": ["--nolazy", "-r", "ts-node/register/transpile-only"]
+            "runtimeArgs": [
+                "--nolazy",
+                "-r",
+                "ts-node/register/transpile-only"
+            ]
         },
         {
             "type": "node",
             "request": "launch",
             "name": "EguaP > Bloco Escolha",
-            "skipFiles": ["<node_internals>/**", "node_modules/**"],
+            "skipFiles": [
+                "<node_internals>/**",
+                "node_modules/**"
+            ],
             "cwd": "${workspaceRoot}",
             "console": "integratedTerminal",
             "args": [
@@ -742,13 +1094,20 @@
                 "./exemplos/dialetos/eguap/condicionais/escolha.eguap"
             ],
             "runtimeExecutable": "node",
-            "runtimeArgs": ["--nolazy", "-r", "ts-node/register/transpile-only"]
+            "runtimeArgs": [
+                "--nolazy",
+                "-r",
+                "ts-node/register/transpile-only"
+            ]
         },
         {
             "type": "node",
             "request": "launch",
             "name": "EguaP > Bloco Fazer ... Enquanto",
-            "skipFiles": ["<node_internals>/**", "node_modules/**"],
+            "skipFiles": [
+                "<node_internals>/**",
+                "node_modules/**"
+            ],
             "cwd": "${workspaceRoot}",
             "console": "integratedTerminal",
             "args": [
@@ -758,13 +1117,20 @@
                 "./exemplos/dialetos/eguap/estruturas-de-repeticao/fazer-enquanto.eguap"
             ],
             "runtimeExecutable": "node",
-            "runtimeArgs": ["--nolazy", "-r", "ts-node/register/transpile-only"]
+            "runtimeArgs": [
+                "--nolazy",
+                "-r",
+                "ts-node/register/transpile-only"
+            ]
         },
         {
             "type": "node",
             "request": "launch",
             "name": "EguaP > Bloco Para",
-            "skipFiles": ["<node_internals>/**", "node_modules/**"],
+            "skipFiles": [
+                "<node_internals>/**",
+                "node_modules/**"
+            ],
             "cwd": "${workspaceRoot}",
             "console": "integratedTerminal",
             "args": [
@@ -774,13 +1140,20 @@
                 "./exemplos/dialetos/eguap/estruturas-de-repeticao/para.eguap"
             ],
             "runtimeExecutable": "node",
-            "runtimeArgs": ["--nolazy", "-r", "ts-node/register/transpile-only"]
+            "runtimeArgs": [
+                "--nolazy",
+                "-r",
+                "ts-node/register/transpile-only"
+            ]
         },
         {
             "type": "node",
             "request": "launch",
             "name": "EguaP > Bloco Se",
-            "skipFiles": ["<node_internals>/**", "node_modules/**"],
+            "skipFiles": [
+                "<node_internals>/**",
+                "node_modules/**"
+            ],
             "cwd": "${workspaceRoot}",
             "console": "integratedTerminal",
             "args": [
@@ -790,13 +1163,20 @@
                 "./exemplos/dialetos/eguap/condicionais/se.eguap"
             ],
             "runtimeExecutable": "node",
-            "runtimeArgs": ["--nolazy", "-r", "ts-node/register/transpile-only"]
+            "runtimeArgs": [
+                "--nolazy",
+                "-r",
+                "ts-node/register/transpile-only"
+            ]
         },
         {
             "type": "node",
             "request": "launch",
             "name": "EguaP > Classes",
-            "skipFiles": ["<node_internals>/**", "node_modules/**"],
+            "skipFiles": [
+                "<node_internals>/**",
+                "node_modules/**"
+            ],
             "cwd": "${workspaceRoot}",
             "console": "integratedTerminal",
             "args": [
@@ -806,13 +1186,20 @@
                 "./exemplos/dialetos/eguap/classes/teste-classe.eguap"
             ],
             "runtimeExecutable": "node",
-            "runtimeArgs": ["--nolazy", "-r", "ts-node/register/transpile-only"]
+            "runtimeArgs": [
+                "--nolazy",
+                "-r",
+                "ts-node/register/transpile-only"
+            ]
         },
         {
             "type": "node",
             "request": "launch",
             "name": "EguaP > Classes > Construtor",
-            "skipFiles": ["<node_internals>/**", "node_modules/**"],
+            "skipFiles": [
+                "<node_internals>/**",
+                "node_modules/**"
+            ],
             "cwd": "${workspaceRoot}",
             "console": "integratedTerminal",
             "args": [
@@ -822,13 +1209,20 @@
                 "./exemplos/dialetos/eguap/classes/construtor-classe.eguap"
             ],
             "runtimeExecutable": "node",
-            "runtimeArgs": ["--nolazy", "-r", "ts-node/register/transpile-only"]
+            "runtimeArgs": [
+                "--nolazy",
+                "-r",
+                "ts-node/register/transpile-only"
+            ]
         },
         {
             "type": "node",
             "request": "launch",
             "name": "EguaP > FizzBuzz",
-            "skipFiles": ["<node_internals>/**", "node_modules/**"],
+            "skipFiles": [
+                "<node_internals>/**",
+                "node_modules/**"
+            ],
             "cwd": "${workspaceRoot}",
             "console": "integratedTerminal",
             "args": [
@@ -838,13 +1232,20 @@
                 "./exemplos/dialetos/eguap/fizzbuzz.eguap"
             ],
             "runtimeExecutable": "node",
-            "runtimeArgs": ["--nolazy", "-r", "ts-node/register/transpile-only"]
+            "runtimeArgs": [
+                "--nolazy",
+                "-r",
+                "ts-node/register/transpile-only"
+            ]
         },
         {
             "type": "node",
             "request": "launch",
             "name": "EguaP > Média",
-            "skipFiles": ["<node_internals>/**", "node_modules/**"],
+            "skipFiles": [
+                "<node_internals>/**",
+                "node_modules/**"
+            ],
             "cwd": "${workspaceRoot}",
             "console": "integratedTerminal",
             "args": [
@@ -854,18 +1255,33 @@
                 "./exemplos/dialetos/eguap/media.eguap"
             ],
             "runtimeExecutable": "node",
-            "runtimeArgs": ["--nolazy", "-r", "ts-node/register/transpile-only"]
+            "runtimeArgs": [
+                "--nolazy",
+                "-r",
+                "ts-node/register/transpile-only"
+            ]
         },
         {
             "type": "node",
             "request": "launch",
             "name": "EguaP > REPL",
-            "skipFiles": ["<node_internals>/**", "node_modules/**"],
+            "skipFiles": [
+                "<node_internals>/**",
+                "node_modules/**"
+            ],
             "cwd": "${workspaceRoot}",
             "console": "integratedTerminal",
-            "args": ["${workspaceFolder}${pathSeparator}execucao.ts", "--dialeto", "eguap"],
+            "args": [
+                "${workspaceFolder}${pathSeparator}execucao.ts",
+                "--dialeto",
+                "eguap"
+            ],
             "runtimeExecutable": "node",
-            "runtimeArgs": ["--nolazy", "-r", "ts-node/register/transpile-only"]
+            "runtimeArgs": [
+                "--nolazy",
+                "-r",
+                "ts-node/register/transpile-only"
+            ]
         },
         {
             "type": "node",
@@ -894,7 +1310,11 @@
                 "${workspaceFolder}${pathSeparator}fontes${pathSeparator}tradutores${pathSeparator}tradutor-python.ts"
             ],
             "runtimeExecutable": "node",
-            "runtimeArgs": ["--nolazy", "-r", "ts-node/register/transpile-only"]
+            "runtimeArgs": [
+                "--nolazy",
+                "-r",
+                "ts-node/register/transpile-only"
+            ]
         },
     ]
-}
+}
\ No newline at end of file
diff --git a/fontes/avaliador-sintatico/avaliador-sintatico-base.ts b/fontes/avaliador-sintatico/avaliador-sintatico-base.ts
index 51738c07..f427cd85 100644
--- a/fontes/avaliador-sintatico/avaliador-sintatico-base.ts
+++ b/fontes/avaliador-sintatico/avaliador-sintatico-base.ts
@@ -111,7 +111,7 @@ export abstract class AvaliadorSintaticoBase implements AvaliadorSintaticoInterf
         if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.NEGACAO, tiposDeSimbolos.SUBTRACAO)) {
             const operador = this.simbolos[this.atual - 1];
             const direito = this.unario();
-            return new Unario(this.hashArquivo, operador, direito, 'ANTES');
+            return new Unario(this.hashArquivo, operador, direito);
         }
 
         return this.chamar();
@@ -311,9 +311,9 @@ export abstract class AvaliadorSintaticoBase implements AvaliadorSintaticoInterf
 
             if (this.simbolos[this.atual].tipo === tiposDeSimbolos.MULTIPLICACAO) {
                 this.consumir(tiposDeSimbolos.MULTIPLICACAO, null);
-                parametro.abrangencia = 'multiplo';
+                parametro.tipo = 'estrela';
             } else {
-                parametro.abrangencia = 'padrao';
+                parametro.tipo = 'padrao';
             }
 
             parametro.nome = this.consumir(tiposDeSimbolos.IDENTIFICADOR, 'Esperado nome do parâmetro.');
@@ -324,7 +324,7 @@ export abstract class AvaliadorSintaticoBase implements AvaliadorSintaticoInterf
 
             parametros.push(parametro as ParametroInterface);
 
-            if (parametro.abrangencia === 'multiplo') break;
+            if (parametro.tipo === 'estrela') break;
         } while (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.VIRGULA));
         return parametros;
     }
diff --git a/fontes/avaliador-sintatico/avaliador-sintatico.ts b/fontes/avaliador-sintatico/avaliador-sintatico.ts
index 8b32225a..d0290495 100644
--- a/fontes/avaliador-sintatico/avaliador-sintatico.ts
+++ b/fontes/avaliador-sintatico/avaliador-sintatico.ts
@@ -121,119 +121,14 @@ export class AvaliadorSintatico implements AvaliadorSintaticoInterface {
 
     primario(): Construto {
         const simboloAtual = this.simbolos[this.atual];
-        let valores = [];
-        switch (simboloAtual.tipo) {
-            case tiposDeSimbolos.CHAVE_ESQUERDA:
-                this.avancarEDevolverAnterior();
-                const chaves = [];
-                valores = [];
-
-                if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.CHAVE_DIREITA)) {
-                    return new Dicionario(this.hashArquivo, Number(simboloAtual.linha), [], []);
-                }
-
-                while (!this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.CHAVE_DIREITA)) {
-                    const chave = this.atribuir();
-                    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.');
-                    }
-                }
-
-                return new Dicionario(this.hashArquivo, Number(simboloAtual.linha), chaves, valores);
-
-            case tiposDeSimbolos.COLCHETE_ESQUERDO:
-                this.avancarEDevolverAnterior();
-                valores = [];
-
-                if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.COLCHETE_DIREITO)) {
-                    return new Vetor(this.hashArquivo, Number(simboloAtual.linha), []);
-                }
-    
-                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.');
-                    }
-                }
-    
-                return new Vetor(this.hashArquivo, Number(simboloAtual.linha), valores);
-
-            case tiposDeSimbolos.FALSO:
-                this.avancarEDevolverAnterior();
-                return new Literal(this.hashArquivo, Number(simboloAtual.linha), false);
-
-            case tiposDeSimbolos.FUNCAO:
-            case tiposDeSimbolos.FUNÇÃO:
-                const simboloFuncao = this.avancarEDevolverAnterior();
-                return this.corpoDaFuncao(simboloFuncao.lexema);
-
-            case tiposDeSimbolos.IDENTIFICADOR:
-                const simboloIdentificador: SimboloInterface = this.avancarEDevolverAnterior();
-                // Se o próximo símbolo é um incremento ou um decremento,
-                // aqui deve retornar um unário correspondente.
-                // Caso contrário, apenas retornar um construto de variável.
-                if (this.simbolos[this.atual] && [tiposDeSimbolos.INCREMENTAR, tiposDeSimbolos.DECREMENTAR].includes(this.simbolos[this.atual].tipo)) {
-                    const simboloIncrementoDecremento: SimboloInterface = this.avancarEDevolverAnterior();
-                    return new Unario(
-                        this.hashArquivo, 
-                        simboloIncrementoDecremento, 
-                        new Variavel(this.hashArquivo, simboloIdentificador), 
-                        'DEPOIS'
-                    );
-                }
-
-                return new Variavel(this.hashArquivo, simboloIdentificador);
-
-            case tiposDeSimbolos.IMPORTAR:
-                this.avancarEDevolverAnterior();
-                return this.declaracaoImportar();
-
-            case tiposDeSimbolos.ISTO:
-                this.avancarEDevolverAnterior();
-                return new Isto(this.hashArquivo, Number(simboloAtual.linha), simboloAtual);
-
-            case tiposDeSimbolos.NULO:
-                this.avancarEDevolverAnterior();
-                return new Literal(this.hashArquivo, Number(simboloAtual.linha), null);
-
-            case tiposDeSimbolos.NUMERO:
-            case tiposDeSimbolos.TEXTO:
-                const simboloNumeroTexto: SimboloInterface = this.avancarEDevolverAnterior();
-                return new Literal(this.hashArquivo, Number(simboloNumeroTexto.linha), simboloNumeroTexto.literal);
-
-            case tiposDeSimbolos.PARENTESE_ESQUERDO:
-                this.avancarEDevolverAnterior();
-                const expressao = this.expressao();
-                this.consumir(tiposDeSimbolos.PARENTESE_DIREITO, "Esperado ')' após a expressão.");
-
-                return new Agrupamento(this.hashArquivo, Number(simboloAtual.linha), expressao);
-
-            case tiposDeSimbolos.SUPER:
-                const simboloChave = this.avancarEDevolverAnterior();
-                this.consumir(tiposDeSimbolos.PONTO, "Esperado '.' após 'super'.");
-                const metodo = this.consumir(tiposDeSimbolos.IDENTIFICADOR, 'Esperado nome do método da Superclasse.');
-                return new Super(this.hashArquivo, simboloChave, metodo);
-
-            case tiposDeSimbolos.VERDADEIRO:
-                this.avancarEDevolverAnterior();
-                return new Literal(this.hashArquivo, Number(simboloAtual.linha), true);
-        }
-        
-        /*if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.SUPER)) {
+        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.');
             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)) {
@@ -249,9 +144,9 @@ export class AvaliadorSintatico implements AvaliadorSintaticoInterface {
             }
 
             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 = [];
 
@@ -273,9 +168,9 @@ export class AvaliadorSintatico implements AvaliadorSintaticoInterface {
             }
 
             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);
@@ -284,9 +179,9 @@ export class AvaliadorSintatico implements AvaliadorSintaticoInterface {
         if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.NULO))
             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)) {
+        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);
         }
@@ -302,7 +197,7 @@ export class AvaliadorSintatico implements AvaliadorSintaticoInterface {
             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.');
     }
@@ -353,14 +248,12 @@ export class AvaliadorSintatico implements AvaliadorSintaticoInterface {
             this.verificarSeSimboloAtualEIgualA(
                 tiposDeSimbolos.NEGACAO,
                 tiposDeSimbolos.SUBTRACAO,
-                tiposDeSimbolos.BIT_NOT,
-                tiposDeSimbolos.INCREMENTAR,
-                tiposDeSimbolos.DECREMENTAR
+                tiposDeSimbolos.BIT_NOT
             )
         ) {
             const operador = this.simbolos[this.atual - 1];
             const direito = this.unario();
-            return new Unario(this.hashArquivo, operador, direito, 'ANTES');
+            return new Unario(this.hashArquivo, operador, direito);
         }
 
         return this.chamar();
@@ -591,16 +484,11 @@ export class AvaliadorSintatico implements AvaliadorSintaticoInterface {
 
         this.consumir(tiposDeSimbolos.PARENTESE_DIREITO, "Esperado ')' após os valores em escreva.");
 
-        // Ponto-e-vírgula é opcional aqui.
-        this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.PONTO_E_VIRGULA);
-
         return new Escreva(Number(simboloAtual.linha), simboloAtual.hashArquivo, argumentos);
     }
 
     declaracaoExpressao(): Expressao {
         const expressao = this.expressao();
-        // Ponto-e-vírgula é opcional aqui.
-        this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.PONTO_E_VIRGULA);
         return new Expressao(expressao);
     }
 
@@ -658,7 +546,7 @@ export class AvaliadorSintatico implements AvaliadorSintaticoInterface {
 
             this.consumir(tiposDeSimbolos.PARENTESE_ESQUERDO, "Esperado '(' após 'enquanto'.");
             const condicao = this.expressao();
-            this.consumir(tiposDeSimbolos.PARENTESE_DIREITO, "Esperado ')' após condição.");
+            this.consumir(tiposDeSimbolos.PARENTESE_DIREITO, "Esperado ')' após condicional.");
             const corpo = this.resolverDeclaracao();
 
             return new Enquanto(condicao, corpo);
@@ -688,9 +576,6 @@ export class AvaliadorSintatico implements AvaliadorSintaticoInterface {
                 condicao = this.expressao();
             }
 
-            // Ponto-e-vírgula é opcional aqui.
-            this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.PONTO_E_VIRGULA);
-
             let incrementar = null;
             if (!this.verificarTipoSimboloAtual(tiposDeSimbolos.PARENTESE_DIREITO)) {
                 incrementar = this.expressao();
@@ -711,8 +596,6 @@ export class AvaliadorSintatico implements AvaliadorSintaticoInterface {
             this.erro(this.simbolos[this.atual - 1], "'sustar' ou 'pausa' deve estar dentro de um laço de repetição.");
         }
 
-        // Ponto-e-vírgula é opcional aqui.
-        this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.PONTO_E_VIRGULA);
         return new Sustar(this.simbolos[this.atual]);
     }
 
@@ -721,8 +604,6 @@ export class AvaliadorSintatico implements AvaliadorSintaticoInterface {
             this.erro(this.simbolos[this.atual - 1], "'continua' precisa estar em um laço de repetição.");
         }
 
-        // Ponto-e-vírgula é opcional aqui.
-        this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.PONTO_E_VIRGULA);
         return new Continua(this.simbolos[this.atual]);
     }
 
@@ -747,8 +628,6 @@ export class AvaliadorSintatico implements AvaliadorSintaticoInterface {
             valor = this.expressao();
         }
 
-        // Ponto-e-vírgula é opcional aqui.
-        this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.PONTO_E_VIRGULA);
         return new Retorna(simboloChave, valor);
     }
 
@@ -895,58 +774,21 @@ export class AvaliadorSintatico implements AvaliadorSintaticoInterface {
     }
 
     resolverDeclaracao(): RetornoResolverDeclaracao {
-        switch (this.simbolos[this.atual].tipo) {
-            case tiposDeSimbolos.CHAVE_ESQUERDA:
-                const simboloInicioBloco: SimboloInterface = this.avancarEDevolverAnterior();
-                return new Bloco(simboloInicioBloco.hashArquivo, Number(simboloInicioBloco.linha), this.blocoEscopo());
-            case tiposDeSimbolos.CONTINUA:
-                this.avancarEDevolverAnterior();
-                return this.declaracaoContinua();
-            case tiposDeSimbolos.ENQUANTO:
-                this.avancarEDevolverAnterior();
-                return this.declaracaoEnquanto();
-            case tiposDeSimbolos.ESCOLHA:
-                this.avancarEDevolverAnterior();
-                return this.declaracaoEscolha();
-            case tiposDeSimbolos.ESCREVA:
-                this.avancarEDevolverAnterior();
-                return this.declaracaoEscreva();
-            case tiposDeSimbolos.FAZER:
-                this.avancarEDevolverAnterior();
-                return this.declaracaoFazer();
-            case tiposDeSimbolos.PARA:
-                this.avancarEDevolverAnterior();
-                return this.declaracaoPara();
-            case tiposDeSimbolos.PAUSA:
-            case tiposDeSimbolos.SUSTAR:
-                this.avancarEDevolverAnterior();
-                return this.declaracaoSustar();
-            case tiposDeSimbolos.SE:
-                this.avancarEDevolverAnterior();
-                return this.declaracaoSe();
-            case tiposDeSimbolos.RETORNA:
-                this.avancarEDevolverAnterior();
-                return this.declaracaoRetorna();
-            case tiposDeSimbolos.TENTE:
-                this.avancarEDevolverAnterior();
-                return this.declaracaoTente();
-            
-        }
-        // 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, tiposDeSimbolos.SUSTAR))
-            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)) {
+        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, tiposDeSimbolos.SUSTAR))
+            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];
         if (simboloAtual.tipo === tiposDeSimbolos.IDENTIFICADOR) {
@@ -981,8 +823,6 @@ export class AvaliadorSintatico implements AvaliadorSintaticoInterface {
             inicializador = this.expressao();
         }
 
-        // Ponto-e-vírgula é opcional aqui.
-        this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.PONTO_E_VIRGULA);
         return new Var(simbolo, inicializador);
     }
 
@@ -1011,9 +851,9 @@ export class AvaliadorSintatico implements AvaliadorSintaticoInterface {
 
             if (this.simbolos[this.atual].tipo === tiposDeSimbolos.MULTIPLICACAO) {
                 this.consumir(tiposDeSimbolos.MULTIPLICACAO, null);
-                parametro.abrangencia = 'multiplo';
+                parametro.tipo = 'estrela';
             } else {
-                parametro.abrangencia = 'padrao';
+                parametro.tipo = 'padrao';
             }
 
             parametro.nome = this.consumir(tiposDeSimbolos.IDENTIFICADOR, 'Esperado nome do parâmetro.');
@@ -1024,7 +864,7 @@ export class AvaliadorSintatico implements AvaliadorSintaticoInterface {
 
             parametros.push(parametro as ParametroInterface);
 
-            if (parametro.abrangencia === 'multiplo') break;
+            if (parametro.tipo === 'estrela') break;
         } while (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.VIRGULA));
         return parametros;
     }
diff --git a/fontes/avaliador-sintatico/dialetos/avaliador-sintatico-birl.ts b/fontes/avaliador-sintatico/dialetos/avaliador-sintatico-birl.ts
index d96ec83d..9d610a39 100644
--- a/fontes/avaliador-sintatico/dialetos/avaliador-sintatico-birl.ts
+++ b/fontes/avaliador-sintatico/dialetos/avaliador-sintatico-birl.ts
@@ -1,11 +1,33 @@
-import { AcessoIndiceVariavel, AcessoMetodo, Agrupamento, AtribuicaoSobrescrita, Atribuir, Construto, DefinirValor, FuncaoConstruto, Literal, Variavel } from '../../construtos';
-import { Escreva, Declaracao, Enquanto, Para, Escolha, Fazer, Se, Retorna } from '../../declaracoes';
-import { RetornoLexador, RetornoAvaliadorSintatico } from '../../interfaces/retornos';
+import {
+    AcessoIndiceVariavel,
+    AcessoMetodo,
+    Agrupamento,
+    AtribuicaoSobrescrita,
+    Atribuir,
+    Construto,
+    DefinirValor,
+    FuncaoConstruto,
+    Literal,
+    Variavel,
+} from '../../construtos';
+import {
+    Declaracao,
+    Enquanto,
+    Escolha,
+    Escreva,
+    Expressao,
+    Fazer,
+    Leia,
+    Para,
+    Retorna,
+    Se,
+    Var,
+} from '../../declaracoes';
+import { RetornoAvaliadorSintatico, RetornoLexador } from '../../interfaces/retornos';
 import { AvaliadorSintaticoBase } from '../avaliador-sintatico-base';
-import { ErroAvaliadorSintatico } from '../erro-avaliador-sintatico';
 
-import tiposDeSimbolos from '../../tipos-de-simbolos/birl';
 import { SimboloInterface } from '../../interfaces';
+import tiposDeSimbolos from '../../tipos-de-simbolos/birl';
 
 export class AvaliadorSintaticoBirl extends AvaliadorSintaticoBase {
     validarSegmentoHoraDoShow(): void {
@@ -28,19 +50,19 @@ export class AvaliadorSintaticoBirl extends AvaliadorSintaticoBase {
         if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.POSITIVO))
             return new Literal(this.hashArquivo, Number(simboloAtual.linha), true);
 
-        /* if (
-            this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.IDENTIFICADOR, tiposDeSimbolos.METODO_BIBLIOTECA_GLOBAL)
-        ) {
+        if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.IDENTIFICADOR)) {
             return new Variavel(this.hashArquivo, this.simbolos[this.atual - 1]);
-        } */
+        }
 
-        if (this.verificarSeSimboloAtualEIgualA(
-                tiposDeSimbolos.NUMERO, 
-                tiposDeSimbolos.FRANGAO, 
-                tiposDeSimbolos.FRANGÃO, 
-                tiposDeSimbolos.FRANGO, 
-                tiposDeSimbolos.TEXTO)) 
-        {
+        if (
+            this.verificarSeSimboloAtualEIgualA(
+                tiposDeSimbolos.NUMERO,
+                tiposDeSimbolos.FRANGAO,
+                tiposDeSimbolos.FRANGÃO,
+                tiposDeSimbolos.FRANGO,
+                tiposDeSimbolos.TEXTO
+            )
+        ) {
             const simboloAnterior: SimboloInterface = this.simbolos[this.atual - 1];
             return new Literal(this.hashArquivo, Number(simboloAnterior.linha), simboloAnterior.literal);
         }
@@ -90,11 +112,82 @@ export class AvaliadorSintaticoBirl extends AvaliadorSintaticoBase {
     }
 
     declaracaoEnquanto(): Enquanto {
-        throw new Error('Método não implementado.');
+        this.consumir(tiposDeSimbolos.NEGATIVA, 'Esperado expressão `NEGATIVA` para iniciar o bloco `ENQUANTO`.');
+        this.consumir(
+            tiposDeSimbolos.BAMBAM,
+            'Esperado expressão `BAMBAM` após `NEGATIVA` para iniciar o bloco `ENQUANTO`.'
+        );
+        this.consumir(
+            tiposDeSimbolos.PARENTESE_ESQUERDO,
+            'Esperado expressão `(` após `BAMBAM` para iniciar o bloco `ENQUANTO`.'
+        );
+        const codicao = this.expressao();
+        this.consumir(
+            tiposDeSimbolos.PARENTESE_DIREITO,
+            'Esperado expressão `)` após a condição para iniciar o bloco `ENQUANTO`.'
+        );
+
+        const declaracoes = [];
+
+        while (!this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.BIRL)) {
+            declaracoes.push(this.declaracao());
+        }
+
+        this.consumir(tiposDeSimbolos.BIRL, 'Esperado expressão `BIRL` para fechar o bloco `ENQUANTO`.');
+        return new Enquanto(codicao, declaracoes);
+    }
+
+    declaracaoExpressao(): Expressao {
+        const expressao = this.expressao();
+        this.consumir(tiposDeSimbolos.PONTO_E_VIRGULA, "Esperado ';' após expressão.");
+        return new Expressao(expressao);
     }
 
     declaracaoPara(): Para {
-        throw new Error('Método não implementado.');
+        const simboloPara: SimboloInterface = this.consumir(
+            tiposDeSimbolos.MAIS,
+            'Esperado expressão `MAIS` para iniciar o bloco `PARA`.'
+        );
+        this.consumir(tiposDeSimbolos.QUERO, 'Esperado expressão `QUERO` após `MAIS` para iniciar o bloco `PARA`.');
+        this.consumir(tiposDeSimbolos.MAIS, 'Esperado expressão `MAIS` após `QUERO` para iniciar o bloco `PARA`.');
+        this.consumir(
+            tiposDeSimbolos.PARENTESE_ESQUERDO,
+            'Esperado expressão `(` após `MAIS` para iniciar o bloco `PARA`.'
+        );
+
+        let inicializador: Var | Expressao;
+        if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.PONTO_E_VIRGULA)) {
+            inicializador = null;
+        } else if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.MONSTRO)) {
+            inicializador = this.declaracaoDeVariavel();
+        } else {
+            inicializador = this.declaracaoExpressao();
+        }
+
+        let condicao = null;
+        if (!this.verificarTipoSimboloAtual(tiposDeSimbolos.PONTO_E_VIRGULA)) {
+            condicao = this.expressao();
+        }
+
+        let incrementar = null;
+        if (!this.verificarTipoSimboloAtual(tiposDeSimbolos.PARENTESE_DIREITO)) {
+            incrementar = this.expressao();
+        }
+
+        this.consumir(
+            tiposDeSimbolos.PARENTESE_DIREITO,
+            'Esperado expressão `)` após a condição para iniciar o bloco `PARA`.'
+        );
+
+        const declaracao = [];
+
+        while (!this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.BIRL)) {
+            declaracao.push(this.declaracao());
+        }
+
+        this.consumir(tiposDeSimbolos.BIRL, 'Esperado expressão `BIRL` para fechar o bloco `PARA`.');
+
+        return new Para(this.hashArquivo, simboloPara.linha, 0, 0, 0, 0);
     }
 
     declaracaoEscolha(): Escolha {
@@ -108,11 +201,17 @@ export class AvaliadorSintaticoBirl extends AvaliadorSintaticoBase {
         this.consumir(tiposDeSimbolos.ESSA, 'Esperado expressão `ESSA` após `VER` para escrever mensagem.');
         this.consumir(tiposDeSimbolos.PORRA, 'Esperado expressão `PORRA` após `ESSA` para escrever mensagem.');
         this.consumir(tiposDeSimbolos.INTERROGACAO, 'Esperado interrogação após `PORRA` para escrever mensagem.');
-        this.consumir(tiposDeSimbolos.PARENTESE_ESQUERDO, 'Esperado parêntese esquerdo após interrogação para escrever mensagem.');
+        this.consumir(
+            tiposDeSimbolos.PARENTESE_ESQUERDO,
+            'Esperado parêntese esquerdo após interrogação para escrever mensagem.'
+        );
 
         const argumento = this.declaracao();
 
-        this.consumir(tiposDeSimbolos.PARENTESE_DIREITO, 'Esperado parêntese direito após argumento para escrever mensagem.');
+        this.consumir(
+            tiposDeSimbolos.PARENTESE_DIREITO,
+            'Esperado parêntese direito após argumento para escrever mensagem.'
+        );
 
         return new Escreva(Number(primeiroSimbolo.linha), this.hashArquivo, [argumento]);
     }
@@ -121,16 +220,140 @@ export class AvaliadorSintaticoBirl extends AvaliadorSintaticoBase {
         throw new Error('Método não implementado.');
     }
 
+    declaracaoCaracteres(): Var[] {
+        const simboloCaractere = this.consumir(tiposDeSimbolos.FRANGO, '');
+
+        const inicializacoes = [];
+
+        do {
+            const identificador = this.consumir(
+                tiposDeSimbolos.IDENTIFICADOR,
+                "Esperado identificador após palavra reservada 'FRANGO'."
+            );
+            inicializacoes.push(
+                new Var(identificador, new Literal(this.hashArquivo, Number(simboloCaractere.hashArquivo), 0))
+            );
+
+            // Inicialização de variáveis que podem ter valor definido;
+            let valorInicializacao = '';
+            if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.IGUAL)) {
+                this.consumir(tiposDeSimbolos.TEXTO, "Esperado ' para começar o texto.");
+                const literalInicializacao = this.consumir(
+                    tiposDeSimbolos.IDENTIFICADOR,
+                    'Esperado literal de FRANGO após símbolo de igual em declaração de variável.'
+                );
+                this.consumir(tiposDeSimbolos.TEXTO, "Esperado ' para terminar o texto.");
+                valorInicializacao = String(literalInicializacao.literal); // Error nessa linha
+            }
+
+            inicializacoes.push(
+                new Var(
+                    identificador,
+                    new Literal(this.hashArquivo, Number(simboloCaractere.linha), valorInicializacao)
+                )
+            );
+        } while (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.VIRGULA));
+
+        return inicializacoes;
+    }
+
+    declaracaoInteiros(): Var[] {
+        const simboloInteiro = this.consumir(tiposDeSimbolos.MONSTRO, '');
+
+        const inicializacoes = [];
+        do {
+            const identificador = this.consumir(
+                tiposDeSimbolos.IDENTIFICADOR,
+                "Esperado identificador após palavra reservada 'MONSTRO'."
+            );
+            inicializacoes.push(new Var(identificador, new Literal(this.hashArquivo, Number(simboloInteiro.linha), 0)));
+
+            // Inicializações de variáveis podem ter valores definidos.
+            let valorInicializacao = 0;
+            if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.IGUAL)) {
+                const literalInicializacao = this.consumir(
+                    tiposDeSimbolos.NUMERO,
+                    'Esperado literal de MONSTRO após símbolo de igual em declaração de variável.'
+                );
+                valorInicializacao = Number(literalInicializacao.literal);
+            }
+
+            inicializacoes.push(
+                new Var(identificador, new Literal(this.hashArquivo, Number(simboloInteiro.linha), valorInicializacao))
+            );
+        } while (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.VIRGULA));
+
+        return inicializacoes;
+    }
+
+    declaracaoPontoFlutuante(): Var[] {
+        const simboloFloat = this.consumir(tiposDeSimbolos.TRAPEZIO, '');
+
+        const inicializacoes = [];
+
+        do {
+            const identificador = this.consumir(
+                tiposDeSimbolos.IDENTIFICADOR,
+                "Esperado identificador após palavra reservada 'TRAPEZIO'."
+            );
+
+            inicializacoes.push(new Var(identificador, new Literal(this.hashArquivo, Number(simboloFloat.linha), 0)));
+
+            // Inicializações de variáveis que podem ter valores definidos
+            let valorInicializacao = 0x00;
+            if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.IGUAL)) {
+                const literalInicializacao = this.consumir(
+                    tiposDeSimbolos.NUMERO,
+                    'Esperado literal de TRAPEZIO após símbolo de igual em declaração de variavel.'
+                );
+                valorInicializacao = parseFloat(literalInicializacao.literal);
+            }
+
+            inicializacoes.push(
+                new Var(identificador, new Literal(this.hashArquivo, Number(simboloFloat.linha), valorInicializacao))
+            );
+        } while (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.VIRGULA));
+        return inicializacoes;
+    }
+
     declaracaoRetorna(): Retorna {
         const primeiroSimbolo = this.consumir(tiposDeSimbolos.BORA, 'Esperado expressão `BORA` para retornar valor.');
         this.consumir(tiposDeSimbolos.CUMPADE, 'Esperado expressão `CUMPADE` após `BORA` para retornar valor.');
-        this.consumir(tiposDeSimbolos.INTERROGACAO, 'Esperado interrogação após `CUMPADE` para retornar valor.');
+        // this.consumir(tiposDeSimbolos.INTERROGACAO, 'Esperado interrogação após `CUMPADE` para retornar valor.');
 
         const valor = this.declaracao();
-        
+
         return new Retorna(primeiroSimbolo, valor);
     }
 
+    declaracaoLeia(): Leia {
+        const primeiroSimbolo = this.consumir(tiposDeSimbolos.QUE, 'Esperado expressão `QUE` para ler valor.');
+        this.consumir(tiposDeSimbolos.QUE, 'Esperado expressão `QUE` após `QUE` para ler valor.');
+        this.consumir(tiposDeSimbolos.CE, 'Esperado expressão `CE` após `QUE` para ler valor.');
+        this.consumir(tiposDeSimbolos.QUER, 'Esperado expressão `QUER` após `CE` para ler valor.');
+        this.consumir(tiposDeSimbolos.MONSTRAO, 'Esperado expressão `MONSTRAO` após `QUER` para ler valor.');
+        this.consumir(tiposDeSimbolos.INTERROGACAO, 'Esperado interrogação após `MONSTRAO` para ler valor.');
+        this.consumir(
+            tiposDeSimbolos.PARENTESE_ESQUERDO,
+            'Esperado parêntese esquerdo após interrogação para ler valor.'
+        );
+        const simbolo = this.consumir(tiposDeSimbolos.TEXTO, 'Esperado texto após parêntese esquerdo para ler valor.');
+        const ponteiro = this.consumir(
+            tiposDeSimbolos.IDENTIFICADOR,
+            'Esperado identificador após texto para ler valor.'
+        );
+        this.consumir(
+            tiposDeSimbolos.PARENTESE_DIREITO,
+            'Esperado parêntese direito após identificador para ler valor.'
+        );
+        this.consumir(
+            tiposDeSimbolos.PONTO_E_VIRGULA,
+            'Esperado ponto e vírgula após parêntese direito para ler valor.'
+        );
+
+        return new Leia(Number(primeiroSimbolo.linha), this.hashArquivo, []);
+    }
+
     declaracaoSe(): Se {
         throw new Error('Método não implementado.');
     }
@@ -144,6 +367,29 @@ export class AvaliadorSintaticoBirl extends AvaliadorSintaticoBase {
         switch (simboloAtual.tipo) {
             case tiposDeSimbolos.BORA: // BORA CUMPADE?
                 return this.declaracaoRetorna();
+            case tiposDeSimbolos.QUE:
+                return this.declaracaoLeia();
+            case tiposDeSimbolos.ELE:
+            // Retornar uma declaração de IF
+            case tiposDeSimbolos.NEGATIVA:
+            // Retornar uma declaração de WHILE
+            case tiposDeSimbolos.MAIS:
+                return this.declaracaoPara();
+            // Declaração de inteiros
+            case tiposDeSimbolos.MONSTRO:
+                return this.declaracaoInteiros();
+            case tiposDeSimbolos.FRANGO:
+                return this.declaracaoCaracteres();
+            case tiposDeSimbolos.TRAPEZIO:
+                return this.declaracaoPontoFlutuante();
+            case tiposDeSimbolos.VAMO:
+            // Retornar uma declaração de continue
+            case tiposDeSimbolos.SAI:
+            // Retornar uma declaração de break
+            case tiposDeSimbolos.OH:
+            // Retornar uma declaração de funcao
+            case tiposDeSimbolos.AJUDA:
+            // Retornar uma declaração de chamar funcao
             case tiposDeSimbolos.CE: // "CE QUER VER ESSA PORRA?"
                 return this.declaracaoEscreva();
             case tiposDeSimbolos.PONTO_E_VIRGULA:
diff --git a/fontes/avaliador-sintatico/dialetos/avaliador-sintatico-egua-classico.ts b/fontes/avaliador-sintatico/dialetos/avaliador-sintatico-egua-classico.ts
index cead204b..c6fe17cf 100644
--- a/fontes/avaliador-sintatico/dialetos/avaliador-sintatico-egua-classico.ts
+++ b/fontes/avaliador-sintatico/dialetos/avaliador-sintatico-egua-classico.ts
@@ -763,7 +763,7 @@ export class AvaliadorSintaticoEguaClassico implements AvaliadorSintaticoInterfa
 
                 if (this.simboloAtual().tipo === tiposDeSimbolos.MULTIPLICACAO) {
                     this.consumir(tiposDeSimbolos.MULTIPLICACAO, null);
-                    parametro['tipo'] = 'multiplo';
+                    parametro['tipo'] = 'estrela';
                 } else {
                     parametro['tipo'] = 'padrao';
                 }
@@ -776,7 +776,7 @@ export class AvaliadorSintaticoEguaClassico implements AvaliadorSintaticoInterfa
 
                 parametros.push(parametro);
 
-                if (parametro['tipo'] === 'multiplo') break;
+                if (parametro['tipo'] === 'estrela') break;
             } while (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.VIRGULA));
         }
 
diff --git a/fontes/avaliador-sintatico/dialetos/avaliador-sintatico-eguap.ts b/fontes/avaliador-sintatico/dialetos/avaliador-sintatico-eguap.ts
index 196e1cc2..2e7bc143 100644
--- a/fontes/avaliador-sintatico/dialetos/avaliador-sintatico-eguap.ts
+++ b/fontes/avaliador-sintatico/dialetos/avaliador-sintatico-eguap.ts
@@ -860,7 +860,7 @@ export class AvaliadorSintaticoEguaP implements AvaliadorSintaticoInterface {
 
             if (this.simboloAtual().tipo === tiposDeSimbolos.MULTIPLICACAO) {
                 this.consumir(tiposDeSimbolos.MULTIPLICACAO, null);
-                parametro['tipo'] = 'multiplo';
+                parametro['tipo'] = 'estrela';
             } else {
                 parametro['tipo'] = 'padrao';
             }
@@ -873,7 +873,7 @@ export class AvaliadorSintaticoEguaP implements AvaliadorSintaticoInterface {
 
             parametros.push(parametro);
 
-            if (parametro['tipo'] === 'multiplo') break;
+            if (parametro['tipo'] === 'estrela') break;
         } while (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.VIRGULA));
         return parametros;
     }
diff --git a/fontes/avaliador-sintatico/dialetos/avaliador-sintatico-portugol-studio.ts b/fontes/avaliador-sintatico/dialetos/avaliador-sintatico-portugol-studio.ts
index 257e5512..bac8c55c 100644
--- a/fontes/avaliador-sintatico/dialetos/avaliador-sintatico-portugol-studio.ts
+++ b/fontes/avaliador-sintatico/dialetos/avaliador-sintatico-portugol-studio.ts
@@ -6,7 +6,6 @@ import {
     Construto,
     FuncaoConstruto,
     Literal,
-    Unario,
     Variavel,
 } from '../../construtos';
 import {
@@ -26,14 +25,14 @@ import {
 import { RetornoLexador, RetornoAvaliadorSintatico } from '../../interfaces/retornos';
 import { AvaliadorSintaticoBase } from '../avaliador-sintatico-base';
 
-import { ParametroInterface, SimboloInterface } from '../../interfaces';
+import { SimboloInterface } from '../../interfaces';
 
 import tiposDeSimbolos from '../../tipos-de-simbolos/portugol-studio';
 import { RetornoDeclaracao } from '../retornos';
 import { DeleguaFuncao } from '../../estruturas';
 
 /**
- * O avaliador sintático (_Parser_) é responsável por transformar os símbolos do Lexador em estruturas de alto nível.
+ * 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.
  * Há dois grupos de estruturas de alto nível: Construtos e Declarações.
  */
@@ -70,29 +69,13 @@ export class AvaliadorSintaticoPortugolStudio extends AvaliadorSintaticoBase {
     }
 
     primario(): Construto {
-        switch (this.simbolos[this.atual].tipo) {
-            case tiposDeSimbolos.IDENTIFICADOR:
-                const simboloIdentificador: SimboloInterface = this.avancarEDevolverAnterior();
-                // Se o próximo símbolo é um incremento ou um decremento,
-                // aqui deve retornar um unário correspondente.
-                // Caso contrário, apenas retornar um construto de variável.
-                if (this.simbolos[this.atual] && [tiposDeSimbolos.INCREMENTAR, tiposDeSimbolos.DECREMENTAR].includes(this.simbolos[this.atual].tipo)) {
-                    const simboloIncrementoDecremento: SimboloInterface = this.avancarEDevolverAnterior();
-                    return new Unario(
-                        this.hashArquivo, 
-                        simboloIncrementoDecremento, 
-                        new Variavel(this.hashArquivo, simboloIdentificador), 
-                        'DEPOIS'
-                    );
-                }
-
-                return new Variavel(this.hashArquivo, simboloIdentificador);
-            case tiposDeSimbolos.CADEIA:
-            case tiposDeSimbolos.CARACTER:
-            case tiposDeSimbolos.INTEIRO:
-            case tiposDeSimbolos.REAL:
-                const simboloVariavel: SimboloInterface = this.avancarEDevolverAnterior();
-                return new Literal(this.hashArquivo, Number(simboloVariavel.linha), simboloVariavel.literal);
+        if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.IDENTIFICADOR)) {
+            return new Variavel(this.hashArquivo, this.simbolos[this.atual - 1]);
+        }
+
+        if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.REAL, tiposDeSimbolos.INTEIRO, tiposDeSimbolos.CADEIA)) {
+            const simboloAnterior: SimboloInterface = this.simbolos[this.atual - 1];
+            return new Literal(this.hashArquivo, Number(simboloAnterior.linha), simboloAnterior.literal);
         }
     }
 
@@ -183,7 +166,7 @@ export class AvaliadorSintaticoPortugolStudio extends AvaliadorSintaticoBase {
     }
 
     declaracaoSe(): Se {
-        this.avancarEDevolverAnterior();
+        this.consumir(tiposDeSimbolos.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.");
@@ -199,82 +182,15 @@ export class AvaliadorSintaticoPortugolStudio extends AvaliadorSintaticoBase {
     }
 
     declaracaoEnquanto(): Enquanto {
-        try {
-            this.avancarEDevolverAnterior();
-            this.blocos += 1;
-
-            this.consumir(tiposDeSimbolos.PARENTESE_ESQUERDO, "Esperado '(' após 'enquanto'.");
-            const condicao = this.expressao();
-            this.consumir(tiposDeSimbolos.PARENTESE_DIREITO, "Esperado ')' após condição.");
-            const corpo = this.declaracao();
-
-            return new Enquanto(condicao, corpo);
-        } finally {
-            this.blocos -= 1;
-        }
+        throw new Error('Método não implementado.');
     }
 
     declaracaoEscolha(): Escolha {
         throw new Error('Método não implementado.');
     }
 
-    /**
-     * No Portugol Studio, a palavra reservada é `faca`, sem acento.
-     */
     declaracaoFazer(): Fazer {
-        const simboloFaca: SimboloInterface = this.avancarEDevolverAnterior();
-        try {
-            this.blocos += 1;
-
-            const caminhoFazer = this.declaracao();
-
-            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(simboloFaca.hashArquivo, Number(simboloFaca.linha), caminhoFazer, condicaoEnquanto);
-        } finally {
-            this.blocos -= 1;
-        }
-    }
-
-    protected logicaComumParametros(): ParametroInterface[] {
-        const parametros: ParametroInterface[] = [];
-
-        do {
-            if (parametros.length >= 255) {
-                this.erro(this.simbolos[this.atual], 'Não pode haver mais de 255 parâmetros');
-            }
-
-            const parametro: Partial<ParametroInterface> = {
-                abrangencia: 'padrao'
-            };
-
-            if (!this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.CADEIA, tiposDeSimbolos.REAL, tiposDeSimbolos.REAL)) {
-                throw this.erro(this.simbolos[this.atual], 'Esperado tipo de parâmetro válido para declaração de função.');
-            }
-
-            parametro.nome = this.consumir(tiposDeSimbolos.IDENTIFICADOR, 'Esperado nome do parâmetro.');
-
-            // Em Portugol Studio, um parâmetro múltiplo é terminado por abre e fecha colchetes.
-            if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.COLCHETE_ESQUERDO)) {
-                this.consumir(tiposDeSimbolos.COLCHETE_DIREITO, 
-                    'Esperado colchete direito após colchete esquerdo ao definir parâmetro múltiplo em função.');
-                parametro.abrangencia = 'multiplo';
-            }
-
-            if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.IGUAL)) {
-                parametro.valorPadrao = this.primario();
-            }
-
-            parametros.push(parametro as ParametroInterface);
-
-            if (parametro.abrangencia === 'multiplo') break;
-        } while (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.VIRGULA));
-        return parametros;
+        throw new Error('Método não implementado.');
     }
 
     corpoDaFuncao(tipo: string): FuncaoConstruto {
@@ -291,94 +207,14 @@ export class AvaliadorSintaticoPortugolStudio extends AvaliadorSintaticoBase {
         }
 
         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);
     }
 
-    /**
-     * Declaração de apenas uma variável. 
-     * Neste caso, o símbolo que determina o tipo da variável já foi consumido, 
-     * e o retorno conta com apenas uma variável retornada.
-     */
-    declaracaoDeVariavel(): Var {
-        switch (this.simboloAnterior().tipo) {
-            case tiposDeSimbolos.INTEIRO:
-                const identificador = this.consumir(
-                    tiposDeSimbolos.IDENTIFICADOR,
-                    "Esperado identificador após palavra reservada 'inteiro'."
-                );
-                this.consumir(tiposDeSimbolos.IGUAL, "Esperado símbolo igual para inicialização de variável.");
-                const literalInicializacao = this.consumir(tiposDeSimbolos.INTEIRO, 
-                    'Esperado literal inteiro após símbolo de igual em declaração de variável.');
-                const valorInicializacao = Number(literalInicializacao.literal);
-                return new Var(
-                    identificador, 
-                    new Literal(this.hashArquivo, 
-                        Number(literalInicializacao.linha), 
-                        valorInicializacao
-                    )
-                );
-        }
-    }
-
-    declaracaoCadeiasCaracteres(): Var[] {
-        const simboloCadeia = this.consumir(tiposDeSimbolos.CADEIA, '');
-
-        const inicializacoes = [];
-        do {
-            const identificador = this.consumir(
-                tiposDeSimbolos.IDENTIFICADOR,
-                "Esperado identificador após palavra reservada 'cadeia'."
-            );
-
-            // Inicializações de variáveis podem ter valores definidos.
-            let valorInicializacao = 0;
-            if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.IGUAL)) {
-                const literalInicializacao = this.consumir(tiposDeSimbolos.CADEIA, 
-                    'Esperado literal de cadeia de caracteres após símbolo de igual em declaração de variável.');
-                valorInicializacao = Number(literalInicializacao.literal);
-            }
-
-            inicializacoes.push(new Var(identificador, new Literal(this.hashArquivo, Number(simboloCadeia.linha), 0)));
-        } while (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.VIRGULA));
-
-        return inicializacoes;
-    }
-
-    declaracaoCaracteres(): Var[] {
-        const simboloCaracter = this.consumir(tiposDeSimbolos.CARACTER, '');
-
-        const inicializacoes = [];
-        do {
-            const identificador = this.consumir(
-                tiposDeSimbolos.IDENTIFICADOR,
-                "Esperado identificador após palavra reservada 'caracter'."
-            );
-
-            // Inicializações de variáveis podem ter valores definidos.
-            let valorInicializacao = 0;
-            if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.IGUAL)) {
-                const literalInicializacao = this.consumir(tiposDeSimbolos.CARACTER, 
-                    'Esperado literal de caracter após símbolo de igual em declaração de variável.');
-                valorInicializacao = Number(literalInicializacao.literal);
-            }
-
-            inicializacoes.push(new Var(identificador, new Literal(this.hashArquivo, Number(simboloCaracter.linha), 0)));
-        } while (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.VIRGULA));
-
-        return inicializacoes;
-    }
-
-    declaracaoExpressao(): Expressao {
-        const expressao = this.expressao();
-        // Ponto-e-vírgula é opcional aqui.
-        this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.PONTO_E_VIRGULA);
-        return new Expressao(expressao);
-    }
-
-    declaracaoInteiros(): Var[] {
+    declaracaoInteiro(): Var[] {
         const simboloInteiro = this.consumir(tiposDeSimbolos.INTEIRO, '');
 
         const inicializacoes = [];
@@ -387,16 +223,7 @@ export class AvaliadorSintaticoPortugolStudio extends AvaliadorSintaticoBase {
                 tiposDeSimbolos.IDENTIFICADOR,
                 "Esperado identificador após palavra reservada 'inteiro'."
             );
-
-            // Inicializações de variáveis podem ter valores definidos.
-            let valorInicializacao = 0;
-            if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.IGUAL)) {
-                const literalInicializacao = this.consumir(tiposDeSimbolos.INTEIRO, 
-                    'Esperado literal inteiro após símbolo de igual em declaração de variável.');
-                valorInicializacao = Number(literalInicializacao.literal);
-            }
-
-            inicializacoes.push(new Var(identificador, new Literal(this.hashArquivo, Number(simboloInteiro.linha), valorInicializacao)));
+            inicializacoes.push(new Var(identificador, new Literal(this.hashArquivo, Number(simboloInteiro.linha), 0)));
         } while (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.VIRGULA));
 
         return inicializacoes;
@@ -421,69 +248,11 @@ export class AvaliadorSintaticoPortugolStudio extends AvaliadorSintaticoBase {
         return new Leia(simboloAtual.hashArquivo, Number(simboloAtual.linha), argumentos);
     }
 
-    declaracaoLogicos(): Var[] {
-        const simboloLogico = this.consumir(tiposDeSimbolos.LOGICO, '');
-
-        const inicializacoes = [];
-        do {
-            const identificador = this.consumir(
-                tiposDeSimbolos.IDENTIFICADOR,
-                "Esperado identificador após palavra reservada 'logico'."
-            );
-
-            // Inicializações de variáveis podem ter valores definidos.
-            let valorInicializacao = 0;
-            if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.IGUAL)) {
-                if (![tiposDeSimbolos.VERDADEIRO, tiposDeSimbolos.FALSO].includes(this.simbolos[this.atual].tipo)) {
-                    throw this.erro(this.simbolos[this.atual], 'Esperado literal verdadeiro ou falso após símbolo de igual em declaração de variável.');
-                }
-                const literalInicializacao = this.avancarEDevolverAnterior();
-                valorInicializacao = Number(literalInicializacao.literal);
-            }
-
-            inicializacoes.push(new Var(identificador, new Literal(this.hashArquivo, Number(simboloLogico.linha), 0)));
-        } while (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.VIRGULA));
-
-        return inicializacoes;
-    }
-
     declaracaoPara(): Para {
-        try {
-            const simboloPara: SimboloInterface = this.avancarEDevolverAnterior();
-            this.blocos += 1;
-
-            this.consumir(tiposDeSimbolos.PARENTESE_ESQUERDO, "Esperado '(' após 'para'.");
-
-            let inicializador: Var | Expressao;
-            if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.PONTO_E_VIRGULA)) {
-                inicializador = null;
-            } else if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.INTEIRO)) {
-                inicializador = this.declaracaoDeVariavel();
-            } else {
-                inicializador = this.declaracaoExpressao();
-            }
-
-            let condicao = null;
-            if (!this.verificarTipoSimboloAtual(tiposDeSimbolos.PONTO_E_VIRGULA)) {
-                condicao = this.expressao();
-            }
-
-            let incrementar = null;
-            if (!this.verificarTipoSimboloAtual(tiposDeSimbolos.PARENTESE_DIREITO)) {
-                incrementar = this.expressao();
-            }
-
-            this.consumir(tiposDeSimbolos.PARENTESE_DIREITO, "Esperado ')' após cláusulas");
-
-            const corpo = this.declaracao();
-
-            return new Para(this.hashArquivo, Number(simboloPara.linha), inicializador, condicao, incrementar, corpo);
-        } finally {
-            this.blocos -= 1;
-        }
+        throw new Error('Método não implementado.');
     }
 
-    declaracaoReais(): Var[] {
+    declaracaoReal(): Var[] {
         const simboloReal = this.consumir(tiposDeSimbolos.REAL, '');
 
         const inicializacoes = [];
@@ -492,15 +261,6 @@ export class AvaliadorSintaticoPortugolStudio extends AvaliadorSintaticoBase {
                 tiposDeSimbolos.IDENTIFICADOR,
                 "Esperado identificador após palavra reservada 'real'."
             );
-
-            // Inicializações de variáveis podem ter valores definidos.
-            let valorInicializacao = 0;
-            if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.IGUAL)) {
-                const literalInicializacao = this.consumir(tiposDeSimbolos.REAL, 
-                    'Esperado literal real após símbolo de igual em declaração de variável.');
-                valorInicializacao = Number(literalInicializacao.literal);
-            }
-
             inicializacoes.push(new Var(identificador, new Literal(this.hashArquivo, Number(simboloReal.linha), 0)));
         } while (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.VIRGULA));
 
@@ -512,60 +272,26 @@ export class AvaliadorSintaticoPortugolStudio extends AvaliadorSintaticoBase {
         return this.atribuir();
     }
 
-    funcao(tipo: string): FuncaoDeclaracao {
-        const simboloFuncao: SimboloInterface = this.avancarEDevolverAnterior();
-
-        // No Portugol Studio, se temos um símbolo de tipo após `função`, 
-        // teremos um retorno no corpo da função.
-        if (
-            [
-                tiposDeSimbolos.REAL, 
-                tiposDeSimbolos.INTEIRO, 
-                tiposDeSimbolos.CADEIA,
-                tiposDeSimbolos.CARACTER,
-                tiposDeSimbolos.LOGICO
-            ].includes(this.simbolos[this.atual].tipo)
-        ) {
-            // Por enquanto apenas consumimos o símbolo sem ações adicionais.
-            this.avancarEDevolverAnterior();
-        }
-
-        const nomeFuncao: SimboloInterface = this.consumir(tiposDeSimbolos.IDENTIFICADOR, `Esperado nome ${tipo}.`);
-        return new FuncaoDeclaracao(nomeFuncao, this.corpoDaFuncao(tipo));
-    }
-
     declaracao(): Declaracao | Declaracao[] | Construto | Construto[] | any {
         const simboloAtual = this.simbolos[this.atual];
         switch (simboloAtual.tipo) {
-            case tiposDeSimbolos.CADEIA:
-                return this.declaracaoCadeiasCaracteres();
-            case tiposDeSimbolos.CARACTER:
-                return this.declaracaoCaracteres();
             case tiposDeSimbolos.CHAVE_ESQUERDA:
                 const simboloInicioBloco: SimboloInterface = this.simbolos[this.atual];
                 return new Bloco(simboloInicioBloco.hashArquivo, Number(simboloInicioBloco.linha), this.blocoEscopo());
-            case tiposDeSimbolos.ENQUANTO:
-                return this.declaracaoEnquanto();
             case tiposDeSimbolos.ESCREVA:
                 return this.declaracaoEscreva();
-            case tiposDeSimbolos.FACA:
-                return this.declaracaoFazer();
             case tiposDeSimbolos.FUNCAO:
                 return this.funcao('funcao');
             case tiposDeSimbolos.INTEIRO:
-                return this.declaracaoInteiros();
+                return this.declaracaoInteiro();
             case tiposDeSimbolos.LEIA:
-                return this.declaracaoLeia();
-            case tiposDeSimbolos.LOGICO:
-                return this.declaracaoLogicos();
-            case tiposDeSimbolos.PARA:
-                return this.declaracaoPara();        
+                return this.declaracaoLeia();            
             case tiposDeSimbolos.PROGRAMA:
             case tiposDeSimbolos.CHAVE_DIREITA:
                 this.avancarEDevolverAnterior();
                 return null;
             case tiposDeSimbolos.REAL:
-                return this.declaracaoReais();
+                return this.declaracaoReal();
             case tiposDeSimbolos.SE:
                 return this.declaracaoSe();
             default:
diff --git a/fontes/avaliador-sintatico/dialetos/avaliador-sintatico-visualg.ts b/fontes/avaliador-sintatico/dialetos/avaliador-sintatico-visualg.ts
index 234a8e7e..a734d94b 100644
--- a/fontes/avaliador-sintatico/dialetos/avaliador-sintatico-visualg.ts
+++ b/fontes/avaliador-sintatico/dialetos/avaliador-sintatico-visualg.ts
@@ -744,7 +744,7 @@ export class AvaliadorSintaticoVisuAlg extends AvaliadorSintaticoBase {
                 const dadosParametros = this.logicaComumParametroVisuAlg();
                 for (let parametro of dadosParametros.identificadores) {
                     parametros.push({
-                        abrangencia: 'padrao',
+                        tipo: 'padrao',
                         nome: parametro
                     });
                 }
diff --git a/fontes/construtos/unario.ts b/fontes/construtos/unario.ts
index 7432a342..d2f11171 100644
--- a/fontes/construtos/unario.ts
+++ b/fontes/construtos/unario.ts
@@ -6,21 +6,14 @@ export class Unario implements Construto {
     hashArquivo?: number;
 
     operador: SimboloInterface;
-    operando: any;
-    incidenciaOperador: 'ANTES' | 'DEPOIS';
+    direita: any;
 
-    constructor(
-        hashArquivo: number, 
-        operador: SimboloInterface, 
-        operando: any, 
-        incidenciaOperador: 'ANTES' | 'DEPOIS' = 'ANTES'
-    ) {
+    constructor(hashArquivo: number, operador: SimboloInterface, direita: any) {
         this.linha = operador.linha;
         this.hashArquivo = hashArquivo;
 
         this.operador = operador;
-        this.operando = operando;
-        this.incidenciaOperador = incidenciaOperador;
+        this.direita = direita;
     }
 
     async aceitar(visitante: InterpretadorInterface): Promise<any> {
diff --git a/fontes/interfaces/parametro-interface.ts b/fontes/interfaces/parametro-interface.ts
index b67927a4..9cf651b9 100644
--- a/fontes/interfaces/parametro-interface.ts
+++ b/fontes/interfaces/parametro-interface.ts
@@ -1,7 +1,7 @@
 import { SimboloInterface } from './simbolo-interface';
 
 export interface ParametroInterface {
-    abrangencia: 'padrao' | 'multiplo';
+    tipo: 'estrela' | 'padrao';
     nome: SimboloInterface;
     valorPadrao?: any;
 }
diff --git a/fontes/interpretador/dialetos/egua-classico/interpretador-egua-classico.ts b/fontes/interpretador/dialetos/egua-classico/interpretador-egua-classico.ts
index cb50c620..0e9d4461 100644
--- a/fontes/interpretador/dialetos/egua-classico/interpretador-egua-classico.ts
+++ b/fontes/interpretador/dialetos/egua-classico/interpretador-egua-classico.ts
@@ -304,7 +304,7 @@ export class InterpretadorEguaClassico implements InterpretadorInterface {
                 argumentos.push(null);
             }
         } else {
-            if (parametros && parametros.length > 0 && parametros[parametros.length - 1]['tipo'] === 'multiplo') {
+            if (parametros && parametros.length > 0 && parametros[parametros.length - 1]['tipo'] === 'estrela') {
                 const novosArgumentos = argumentos.slice(0, parametros.length - 1);
                 novosArgumentos.push(argumentos.slice(parametros.length - 1, argumentos.length));
                 argumentos = novosArgumentos;
diff --git a/fontes/interpretador/interpretador-base.ts b/fontes/interpretador/interpretador-base.ts
index fbe05934..9c8d2e5b 100644
--- a/fontes/interpretador/interpretador-base.ts
+++ b/fontes/interpretador/interpretador-base.ts
@@ -204,8 +204,8 @@ export class InterpretadorBase implements InterpretadorInterface {
     }
 
     async visitarExpressaoUnaria(expressao: Unario): Promise<any> {
-        const operando = await this.avaliar(expressao.operando);
-        let valor: any = operando.hasOwnProperty('valor') ? operando.valor : operando;
+        const direita = await this.avaliar(expressao.direita);
+        const valor: any = direita.hasOwnProperty('valor') ? direita.valor : direita;
 
         switch (expressao.operador.tipo) {
             case tiposDeSimbolos.SUBTRACAO:
@@ -215,36 +215,6 @@ export class InterpretadorBase implements InterpretadorInterface {
                 return !this.eVerdadeiro(valor);
             case tiposDeSimbolos.BIT_NOT:
                 return ~valor;
-            // Para incrementar e decrementar, primeiro precisamos saber se o operador
-            // veio antes do literal ou variável.
-            // Se veio antes e o operando é uma variável, precisamos incrementar/decrementar,
-            // armazenar o valor da variável pra só então devolver o valor.
-            case tiposDeSimbolos.INCREMENTAR:
-                if (expressao.incidenciaOperador === 'ANTES') {
-                    valor++;
-                    if (expressao.operando instanceof Variavel) {
-                        this.pilhaEscoposExecucao.atribuirVariavel(expressao.operando.simbolo, valor);
-                    }
-                    
-                    return valor;
-                } 
-                
-                const valorAnteriorIncremento = valor;
-                this.pilhaEscoposExecucao.atribuirVariavel(expressao.operando.simbolo, ++valor);
-                return valorAnteriorIncremento;
-            case tiposDeSimbolos.DECREMENTAR:
-                if (expressao.incidenciaOperador === 'ANTES') {
-                    valor--;
-                    if (expressao.operando instanceof Variavel) {
-                        this.pilhaEscoposExecucao.atribuirVariavel(expressao.operando.simbolo, valor);
-                    }
-
-                    return valor;
-                } 
-                
-                const valorAnteriorDecremento = valor;
-                this.pilhaEscoposExecucao.atribuirVariavel(expressao.operando.simbolo, --valor);
-                return valorAnteriorDecremento;
         }
 
         return null;
@@ -478,7 +448,7 @@ export class InterpretadorBase implements InterpretadorInterface {
                     argumentos.push(null);
                 }
             } else {
-                if (parametros && parametros.length > 0 && parametros[parametros.length - 1].abrangencia === 'multiplo') {
+                if (parametros && parametros.length > 0 && parametros[parametros.length - 1].tipo === 'estrela') {
                     const novosArgumentos = argumentos.slice(0, parametros.length - 1);
                     novosArgumentos.push(argumentos.slice(parametros.length - 1, argumentos.length));
                     argumentos = novosArgumentos;
diff --git a/fontes/lexador/dialetos/lexador-birl.ts b/fontes/lexador/dialetos/lexador-birl.ts
index 644a4ff5..c10cd0cf 100644
--- a/fontes/lexador/dialetos/lexador-birl.ts
+++ b/fontes/lexador/dialetos/lexador-birl.ts
@@ -3,8 +3,8 @@ import { ErroLexador } from '../erro-lexador';
 import { LexadorBaseLinhaUnica } from '../lexador-base-linha-unica';
 import { Simbolo } from '../simbolo';
 
-import palavrasReservadas from './palavras-reservadas/birl';
 import tiposDeSimbolos from '../../tipos-de-simbolos/birl';
+import palavrasReservadas from './palavras-reservadas/birl';
 
 export class LexadorBirl extends LexadorBaseLinhaUnica {
     adicionarSimbolo(tipo: string, lexema: string = '', literal: any = null): void {
@@ -62,21 +62,43 @@ export class LexadorBirl extends LexadorBaseLinhaUnica {
             this.avancar();
         }
 
-        const codigo: string = 
-            this.codigo.substring(this.inicioSimbolo, this.atual)
-            .toLowerCase();
+        const codigo: string = this.codigo.substring(this.inicioSimbolo, this.atual);
 
-        const tipo: string = codigo in palavrasReservadas ? 
-            palavrasReservadas[codigo] : 
-            tiposDeSimbolos.IDENTIFICADOR;
+        const codigoMinusculo = codigo.toLowerCase();
 
-        this.adicionarSimbolo(tipo);
+        const tipo: string =
+            codigoMinusculo in palavrasReservadas ? palavrasReservadas[codigoMinusculo] : tiposDeSimbolos.IDENTIFICADOR;
+
+        this.adicionarSimbolo(tipo, codigo, codigo);
     }
 
     analisarToken(): void {
         const caractere = this.simboloAtual();
 
         switch (caractere) {
+            case ',':
+                this.adicionarSimbolo(tiposDeSimbolos.VIRGULA, ',', null);
+                this.avancar();
+                break;
+            case '<':
+                this.avancar();
+                if (this.simboloAtual() === '=') {
+                    this.adicionarSimbolo(tiposDeSimbolos.MENOR_IGUAL);
+                    this.avancar();
+                } else {
+                    this.adicionarSimbolo(tiposDeSimbolos.MENOR);
+                }
+                break;
+
+            case '>':
+                this.avancar();
+                if (this.simboloAtual() === '=') {
+                    this.adicionarSimbolo(tiposDeSimbolos.MAIOR_IGUAL);
+                    this.avancar();
+                } else {
+                    this.adicionarSimbolo(tiposDeSimbolos.MAIOR);
+                }
+                break;
             case '(':
                 this.adicionarSimbolo(tiposDeSimbolos.PARENTESE_ESQUERDO, '(', null);
                 this.avancar();
@@ -94,11 +116,32 @@ export class LexadorBirl extends LexadorBaseLinhaUnica {
                     this.adicionarSimbolo(tiposDeSimbolos.IGUAL);
                 }
 
+                break;
+            case '&':
+                // Ler o simbolo porem não é tratado.
+                this.adicionarSimbolo(tiposDeSimbolos.PONTEIRO);
+                this.avancar();
                 break;
             case '+':
                 this.adicionarSimbolo(tiposDeSimbolos.ADICAO);
                 this.avancar();
                 break;
+            case '-':
+                this.adicionarSimbolo(tiposDeSimbolos.SUBTRACAO);
+                this.avancar();
+                break;
+            case '*':
+                this.adicionarSimbolo(tiposDeSimbolos.MULTIPLICACAO);
+                this.avancar();
+                break;
+            case '/':
+                this.adicionarSimbolo(tiposDeSimbolos.DIVISAO);
+                this.avancar();
+                break;
+            case '%':
+                this.adicionarSimbolo(tiposDeSimbolos.MODULO);
+                this.avancar();
+                break;
             case "'":
                 this.analisarTexto("'");
                 this.avancar();
@@ -116,10 +159,12 @@ export class LexadorBirl extends LexadorBaseLinhaUnica {
                 this.adicionarSimbolo(tiposDeSimbolos.INTERROGACAO, '?', null);
                 this.avancar();
                 break;
+
             case '\0':
             case '\n':
                 this.adicionarSimbolo(tiposDeSimbolos.QUEBRA_LINHA, null, null);
                 this.avancar();
+                this.linha++;
                 break;
             case ' ':
             case '\r':
@@ -130,12 +175,14 @@ export class LexadorBirl extends LexadorBaseLinhaUnica {
             default:
                 if (this.eDigito(caractere)) this.analisarNumero();
                 else if (this.eAlfabeto(caractere)) this.identificarPalavraChave();
-                else
+                else {
                     this.erros.push({
                         linha: this.linha,
                         caractere: caractere,
                         mensagem: 'Caractere inesperado.',
                     } as ErroLexador);
+                    this.avancar();
+                }
                 break;
         }
     }
diff --git a/fontes/lexador/dialetos/lexador-portugol-studio.ts b/fontes/lexador/dialetos/lexador-portugol-studio.ts
index 78364555..cb5b3062 100644
--- a/fontes/lexador/dialetos/lexador-portugol-studio.ts
+++ b/fontes/lexador/dialetos/lexador-portugol-studio.ts
@@ -10,13 +10,9 @@ import tiposDeSimbolos from '../../tipos-de-simbolos/portugol-studio';
  * Cada token de linguagem é representado por um tipo, um lexema e informações da linha de código em que foi expresso.
  * Também é responsável por mapear as palavras reservadas da linguagem, que não podem ser usadas por outras
  * estruturas, tais como nomes de variáveis, funções, literais, classes e assim por diante.
- * 
- * O Lexador de Portugol Studio possui algumas particularidades:
- * - Aspas simples são para caracteres individuais, e aspas duplas para cadeias de caracteres.
- * - Literais de vetores usam chaves, e não colchetes.
  */
 export class LexadorPortugolStudio extends LexadorBase {
-    protected logicaComumCaracteres(delimitador: string) {
+    analisarTexto(delimitador: string): void {
         while (this.simboloAtual() !== delimitador && !this.eFinalDoCodigo()) {
             this.avancar();
         }
@@ -31,16 +27,6 @@ export class LexadorPortugolStudio extends LexadorBase {
         }
 
         const valor = this.codigo[this.linha].substring(this.inicioSimbolo + 1, this.atual);
-        return valor;
-    }
-
-    analisarCaracter() {
-        const valor = this.logicaComumCaracteres("'");
-        this.adicionarSimbolo(tiposDeSimbolos.CARACTER, valor);
-    }
-
-    analisarTexto(): void {
-        const valor = this.logicaComumCaracteres('"');
         this.adicionarSimbolo(tiposDeSimbolos.CADEIA, valor);
     }
 
@@ -115,50 +101,33 @@ export class LexadorPortugolStudio extends LexadorBase {
                 this.avancar();
                 break;
             case '-':
-                this.inicioSimbolo = this.atual;
+                this.adicionarSimbolo(tiposDeSimbolos.SUBTRACAO);
                 this.avancar();
-                if (this.simboloAtual() === '=') {
-                    this.adicionarSimbolo(tiposDeSimbolos.MENOS_IGUAL);
-                    this.avancar();
-                } else if (this.simboloAtual() === '-') {
-                    this.adicionarSimbolo(tiposDeSimbolos.DECREMENTAR);
-                    this.avancar();
-                } else {
-                    this.adicionarSimbolo(tiposDeSimbolos.SUBTRACAO);
-                }
+                break;
             case '+':
-                this.inicioSimbolo = this.atual;
+                this.adicionarSimbolo(tiposDeSimbolos.ADICAO);
                 this.avancar();
-                if (this.simboloAtual() === '=') {
-                    this.adicionarSimbolo(tiposDeSimbolos.MAIS_IGUAL);
-                    this.avancar();
-                } else if (this.simboloAtual() === '+') {
-                    this.adicionarSimbolo(tiposDeSimbolos.INCREMENTAR);
-                    this.avancar();
-                } else {
-                    this.adicionarSimbolo(tiposDeSimbolos.ADICAO);
-                }
-
                 break;
 
-            case '%':
-                this.adicionarSimbolo(tiposDeSimbolos.MODULO);
-                this.avancar();
-                break;
-            case '*':
+            /* case '%':
                 this.inicioSimbolo = this.atual;
                 this.avancar();
                 switch (this.simboloAtual()) {
                     case '=':
                         this.avancar();
-                        this.adicionarSimbolo(tiposDeSimbolos.MULTIPLICACAO_IGUAL);
+                        this.adicionarSimbolo(tiposDeSimbolos.MODULO_IGUAL);
                         break;
                     default:
-                        this.adicionarSimbolo(tiposDeSimbolos.MULTIPLICACAO);
+                        this.adicionarSimbolo(tiposDeSimbolos.MODULO);
                         break;
                 }
+
+                break; */
+            case '*':
+                this.adicionarSimbolo(tiposDeSimbolos.MULTIPLICACAO);
+                this.avancar();
                 break;
-            case '!':
+            /* case '!':
                 this.avancar();
                 if (this.simboloAtual() === '=') {
                     this.adicionarSimbolo(tiposDeSimbolos.DIFERENTE);
@@ -167,7 +136,7 @@ export class LexadorPortugolStudio extends LexadorBase {
                     this.adicionarSimbolo(tiposDeSimbolos.NEGACAO);
                 }
 
-                break;
+                break; */
             case '=':
                 this.avancar();
                 if (this.simboloAtual() === '=') {
@@ -228,10 +197,6 @@ export class LexadorPortugolStudio extends LexadorBase {
                     case '*':
                         this.encontrarFimComentarioAsterisco();
                         break;
-                    case '=':
-                        this.adicionarSimbolo(tiposDeSimbolos.DIVISAO_IGUAL);
-                        this.avancar();
-                        break;
                     default:
                         this.adicionarSimbolo(tiposDeSimbolos.DIVISAO);
                         break;
@@ -251,13 +216,13 @@ export class LexadorPortugolStudio extends LexadorBase {
 
             case '"':
                 this.avancar();
-                this.analisarTexto();
+                this.analisarTexto('"');
                 this.avancar();
                 break;
 
             case "'":
                 this.avancar();
-                this.analisarCaracter();
+                this.analisarTexto("'");
                 this.avancar();
                 break;
 
diff --git a/fontes/lexador/dialetos/palavras-reservadas/birl.ts b/fontes/lexador/dialetos/palavras-reservadas/birl.ts
index 1d9f0dd1..a68164a8 100644
--- a/fontes/lexador/dialetos/palavras-reservadas/birl.ts
+++ b/fontes/lexador/dialetos/palavras-reservadas/birl.ts
@@ -28,6 +28,7 @@ export default {
     ele: tiposDeSimbolos.ELE,
     essa: tiposDeSimbolos.ESSA,
     filho: tiposDeSimbolos.FILHO,
+    frango: tiposDeSimbolos.FRANGO,
     gente: tiposDeSimbolos.GENTE,
     home: tiposDeSimbolos.HOME,
     hora: tiposDeSimbolos.HORA,
@@ -51,4 +52,5 @@ export default {
     vai: tiposDeSimbolos.VAI,
     vamo: tiposDeSimbolos.VAMO,
     ver: tiposDeSimbolos.VER,
+    trapezio: tiposDeSimbolos.TRAPEZIO,
 };
diff --git a/fontes/lexador/dialetos/palavras-reservadas/portugol-studio.ts b/fontes/lexador/dialetos/palavras-reservadas/portugol-studio.ts
index b5f5449e..632b9952 100644
--- a/fontes/lexador/dialetos/palavras-reservadas/portugol-studio.ts
+++ b/fontes/lexador/dialetos/palavras-reservadas/portugol-studio.ts
@@ -1,24 +1,12 @@
 import tiposDeSimbolos from '../../../tipos-de-simbolos/portugol-studio';
 
 export default {
-    cadeia: tiposDeSimbolos.CADEIA,
-    caracter: tiposDeSimbolos.CARACTER,
-    const: tiposDeSimbolos.CONSTANTE,
-    enquanto: tiposDeSimbolos.ENQUANTO,
     escreva: tiposDeSimbolos.ESCREVA,
-    e: tiposDeSimbolos.E,
-    faca: tiposDeSimbolos.FACA,
-    falso: tiposDeSimbolos.FALSO,
     funcao: tiposDeSimbolos.FUNCAO,
     inteiro: tiposDeSimbolos.INTEIRO,
     leia: tiposDeSimbolos.LEIA,
-    logico: tiposDeSimbolos.LOGICO,
-    ou: tiposDeSimbolos.OU,
-    para: tiposDeSimbolos.PARA,
     programa: tiposDeSimbolos.PROGRAMA,
     real: tiposDeSimbolos.REAL,
     se: tiposDeSimbolos.SE,
     senao: tiposDeSimbolos.SENAO,
-    vazio: tiposDeSimbolos.VAZIO,
-    verdadeiro: tiposDeSimbolos.VERDADEIRO
 }
\ No newline at end of file
diff --git a/fontes/lexador/lexador.ts b/fontes/lexador/lexador.ts
index 44c294c0..e9c88579 100644
--- a/fontes/lexador/lexador.ts
+++ b/fontes/lexador/lexador.ts
@@ -394,20 +394,15 @@ export class Lexador implements LexadorInterface {
                 break;
 
             // Esta sessão ignora espaços em branco na tokenização.
-            
+            // Ponto-e-vírgula é opcional em Delégua, então pode apenas ser ignorado.
             case ' ':
             case '\0':
             case '\r':
             case '\t':
-                this.avancar();
-                break;
-
-            // Ponto-e-vírgula é opcional em Delégua, mas em alguns casos pode ser
-            // necessário. Por exemplo, declaração de `para` sem inicializador.
             case ';':
-                this.adicionarSimbolo(tiposDeSimbolos.PONTO_E_VIRGULA);
                 this.avancar();
                 break;
+
             case '"':
                 this.avancar();
                 this.analisarTexto('"');
diff --git a/fontes/tipos-de-simbolos/birl.ts b/fontes/tipos-de-simbolos/birl.ts
index e56a4c40..9f33fab5 100644
--- a/fontes/tipos-de-simbolos/birl.ts
+++ b/fontes/tipos-de-simbolos/birl.ts
@@ -25,6 +25,7 @@ export default {
     MALUCO: 'MALUCO',
     MONSTRAO: 'MONSTRAO',
     MONSTRO: 'MONSTRO',
+    TRAPEZIO: 'TRAPEZIO',
     NAO: 'NAO',
     NEGATIVA: 'NEGATIVA',
     NEGATIVO: 'NEGATIVO',
@@ -45,18 +46,33 @@ export default {
     VER: 'VER',
 
     // Símbolos de propósito geral
+    IGUAL: 'IGUAL',
     PARENTESE_DIREITO: 'PARENTESE_DIREITO',
     PARENTESE_ESQUERDO: 'PARENTESE_ESQUERDO',
-    IGUAL: 'IGUAL',
-    IGUAL_IGUAL: 'IGUAL_IGUAL',
     PONTO_E_VIRGULA: 'PONTO_E_VIRGULA',
     QUEBRA_LINHA: 'QUEBRA_LINHA',
     INTERROGACAO: 'INTERROGACAO',
+    VIRGULA: 'VIRGULA',
 
     // Operações matemáticas
     ADICAO: 'ADICAO',
+    SUBTRACAO: 'SUBTRACAO',
+    MULTIPLICACAO: 'MULTIPLICACAO',
+    DIVISAO: 'DIVISAO',
+    MODULO: 'MODULO',
 
+    // Comparadores
+    IGUAL_IGUAL: 'IGUAL_IGUAL',
+    MAIOR: 'MAIOR',
+    MAIOR_IGUAL: 'MAIOR_IGUAL',
+    MENOR: 'MENOR',
+    MENOR_IGUAL: 'MENOR_IGUAL',
+
+    // Tipos de dados
     TEXTO: 'TEXTO',
     NUMERO: 'NUMERO',
     IDENTIFICADOR: 'IDENTIFICADOR',
+
+    // SINTAXE BIRL
+    PONTEIRO: 'PONTEIRO',
 };
diff --git a/fontes/tipos-de-simbolos/portugol-studio.ts b/fontes/tipos-de-simbolos/portugol-studio.ts
index ef02e8ee..6821095a 100644
--- a/fontes/tipos-de-simbolos/portugol-studio.ts
+++ b/fontes/tipos-de-simbolos/portugol-studio.ts
@@ -1,52 +1,36 @@
 export default {
     ADICAO: 'ADICAO',
     CADEIA: 'CADEIA',
-    CARACTER: 'CARACTER',
     CHAVE_ESQUERDA: 'CHAVE_ESQUERDA',
     CHAVE_DIREITA: 'CHAVE_DIREITA',
     COLCHETE_ESQUERDO: 'COLCHETE_ESQUERDO',
     COLCHETE_DIREITO: 'COLCHETE_DIREITO',
-    CONSTANTE: 'CONSTANTE',
-    DECREMENTAR: 'DECREMENTAR',
     DIFERENTE: 'DIFERENTE',
     DIVISAO: 'DIVISAO',
-    DIVISAO_IGUAL: 'DIVISAO_IGUAL',
     DIVISAO_INTEIRA: 'DIVISAO_INTEIRA',
     E: 'E',
-    ENQUANTO: 'ENQUANTO',
     ESCREVA: 'ESCREVA',
-    FACA: 'FACA',
-    FALSO: 'FALSO',
     FUNCAO: 'FUNCAO',
     IDENTIFICADOR: 'IDENTIFICADOR',
     IGUAL: 'IGUAL',
     IGUAL_IGUAL: 'IGUAL_IGUAL',
-    INCREMENTAR: 'INCREMENTAR',
     INTEIRO: 'INTEIRO',
     LEIA: 'LEIA',
-    LOGICO: 'LOGICO',
     MAIOR: 'MAIOR',
     MAIOR_IGUAL: 'MAIOR_IGUAL',
-    MAIS_IGUAL: 'MAIS_IGUAL',
     MENOR: 'MENOR',
     MENOR_IGUAL: 'MENOR_IGUAL',
-    MENOS_IGUAL: 'MENOS_IGUAL',
     MODULO: 'MODULO',
     MULTIPLICACAO: 'MULTIPLICACAO',
-    MULTIPLICACAO_IGUAL: 'MULTIPLICACAO_IGUAL',
     NEGACAO: 'NEGACAO',
     OU: 'OU',
-    PARA: 'PARA',
     PARENTESE_ESQUERDO: 'PARENTESE_ESQUERDO',
     PARENTESE_DIREITO: 'PARENTESE_DIREITO',
     PONTO: 'PONTO',
-    PONTO_E_VIRGULA: 'PONTO_E_VIRGULA',
     PROGRAMA: 'PROGRAMA',
     REAL: 'REAL',
     SUBTRACAO: 'SUBTRACAO',
     VIRGULA: 'VIRGULA',
     SE: 'SE',
     SENAO: 'SENAO',
-    VAZIO: 'VAZIO',
-    VERDADEIRO: 'VERDADEIRO'
 };
diff --git a/fontes/tradutores/tradutor-javascript.ts b/fontes/tradutores/tradutor-javascript.ts
index b58eae0c..c4cc1651 100644
--- a/fontes/tradutores/tradutor-javascript.ts
+++ b/fontes/tradutores/tradutor-javascript.ts
@@ -537,7 +537,7 @@ export class TradutorJavaScript implements TradutorInterface {
     traduzirConstrutoUnario(unario: Unario): string {
         let resultado = '';
         resultado += this.traduzirSimboloOperador(unario.operador);
-        resultado += unario.operando.valor ?? unario.operando.simbolo.lexema;
+        resultado += unario.direita.valor ?? unario.direita.simbolo.lexema;
         return resultado;
     }
 
diff --git a/package.json b/package.json
index 0530eb30..2e88125d 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
     "name": "@designliquido/delegua",
-    "version": "0.15.0",
+    "version": "0.14.7",
     "description": "Linguagem de programação simples e moderna usando português estruturado, com suporte a múltiplos dialetos",
     "main": "index.js",
     "scripts": {
diff --git a/recursos/imagens/badge-branches.svg b/recursos/imagens/badge-branches.svg
index edd81979..214a3d46 100644
--- a/recursos/imagens/badge-branches.svg
+++ b/recursos/imagens/badge-branches.svg
@@ -1,1 +1,1 @@
-<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" width="170" height="20" role="img" aria-label="Coverage:branches: 63.09%"><title>Coverage:branches: 63.09%</title><linearGradient id="s" x2="0" y2="100%"><stop offset="0" stop-color="#bbb" stop-opacity=".1"/><stop offset="1" stop-opacity=".1"/></linearGradient><clipPath id="r"><rect width="170" height="20" rx="3" fill="#fff"/></clipPath><g clip-path="url(#r)"><rect width="117" height="20" fill="#555"/><rect x="117" width="53" height="20" fill="#e05d44"/><rect width="170" height="20" fill="url(#s)"/></g><g fill="#fff" text-anchor="middle" font-family="Verdana,Geneva,DejaVu Sans,sans-serif" text-rendering="geometricPrecision" font-size="110"><text aria-hidden="true" x="595" y="150" fill="#010101" fill-opacity=".3" transform="scale(.1)" textLength="1070">Coverage:branches</text><text x="595" y="140" transform="scale(.1)" fill="#fff" textLength="1070">Coverage:branches</text><text aria-hidden="true" x="1425" y="150" fill="#010101" fill-opacity=".3" transform="scale(.1)" textLength="430">63.09%</text><text x="1425" y="140" transform="scale(.1)" fill="#fff" textLength="430">63.09%</text></g></svg>
\ No newline at end of file
+<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" width="170" height="20" role="img" aria-label="Coverage:branches: 61.53%"><title>Coverage:branches: 61.53%</title><linearGradient id="s" x2="0" y2="100%"><stop offset="0" stop-color="#bbb" stop-opacity=".1"/><stop offset="1" stop-opacity=".1"/></linearGradient><clipPath id="r"><rect width="170" height="20" rx="3" fill="#fff"/></clipPath><g clip-path="url(#r)"><rect width="117" height="20" fill="#555"/><rect x="117" width="53" height="20" fill="#e05d44"/><rect width="170" height="20" fill="url(#s)"/></g><g fill="#fff" text-anchor="middle" font-family="Verdana,Geneva,DejaVu Sans,sans-serif" text-rendering="geometricPrecision" font-size="110"><text aria-hidden="true" x="595" y="150" fill="#010101" fill-opacity=".3" transform="scale(.1)" textLength="1070">Coverage:branches</text><text x="595" y="140" transform="scale(.1)" fill="#fff" textLength="1070">Coverage:branches</text><text aria-hidden="true" x="1425" y="150" fill="#010101" fill-opacity=".3" transform="scale(.1)" textLength="430">61.53%</text><text x="1425" y="140" transform="scale(.1)" fill="#fff" textLength="430">61.53%</text></g></svg>
\ No newline at end of file
diff --git a/recursos/imagens/badge-functions.svg b/recursos/imagens/badge-functions.svg
index 76ecc7f5..2dcd4457 100644
--- a/recursos/imagens/badge-functions.svg
+++ b/recursos/imagens/badge-functions.svg
@@ -1,1 +1,1 @@
-<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" width="170" height="20" role="img" aria-label="Coverage:functions: 75.17%"><title>Coverage:functions: 75.17%</title><linearGradient id="s" x2="0" y2="100%"><stop offset="0" stop-color="#bbb" stop-opacity=".1"/><stop offset="1" stop-opacity=".1"/></linearGradient><clipPath id="r"><rect width="170" height="20" rx="3" fill="#fff"/></clipPath><g clip-path="url(#r)"><rect width="117" height="20" fill="#555"/><rect x="117" width="53" height="20" fill="#e05d44"/><rect width="170" height="20" fill="url(#s)"/></g><g fill="#fff" text-anchor="middle" font-family="Verdana,Geneva,DejaVu Sans,sans-serif" text-rendering="geometricPrecision" font-size="110"><text aria-hidden="true" x="595" y="150" fill="#010101" fill-opacity=".3" transform="scale(.1)" textLength="1070">Coverage:functions</text><text x="595" y="140" transform="scale(.1)" fill="#fff" textLength="1070">Coverage:functions</text><text aria-hidden="true" x="1425" y="150" fill="#010101" fill-opacity=".3" transform="scale(.1)" textLength="430">75.17%</text><text x="1425" y="140" transform="scale(.1)" fill="#fff" textLength="430">75.17%</text></g></svg>
\ No newline at end of file
+<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" width="170" height="20" role="img" aria-label="Coverage:functions: 73.79%"><title>Coverage:functions: 73.79%</title><linearGradient id="s" x2="0" y2="100%"><stop offset="0" stop-color="#bbb" stop-opacity=".1"/><stop offset="1" stop-opacity=".1"/></linearGradient><clipPath id="r"><rect width="170" height="20" rx="3" fill="#fff"/></clipPath><g clip-path="url(#r)"><rect width="117" height="20" fill="#555"/><rect x="117" width="53" height="20" fill="#e05d44"/><rect width="170" height="20" fill="url(#s)"/></g><g fill="#fff" text-anchor="middle" font-family="Verdana,Geneva,DejaVu Sans,sans-serif" text-rendering="geometricPrecision" font-size="110"><text aria-hidden="true" x="595" y="150" fill="#010101" fill-opacity=".3" transform="scale(.1)" textLength="1070">Coverage:functions</text><text x="595" y="140" transform="scale(.1)" fill="#fff" textLength="1070">Coverage:functions</text><text aria-hidden="true" x="1425" y="150" fill="#010101" fill-opacity=".3" transform="scale(.1)" textLength="430">73.79%</text><text x="1425" y="140" transform="scale(.1)" fill="#fff" textLength="430">73.79%</text></g></svg>
\ No newline at end of file
diff --git a/recursos/imagens/badge-lines.svg b/recursos/imagens/badge-lines.svg
index e3b371c4..f343cf59 100644
--- a/recursos/imagens/badge-lines.svg
+++ b/recursos/imagens/badge-lines.svg
@@ -1,1 +1,1 @@
-<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" width="146" height="20" role="img" aria-label="Coverage:lines: 75.33%"><title>Coverage:lines: 75.33%</title><linearGradient id="s" x2="0" y2="100%"><stop offset="0" stop-color="#bbb" stop-opacity=".1"/><stop offset="1" stop-opacity=".1"/></linearGradient><clipPath id="r"><rect width="146" height="20" rx="3" fill="#fff"/></clipPath><g clip-path="url(#r)"><rect width="93" height="20" fill="#555"/><rect x="93" width="53" height="20" fill="#e05d44"/><rect width="146" height="20" fill="url(#s)"/></g><g fill="#fff" text-anchor="middle" font-family="Verdana,Geneva,DejaVu Sans,sans-serif" text-rendering="geometricPrecision" font-size="110"><text aria-hidden="true" x="475" y="150" fill="#010101" fill-opacity=".3" transform="scale(.1)" textLength="830">Coverage:lines</text><text x="475" y="140" transform="scale(.1)" fill="#fff" textLength="830">Coverage:lines</text><text aria-hidden="true" x="1185" y="150" fill="#010101" fill-opacity=".3" transform="scale(.1)" textLength="430">75.33%</text><text x="1185" y="140" transform="scale(.1)" fill="#fff" textLength="430">75.33%</text></g></svg>
\ No newline at end of file
+<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" width="140" height="20" role="img" aria-label="Coverage:lines: 73.7%"><title>Coverage:lines: 73.7%</title><linearGradient id="s" x2="0" y2="100%"><stop offset="0" stop-color="#bbb" stop-opacity=".1"/><stop offset="1" stop-opacity=".1"/></linearGradient><clipPath id="r"><rect width="140" height="20" rx="3" fill="#fff"/></clipPath><g clip-path="url(#r)"><rect width="93" height="20" fill="#555"/><rect x="93" width="47" height="20" fill="#e05d44"/><rect width="140" height="20" fill="url(#s)"/></g><g fill="#fff" text-anchor="middle" font-family="Verdana,Geneva,DejaVu Sans,sans-serif" text-rendering="geometricPrecision" font-size="110"><text aria-hidden="true" x="475" y="150" fill="#010101" fill-opacity=".3" transform="scale(.1)" textLength="830">Coverage:lines</text><text x="475" y="140" transform="scale(.1)" fill="#fff" textLength="830">Coverage:lines</text><text aria-hidden="true" x="1155" y="150" fill="#010101" fill-opacity=".3" transform="scale(.1)" textLength="370">73.7%</text><text x="1155" y="140" transform="scale(.1)" fill="#fff" textLength="370">73.7%</text></g></svg>
\ No newline at end of file
diff --git a/recursos/imagens/badge-statements.svg b/recursos/imagens/badge-statements.svg
index 17590b02..9ccb4a21 100644
--- a/recursos/imagens/badge-statements.svg
+++ b/recursos/imagens/badge-statements.svg
@@ -1,1 +1,1 @@
-<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" width="176" height="20" role="img" aria-label="Coverage:statements: 74.9%"><title>Coverage:statements: 74.9%</title><linearGradient id="s" x2="0" y2="100%"><stop offset="0" stop-color="#bbb" stop-opacity=".1"/><stop offset="1" stop-opacity=".1"/></linearGradient><clipPath id="r"><rect width="176" height="20" rx="3" fill="#fff"/></clipPath><g clip-path="url(#r)"><rect width="129" height="20" fill="#555"/><rect x="129" width="47" height="20" fill="#e05d44"/><rect width="176" height="20" fill="url(#s)"/></g><g fill="#fff" text-anchor="middle" font-family="Verdana,Geneva,DejaVu Sans,sans-serif" text-rendering="geometricPrecision" font-size="110"><text aria-hidden="true" x="655" y="150" fill="#010101" fill-opacity=".3" transform="scale(.1)" textLength="1190">Coverage:statements</text><text x="655" y="140" transform="scale(.1)" fill="#fff" textLength="1190">Coverage:statements</text><text aria-hidden="true" x="1515" y="150" fill="#010101" fill-opacity=".3" transform="scale(.1)" textLength="370">74.9%</text><text x="1515" y="140" transform="scale(.1)" fill="#fff" textLength="370">74.9%</text></g></svg>
\ No newline at end of file
+<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" width="182" height="20" role="img" aria-label="Coverage:statements: 73.34%"><title>Coverage:statements: 73.34%</title><linearGradient id="s" x2="0" y2="100%"><stop offset="0" stop-color="#bbb" stop-opacity=".1"/><stop offset="1" stop-opacity=".1"/></linearGradient><clipPath id="r"><rect width="182" height="20" rx="3" fill="#fff"/></clipPath><g clip-path="url(#r)"><rect width="129" height="20" fill="#555"/><rect x="129" width="53" height="20" fill="#e05d44"/><rect width="182" height="20" fill="url(#s)"/></g><g fill="#fff" text-anchor="middle" font-family="Verdana,Geneva,DejaVu Sans,sans-serif" text-rendering="geometricPrecision" font-size="110"><text aria-hidden="true" x="655" y="150" fill="#010101" fill-opacity=".3" transform="scale(.1)" textLength="1190">Coverage:statements</text><text x="655" y="140" transform="scale(.1)" fill="#fff" textLength="1190">Coverage:statements</text><text aria-hidden="true" x="1545" y="150" fill="#010101" fill-opacity=".3" transform="scale(.1)" textLength="430">73.34%</text><text x="1545" y="140" transform="scale(.1)" fill="#fff" textLength="430">73.34%</text></g></svg>
\ No newline at end of file


Test patch:
diff --git a/testes/avaliador-sintatico.test.ts b/testes/avaliador-sintatico.test.ts
index 63e820c7..72c295bd 100644
--- a/testes/avaliador-sintatico.test.ts
+++ b/testes/avaliador-sintatico.test.ts
@@ -6,148 +6,129 @@ describe('Avaliador sintático', () => {
         let lexador = new Lexador();
         let avaliadorSintatico = new AvaliadorSintatico();
 
-        describe('Cenários de sucesso', () => {
-            it('Sucesso - Olá Mundo', () => {
-                const retornoLexador = lexador.mapear(["escreva('Olá mundo')"], -1);
-                const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador);
-    
-                expect(retornoAvaliadorSintatico).toBeTruthy();
-                expect(retornoAvaliadorSintatico.declaracoes).toHaveLength(1);
-            });
-    
-            it('Sucesso - Vetor vazio', () => {
-                const retornoLexador = lexador.mapear(['var vetorVazio = []'], -1);
-                const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador);
-    
-                expect(retornoAvaliadorSintatico).toBeTruthy();
-                expect(retornoAvaliadorSintatico.declaracoes).toHaveLength(1);
-            });
-    
-            it('Sucesso - Dicionário vazio', () => {
-                const retornoLexador = lexador.mapear(['var dicionarioVazio = {}'], -1);
-                const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador);
-    
-                expect(retornoAvaliadorSintatico).toBeTruthy();
-                expect(retornoAvaliadorSintatico.declaracoes).toHaveLength(1);
-            });
-    
-            it('Sucesso - Undefined', () => {
-                const retornoAvaliadorSintatico = avaliadorSintatico.analisar(undefined as any);
-    
-                expect(retornoAvaliadorSintatico).toBeTruthy();
-                expect(retornoAvaliadorSintatico.declaracoes).toHaveLength(0);
-            });
-    
-            it('Sucesso - Null', () => {
-                const retornoAvaliadorSintatico = avaliadorSintatico.analisar(null as any);
-    
-                expect(retornoAvaliadorSintatico).toBeTruthy();
-                expect(retornoAvaliadorSintatico.declaracoes).toHaveLength(0);
-            });
+        it('Sucesso - Olá Mundo', () => {
+            const retornoLexador = lexador.mapear(["escreva('Olá mundo')"], -1);
+            const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador);
 
-            it('Sucesso - Incremento e decremento após variável ou literal', () => {
-                const retornoLexador = lexador.mapear([
-                    'var a = 1',
-                    'a++',
-                    'a--',
-                    '++5',
-                    '--5'
-                ], -1);
+            expect(retornoAvaliadorSintatico).toBeTruthy();
+            expect(retornoAvaliadorSintatico.declaracoes).toHaveLength(1);
+        });
 
-                const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador);
-    
-                expect(retornoAvaliadorSintatico).toBeTruthy();
-                expect(retornoAvaliadorSintatico.erros).toHaveLength(0);
-            });
-    
-            it('Sucesso - leia sem parametro', () => {
-                const retornoLexador = lexador.mapear(['var nome = leia()'], -1);
-                const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador);
-    
-                expect(retornoAvaliadorSintatico).toBeTruthy();
-                expect(retornoAvaliadorSintatico.erros).toHaveLength(0);
-            });
-    
-            it('Sucesso - leia com parametro', () => {
-                const retornoLexador = lexador.mapear(["var nome = leia('Digite seu nome:')"], -1);
-                const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador);
-    
-                expect(retornoAvaliadorSintatico).toBeTruthy();
-                expect(retornoAvaliadorSintatico.erros).toHaveLength(0);
-            });
-    
-            it('Sucesso - para/sustar', async () => {
-                const retornoLexador = lexador.mapear(
-                    [
-                        'para (var i = 0; i < 10; i = i + 1) {',
-                        '   se (i == 5) { sustar; }',
-                        "   escreva('Valor: ', i)",
-                        '}',
-                    ],
-                    -1
-                );
-                const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador);
-    
-                expect(retornoAvaliadorSintatico.erros).toHaveLength(0);
-            });
+        it('Sucesso - Vetor vazio', () => {
+            const retornoLexador = lexador.mapear(['var vetorVazio = []'], -1);
+            const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador);
+
+            expect(retornoAvaliadorSintatico).toBeTruthy();
+            expect(retornoAvaliadorSintatico.declaracoes).toHaveLength(1);
         });
 
-        describe('Cenários de falha', () => {
-            it('Falha - sustar fora de laço de repetição', async () => {
-                const retornoLexador = lexador.mapear(['sustar;'], -1);
-                const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador);
-    
-                expect(retornoAvaliadorSintatico.erros.length).toBeGreaterThan(0);
-                expect(retornoAvaliadorSintatico.erros[0].message).toBe(
-                    "'sustar' ou 'pausa' deve estar dentro de um laço de repetição."
-                );
-            });
-    
-            it('Falha - continua fora de laço de repetição', async () => {
-                const retornoLexador = lexador.mapear(['continua;'], -1);
-                const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador);
-    
-                expect(retornoAvaliadorSintatico.erros.length).toBeGreaterThan(0);
-                expect(retornoAvaliadorSintatico.erros[0].message).toBe(
-                    "'continua' precisa estar em um laço de repetição."
-                );
-            });
-    
-            it('Falha - Não é permitido ter dois identificadores seguidos na mesma linha', () => {
-                const retornoLexador = lexador.mapear(["escreva('Olá mundo') identificador1 identificador2"], -1);
-                const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador);
-    
-                expect(retornoAvaliadorSintatico.erros.length).toBeGreaterThan(0);
-                expect(retornoAvaliadorSintatico.erros[0].message).toBe(
-                    'Não é permitido ter dois identificadores seguidos na mesma linha.'
-                );
-            });
-    
-            describe('Funções Anônimas', () => {
-                it('Função anônima com mais de 255 parâmetros', () => {
-                    let acumulador = '';
-                    for (let i = 1; i <= 256; i++) {
-                        acumulador += 'a' + i + ', ';
-                    }
-    
-                    acumulador = acumulador.substring(0, acumulador.length - 2);
-    
-                    const funcaoCom256Argumentos = 'var f = funcao(' + acumulador + ') {}';
-                    const retornoLexador = lexador.mapear([funcaoCom256Argumentos], -1);
-                    const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador);
-    
-                    expect(retornoAvaliadorSintatico).toBeTruthy();
-                    expect(retornoAvaliadorSintatico.erros).toHaveLength(1);
-                    expect(retornoAvaliadorSintatico.erros[0].message).toBe('Não pode haver mais de 255 parâmetros');
-                });
-            });
-    
-            it('Declaração `tente`', () => {
-                const retornoLexador = lexador.mapear(['tente { i = i + 1 } pegue (erro) { escreva(erro) }'], -1);
+        it('Sucesso - Dicionário vazio', () => {
+            const retornoLexador = lexador.mapear(['var dicionarioVazio = {}'], -1);
+            const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador);
+
+            expect(retornoAvaliadorSintatico).toBeTruthy();
+            expect(retornoAvaliadorSintatico.declaracoes).toHaveLength(1);
+        });
+
+        it('Sucesso - Undefined', () => {
+            const retornoAvaliadorSintatico = avaliadorSintatico.analisar(undefined as any);
+
+            expect(retornoAvaliadorSintatico).toBeTruthy();
+            expect(retornoAvaliadorSintatico.declaracoes).toHaveLength(0);
+        });
+
+        it('Sucesso - Null', () => {
+            const retornoAvaliadorSintatico = avaliadorSintatico.analisar(null as any);
+
+            expect(retornoAvaliadorSintatico).toBeTruthy();
+            expect(retornoAvaliadorSintatico.declaracoes).toHaveLength(0);
+        });
+
+        it('Sucesso - leia sem parametro', () => {
+            const retornoLexador = lexador.mapear(['var nome = leia()'], -1);
+            const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador);
+
+            expect(retornoAvaliadorSintatico).toBeTruthy();
+            expect(retornoAvaliadorSintatico.erros).toHaveLength(0);
+        });
+
+        it('Sucesso - leia com parametro', () => {
+            const retornoLexador = lexador.mapear(["var nome = leia('Digite seu nome:')"], -1);
+            const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador);
+
+            expect(retornoAvaliadorSintatico).toBeTruthy();
+            expect(retornoAvaliadorSintatico.erros).toHaveLength(0);
+        });
+
+        it.only('Sucesso - para/sustar', async () => {
+            const retornoLexador = lexador.mapear(
+                [
+                    'para (var i = 0; i < 10; i = i + 1) {',
+                    '   se (i == 5) { sustar; }',
+                    "   escreva('Valor: ', i)",
+                    '}',
+                ],
+                -1
+            );
+            const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador);
+
+            expect(retornoAvaliadorSintatico.erros).toHaveLength(0);
+        });
+
+        it('Falha - sustar fora de laço de repetição', async () => {
+            const retornoLexador = lexador.mapear(['sustar;'], -1);
+            const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador);
+
+            expect(retornoAvaliadorSintatico.erros.length).toBeGreaterThan(0);
+            expect(retornoAvaliadorSintatico.erros[0].message).toBe(
+                "'sustar' ou 'pausa' deve estar dentro de um laço de repetição."
+            );
+        });
+
+        it('Falha - continua fora de laço de repetição', async () => {
+            const retornoLexador = lexador.mapear(['continua;'], -1);
+            const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador);
+
+            expect(retornoAvaliadorSintatico.erros.length).toBeGreaterThan(0);
+            expect(retornoAvaliadorSintatico.erros[0].message).toBe(
+                "'continua' precisa estar em um laço de repetição."
+            );
+        });
+
+        it('Falha - Não é permitido ter dois identificadores seguidos na mesma linha', () => {
+            const retornoLexador = lexador.mapear(["escreva('Olá mundo') identificador1 identificador2"], -1);
+            const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador);
+
+            expect(retornoAvaliadorSintatico.erros.length).toBeGreaterThan(0);
+            expect(retornoAvaliadorSintatico.erros[0].message).toBe(
+                'Não é permitido ter dois identificadores seguidos na mesma linha.'
+            );
+        });
+
+        describe('Funções Anônimas', () => {
+            it('Função anônima com mais de 255 parâmetros', () => {
+                let acumulador = '';
+                for (let i = 1; i <= 256; i++) {
+                    acumulador += 'a' + i + ', ';
+                }
+
+                acumulador = acumulador.substring(0, acumulador.length - 2);
+
+                const funcaoCom256Argumentos = 'var f = funcao(' + acumulador + ') {}';
+                const retornoLexador = lexador.mapear([funcaoCom256Argumentos], -1);
                 const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador);
-    
+
                 expect(retornoAvaliadorSintatico).toBeTruthy();
+                expect(retornoAvaliadorSintatico.erros).toHaveLength(1);
+                expect(retornoAvaliadorSintatico.erros[0].message).toBe('Não pode haver mais de 255 parâmetros');
             });
         });
+
+        it('Declaração `tente`', () => {
+            const retornoLexador = lexador.mapear(['tente { i = i + 1 } pegue (erro) { escreva(erro) }'], -1);
+            const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador);
+
+            expect(retornoAvaliadorSintatico).toBeTruthy();
+        });
     });
 });
diff --git a/testes/birl/avaliador-sintatico.test.ts b/testes/birl/avaliador-sintatico.test.ts
index 61f8e2b0..dfa11e64 100644
--- a/testes/birl/avaliador-sintatico.test.ts
+++ b/testes/birl/avaliador-sintatico.test.ts
@@ -1,7 +1,7 @@
 import { AvaliadorSintaticoBirl } from '../../fontes/avaliador-sintatico/dialetos';
 import { LexadorBirl } from '../../fontes/lexador/dialetos';
 
-describe('Avaliador sintático Birl', () => {
+describe('Avaliador Sintático Birl', () => {
     describe('analisar()', () => {
         let lexador: LexadorBirl;
         let avaliadorSintatico: AvaliadorSintaticoBirl;
@@ -11,16 +11,86 @@ describe('Avaliador sintático Birl', () => {
             avaliadorSintatico = new AvaliadorSintaticoBirl();
         });
 
-        it.skip('Sucesso - Hello, World! Porra!', () => {
+        it('Sucesso - Hello, World! Porra!', () => {
             const retornoLexador = lexador.mapear(
-                ['HORA DO SHOW', 'CE QUER VER ESSA PORRA? ("Hello, World! Porra!\n");', 'BORA CUMPADE 0;', 'BIRL'],
+                ['HORA DO SHOW', '  CE QUER VER ESSA PORRA? ("Hello, World! Porra!\n");', '  BORA CUMPADE 0;', 'BIRL'],
                 -1
             );
 
             const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador);
 
             expect(retornoAvaliadorSintatico).toBeTruthy();
-            expect(retornoAvaliadorSintatico.declaracoes).toHaveLength(4);
+            expect(retornoAvaliadorSintatico.declaracoes).toHaveLength(2);
+        });
+
+        it.skip('Sucesso - For', () => {
+            //@TODO: @ItaloCobains - Implementar esse teste
+            const retornoLexador = lexador.mapear(
+                [
+                    'HORA DO SHOW',
+                    '  MONSTRO M;',
+                    '  MAIS QUERO MAIS (M = 0; M < 5; M++)',
+                    '    CE QUER VER ESSA PORRA? ("%d", M);',
+                    '  BIRL',
+                    'BIRL',
+                ],
+                -1
+            );
+
+            const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador);
+            expect(retornoAvaliadorSintatico).toBeTruthy();
+            // expect(retornoAvaliadorSintatico.declaracoes).toHaveLength(2);
+        });
+
+        it('Sucesso - Variavel - Numero', () => {
+            const retornoLexador = lexador.mapear(
+                [
+                    'HORA DO SHOW \n',
+                    '  MONSTRO M1 = 1; \n',
+                    '  CE QUER VER ESSA PORRA? (M1); \n',
+                    '  BORA CUMPADE 0; \n',
+                    'BIRL \n',
+                ],
+                -1
+            );
+
+            const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador);
+
+            expect(retornoAvaliadorSintatico).toBeTruthy();
+            expect(retornoAvaliadorSintatico.declaracoes).toHaveLength(3);
+        });
+
+        it('Sucesso - Variavel - String', () => {
+            const retornoLexador = lexador.mapear([
+                'HORA DO SHOW \n',
+                "   FRANGO FR = 'testes';\n",
+                '   CE QUER VER ESSA PORRA? (FR); \n',
+                '   BORA CUMPADE 0; \n',
+                'BIRL \n',
+            ]);
+            //  FRANGO esta vindo como um indentificador
+            const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador);
+
+            expect(retornoAvaliadorSintatico).toBeTruthy();
+            expect(retornoAvaliadorSintatico.declaracoes).toHaveLength(3);
+        });
+
+        it('Sucesso - Variavel - Float', () => {
+            const retornoLexador = lexador.mapear(
+                [
+                    'HORA DO SHOW \n',
+                    '  TRAPEZIO M1 = 1.03; \n',
+                    '  CE QUER VER ESSA PORRA? (M1); \n',
+                    '  BORA CUMPADE 0; \n',
+                    'BIRL \n',
+                ],
+                -1
+            );
+
+            const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador);
+
+            expect(retornoAvaliadorSintatico).toBeTruthy();
+            expect(retornoAvaliadorSintatico.declaracoes).toHaveLength(3);
         });
     });
 });
diff --git a/testes/birl/lexador.test.ts b/testes/birl/lexador.test.ts
index 34592e6d..ce2b0915 100644
--- a/testes/birl/lexador.test.ts
+++ b/testes/birl/lexador.test.ts
@@ -38,7 +38,19 @@ describe('Lexador (BIRL)', () => {
                 expect(resultado.simbolos).toHaveLength(27);
                 expect(resultado.erros).toHaveLength(0);
             });
+            it('Sucesso - Ler da tela', () => {
+                const resultado = lexador.mapear([
+                    'HORA DO SHOW \n',
+                    'MONSTRO? X;',
+                    'QUE QUE CE QUER MONSTRAO? ("%d", &X);',
+                    'BORA CUMPADE 1;',
+                    'BIRL \n'
+                ], -1)
 
+                expect(resultado).toBeTruthy();
+                expect(resultado.simbolos).toHaveLength(32);
+                expect(resultado.erros).toHaveLength(0);
+            });
             it('Sucesso - Variavel - Atribuição', () => {
                 const resultado = lexador.mapear(
                     [
@@ -56,6 +68,153 @@ describe('Lexador (BIRL)', () => {
                 expect(resultado.simbolos).toHaveLength(41);
                 expect(resultado.erros).toHaveLength(0);
             });
+            it('Sucesso - Loop - For', () => {
+                const resultado = lexador.mapear([
+                    'HORA DO SHOW \n',
+                    'MONSTRO M;',
+                    'MAIS QUERO MAIS (M = 0; M < 5; M++)',
+                    '   CE QUER VER ESSA PORRA? ("%d", M);',
+                    'BIRL',
+                    'BORA CUMPADE? 0; \n',
+                    'BIRL \n',
+                ], -1)
+
+                expect(resultado).toBeTruthy();
+                expect(resultado.simbolos).toHaveLength(51);
+                expect(resultado.erros).toHaveLength(0);
+            })
+            it('Sucesso - Loop - While', () => {
+                const resultado = lexador.mapear([
+                    'HORA DO SHOW \n',
+                    'MONSTRO X = 5;',
+                    'NEGATIVA BAMBAM (X > 2)',
+                    '   CE QUER VER ESSA PORRA? ("%d", X);',
+                    '   X--;',
+                    'BIRL',
+                    'BORA CUMPADE? 0; \n',
+                    'BIRL \n',
+                ], -1)
+
+                expect(resultado).toBeTruthy();
+                expect(resultado.simbolos).toHaveLength(49);
+                expect(resultado.erros).toHaveLength(0);
+            })
+            it('Sucesso - Condição - If', () => {
+                const resultado = lexador.mapear([
+                    'HORA DO SHOW \n',
+                    'ELE QUE A GENTE QUER? (3 > 2)',
+                    '   CE QUER VER ESSA PORRA? ("%d", 3);',
+                    'BIRL',
+                    'BORA CUMPADE? 0; \n',
+                    'BIRL \n',
+                ], -1)
+
+                expect(resultado).toBeTruthy();
+                expect(resultado.simbolos).toHaveLength(42);
+                expect(resultado.erros).toHaveLength(0);
+            })
+            it('Sucesso - Condição - If Else', () => {
+                const resultado = lexador.mapear([
+                    'HORA DO SHOW \n',
+                    'ELE QUE A GENTE QUER? (3 > 2)',
+                    '   CE QUER VER ESSA PORRA? ("%d", 3);',
+                    'NAO VAI DAR NAO',
+                    '   CE QUER VER ESSA PORRA? ("%d", 2);',
+                    'BIRL',
+                    'BORA CUMPADE? 0; \n',
+                    'BIRL \n',
+                ], -1)
+
+                expect(resultado).toBeTruthy();
+                expect(resultado.simbolos).toHaveLength(60);
+                expect(resultado.erros).toHaveLength(0);
+            })
+            it('Sucesso - Condição - If Else If', () => {
+                const resultado = lexador.mapear([
+                    'HORA DO SHOW \n',
+                    'ELE QUE A GENTE QUER? (3 > 2)',
+                    '   CE QUER VER ESSA PORRA? ("%d", 3);',
+                    'ELE NAO VAI DAR O QUE? (3 > 2)',
+                    '   CE QUER VER ESSA PORRA? ("%d", 2);',
+                    'NAO VAI DAR NAO',
+                    '   CE QUER VER ESSA PORRA? ("%d", 1);',
+                    'BIRL',
+                    'BORA CUMPADE? 0; \n',
+                    'BIRL \n',
+                ], -1)
+
+                expect(resultado).toBeTruthy();
+                expect(resultado.simbolos).toHaveLength(86);
+                expect(resultado.erros).toHaveLength(0);
+            });
+            it('Sucesso - Condição - BREAK/CONTINUE', () => {
+                const resultado = lexador.mapear([
+                    'HORA DO SHOW \n',
+                    'MONSTRO M = 0;',
+                    'MAIS QUERO MAIS (M = 0; M < 5; M++)',
+                    '   ELE QUE A GENTE QUER? (M == 3)',
+                    '   VAMO MONSTRO;',
+                    '   SAI FILHO DA PUTA;',
+                    'BIRL',
+                    'BORA CUMPADE? 0; \n',
+                    'BIRL \n',
+                ], -1);
+
+                expect(resultado).toBeTruthy();
+                expect(resultado.simbolos).toHaveLength(62);
+                expect(resultado.erros).toHaveLength(0);
+            })
+            it('Sucesso - Declaração de Função', () => {
+                const resultado = lexador.mapear([
+                    'HORA DO SHOW \n',
+                    'OH O HOME AI PO (MONSTRO NOMEFUNC(MONSTRO A, MONSTRO B))',
+                    '   CE QUER VER ESSA PORRA? ("%d", A + B);',
+                    '   BORA CUMPADE? 1; \n',
+                    'BIRL',
+                    'BORA CUMPADE? 0; \n',
+                    'BIRL \n',
+                ], -1);
+
+                expect(resultado).toBeTruthy();
+                expect(resultado.simbolos).toHaveLength(56);
+                expect(resultado.erros).toHaveLength(0);
+            })
+            it('Sucesso - Chamada de função', () => {
+                const resultado = lexador.mapear([
+                    'HORA DO SHOW \n',
+                    'MONSTRO A = 5;',
+                    'MONSTRO B = 8;',
+                    'MONSTRO C = AJUDA O MALUCO TA DOENTE SOMAR(A, B);'
+                ], -1)
+
+                expect(resultado).toBeTruthy();
+                expect(resultado.simbolos).toHaveLength(33);
+                expect(resultado.erros).toHaveLength(0);
+            });
+            it('Sucesso - EXEMPLO DESCENDENTE', () => {
+                const resultado = lexador.mapear([
+                    'OH O HOME AI PO (MONSTRO SOMAR(MONSTRO A, MONSTRO B))',
+                    '   BORA CUMPADE A + B;',
+                    'BIRL',
+                    'HORA DO SHOW \n',
+                    '   MONSTRO A, B, RES;',
+                    '   CE QUER VER ESSA PORRA? ("Entra com a e b ai cumpade!!\n");',
+                    '   QUE QUE CE QUER MONSTRAO? ("%d %d", &A, &B);',
+                    '   RES = AJUDA O MALUCO TA DOENTE SOMAR(A, B);',
+                    '   CE QUER VER ESSA PORRA? ("Oh o resultado ai po: %d\n", RES);',
+                    '   ELE QUE A GENTE QUER? (RES == 37)',
+                    '       CE QUER VER ESSA PORRA? ("É 37 anos caralho!\n");',
+                    '   NAO VAI DAR NAO',
+                    '       CE QUER VER ESSA PORRA? ("Manda o double biceps!\n");',
+                    '   BIRL',
+                    '   BORA CUMPADE 0;',
+                    'BIRL'
+                ], -1)
+
+                expect(resultado).toBeTruthy();
+                expect(resultado.simbolos).toHaveLength(143);
+                expect(resultado.erros).toHaveLength(0);
+            })
         });
     });
 });
diff --git a/testes/egua-classico/biblioteca-global.test.ts b/testes/egua-classico/biblioteca-global.test.ts
index 7a76ecfa..3d176bc0 100644
--- a/testes/egua-classico/biblioteca-global.test.ts
+++ b/testes/egua-classico/biblioteca-global.test.ts
@@ -27,7 +27,7 @@ describe('Biblioteca Global', () => {
     describe('aleatorioEntre()', () => {
         it('Trivial', () => {
             const resultado = funcoes['aleatorioEntre'](2, 10);
-            expect(resultado).toBeGreaterThanOrEqual(2);
+            expect(resultado).toBeGreaterThan(2);
             expect(resultado).toBeLessThan(10);
         });
     });
diff --git a/testes/interpretador.test.ts b/testes/interpretador.test.ts
index 776ee371..706b065a 100644
--- a/testes/interpretador.test.ts
+++ b/testes/interpretador.test.ts
@@ -63,24 +63,6 @@ describe('Interpretador', () => {
 
                     expect(retornoInterpretador.erros).toHaveLength(0);
                 });
-
-                it('Incremento e decremento após variável ou literal', async () => {
-                    const retornoLexador = lexador.mapear([
-                        'var a = 1',
-                        'escreva(a++)',
-                        'escreva(a--)',
-                        'escreva(++a)',
-                        'escreva(--a)',
-                        'escreva(++5)',
-                        'escreva(--5)'
-                    ], -1);
-    
-                    const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador);
-        
-                    const retornoInterpretador = await interpretador.interpretar(retornoAvaliadorSintatico.declaracoes);
-
-                    expect(retornoInterpretador.erros).toHaveLength(0);
-                });
             });
 
             describe('Acesso a variáveis e objetos', () => {
diff --git a/testes/lexador.test.ts b/testes/lexador.test.ts
index 7ead9484..2cf7a39b 100644
--- a/testes/lexador.test.ts
+++ b/testes/lexador.test.ts
@@ -22,7 +22,7 @@ describe('Lexador', () => {
                 const resultado = lexador.mapear([';;;;;;;;;;;;;;;;;;;;;'], -1);
 
                 expect(resultado).toBeTruthy();
-                expect(resultado.simbolos).toHaveLength(21);
+                expect(resultado.simbolos).toHaveLength(0);
             });
 
             it('Sucesso - Olá mundo', () => {
diff --git a/testes/portugol-studio/avaliador-sintatico.test.ts b/testes/portugol-studio/avaliador-sintatico.test.ts
index ef836d29..1a4879b6 100644
--- a/testes/portugol-studio/avaliador-sintatico.test.ts
+++ b/testes/portugol-studio/avaliador-sintatico.test.ts
@@ -2,7 +2,7 @@ import { AvaliadorSintaticoPortugolStudio } from '../../fontes/avaliador-sintati
 import { ErroAvaliadorSintatico } from '../../fontes/avaliador-sintatico/erro-avaliador-sintatico';
 import { LexadorPortugolStudio } from '../../fontes/lexador/dialetos';
 
-describe('Avaliador sintático (Portugol Studio)', () => {
+describe.skip('Avaliador sintático (Portugol Studio)', () => {
     describe('analisar()', () => {
         let lexador: LexadorPortugolStudio;
         let avaliadorSintatico: AvaliadorSintaticoPortugolStudio;
@@ -32,32 +32,6 @@ describe('Avaliador sintático (Portugol Studio)', () => {
                 expect(retornoAvaliadorSintatico.declaracoes).toHaveLength(2);
             });
 
-            it('Sucesso - Estruturas de dados', () => {
-                const retornoLexador = lexador.mapear(
-                    [
-                        'programa',
-                        '{',
-                        '    inteiro variavel',
-                        '    ',
-                        '    funcao inicio()',
-                        '    {',
-                        '        inteiro outra_variavel',
-                        '        real altura = 1.79',
-                        '        cadeia frase = "Isso é uma variável do tipo cadeia"',
-                        '        caracter inicial = \'P\'',  
-                        '        logico exemplo = verdadeiro',
-                        '        escreva(altura)',
-                        '    }',
-                        '}'
-                    ],
-                    -1
-                );
-                const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador);
-
-                expect(retornoAvaliadorSintatico).toBeTruthy();
-                expect(retornoAvaliadorSintatico.declaracoes.length).toBeGreaterThan(0);
-            });
-
             it('Sucesso - Leia', () => {
                 const retornoLexador = lexador.mapear(
                     [
@@ -79,154 +53,6 @@ describe('Avaliador sintático (Portugol Studio)', () => {
                 expect(retornoAvaliadorSintatico).toBeTruthy();
                 expect(retornoAvaliadorSintatico.declaracoes.length).toBeGreaterThan(0);
             });
-
-            it('Sucesso - Funções', () => {
-                const retornoLexador = lexador.mapear([
-                    'programa',
-                    '{',
-                    '    funcao inicio()',
-                    '    {',
-                    '      mensagem("Bem Vindo")',
-                    '      escreva("O resultado do primeiro cálculo é: ", calcula (3.0, 4.0))',
-                    '      escreva("\nO resultado do segundo cálculo é: ", calcula (7.0, 2.0), "\n")',
-                    '      mensagem("Tchau")',
-                    '    }',
-                    '',
-                    '    funcao mensagem (cadeia texto)',
-                    '    {',
-                    '        inteiro i',
-                    '        ',
-                    '        para (i = 0; i < 50; i++)',
-                    '        {',
-                    '          escreva ("-")',
-                    '        }',
-                    '        ',
-                    '        escreva ("\n", texto, "\n")',
-                    '        ',
-                    '        para (i = 0; i < 50; i++)',
-                    '        {',
-                    '          escreva ("-")',
-                    '        }',
-                    '        ',
-                    '        escreva("\n")',
-                    '    }',
-                    '',
-                    '    funcao real calcula (real a, real b)',
-                    '    {',
-                    '        real resultado',
-                    '        resultado = a * a + b * b',
-                    '        retorne resultado',
-                    '    }',
-                    '}'
-                ], -1);
-
-                const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador);
-    
-                expect(retornoAvaliadorSintatico).toBeTruthy();
-                expect(retornoAvaliadorSintatico.erros).toHaveLength(0);
-            });
-
-            it('Estrutura condicional - se e senao.', () => {
-                const resultado = lexador.mapear(
-                    [
-                        'programa',
-                        '{',
-                        '    funcao inicio()',
-                        '    {',
-                        '        real numeroUm, numeroDois, soma',
-                        '        numeroUm = 12.0',
-                        '        numeroDois = 20.0',
-                        '        soma = numeroUm + numeroDois',
-                        '        se (soma > 20)',
-                        '        {',
-                        '            escreva("Numero maior que 20")',
-                        '        }',
-                        '        senao',
-                        '        {',
-                        '            escreva("Numero menor que 20")',
-                        '        }',
-                        '    }',
-                        '}',
-                    ],
-                    -1
-                );
-    
-                const retornoAvaliadorSintatico = avaliadorSintatico.analisar(resultado);
-    
-                expect(retornoAvaliadorSintatico).toBeTruthy();
-                expect(retornoAvaliadorSintatico.declaracoes.length).toBeGreaterThan(0);
-            });
-    
-            it('Estruturas de repetição - Enquanto', () => {
-                const resultado = lexador.mapear([
-                    'programa',
-                    '{',
-                    '    funcao inicio()',
-                    '    {',
-                    '        inteiro numero, atual = 1, fatorial = 1',
-                    '        ',
-                    '        escreva("Digite um numero: ")',
-                    '        leia(numero)',
-                    '        ',
-                    '        enquanto (atual <= numero)',
-                    '        {',
-                    '            fatorial = fatorial * atual',
-                    '            atual = atual + 1',
-                    '        }',
-                    '        ',
-                    '        escreva("O fatorial de ", numero, " é: ", fatorial, "\n")',
-                    '    }',
-                    '}'
-                ], -1);
-    
-                const retornoAvaliadorSintatico = avaliadorSintatico.analisar(resultado);
-    
-                expect(retornoAvaliadorSintatico).toBeTruthy();
-                expect(retornoAvaliadorSintatico.declaracoes.length).toBeGreaterThan(0);
-            });
-
-            it('Estruturas de repetição - Faca ... Enquanto', () => {
-                const resultado = lexador.mapear([
-                    'programa',
-                    '{',
-                    '    funcao inicio()',
-                    '    {',
-                    '        inteiro idade',
-                    '        ',
-                    '        faca',
-                    '        {',
-                    '            escreva ("Informe sua idade (valores aceitos de 5 a 150): ")',
-                    '            leia (idade)',
-                    '        }',
-                    '        enquanto (idade < 5 ou idade > 120)',
-                    '        ',
-                    '        escreva ("\nCorreto!\n")',
-                    '    }',
-                    '}'
-                ], -1);
-
-                const retornoAvaliadorSintatico = avaliadorSintatico.analisar(resultado);
-    
-                expect(retornoAvaliadorSintatico).toBeTruthy();
-                expect(retornoAvaliadorSintatico.declaracoes.length).toBeGreaterThan(0);
-            });
-
-            it('Estruturas de repetição - Para', () => {
-                const resultado = lexador.mapear([
-                    'programa {',
-                    '    funcao inicio() {',
-                    '      para (inteiro i = 1; i <= 10; i++) {',
-                    '        escreva(i)',
-                    '      }',
-                    '    }',
-                    '  }'
-                ], -1);
-
-                const retornoAvaliadorSintatico = avaliadorSintatico.analisar(resultado);
-    
-                expect(retornoAvaliadorSintatico).toBeTruthy();
-                expect(retornoAvaliadorSintatico.declaracoes.length).toBeGreaterThan(0);
-            });
         });
 
         describe('Casos de Falha', () => {
@@ -252,6 +78,35 @@ describe('Avaliador sintático (Portugol Studio)', () => {
             });
         });
 
-        
+        it('Estrutura condicional - se e senao.', () => {
+            const resultado = lexador.mapear(
+                [
+                    'programa',
+                    '{',
+                    '    funcao inicio()',
+                    '    {',
+                    '        real numeroUm, numeroDois, soma',
+                    '        numeroUm = 12.0',
+                    '        numeroDois = 20.0',
+                    '        soma = numeroUm + numeroDois',
+                    '        se (soma > 20)',
+                    '        {',
+                    '            escreva("Numero maior que 20")',
+                    '        }',
+                    '        senao',
+                    '        {',
+                    '            escreva("Numero menor que 20")',
+                    '        }',
+                    '    }',
+                    '}',
+                ],
+                -1
+            );
+
+            const retornoAvaliadorSintatico = avaliadorSintatico.analisar(resultado);
+
+            expect(resultado).toBeTruthy();
+            expect(resultado.simbolos).toHaveLength(45);
+        });
     });
 });
diff --git a/testes/portugol-studio/interpretador.test.ts b/testes/portugol-studio/interpretador.test.ts
index 7a95ae0a..6011aa67 100644
--- a/testes/portugol-studio/interpretador.test.ts
+++ b/testes/portugol-studio/interpretador.test.ts
@@ -2,7 +2,7 @@ import { AvaliadorSintaticoPortugolStudio } from '../../fontes/avaliador-sintati
 import { LexadorPortugolStudio } from '../../fontes/lexador/dialetos';
 import { InterpretadorPortugolStudio } from '../../fontes/interpretador/dialetos';
 
-describe('Interpretador (Portugol Studio)', () => {
+describe.skip('Interpretador (Portugol Studio)', () => {
     describe('interpretar()', () => {
         let lexador: LexadorPortugolStudio;
         let avaliadorSintatico: AvaliadorSintaticoPortugolStudio;
@@ -15,7 +15,7 @@ describe('Interpretador (Portugol Studio)', () => {
         });
 
         describe('Cenários de sucesso', () => {
-            it('Trivial', async () => {
+            it.skip('Trivial', async () => {
                 const retornoLexador = lexador.mapear([
                     'programa',
                     '{',
@@ -33,7 +33,7 @@ describe('Interpretador (Portugol Studio)', () => {
                 expect(retornoInterpretador.erros).toHaveLength(0);
             });
 
-            it('Sucesso - Leia', async () => {
+            it.skip('Sucesso - Leia', async () => {
                 // Aqui vamos simular a resposta para cinco variáveis de `leia()`.
                 const respostas = [1, 2, 3, 4, 5];
                 interpretador.interfaceEntradaSaida = {
diff --git a/testes/portugol-studio/lexador.test.ts b/testes/portugol-studio/lexador.test.ts
index a719ee9e..89b1ad08 100644
--- a/testes/portugol-studio/lexador.test.ts
+++ b/testes/portugol-studio/lexador.test.ts
@@ -61,7 +61,7 @@ describe('Lexador (Portugol Studio)', () => {
                 ], -1);
 
                 expect(resultado).toBeTruthy();
-                expect(resultado.simbolos).toHaveLength(16);
+                expect(resultado.simbolos).toHaveLength(15);
             });
 
             it('Operação matematica - multiplicação', () => {
@@ -122,47 +122,6 @@ describe('Lexador (Portugol Studio)', () => {
                 expect(resultado).toBeTruthy();
                 expect(resultado.simbolos).toHaveLength(45);
             });
-
-            it('Enquanto', () => {
-                const resultado = lexador.mapear([
-                    'programa',
-                    '{',
-                    '    funcao inicio()',
-                    '    {',
-                    '        inteiro numero, atual = 1, fatorial = 1',
-                    '        ',
-                    '        escreva("Digite um numero: ")',
-                    '        leia(numero)',
-                    '        ',
-                    '        enquanto (atual <= numero)',
-                    '        {',
-                    '            fatorial = fatorial * atual',
-                    '            atual = atual + 1',
-                    '        }',
-                    '        ',
-                    '        escreva("O fatorial de ", numero, " é: ", fatorial, "\n")',
-                    '    }',
-                    '}'
-                ], -1);
-
-                expect(resultado).toBeTruthy();
-                expect(resultado.simbolos).toHaveLength(57);
-            });
-
-            it('Para', () => {
-                const resultado = lexador.mapear([
-                    'programa {',
-                    '    funcao inicio() {',
-                    '      para (inteiro i = 1; i <= 10; i++) {',
-                    '        escreva(i)',
-                    '      }',
-                    '    }',
-                    '  }'
-                ], -1);
-
-                expect(resultado).toBeTruthy();
-                expect(resultado.simbolos).toHaveLength(27);
-            });
         });
     });
 });