diff --git a/.vscode/extensions.json b/.vscode/extensions.json
index 23ca26c..2b9b481 100644
--- a/.vscode/extensions.json
+++ b/.vscode/extensions.json
@@ -11,7 +11,6 @@
         "ms-python.vscode-pylance",
         "ms-python.python",
         "njpwerner.autodocstring",
-        "ms-vscode.vs-keybindings",
-        "argutec.argutec-azure-repos"
+        "ms-vscode.vs-keybindings"
     ]
 }
\ No newline at end of file
diff --git a/.vscode/launch.json b/.vscode/launch.json
index 3fee283..3ba84a6 100644
--- a/.vscode/launch.json
+++ b/.vscode/launch.json
@@ -1,11 +1,17 @@
 {
     "version": "1.0",
     "configurations": [
-      {
-        "type": "python",
-        "request": "launch",
-        "name": "Launch Program",
-        "program": "${workspaceFolder}\\pdfconverter.py"
-      }
+        {
+            "type": "python",
+            "request": "launch",
+            "name": "Módulo Principal",
+            "program": "${workspaceFolder}\\pdfconverter.py"
+        },
+        {
+            "type": "python",
+            "request": "launch",
+            "name": "Rodar Setup",
+            "program": "${workspaceFolder}\\setup.py"
+        }
     ]
-  }
\ No newline at end of file
+}
\ No newline at end of file
diff --git a/build/lib/pdfconverter/__init__.py b/build/lib/pdfconverter/__init__.py
new file mode 100644
index 0000000..75b8f09
--- /dev/null
+++ b/build/lib/pdfconverter/__init__.py
@@ -0,0 +1,19 @@
+"""
+---
+---
+---
+
+## Package: pdfconverter
+---
+---
+### Module Name: pdfconverter (Constructor, __init__)
+---
+### path: "pdfconverter\\\\\\\\__init__.py"
+---
+---
+Pacote e módulo que representa o projeto PDFConverter.
+
+---
+---
+---
+"""
\ No newline at end of file
diff --git a/build/lib/pdfconverter/__main__.py b/build/lib/pdfconverter/__main__.py
new file mode 100644
index 0000000..430d216
--- /dev/null
+++ b/build/lib/pdfconverter/__main__.py
@@ -0,0 +1,21 @@
+"""
+---
+---
+---
+
+## Package: pdfconverter
+---
+---
+### Module Name: __main__
+---
+### path: "pdfconverter\\\\\\\\__main__.py"
+---
+---
+Módulo delimitado como  escopo  do  projeto,  atualmente,  é  o
+módulo inicializado por padrão dentro do  Workspace  do  Visual
+Code, quando pressionada a tecla 'F5', por exemplo.
+
+---
+---
+---
+"""
\ No newline at end of file
diff --git a/build/lib/pdfconverter/__variables__.py b/build/lib/pdfconverter/__variables__.py
new file mode 100644
index 0000000..9915963
--- /dev/null
+++ b/build/lib/pdfconverter/__variables__.py
@@ -0,0 +1,457 @@
+"""
+---
+---
+---
+
+## Package: pdfconverter
+---
+---
+### Module Name: __variables__
+---
+### path: "pdfconverter\\\\\\\\__variables__.py
+---
+---
+Módulo  que  comporta  classes  com  variáveis  utilizadas   no
+projeto.
+
+---
+---
+---
+"""
+
+
+#region VARIABLES
+
+#region MANAGEMENT
+
+class mvar:
+    """
+    ---
+    ---
+    ---
+    
+    ## Management Variables (mvar)
+    ---
+    ---
+    Classe  que   possui   variável   que   são   relacionadas   ao
+    gerenciamento de ações do projeto.
+    
+    ---
+    ---
+    ---
+    """
+
+    ConversionStart = ""
+    """
+    Variável que segura a função que vai ser executada  no  arquivo
+    principal em  __main__.  A  função  que  vai  ser  executada  é
+    atribuida  no  momento  em  que  o  argumento  de  caminho   de
+    importação é validado.
+    
+    Atualmente o  arquivo  de  importção  está  sendo  validado  na
+    função   "__ValidateImportPath()"   presente   no   pacote   de
+    argumentos "argument"
+    """
+
+#endregion
+
+#region GENERAL
+
+class avar:
+    """
+    ---
+    ---
+    ---
+    
+    ## Argument Variables (avar)
+    ---
+    ---
+    Classe que possui  variáveis  relacionadas  à  alguma  ação  ou
+    função relacionada à argumentos.
+    
+    ---
+    ---
+    ---
+    """
+
+    # [>] Todos os argumentos que são  relacionados  à  alterar  as
+    # colunas padrão dentro de uma array.
+    patternColumnArgs = [
+        "Lote",
+        "Ordem",
+        "Codigo",
+        "Produto",
+        "Unidade",
+        "Quantidade",
+        "ValorMedio"
+    ]
+
+    #region PARSER
+    parser_Main = None
+    """Variável que vai ser responsável por criar o parser."""
+    parser_ArgsMain = None
+    """
+    Variável que vai ser responsável por fazer  a  manipulação  dos
+    argumentos dados.
+    """
+    #endregion
+
+    #region USER ARGS
+    # [!] path_Import
+    path_ImportArg = ""
+    """
+    Caminho de importação com o valor fornecido pelo usuário.
+    """
+    path_ExportArg = ""
+    """
+    Caminho de exportação  com  o  valor  fornecido  pelo  usuário.
+    Atualmente esse valor apenas pode ser uma referência de pasta
+    """
+    readPDFPagesArg = "all"
+    """Páginas que vão ser lidas para realizar a conversão."""
+    #endregion
+
+    #region ARGS DEFAULT VALUES
+    argName = ""
+    """Nome do argumento."""
+    defaultValue = None
+    """Valor que vem por padrão no argumento."""
+    nargsValue = '?'
+    """
+    Variável  que  define  o  número  de  valores  suportado   pelo
+    argumento, além de poder definir um  número  que  representa  a
+    quantidade em si, também é possível definir:
+    - '+' == 1 ou mais;
+    - '*' == 0 ou mais;
+    - '?' == 0 or 1.
+    """
+    contentType = str
+    """Tipo de valor do argumento."""
+    #endregion
+
+class cvar:
+    """
+    ---
+    ---
+    ---
+    
+    ## Conversion Variables (cvar)
+    ---
+    ---
+    Variáveis relacionadas à conversão.
+    
+    ---
+    ---
+    ---
+    """
+    
+    list_DataFrames = []
+    """
+    Variável que vai conter a lista de DataFrames de um determinado
+    arquivo PDF baseado  em  um  método  de  leitura,  podendo  ser
+    lattice ou stream.
+    """
+
+class fvar:
+    """
+    ---
+    ---
+    ---
+    
+    ## File Variables (fvar)
+    ---
+    ---
+    Variáveis  relacionadas  à  arquivos  como  nome  de  arquivos,
+    caminhos de importação e exportção, pasta do Script, número  de
+    páginas de arquivos PDF e estrutura de pastas.
+    
+    ---
+    ---
+    ---
+    """
+
+    #region PROJECT
+
+    #region GENERAL
+    folderpath_Script = ""
+    """
+    Caminho do arquivo de script que está sendo executado.
+    """
+    #endregion
+
+    #region TERMINAL FILE
+    file_TerminalFile = ""
+    """Variável que armazena o arquivo de saída do terminal em si."""
+    filepath_TerminalFile = ""
+    """Caminho para o arquivo do terminal."""
+    #endregion
+
+    #endregion
+
+    #region CONVERSION RUNTIME
+
+    #region GENERAL
+    # [!] path_FolderImport
+    folderpath_Import = ""
+    """
+    Caminho da pasta de importação onde os  arquivos  PDF  vão  ser
+    alocados.
+    """
+    folderpath_Export = ""
+    """
+    Caminho da pasta de exportação onde os arquivos  de  saída  vão
+    ser alocados.
+    """
+    folderpath_Result = ""
+    #endregion
+
+    #region PDF INFO
+    filename_PDF = ""
+    """
+    Nome do arquivo PDF que vai ser convertido  (sem a extensão).
+    """
+    counter_PdfFile = 0
+    """
+    Contador do 'For' que manipula a conversão  dos  arquivos  PDF.
+    Conta os arquivos PDFs convertidos.
+    """
+    #endregion
+
+    #region CONVERSION FILE GENERATION INFO
+    # [!] filepath_ExportTxt
+    filepath_WithoutFormatting = ""
+    """
+    Caminho do arquivo de texto que vai ser gerado pelo PDF que vai
+    ser convertido.
+    """
+    counter_DataFrame = 0
+    """
+    Contador do 'For' que manipula o DataFrame que vai ser  passado
+    para o arquivo sem formatação.
+    """
+    #endregion
+
+    #region FORMATTING TYPES FILE PATH
+    # [!] tableWithBlankCells_OutputTxt
+    filepath_TableWithBlankCells = ""
+    """"""
+    # [!] main_OutputTxt
+    filepath_Main = ""
+    """"""
+    # [!] fullclear_OutputTxt
+    filepath_FullClear = ""
+    """"""
+    #endregion
+
+    #endregion
+
+    #region FOLDER STRUCTURE
+    # [i] rootPath
+    foldername_Results = "resultados"
+    """
+    Caminhos que indicam a localização das pastas raíz que irão ser
+    geradas futuramente.
+    """
+    # [i] list_readingPaths
+    list_ReadingPaths = [
+        "lattice",
+        "stream"
+    ]
+    """
+    Caminhos que indicam a localização das pastas  dos  métodos  de
+    leitura que vão ser geradas  futuramente  dentro  da  pasta  de
+    exportação.
+    """
+    # [!] list_formattingPaths
+    list_FormattingPaths = [
+        "main",
+        "fullClear",
+        "tableWithBlankCells",
+        "withoutFormatting"
+    ]
+    """
+    Caminhos que indicam a localização das pastas  dos  métodos  de
+    formatação que vão ser geradas futuramente  dentro  das  pastas
+    de métodos de leitura, que estão dentro da pasta de exportação.
+    """
+    #endregion
+
+class pvar:
+    """
+    ---
+    ---
+    ---
+    
+    ## Pattern Variables (pvar)
+    ---
+    ---
+    Variáveis relacionadas à padronização de colunas.
+    
+    ---
+    ---
+    ---
+    """
+    
+    # [!] list_columnFieldsToChange
+    list_UserGivenColumnToChange = []
+    """
+    Variável que vai segurar e possuir todos os argumentos
+    que o usuário quer que altere nas colunas.
+    """
+
+    #region COLUMN MAPPING
+
+    #region SORTED BY COLUMN
+    lote =\
+        [
+        '--Lote',
+        'lote'
+        ]
+    """Lote."""
+    ordem =\
+        [
+        '--Ordem',
+        'ordem',
+        'item',
+        'nº item'
+        ]
+    """Ordem (Sequencial)."""
+    codigo =\
+        [
+        '--Codigo',
+        'codigo',
+        'código',
+        'cód',
+        'cod. produto'
+        ]
+    """Código."""
+    descricao = [
+        '--Produto',
+        'produto',
+        'descricao',
+        'descriçao',
+        'descricão',
+        'descrição',
+        'descrição do item',
+        'descrição do produto',
+        'descrição do material',
+        'descrição dos materiais',
+        'descrição dos medicamentos',
+        'descrição do material/serviço',
+        'especificações dos medicamentos',
+        'objeto',
+        'medicamento',
+        'objeto/medicamento',
+        'produto - especificação',
+        'especificações técnicas']
+    """Descrição."""
+    unidade =\
+        [
+        '--Unidade',
+        'unidade',
+        'un',
+        'und',
+        'unid',
+        'unid.',
+        'emb',
+        'u/m',
+        'apresentação',
+        'especificação'
+        ]
+    """Unidade."""
+    quantidade =\
+        [
+        '--Quantidade',
+        'quantidade',
+        'qtd',
+        'qte',
+        'qtd.',
+        'qde.',
+        'qtde',
+        'qntd',
+        'qntd.',
+        'quant.'
+        ]
+    """Quantidade."""
+    valormedio =\
+        [
+        '--ValorMedio',
+        'valormedio',
+        'prev. custo unit. (r$)',
+        'valor unit',
+        'v. unit',
+        'val. unitário',
+        'valor unitário',
+        'valor médio',
+        'valor médio unitário r$',
+        'estimado unitário'
+        ]
+    """Valor Médio."""
+    #endregion
+
+    #region ALL
+    StoredColumns = []
+    """Todas as recomendações de colunas agrupadas."""
+    StoredColumns.extend((
+        lote,
+        ordem,
+        codigo,
+        descricao,
+        unidade,
+        quantidade,
+        valormedio
+    ))
+    #endregion
+
+    #endregion
+
+class vvar:
+    """
+    ---
+    ---
+    ---
+    
+    ## Visual Variables (vvar)
+    ---
+    ---
+    Variáveis relacionadas ao visual da aplicação.
+    
+    ---
+    ---
+    ---
+    """
+
+    GiantLine = (
+        "_________________________________________"
+        "_________________________________________"
+        "_________________________________________"
+        "_________________________________________"
+        "_________________________________________"
+        "_________________________________________"
+        "_________________________________________"
+        "_________________________________________"
+        "_________________________________________"
+        "_________________________________"
+    )
+    """
+    Linha gigante que vai ficar disposta  em  alguns  lugares  como
+    divisão no terminal.
+
+    Existem 402 linhas.
+    """
+    BlankSpaces = (
+        "                                         "
+        "                                         "
+        "                                         "
+        "                                         "
+        "    "
+    )
+    """
+    Variável que contém um espaço gigante usado em alguns layouts.
+    
+    Existem 168 espaços.
+    """
+
+#endregion
+
+#endregion
\ No newline at end of file
diff --git a/build/lib/pdfconverter/argument/__init__.py b/build/lib/pdfconverter/argument/__init__.py
new file mode 100644
index 0000000..0073e90
--- /dev/null
+++ b/build/lib/pdfconverter/argument/__init__.py
@@ -0,0 +1,239 @@
+"""
+---
+---
+---
+
+## Package: pdfconverter >> argument
+---
+---
+### Module Name: argument (Constructor, __init__)
+---
+### path: "pdfconverter\\\\\\\\argument\\\\\\\\__init__.py"
+---
+---
+Pacote e módulo que comporta  todas  as  ações  relacionadas  à
+argumentos no projeto
+
+---
+---
+---
+"""
+
+
+# [>] Geral
+import argparse
+# [>] PDFConverter
+# [i] Variáveis
+from pdfconverter.__variables__ import avar, pvar
+# [i] Argumentos
+from pdfconverter.argument.validateargs import validateargs
+# [i] Arquivo do Terminal
+from pdfconverter.terminalfile.message import error
+
+
+#region PUBLIC METHODS
+
+def Set():
+    """
+    ---
+    ---
+    ---
+
+    ### Create (Public)
+    ---
+    Método que cria o ArgumentParser, que é uma ferramenta que rea-
+    liza a interpretação de argumentos que são recebidos no momento
+    em que a aplicação é chamada, sejam eles passados pelo  usuário
+    ou por meio de algum terceiro programaticamente,  para  futuros
+    usos.
+    
+    ---
+    ---
+    ---
+    """
+
+    # [>] Criando e instanciando um novo parser e atribuindo para a
+    # variável sem permitir reconhecimento de abreviação automático
+    # de argumentos
+    avar.parser_Main = argparse.ArgumentParser(allow_abbrev = False)
+
+    # [i] Adiciona os argumentos
+    __AddArgs(
+        # ARGUMENTOS DE CONFIGURAÇÕES INICIAIS
+        "ImportPath", # [i] Argumento   que   conterá   o  caminho   de    importação
+                        # (Obrigatório)
+        "ExportPath", # [i] Argumento que conterá o caminho de exportação (Opcional)
+        "PageNumber", # [i] Argumento que recebe o número de páginas para realizar  a
+                        # leitura do arquivo PDF
+        # ARGUMENTOS REFERENTES AS COLUNAS
+        "Lote",       # [i] Lote
+        "Ordem",      # [i] Ordem
+        "Codigo",     # [i] Código
+        "Produto",    # [i] Produto
+        "Unidade",    # [i] Unidade
+        "Quantidade", # [i] Quantidade
+        "ValorMedio"  # [i] Valor Médio
+    )
+
+    # [>] Valida os argumentos adicionados
+    validateargs().All()
+
+#endregion
+
+#region PRIVATE METHODS
+
+def __AddArgs(*args):
+    """
+    ---
+    ---
+    ---
+    
+    ## __AddArgs (Private)
+    ---
+    ---
+    Método  que  realiza  a  adição  de  argumentos  com  os   seus
+    respectivos nomes passados no argumento do método. Dentro desse
+    método, é possível ainda customizar o argumento,  alterando  os
+    valores padrão das variáveis.
+
+    ### Args
+    ---
+    - args (str, optional):
+        - Argumentos que vão ser adicionados à  variável  principal  de
+        argumento, presente na classe de  variáveis  de  argumento,  no
+        módulo de variáveis (avar.parser_Main).
+
+    ---
+    ---
+    ---
+    """
+    
+    # [>] Para cada argumento passado no parâmetro do  método  para
+    # ser adicionado a variável principal de argumentos
+    for arg in args:
+        # VALORES PADRÃO
+        # -------------------------------------------------------------
+        # Descrição: Aqui estão os valores que são  definidos  por  pa-
+        # drão.
+        # >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
+        # [i] Nome do argumento
+        # [>] Adiciona o prefixo no argumento
+        avar.argName = "--" + arg
+        # [i] Valor do argumento que vem por padrão
+        avar.defaultValue = None
+        # [i] Número de valores suportado pelo argumento
+        avar.nargsValue = '?'
+        """
+        '+' == 1 or more.
+        '*' == 0 or more.
+        '?' == 0 or 1.
+        """
+        avar.contentType = str
+        # >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
+        # -------------------------------------------------------------
+
+        # [i] Customização de argumentos
+        # -------------------------------------------------------------
+        # Descrição: Aqui dentro da condicional, podem ser alterados os
+        # valores padrão caso necessário.
+        # >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
+        if (arg in "--PageNumber"): avar.defaultValue = "all"
+        if ("Path" not in arg and "PageNumber" != arg): avar.nargsValue = '*'
+        # >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
+        # -------------------------------------------------------------
+
+
+        # [>] Adiciona um argumento ao parser para cada String de argu-
+        # mento que tiver sido passado no parâmetro.
+        avar.parser_Main.add_argument(
+            # [i] Valores passíveis de alteração
+            avar.argName,
+            default = avar.defaultValue,
+            nargs = avar.nargsValue,
+            type = avar.contentType,
+            # [i] Valores Padrão
+            required = False
+        )
+    
+    try:
+        avar.parser_ArgsMain = avar.parser_Main.parse_args()
+    except Exception as ExceptionError:
+        # [>] Exibe mensagem de erro caso não tenha sido informado  um
+        # caminho de importação
+        error.Show("Ocorreu um erro desconhecido ao tentar adicionar os argumentos ao parse args.", ExceptionError)
+
+    # [>] Atualiza a variável que segura a lista com os  argumentos
+    # relacionados ao campos de colunas que foram  preenchidos  com
+    # algum valor
+    __GetUserGivenPatternColumnsArgs()
+
+def __GetUserGivenPatternColumnsArgs():
+    """
+    ---
+    ---
+    ---
+    
+    ## __StoreArgs (Private)
+    ---
+    ---
+    Método que atualiza a  variável  que  vai  armazenar  todos  os
+    argumentos relacionados  à  ordenação  de  colunas  que  tenham
+    recebido algum valor pelo usuário.
+    
+    ---
+    ---
+    ---
+    """
+
+    counter_ArgListIterator = 0
+    for argName in avar.patternColumnArgs:
+        # [>] Recebe o valor do argumento atual baseado  na  lista  que
+        # possui as colunas padrão
+        argValue = vars(avar.parser_ArgsMain)[argName]
+        # [>] Se o argumento da lista de colunas padrão tiver algum va-
+        # lor
+        if (argValue != None):
+            # [>] Adiciona um novo container na lista de colunas
+            pvar.list_UserGivenColumnToChange.append([])
+            # [>] Adiciona o título do argumento
+            pvar.list_UserGivenColumnToChange[counter_ArgListIterator].append(argName)
+
+            # [i] Caso tenha vindo uma lista de valores
+            if isinstance(argValue, list):
+                # [>] Para cada valor na lista de valores passados na variável,
+                # adiciona o valor na lista
+                for value in argValue: pvar.list_UserGivenColumnToChange[counter_ArgListIterator].append(value)
+            # [i] Caso contrário, adiciona o valor do argumento  direto  na
+            # lista
+            else: pvar.list_UserGivenColumnToChange[counter_ArgListIterator].append(argValue)
+
+            # [>] Adiciona +1 ao contador da lista
+            counter_ArgListIterator += 1
+
+#endregion
+
+def ParseArgsProgramatically():
+    """
+    ---
+    ---
+    ---
+    
+    ## ParseArgsProgramatically Public
+    ---
+    ---
+    Método que passa os argumentso que normalmente são passados pe-
+    lo terminal programaticamente. O método deve ser colocado  den-
+    tro da variável avar.parser_Main.parse_args.
+    
+    ### Returns
+    ---
+        list: Variável que segura os valores da lista de argumentos.
+    
+    ---
+    ---
+    ---
+    """
+    
+    ArgsList = ["--ImportPath", "C:\\users\\dvp10\\desktop\\EDITAL (2).pdf"]
+    ArgsList = [""]
+    return ArgsList
\ No newline at end of file
diff --git a/build/lib/pdfconverter/argument/validateargs.py b/build/lib/pdfconverter/argument/validateargs.py
new file mode 100644
index 0000000..16b214d
--- /dev/null
+++ b/build/lib/pdfconverter/argument/validateargs.py
@@ -0,0 +1,130 @@
+# [>] Geral
+import os.path
+# [>] PDFConverter
+# [i] Variáveis
+from pdfconverter.__variables__ import mvar, avar, fvar
+# [i] Arquivo do Terminal
+from pdfconverter.terminalfile.message import error
+# [i] Conversão
+from pdfconverter import conversion
+# [i] Formatação de String
+from pdfconverter.stringformat import stringformat
+# [i] Programa
+from pdfconverter.program import utilities
+
+
+#region VALIDATE ARGS
+
+class validateargs:
+    """Classe que realiza algumas validações de argumentos."""
+
+    #region CONSTRUCTOR
+
+    def __init__(self): pass
+
+    #endregion
+
+    #region PUBLIC METHODS
+
+    def All(self):
+        self.ImportPath()
+        self.ExportPath()
+        self.PageNumber()
+
+    @staticmethod
+    def ImportPath():
+        try:
+            # [>] Pega dos argumentos o caminho de importação
+            ImportPathArg = avar.parser_ArgsMain.ImportPath
+
+            # [i] Caso o usuário não tenha preenchido o caminho de importa-
+            # ção, exibe uma mensagem de erro mostrando que  é  obrigatório
+            # a inserção do caminho de importação
+            if (ImportPathArg == None): error.Show("É necessário colocar um valor para o caminho de importação, '--ImportPath <caminho_de_exportação>'.")
+            # [i] Caso seja percebido que o valor do argumento de  importa-
+            # ção se refere à um arquivo
+            elif (os.path.isfile(ImportPathArg)):
+                # [i] E esse arquivo referido seja um PDF
+                if (utilities.IsPDF(ImportPathArg)):
+                    # [>] Passa o valor para a classe de variáveis
+                    avar.path_ImportArg = ImportPathArg
+                    fvar.folderpath_Import = os.path.dirname(ImportPathArg)
+                    # [>] Lá na frente, vai executar a função que realizará a  con-
+                    # versão do arquivo individual que foi indicado
+                    functionName = "IndividualConversion"
+                # [i] Caso tenha sido indicado um arquivo que não seja  um  PDF
+                # exibe uma mensagem de erro
+                else: error.Show("O arquivo informado no argumento de importação, precisa ser uma pasta ou um arquivo PDF.")
+            # [i] Caso seja percebido que o valor do argumento de  importa-
+            # ção se refere à uma pasta
+            elif (os.path.isdir(ImportPathArg)):
+                # [>] Passa o valor para a classe de variáveis
+                avar.path_ImportArg = ImportPathArg
+                fvar.folderpath_Import = ImportPathArg
+                # [>] Lá na frente, vai executar a função que realizará  a  con-
+                # versão de todos os PDFs indicados na pasta
+                functionName = "MultipleConversion"
+            # [i] Exibe um erro caso o argument o não tenha passado nas va-
+            # lidações
+            else: error.Show("O argumento ('" + ImportPathArg + "') passado como caminho de importação não é válido.")
+
+            # [>] Atribui o objeto que referencia a função com  o  nome  da
+            # função passada nas validações acima
+            mvar.ConversionStart = getattr(conversion, functionName)
+        # [>] Caso ocorra um erro desconhecido exibe uma mensagem
+        except Exception as ExceptionError:
+            error.Show("Ocorreu um erro desconhecido ao tentar receber os argumentos dos caminhos de importação.", ExceptionError)
+
+    @staticmethod
+    def ExportPath():
+        try:
+            # [>] Pega dos argumentos o caminho de importação
+            ExportPath = avar.parser_ArgsMain.ExportPath
+
+            # [i] Caso o caminho de exportação não tenha sido informado pe-
+            # lo usuário, informa o caminho da pasta de importação como re-
+            # ferência para o caminho de exportação
+            if (ExportPath == None): fvar.folderpath_Export = fvar.folderpath_Import
+            # [i] Se o caminho fornecido for um diretório,  passa  para  as
+            # variáveis globais o valor fornecido no argumento
+            elif (os.path.isdir(ExportPath)): fvar.folderpath_Export = ExportPath
+            # [i] Caso a pasta de acordo com a ação realizada não exista
+            else: error.Show("A pasta de exportação ('" + ExportPath + "') informada não existe.")
+        # [>] Caso ocorra um erro desconhecido exibe uma mensagem
+        except Exception as ExceptionError:
+            error.Show("Ocorreu um erro desconhecido ao tentar receber os  argumentos dos caminhos de exportação.", ExceptionError)
+
+    @staticmethod
+    def PageNumber():
+        """
+        ---
+        ---
+        ---
+        
+        ## __ValidatePageNumberArg (Private)
+        ---
+        ---
+        Método que valida o número de página, ou  números  de  páginas,
+        passados no argumentos.
+        
+        ---
+        ---
+        ---
+        """
+
+
+        try:
+            # [i] Se o valor digitado é válido como número de página  passa
+            # o número de páginas do argumento para uma variável dentro  da
+            # classe de variáveis
+            if (stringformat(avar.parser_ArgsMain.PageNumber).ValidatePageNumber()): avar.readPDFPagesArg = avar.parser_ArgsMain.PageNumber
+            # [i] Se o número de páginas é inválido, exibe uma mensagem  de
+            # erro
+            else: error.Show("O valor '" + avar.parser_ArgsMain.PageNumber + "' não é um valor de número de página válido para --PageNumber.")
+        # [>] Caso ocorra um erro desconhecido exibe uma mensagem
+        except Exception as ExceptionError:
+            error.Show("Ocorreu um erro desconhecido ao validar o número de páginas.\n", ExceptionError)
+
+    #endregion
+
+#endregion
\ No newline at end of file
diff --git a/build/lib/pdfconverter/conversion/__init__.py b/build/lib/pdfconverter/conversion/__init__.py
new file mode 100644
index 0000000..eae17c7
--- /dev/null
+++ b/build/lib/pdfconverter/conversion/__init__.py
@@ -0,0 +1,241 @@
+"""
+---
+---
+---
+
+## Package: pdfconverter >> conversion
+---
+---
+### Module Name: conversion (Constructor, __init__)
+---
+### path: "pdfconverter\\\\\\\\conversion\\\\\\\\__init__.py"
+---
+---
+Pacote e módulo comportando funções relacionadas à conversão.
+
+---
+---
+---
+"""
+
+
+# [>] Geral
+import os
+import tabula
+from glob import glob
+# [>] PDFConverter
+# [i] Variáveis
+from pdfconverter.__variables__ import avar, cvar, fvar
+# [i] Arquivo do Terminal
+from pdfconverter.terminalfile.message import design, error
+# [i] Configurações
+from pdfconverter.settings import project
+# [i] Conversão
+from pdfconverter.conversion import withoutformatting
+from pdfconverter.conversion.format import tablewithblankcells, main, fullclear
+# [i] Colunas Padrão
+from pdfconverter import patterncolumns
+# [i] Programa
+from pdfconverter.program.exceptions import InvalidFormattingType, RepeatedFormattingType
+
+
+#region PUBLIC METHODS
+
+def IndividualConversion():
+    # [>] Inicia a conversão
+    ConversionStart(avar.path_ImportArg)
+    design.CloseLayout(LastLayout = True)
+    LastLatticeMainConvertedFile = fvar.filepath_Main.replace("stream", "lattice", 1)
+
+    patterncolumns.RecognizePattern(LastLatticeMainConvertedFile)
+
+def MultipleConversion():
+    # [>] Filtra pelos PDFs na pasta onde foi indicada para o  sis-
+    # tema pelo "chdir"
+    for PDF in glob(fvar.folderpath_Import + "\\*.pdf"): ConversionStart(PDF)
+    else:
+        # [i] Se até o término da operação algum  PDF  foi  convertido,
+        # fecha o layout do terminal
+        if (fvar.counter_PdfFile > 0): design.CloseLayout(LastLayout = True)
+        # [i] Se ainda até o término da operação nenhum PDF foi conver-
+        # tido, exibe erro mostrando que não  há  arquivos  para  serem
+        # convertidos
+        else: error.Show("Não há arquivos de PDF para serem convertidos.")
+
+def ConversionStart(fullfilepath_PDF, Formatting = "MFT"):
+    """
+    ---
+    ---
+    ---
+    
+    ## ConversionStart (Public)
+    ---
+    ---
+    Método que realiza a conversão dado um caminho  de  um  arquivo
+    PDF.
+    Pode ser feita a escolha de um  método  de  formatação  e  caso
+    feita, serão criadas as pastas e os arquivos  necessários  para
+    # -------------------------------------------------------------
+    gerar os arquivos.
+    
+    ### Args
+    ---
+    - fullfilepath_PDF ([str],):
+        - Caminho do arquivo PDF que vai ser utilizado para realizar  a
+        conversão.
+    - Formatting (str, optional, default = ""):
+        - Com esse parâmetro, é possível escolher um tipo de formatação
+        para ser realizada.
+        T = tableWithBlankCells
+        M = Main
+        F = FullClear
+    
+    ---
+    ---
+    ---
+    """
+
+    # [>] Recebe somente o nome completo do arquivo PDF dado o caminho de importação dele
+    filefullname_PDF = os.path.basename(fullfilepath_PDF)
+
+    # [>] Configura o terminal ou o projeto de acordo com a  situa-
+    # ção
+    # [i] Se não é o primeiro arquivo fecha o layout pulando  algu-
+    # mas linhas
+    if (fvar.counter_PdfFile >= 1): design.CloseLayout(LastLayout = False)
+    # [i] Se é o primeiro arquivo ainda define a estrutura  inicial
+    # do projeto
+    else: project.SetFolderStructure()
+    # [>] Atribuindo mais um ao índice para indicar  que  um  certo
+    # arquivo PDF está sendo convertido
+    fvar.counter_PdfFile += 1
+
+    # [>] Remove extensão do arquivo  (pegando  apenas  o  nome)  e
+    # atribui para a variável
+    fvar.filename_PDF = filefullname_PDF[:-4]
+
+    # [>] Exibe o título ao terminal contendo o nome do  arquivo  e
+    # outras informações complementares
+    design.PDFTitle(filefullname_PDF)
+
+    # MÉTODOS DE LEITURA E CONVERSÃO
+    # -------------------------------------------------------------
+    # Descrição:
+    # [i] Primeiro faz a leitura e conversão pra Lattice e após faz
+    # o mesmo para o Stream
+    # >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
+    for ReadingMethod in ("lattice", "stream"):
+        # [>] Realiza a leitura do arquivo PDF
+        cvar.list_DataFrames = ReadPDF(ReadingMethod, fullfilepath_PDF)
+
+        # [>] Caso a lista de DataFrames vier vazia
+        if (cvar.list_DataFrames == None or len(cvar.list_DataFrames) <= 0):
+            # [>] Dispara um erro no arquivo do terminal
+            error.Show("Não foram encontradas tabelas para realizar a conversão.", ExitProgram = False, RecreateTerminalFile = False)
+            # [>] Passa para o próximo arquivo sem continuar  os  processos
+            # posteriores
+            continue
+
+        # [>] Limpa a lista de DataFrames removendo os DataFrames vazi-
+        # os
+        cvar.list_DataFrames = [DataFrame for DataFrame in cvar.list_DataFrames if not DataFrame.empty]
+
+        # [>] Reseta a variável
+        fvar.counter_DataFrame = 1
+        # [>] Itera os DataFrames contidos na lista de  DataFrames  gerados
+        # pela leitura do tabula
+        for TableDataFrame in cvar.list_DataFrames:
+            # [>] Inicia a função que realiza a conversão com o método  in-
+            # dicado
+            withoutformatting.AppendToFile(ReadingMethod, TableDataFrame)
+            # [>] Avança o contador de DataFrames em um
+            fvar.counter_DataFrame += 1
+        # [>]
+        __MakeFormattedFiles(ReadingMethod, Formatting)
+    # >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
+    # -------------------------------------------------------------
+
+def ReadPDF(ReadingMethod, filefullname_PDF):    
+    """
+    ---
+    ---
+    ---
+    
+    ## ReadPDF (Public)
+    ---
+    ---
+    Método que realiza a leitura do PDF utilizando-se da biblioteca
+    tabula com o método de leitura proveniente. Depois de  realiza-
+    da, retorna as tabelas reconhecidas para uma lista de  DataFra-
+    mes.
+    
+    ### Args
+    ---
+    - ReadingMethod ([str]):
+        - Tipo de leitura a ser realizada pela biblioteca Tabula (Stream ou Lattice).
+    - filefullname_PDF ([str]):
+        - Caminho do arquivo PDF que vai ser lido.
+    
+    ### Returns
+    ---
+        [list]: Retorna uma lista  de  DataFrames  com  o  conteúdo  do
+        arquivo PDF lido.
+    
+    ---
+    ---
+    ---
+    """
+
+    try:
+        # [>] Realiza a leitura do arquivo PDF
+        return tabula.read_pdf(
+            # VALORES ALTERÁVEIS
+            filefullname_PDF,                                          # [i] Caminho do arquivo PDF
+            lattice = True if (ReadingMethod == "lattice") else False, # [>] Define como True caso o método de conversão  esteja  como
+                                                                       # lattice, caso contrário define como False
+            pages = avar.readPDFPagesArg,                              # [i] Páginas do arquivo PDF a serem lidas
+            # VALORES PADRÃO
+            guess = True,                                              # [i] Tenta adivinhar uma porção da página para ler
+            multiple_tables = True,                                    # [i] Se o arquivo PDF tem mais de uma tabela
+            pandas_options = {"dtype": "str"},                         # [i] Tipo de dados do DataFrame
+            silent = True                                              # [i] Não exibe erros da biblioteca Tabula ao terminal, cmd
+        )
+    # [i] Quando ocorre um problema desconhecido na hora de  reali-
+    # zar a leitura
+    except Exception as ExceptionError:
+        # [>] Exibe uma mensagem de erro
+        error.Show(
+            "Arquivo: " + filefullname_PDF + "\n"
+            "Método de Conversão: " + ReadingMethod + "\n"
+            "\n"
+            "Ocorreu um erro ao tentar realizar a leitura do arquivo '" + filefullname_PDF +  "' "
+            "usando o método '" + ReadingMethod + "'.",
+            
+            ExceptionError = ExceptionError,
+            ExitProgram = False,
+            RecreateTerminalFile = False
+        )
+    # >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
+    # -------------------------------------------------------------
+
+#endregion
+
+#region PRIVATE METHODS
+
+def __MakeFormattedFiles(ReadingMethod, Formatting):
+    try:
+        for letter in Formatting:
+            if (str(Formatting).count(letter)) > 1: raise RepeatedFormattingType
+
+            if (letter == "T"): tablewithblankcells.MakeFile(ReadingMethod)
+            elif (letter == "M"): main.MakeFile(ReadingMethod)
+            elif (letter == "F"): fullclear.MakeFile(ReadingMethod)
+            else: raise InvalidFormattingType
+    except InvalidFormattingType as ExceptionError:
+        error.Show("Ocorreu um erro na hora de realizar as formatações em 'ConversionStart()'.", ExceptionError)
+    except RepeatedFormattingType as ExceptionError:
+        error.Show("O tipo de formatação '" + letter + "' foi repetido mais de uma vez em '" + Formatting + "'.", ExceptionError)
+    except Exception as ExceptionError:
+        error.Show("Ocorreu um erro desconhecido ao tentar realizar as formatações requisitadas em 'ConversionStart()'.", ExceptionError)
+
+#endregion
\ No newline at end of file
diff --git a/build/lib/pdfconverter/conversion/format/__init__.py b/build/lib/pdfconverter/conversion/format/__init__.py
new file mode 100644
index 0000000..f452451
--- /dev/null
+++ b/build/lib/pdfconverter/conversion/format/__init__.py
@@ -0,0 +1,20 @@
+"""
+---
+---
+---
+
+## Package: pdfconverter >> conversion >> format
+---
+---
+### Module Name: format (Constructor, __init__)
+---
+### path: "pdfconverter\\\\\\\\conversion\\\\\\\\format\\\\\\\\__init__.py"
+---
+---
+Pacote e  módulo  responsável  por  fazer  o  gerenciamento  de
+arquivos de formatação.
+
+---
+---
+---
+"""
\ No newline at end of file
diff --git a/build/lib/pdfconverter/conversion/format/fullclear.py b/build/lib/pdfconverter/conversion/format/fullclear.py
new file mode 100644
index 0000000..34ece2e
--- /dev/null
+++ b/build/lib/pdfconverter/conversion/format/fullclear.py
@@ -0,0 +1,88 @@
+"""
+---
+---
+---
+
+## Package: pdfconverter >> conversion >> format
+---
+---
+### Module Name: fullclear
+---
+### path: "pdfconverter\\\\\\\\conversion\\\\\\\\format\\\\\\\\fullclear.py"
+---
+---
+Módulo relacionado à formatação FullClear.
+
+---
+---
+---
+"""
+
+
+# [>] PDFConverter
+# [i] Variáveis
+from pdfconverter.__variables__ import fvar
+# [i] Arquivo do terminal
+from pdfconverter.terminalfile.message import error
+# [i] Conversão
+from pdfconverter.conversion.format import main, tablewithblankcells
+# [i] Formatação de String
+from pdfconverter.stringformat import stringformat
+
+
+#region PUBLIC METHODS
+
+def MakeFile(ReadingMethod):
+    try:
+        fvar.filepath_FullClear = fvar.folderpath_Result + "\\" + ReadingMethod + "\\fullClear\\" + fvar.filename_PDF + ".txt"
+        # [>] Abre o arquivo principal (ainda não totalmente pronto pa-
+        # ra ser jogado em uma tabela possui mais dados, porém estrutu-
+        # ra ainda não tão idealizada)
+        with open(fvar.filepath_FullClear, "a", encoding="UTF-8") as TextFile:
+            # [>] Formata o arquivo e escreve um novo arquivo de saída
+            TextFile.write(FormatTextFile(fvar.filepath_WithoutFormatting))
+    except Exception as ExceptionError:
+        error.Show("Ocorreu um erro desconhecido ao criar o arquivo com formatação 'fullclear'.", ExceptionError)
+
+def FormatTextFile(TextFilePath):
+    newString = ""
+    # [i] Abre o arquivo original presente na pasta 'withoutFormat-
+    # ting' para criar formatações baseadas nele
+    with open(TextFilePath, "r", encoding="UTF-8") as TextFile:
+        # [i] Navega por cada linha do documento de texto
+        for line in TextFile:
+            # [>] Realiza as formatações já existentes em tableWithBlankCells
+            line = tablewithblankcells.FormatString(line)
+            if line == ("" or None): continue
+            # [>] Realiza as formatações já existentes em main
+            line = main.FormatString(line)
+            if line == ("" or None): continue
+            # [>] Realiza a formatação do módulo vigente
+            line = FormatString(line)
+            if line == ("" or None): continue
+
+            # [>] Adiciona à nova String
+            newString += line
+    # [>] Devolve pro método a nova String
+    return newString
+
+def FormatString(String):
+    """Caso retorne None não escreve a linha, caso contrário retorna como uma variável normalmente."""
+
+    # [>] Cria um novo objeto para manipular a String
+    formatString = stringformat(String)
+
+    # [>] Caso a linha não comece com aspas deleta
+    formatString.LineNotStartsWithDoubleQuotes()
+    
+    # [>] Caso a linha não termine com aspas deleta
+    formatString.LineNotEndsWithDoubleQuotes()
+
+    # [>] Caso a linha tenha quebra de linha sem aspas duplas
+    formatString.LineWithLinebreakOrWithoutDoubleQuote()
+    
+    # [i] Só escreve a linha se tiver pelo menos mais que 3 colunas
+    # no arquivo fullClear
+    if (formatString.Has3ColumnsOrMore()): return formatString.String
+
+#endregion
\ No newline at end of file
diff --git a/build/lib/pdfconverter/conversion/format/main.py b/build/lib/pdfconverter/conversion/format/main.py
new file mode 100644
index 0000000..96b2049
--- /dev/null
+++ b/build/lib/pdfconverter/conversion/format/main.py
@@ -0,0 +1,137 @@
+"""
+---
+---
+---
+
+## Package: pdfconverter >> conversion >> format
+---
+---
+### Module Name: main
+---
+### path: "pdfconverter\\\\\\\\conversion\\\\\\\\format\\\\\\\\main.py"
+---
+---
+Módulo relacionado à formatação Main.
+
+---
+---
+---
+"""
+
+
+# [>] PDFConverter
+# [i] Variáveis
+from pdfconverter.__variables__ import fvar
+# [i] Arquivo do terminal
+from pdfconverter.terminalfile.message import error
+# [i] Conversão
+from pdfconverter.conversion.format import tablewithblankcells
+# [i] Formatação de String
+from pdfconverter.stringformat import stringformat
+
+
+#region PUBLIC METHODS
+
+def MakeFile(ReadingMethod):
+    try:
+        fvar.filepath_Main= fvar.folderpath_Result + "\\" + ReadingMethod + "\\main\\" + fvar.filename_PDF + ".txt"
+        # [>] Abre o arquivo principal (ainda não totalmente pronto pa-
+        # ra ser jogado em uma tabela possui mais dados, porém estrutu-
+        # ra ainda não tão idealizada)
+        with open(fvar.filepath_Main, "a", encoding="UTF-8") as TextFile:
+            # [>] Formata o arquivo e escreve um novo arquivo de saída
+            TextFile.write(FormatTextFile(fvar.filepath_WithoutFormatting))
+    except Exception as ExceptionError:
+        error.Show("Ocorreu um erro desconhecido ao criar o arquivo com formatação 'main'.", ExceptionError)
+    
+def FormatTextFile(TextFilePath):
+    """
+    ---
+    ---
+    ---
+    
+    ## FormatStart (Public)
+    ---
+    ---
+    Método faz todo esse processo para ficar mais fácil de  decidir
+    quando será gerado um novo arquivo.
+    
+    ### Returns
+    ---
+        [str]: Nova String com as formatações realizadas do módulo presente.
+    
+    ---
+    ---
+    ---
+    """
+    
+    newString = ""
+    # [i] Abre o arquivo original presente na pasta 'withoutFormat-
+    # ting' para criar formatações baseadas nele
+    with open(TextFilePath, "r", encoding="UTF-8") as TextFile:
+        # [i] Navega por cada linha do documento de texto
+        for line in TextFile:
+            # [>] Realiza as formatações já existentes em tableWithBlankCells
+            line = tablewithblankcells.FormatString(line)
+            if line == ("" or None): continue
+            # [>] Realiza a formatação do módulo vigente
+            line = FormatString(line)
+            if line == ("" or None): continue
+
+            # [>] Adiciona à nova String
+            newString += line
+    # [>] Devolve pro método a nova String                
+    return newString
+
+def FormatString(String):
+    """
+    ---
+    ---
+    ---
+    
+    ## FormatString (Public)
+    ---
+    ---
+    Método que realiza a formatação de acordo com o módulo vigente.
+    
+    ### Args
+    ---
+    - String ([str]):
+        - String que será utilizada para realizar a formatação.
+    
+    ### Returns
+    ---
+        [str]: Retorna a nova String formatada.
+    
+    ---
+    ---
+    ---
+    """
+
+    # [>] Cria um novo objeto para manipular a String
+    formatString = stringformat(String)
+
+    if (formatString.String == ""): return ""
+
+    # [>] Remove dados que estão vazios
+    formatString.EmptyBody()
+
+    # [>] Faz uma quebra de linha caso tenha aspas duplas  adjacen-
+    # tes
+    formatString.DoubleQuotesAdjacent("\n")
+
+    # [>] Caso tenha um ponto e vírgula seguido de um espaço  troca
+    # por uma quebra de linha
+    formatString.SemicolonAdjacentSpace("\n")
+
+    # [>] Caso tenha um espaço entre um separador e uma aspas dupla
+    # remove o conteúdo que está atrás
+    formatString.SpaceBetweenSeparatorAndDoubleQuote()
+
+    # [i] Se a linha possui aspas duplas no início  e  no  final  e
+    # ainda possui menos que duas colunas cancela o código
+    if (formatString.IsSmallTable()): return ""
+
+    return formatString.ReturnString()
+
+#endregion
\ No newline at end of file
diff --git a/build/lib/pdfconverter/conversion/format/tablewithblankcells.py b/build/lib/pdfconverter/conversion/format/tablewithblankcells.py
new file mode 100644
index 0000000..25920e2
--- /dev/null
+++ b/build/lib/pdfconverter/conversion/format/tablewithblankcells.py
@@ -0,0 +1,93 @@
+"""
+---
+---
+---
+
+## Package: pdfconverter >> conversion >> format
+---
+---
+### Module Name: tablewithblankcells
+---
+### path: "pdfconverter\\\\\\\\conversion\\\\\\\\format\\\\\\\\tablewithblankcells.py"
+---
+---
+Módulo relacionado à formatação TableWithBlankCells.
+
+---
+---
+---
+"""
+
+
+# [>] PDFConverter
+from pdfconverter.stringformat import stringformat
+# [i] Arquivo do terminal
+from pdfconverter.terminalfile.message import error
+# [i] Variáveis
+from pdfconverter.__variables__ import fvar
+
+
+#region PUBLIC METHODS
+
+def MakeFile(ReadingMethod):
+    try:
+        fvar.filepath_TableWithBlankCells = fvar.folderpath_Result + "\\" + ReadingMethod + "\\tableWithBlankCells\\" + fvar.filename_PDF + ".txt"
+        # [>] Abre o arquivo de texto "tableWithBlankCells"
+        with open(fvar.filepath_TableWithBlankCells, "a", encoding="UTF-8") as TextFile:
+            # [>] Formata o arquivo e escreve um novo arquivo de saída
+            TextFile.write(FormatTextFile(fvar.filepath_WithoutFormatting))
+    except Exception as ExceptionError:
+        error.Show("Ocorreu um erro desconhecido ao criar o arquivo com formatação 'tablewithblankcells'.", ExceptionError)
+            
+def FormatTextFile(TextFilePath):
+    newString = ""
+    # [i] Abre o arquivo original presente na pasta 'withoutFormat-
+    # ting' para criar formatações baseadas nele
+    with open(TextFilePath, "r", encoding="UTF-8") as TextFile:
+        # [i] Navega por cada linha do documento de texto
+        for line in TextFile:
+            # [>] Realiza a formatação do módulo vigente
+            line = FormatString(line)
+            if line == ("" or None): continue
+
+            # [>] Adiciona à nova String
+            newString += line
+    # [>] Devolve pro método a nova String
+    return newString
+
+def FormatString(String):
+    """Caso retorne None não escreve a linha, caso contrário retorna como uma variável normalmente."""
+
+    # [>] Cria um novo objeto para manipular a String
+    formatString = stringformat(String)
+
+    # [>] Detecta os dados vazios que estão presentes no  cabeçalho
+    # "Unnamed: X;"
+    formatString.EmptyHeader()
+
+    # [>] Remove ponto e vírgula no final da linha
+    formatString.EndLineSemicolon()
+    
+    # [>] Remove quebras de linha caso seja no meio dos  dados,  ou
+    # seja, caso não possua '"' atrás da quebra de linha e as subs-
+    # titui por um espaço para manter o padrão
+    formatString.MiddleLineBreak(" ")
+
+    # Condicional que impede o continuamento do processo caso a va-
+    # riável esteja vazia, ou seja, caso tenha  sido  apagada  pelo
+    # processo anterior de limpeza
+    if (formatString.String == ""): return ""
+
+    # [>] Remove ponto e vírgula no final da linha
+    formatString.EndLineSemicolon()
+    
+    # [>] Remove todos os espaços no início de cada linha
+    formatString.StartLineEmptySpace()
+
+    # [i] Se a linha possui aspas duplas no início  e  no  final  e
+    # ainda possui menos que duas colunas cancela o código
+    if (formatString.IsSmallTable()): return ""
+
+    return formatString.ReturnString()
+
+#endregion
\ No newline at end of file
diff --git a/build/lib/pdfconverter/conversion/withoutformatting.py b/build/lib/pdfconverter/conversion/withoutformatting.py
new file mode 100644
index 0000000..5ea34df
--- /dev/null
+++ b/build/lib/pdfconverter/conversion/withoutformatting.py
@@ -0,0 +1,164 @@
+"""
+---
+---
+---
+
+## Package: pdfconverter >> conversion
+---
+---
+### Module Name: withoutformatting
+---
+### path: "pdfconverter\\\\\\\\conversion\\\\\\\\withoutformatting.py"
+---
+---
+Módulo com itens relacionados à geração do arquivo sem formatação.
+
+---
+---
+---
+"""
+
+
+# [>] Geral
+import csv
+import pandas
+# [>] PDFConverter
+# [i] Variáveis
+from pdfconverter.__variables__ import fvar
+# [i] Arquivo do Terminal
+from pdfconverter.terminalfile.message import design, error
+
+
+#region PUBLIC METHODS
+
+def AppendToFile(ReadingMethod, TableDataFrame):    
+    """
+    ---
+    ---
+    ---
+
+    ### Start (Public)
+    ---
+    Inicia a conversão e gera um arquivo sem formatação.
+    
+    Args:
+        ReadingMethod ([type]): Método de leitura.
+        TableDataFrame ([type]): DataFrame atual para gerar o arquivo.
+ 
+    ---
+    ---
+    ---
+    """
+
+    try:
+        # [>] Chama a função que  realiza  algumas  formatações  no
+        # DataFrame
+        TableDataFrame = FormatDataFrame(TableDataFrame)
+
+        # [>] Define o caminho do arquivo  atual  para  a  variável
+        # global filepath_ExportTxt
+        fvar.filepath_WithoutFormatting = fvar.folderpath_Result + "\\" +  ReadingMethod + "\\withoutFormatting\\" + fvar.filename_PDF + ".txt"
+
+        # [>] Converte o arquivo para .txt no formato de um CSV
+        TableDataFrame.to_csv(
+            fvar.filepath_WithoutFormatting,
+            index = False,
+            index_label = False,
+            header = False,
+            line_terminator = "\n", # [i] Define a quebra de linha como '\n' para evitar conflito com o terminal que gera \r
+            mode = "a",
+            sep = ";",
+            quoting = csv.QUOTE_ALL
+        )
+
+        # [>] Indica ao terminal que uma tabela foi convertida  com
+        # sucesso e imprime o DataFrame
+        design.WithoutFormattingConversionTitle(ReadingMethod, TableDataFrame)
+    # [>] Caso haja um erro desconhecido na hora de realizar a con-
+    # versão
+    except Exception as ExceptionError:
+        # [>] Exibe uma mensagem de erro
+        error.Show(
+            "Arquivo: " + fvar.filename_PDF + "\n"
+            "Método de Conversão: " + ReadingMethod + "\n"
+            "\n"
+            "Ocorreu um erro, ao tentar converter o "
+            "arquivo '" + fvar.filename_PDF + ".pdf' usando o "
+            "método " + ReadingMethod + ".",
+            
+            ExceptionError = ExceptionError,
+            ExitProgram = False,
+            RecreateTerminalFile = False
+        )
+        return
+
+def FormatDataFrame(TableDataFrame):
+    # [>] Remove as aspas duplas do que estiverem no DataFrame para
+    # evitar possíveis erros pois os dados normalmente são  separa-
+    # dos por pontos e vírgula e aspas duplas
+    TableDataFrame = TableDataFrame.replace("\"", "", regex = True)
+    # [>] Deleta todas as linhas que estão completamente vazias
+    TableDataFrame = TableDataFrame.dropna(how="all")  
+    # [>] Deleta todas as colunas que estão  completamente  va-
+    # zias
+    TableDataFrame = TableDataFrame.dropna(how="all", axis=1)
+
+    # [>] Transforma o cabeçalho em uma linha comum
+    TableDataFrame = __TurnHeaderInSimpleRow(TableDataFrame)
+
+    # [>] Remove quebras de linha do  DataFrame  que  acontecem
+    # por conta do corpo ser muito grande
+    TableDataFrame.replace({r"\r": " "}, inplace=True, regex=True)
+    # [>] Troca ponto e vírgula dentro do DataFrame para evitar
+    # conflitos
+    TableDataFrame.replace({r";": ","}, inplace=True, regex=True)
+
+    return TableDataFrame
+
+#endregion
+
+#region PRIVATE METHODS
+
+def __TurnHeaderInSimpleRow(TableDataFrame):
+    """
+    ---
+    ---
+    ---
+
+    ### TurnHeaderInSimpleRow (Private)
+    ---
+    Transforma o cabeçalho do DataFrame em  uma  linha  comum  para
+    padronizar a formatação.
+
+    Args:
+        TableDataFrame ([type]): [description]
+ 
+    ---
+    ---
+    ---
+    """
+
+    # [>] Cria e limpa uma lista que vai ser usada para manipular o
+    # cabeçalho no DataFrame
+    TableDataFrameHeader = []
+
+    # [>] Pegando o cabeçalho da tabela e passando ela  como  lista
+    # para a temporária
+    TableDataFrameHeader = [*TableDataFrame]
+
+    # [i] Checando se a lista com o cabeçalho veio preenchida e  se
+    # o cabeçalho não possui campos vazios
+    if (TableDataFrameHeader and not "Unnamed" in TableDataFrameHeader[0]):
+        # [>] Removendo o cabeçalho do DataFrame atual
+        TableDataFrame = TableDataFrame.T.reset_index().T.reset_index(drop=True)
+
+        # [>] Adicionando a lista como primeira linha do corpo do Data-
+        # Frame temporário
+        TableDataFrameHeader.insert(1, TableDataFrameHeader)
+
+        # [>] Concatenando tabela temporária à tabela principal
+        pandas.concat([pandas.DataFrame(TableDataFrameHeader), TableDataFrame], ignore_index=True)
+
+    return TableDataFrame
+
+#endregion
\ No newline at end of file
diff --git a/build/lib/pdfconverter/patterncolumns/__init__.py b/build/lib/pdfconverter/patterncolumns/__init__.py
new file mode 100644
index 0000000..e3bbee7
--- /dev/null
+++ b/build/lib/pdfconverter/patterncolumns/__init__.py
@@ -0,0 +1,185 @@
+"""
+---
+---
+---
+
+## Package: pdfconverter >> patterncolumns
+---
+---
+### Module Name: patterncolumns (Constructor, __init__)
+---
+### path: "pdfconverter\\\\\\\\patterncolumns\\\\\\\\__init__.py"
+---
+---
+Pacote e módulo comportando funções relacionadas à padronização
+de arquivos resultantes da conversão.
+
+---
+---
+---
+"""
+
+
+# [>] Geral
+import re
+import json
+# [>] PDFConverter
+# [i] Variáveis
+from pdfconverter.__variables__ import fvar, pvar
+# [i] Arquivo do Terminal
+from pdfconverter.terminalfile.message import error
+
+
+#region GLOBAL VARIABLES
+
+# [C] PATTERN COLUMNS
+# -------------------------------------------------------------
+# Descrição:
+# Variáveis que possuem relações com a definição de padrões nas
+# colunas
+# >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
+list_textFileTSC = []
+"""teste"""
+tableIndex = -1
+"""teste 2"""
+# >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
+# -------------------------------------------------------------
+
+#endregion
+
+#region PUBLIC METHODS
+
+def SetHeaderToPattern(String):
+    newString = ""
+    # [>] Se a linha for um cabeçalho
+    if IsAHeader(String):
+        # [>] Enxerga cada item do cabeçalho de cada tabela utilizando-
+        # se de  uma  expressão regular e passa para uma lista
+        list_CSVColumns = re.findall(
+            r"""
+            (?<=\")
+            ([^\;]*?)
+            (?=\")
+            """,
+            String,
+            flags = re.MULTILINE | re.VERBOSE
+        )
+
+
+        columnIterator = 0
+        # [>] Para cada coluna da linha vinda do  cabeçalho  encontrado
+        # no arquivo CSV
+        for column in list_CSVColumns:
+            # [i] Variável que vai dizer se a coluna foi mencionada pelo u-
+            # suário
+            foundInArg = False
+            # [i] Contador das colunas do CSV
+            counter_ArgsContainerIterator = 0
+            # [>] Ele olha cada container de argumentos na lista  de  argu-
+            # mentos que o usuário forneceu, contendo os valores de colunas
+            # que ele quer alterar
+            for argContainer in pvar.list_columnFieldsToChange:
+                # [>] Verifica se a coluna atual do CSV ta dentro do container
+                if (column in argContainer):
+                    # [>] Se estiver, olha cada valor do container atual
+                    for lineitem in range(len(pvar.list_columnFieldsToChange[counter_ArgsContainerIterator])):
+                        # [>] Caso seja o primeiro index, pega ele como título do argu-
+                        # mento
+                        if lineitem == 0: argName = argContainer[lineitem]
+                        # [>] Caso não seja o primeiro index
+                        else:
+                            # [>] Pega como valor do argumento
+                            argValue = argContainer[lineitem]
+                            # [>] E verifica se é igual o da coluna e se for
+                            if (column == argValue):
+                                # [>] Substitui o nome da coluna pelo que tá no argmento
+                                newString += '"' + argName + '"'
+                                # [>] Avisa a variável que foi encontrado  uma  correspondência
+                                # de argumento para a coluna atual
+                                foundInArg = True
+                                # [>] Para o for
+                                break
+                # [>] Avança um no contador do container
+                counter_ArgsContainerIterator += 1
+                # [>] Caso a linha tenha sua correspondência encontrada  dentro
+                # do container atual para a operação e parte para a próxima co-
+                # luna
+                if foundInArg is True: break
+            # [i] Se ao término da operaçã
+            else:
+                # [i] Se a coluna não conseguiu ser alterada
+                if not foundInArg: error.Show("Não foi possível alterar o valor da coluna '" + column + "' com os valores fornecidos em '" + str(pvar.list_columnFieldsToChange) + "'.")
+            columnIterator += 1
+
+            # [>] Pra cada coluna que for adicionada, se não for  a  última
+            # coluna bota ';' na frente e se for coloca um '\n'
+            newString += ';' if columnIterator < len(list_CSVColumns) else '\n'
+    # [>] Se a linha não for um cabeçalho, devolve a string como estava
+    else: newString = String
+
+    return newString
+
+def RecognizePattern(FileToReadPath):
+    patterncolumnspath = fvar.folderpath_Result + "\pattercolumns.txt"
+    LogDict = {
+        'info': {
+            'export_path': FileToReadPath,
+            'pattern_path': patterncolumnspath 
+        }
+    }
+
+    with open(FileToReadPath, "r", encoding = "UTF-8") as FileToRead:
+        for line in FileToRead:
+            # [i] Regex que faz a verificação se o conteúdo da  li-
+            # nha é um cabeçalho
+            headerMatch = re.match(r"(^\"[a-zA-Z].*)", line)
+
+            # [>] Se a linha for um cabeçalho
+            if headerMatch is not None:
+                # [>] Enxerga cada item do cabeçalho de cada tabela utilizando-
+                # se de  uma  expressão regular e passa para uma lista
+                TextFile_CSVColumns = re.findall(
+                    r"""
+                    (?<=\")
+                    ([^\;]*?)
+                    (?=\")
+                    """,
+                    line,
+                    flags = re.MULTILINE | re.VERBOSE
+                )
+
+
+                # [>] Para cada coluna da linha vinda do  cabeçalho  encontrado
+                # no arquivo CSV
+                for column in TextFile_CSVColumns:
+                    # [>] Dentro da variável que armazena todas  as  recomendações,
+                    # de todas as colunas, olha cada container (um container repre-
+                    # senta o nome padrão e recomendações de uma colnua)
+                    for container in pvar.StoredColumns:
+                        # [>] Verifica se a coluna foi encontrada como recomendação  no
+                        # container atual
+                        if str(column).lower() in container:
+                            LogDict[str(container[0]).replace("--","")] = column
+                        # [>] Se não foi
+                        else:
+                            # [>] Passa para o próximo container
+                            continue
+                # [>] Para a operação
+                break
+            else:
+                continue
+
+        # [>] O arquivo com as colunas padrão está sendo atualmente ge-
+        # rado na pasta de resultados
+        with open(patterncolumnspath, mode = "w", encoding = "UTF-8") as TextFile:
+            # [>] Transforma o dicionário de log em um JSON e escreve  den-
+            # tro do arquivo
+            TextFile.write(json.dumps(LogDict, indent = 4))
+
+#endregion
+
+#region PRIVATE METHODS
+
+def IsAHeader(String): return True if re.match(r"(^\"[a-zA-Z].*)", String) is not None else False
+
+#endregion
\ No newline at end of file
diff --git a/build/lib/pdfconverter/program/__init__.py b/build/lib/pdfconverter/program/__init__.py
new file mode 100644
index 0000000..e1ac4ac
--- /dev/null
+++ b/build/lib/pdfconverter/program/__init__.py
@@ -0,0 +1,47 @@
+"""
+---
+---
+---
+
+## Package: pdfconverter >> program
+---
+---
+### Module Name: program (Constructor, __init__)
+---
+### path: "pdfconverter\\\\\\\\program\\\\\\\\__init__.py"
+---
+---
+Pacote e módulo contendo funções relacionadas à ações diretas à
+PDFConverter.
+
+---
+---
+---
+"""
+
+
+# [>] Geral
+import sys
+
+
+#region PUBLIC METHODS
+
+def Exit():
+    """
+    ---
+    ---
+    ---
+
+    ### Exit (Public)
+    ---
+    Fecha e para a execução do PDFConverter.
+    
+    ---
+    ---
+    ---
+    """
+
+    # [>] Fecha e para o programa
+    sys.exit()
+
+#endregion
\ No newline at end of file
diff --git a/build/lib/pdfconverter/program/exceptions.py b/build/lib/pdfconverter/program/exceptions.py
new file mode 100644
index 0000000..217d283
--- /dev/null
+++ b/build/lib/pdfconverter/program/exceptions.py
@@ -0,0 +1,76 @@
+"""
+---
+---
+---
+
+## Package: pdfconverter >> program
+---
+---
+### Module Name: exceptions
+---
+### path: "pdfconverter\\\\\\\\program\\\\\\\\exceptions.py"
+---
+---
+Módulo responsável por manter algumas exceções customizadas  do
+programa PDFConverter.
+
+---
+---
+---
+"""
+
+
+#region EXCEPTIONS
+
+class InvalidFormattingType(Exception):
+    """
+    ---
+    ---
+    ---
+    
+    ## InvalidFormattingType
+    ---
+    ---
+    Exceção disparada quando é passado como parâmetro, um método de
+    formatação não existente ou não existente na condicional dentro
+    do método que inicializa a conversão (ConversionStart).
+    
+    ### Default Message
+    ---
+    \"O  método   de   formatação   passado   como   parâmetro   em
+    'ConversionStart' não existe.\"
+    
+    ---
+    ---
+    ---
+    """
+
+    def __init__(self, msg="O método de formatação passado como parâmetro em 'ConversionStart' não existe.", *args, **kwargs):
+        super().__init__(msg, *args, **kwargs)
+
+class RepeatedFormattingType(Exception):
+    """
+    ---
+    ---
+    ---
+    
+    ## InvalidFormattingType
+    ---
+    ---
+    Exceção disparada quando é passado como parâmetro o mesmo  tipo
+    de formatação mais de uma vez.
+    
+    ### Default Message
+    ---
+    \"Não se pode repetir o mesmo tipo de formatação  mais  de  uma
+    vez.\"
+    
+    ---
+    ---
+    ---
+    """
+
+    def __init__(self, msg="Não se pode repetir o mesmo tipo de formatação mais de uma vez.", *args, **kwargs):
+        super().__init__(msg, *args, **kwargs)
+
+#endregion
\ No newline at end of file
diff --git a/build/lib/pdfconverter/program/utilities/__init__.py b/build/lib/pdfconverter/program/utilities/__init__.py
new file mode 100644
index 0000000..fd61dc8
--- /dev/null
+++ b/build/lib/pdfconverter/program/utilities/__init__.py
@@ -0,0 +1,76 @@
+"""
+---
+---
+---
+
+## Package: pdfconverter >> program >> utilities
+---
+---
+### Module Name: utilities (Constructor, __init__)
+---
+### path: "pdfconverter\\\\\\\\program\\\\\\\\utilities\\\\\\\\__init__.py"
+---
+---
+Pacote e módulo que possui algumas funções  utilitárias  feitas
+para o projeto.
+
+---
+---
+---
+"""
+
+
+# [>] Geral
+import re
+import os.path
+
+
+#region PUBLIC METHODS
+
+def IsPDF(File):
+    """
+    ---
+    ---
+    ---
+    
+    ## IsPDF (Public)
+    ---
+    ---
+    Método que valida se o arquivo indicado é um arquivo PDF.
+    
+    ### Args
+    ---
+    - File ([bool]):
+        - Arquivo que será conferido no método.
+    
+    ### Returns
+    ---
+        [bool]: Se o item indicado na variável for um arquivo e tiver a
+        extensão ".pdf" retorna True, caso contrário retorna False
+    
+    ---
+    ---
+    ---
+    """
+
+    return True if(os.path.isfile(File) and (str(File[-4:]).lower() == ".pdf")) else False
+
+def JustifyText(Text, CharQuantity):
+    """
+    ### JustifyText (Public)
+    ---
+    Realiza a justificação do texto com a quantidade de caracteres
+    informada.
+
+    Args:
+        Content ([str]): Texto no qual será justificado.
+        CharQuantity ([int]): Quantidade de caracteres na qual a
+        justificação de texto vai se basear.
+
+    Returns:
+        [str]: Retorna a String justificada.
+    """
+
+    return '\n'.join(re.findall('.{1,%i}' % int(CharQuantity), str(Text)))
+
+#endregion
\ No newline at end of file
diff --git a/build/lib/pdfconverter/program/utilities/temporaryfile.py b/build/lib/pdfconverter/program/utilities/temporaryfile.py
new file mode 100644
index 0000000..4fa56c5
--- /dev/null
+++ b/build/lib/pdfconverter/program/utilities/temporaryfile.py
@@ -0,0 +1,94 @@
+"""
+---
+---
+---
+
+## Package: pdfconverter >> program >> utilities
+---
+---
+### Module Name: temporaryfile
+---
+### path: "pdfconverter\\\\\\\\program\\\\\\\\utilities\\\\\\\\temporaryfile.py"
+---
+---
+Módulo  responsável  por  fazer  a  manipulação   de   arquivos
+temporários.
+
+---
+---
+---
+"""
+
+
+# [>] Geral
+import tempfile
+# [i] Programa
+from pdfconverter.program.utilities import time
+
+
+#region GLOBAL VARIABLES
+
+File = ""
+"""Variável que armazena o objeto do arquivo temporário."""
+
+#endregion
+
+#region TEMPORARY FILE
+
+class temporaryfile():
+    def __init__(self, FilePrefix, FileSuffix = "", DeleteAfterFileClose = True):
+        """
+        ---
+        ---
+        ---
+        
+        ## __init__ (ifpublicmethod{Public}{ÒR}ifprivatemethod{ifPrivate}{OR}ifconstructor{Constructor, __init__})
+        ---
+        ---
+        Método construtor responsável por realizar a criação do arquivo
+        com algumas predefinições,  e  alguns  valores  que  podem  ser
+        alterados por quem vai instanciar o objeto.
+        
+        ### Args
+        ---
+        - FilePrefix (str):
+            - Prefixo do nome do arquivo.
+        - FileSuffix (str, optional, default = ""):
+            - Sufixo do nome do arquivo.
+        - DeleteAfterFileClose (bool, optional, default = True):
+            - Se deseja que o arquivo seja deletado após  o  fechamento  do
+            mesmo via código ou ao término da execução do aplicativo.
+        
+        ---
+        ---
+        ---
+        """
+
+        global File
+        File = tempfile.NamedTemporaryFile(
+            mode = "w+",
+            prefix = "PDFConverter_" + FilePrefix + "_" + time.GetDateAndTime(),
+            suffix = FileSuffix + "_.tmp",
+            delete = DeleteAfterFileClose
+        )
+
+    def Write(self, String):
+        # [i] Escrita
+        # [>] Escreve a linha
+        File.write(String)
+
+    def ReadAllLines(self):
+        # [i] Leitura
+        # [>] Move o cursor para o início do arquivo
+        File.seek(0,0)
+        # [>] Escreve a linha
+        return File.readlines()
+
+    def Close(self):
+        # [>] Fecha o arquivo, e deleta caso tenha não tenha sido  con-
+        # figurado 'DeleteAfterFileClose' como 'False'
+        # -------------------------------------------------------------
+        File.close()
+
+
+#endregion
\ No newline at end of file
diff --git a/build/lib/pdfconverter/program/utilities/time.py b/build/lib/pdfconverter/program/utilities/time.py
new file mode 100644
index 0000000..b31f820
--- /dev/null
+++ b/build/lib/pdfconverter/program/utilities/time.py
@@ -0,0 +1,31 @@
+"""
+---
+---
+---
+
+## Package: pdfconverter >> program >> utilities
+---
+---
+### Module Name: time
+---
+### path: "pdfconverter\\\\\\\\program\\\\\\\\utilities\\\\\\\\time.py"
+---
+---
+Módulo que possui métodos relacionados à tempo.
+
+---
+---
+---
+"""
+
+
+# [>] Geral
+from datetime import datetime
+
+
+#region PUBLIC METHODS
+
+def GetDateAndTime():
+    return datetime.today().strftime("%Y%m%d_%H%M%S")
+
+#endregion
\ No newline at end of file
diff --git a/build/lib/pdfconverter/settings/__init__.py b/build/lib/pdfconverter/settings/__init__.py
new file mode 100644
index 0000000..b59a1c1
--- /dev/null
+++ b/build/lib/pdfconverter/settings/__init__.py
@@ -0,0 +1,19 @@
+"""
+---
+---
+---
+
+## Package: pdfconverter >> settings
+---
+---
+### Module Name: settings (Constructor, __init__)
+---
+### path: "pdfconverter\\\\\\\\settings\\\\\\\\__init__.py"
+---
+---
+Pacote e módulo contendo algumas configurações para o projeto.
+
+---
+---
+---
+"""
\ No newline at end of file
diff --git a/build/lib/pdfconverter/settings/pandassettings.py b/build/lib/pdfconverter/settings/pandassettings.py
new file mode 100644
index 0000000..eba71ef
--- /dev/null
+++ b/build/lib/pdfconverter/settings/pandassettings.py
@@ -0,0 +1,74 @@
+"""
+---
+---
+---
+
+## Package: pdfconverter >> settings
+---
+---
+### Module Name: pandassettings
+---
+### path: "pdfconverter\\\\\\\\settings\\\\\\\\pandassettings.py"
+---
+---
+Pacote e módulo que possui funções relacionadas à configurações
+da biblioteca Pandas.
+
+---
+---
+---
+"""
+
+
+# [>] Geral
+import pandas
+
+
+#region PUBLIC METHODS
+
+def Set(MaxColumnWidth=None, ExpandFrameRepresentation=False, Encoding="UTF-8-sig", MultiColumn=False):
+    """
+    ---
+    ---
+    ---
+    
+    ## Set (Public)
+    ---
+    ---
+    Define as configurações do Pandas. Ele já vem  configurado  por
+    padrão, mas é possível alterar  os  valores  das  configurações
+    passando os mesmos pelos parâmetros desse método.
+    
+    ### Args
+    ---
+    - MaxColumnWidth (int, optional, default = None):
+        - Corresponde à largura máxima das colunas do pandas.
+    - ExpandFrameRepresentation (bool, optional, default = False):
+        - Configuração  que  evita  com  que  os  dados  acabem   sendo
+        quebrados na saída do terminal durante a exibição do  DataFrame
+        do Pandas.
+    - Encoding (str, optional, default = "UTF-8-sig"):
+        - Codificação do conteúdo interpretado pelo Pandas.
+    - MultiColumn (bool, optional, default = False):
+        - Configuração que faz com que caso exista um ';' com  que  ele
+        não passe  os  dados para outra célula.
+    
+    ---
+    ---
+    ---
+    """
+
+    # [>] Configuração que evita com que dados sejam  quebrados  no
+    # arquivo exportado
+    pandas.options.display.max_colwidth = MaxColumnWidth
+    # [>] Configuração que evita com que os dados acabem sendo que-
+    # brados na saída do terminal
+    pandas.options.display.expand_frame_repr = ExpandFrameRepresentation
+    # [>] Configuração que define  o  padrão  de  codificação  para
+    # UTF-8 com BOM
+    pandas.options.display.encoding = Encoding
+    # [>] Configuração que faz com que caso exista um ";"  ele  não
+    # passe os dados pra outra célula
+    pandas.options.display.latex.multicolumn = MultiColumn
+
+#endregion
\ No newline at end of file
diff --git a/build/lib/pdfconverter/settings/project.py b/build/lib/pdfconverter/settings/project.py
new file mode 100644
index 0000000..6020736
--- /dev/null
+++ b/build/lib/pdfconverter/settings/project.py
@@ -0,0 +1,62 @@
+"""
+---
+---
+---
+
+## Package: pdfconverter >> settings
+---
+---
+### Module Name: project
+---
+### path: "pdfconverter\\\\\\\\settings\\\\\\\\project.py"
+---
+---
+Módulo  responsável  por  definir   configurações   diretamente
+relacionadas a montagem e execução do projeto.
+
+---
+---
+---
+"""
+
+
+# [>] Geral
+import os.path
+import pathlib
+# [>] PDFConverter
+from pdfconverter.__variables__ import avar, fvar
+
+
+#region PUBLIC METHODS
+
+def SetFolderStructure():
+    """Define a estrutura atual do projeto."""
+
+    # [>] Cria uma nova pasta, caso já tenha uma chamada resultados
+    int_indexFolderCreation = 0
+    FolderSufix = ""
+    # [>] Caminho da pasta de resultados sem o sufixo
+    fvar.folderpath_Result = fvar.folderpath_Export + "\\" + fvar.foldername_Results
+    # [i] Enquanto houver uma pasta de resultados existente
+    while (os.path.isdir(fvar.folderpath_Result)):
+        int_indexFolderCreation += 1
+        # [>] Atualiza a pasta de resultados com o novo índice
+        FolderSufix = " (" + str(int_indexFolderCreation) + ")"
+        # [>] Passa o caminho da pasta de resultados, onde serão expor-
+        # tados os arquivos com um novo sufixo
+        fvar.folderpath_Result = fvar.folderpath_Export + "\\" + fvar.foldername_Results + FolderSufix
+
+    # [>] Criando pasta raíz
+    pathlib.Path(fvar.folderpath_Result).mkdir(parents = True, exist_ok = True)
+    # [i] Para cada método de leitura, presente na lista de métodos
+    # de leitura
+    for methodPath in fvar.list_ReadingPaths:
+        # [>] Cria uma pasta
+        pathlib.Path(fvar.folderpath_Result + "\\" + methodPath).mkdir(parents = True, exist_ok = True)
+        # [i] Para cada método de formatação, presente na lista de  mé-
+        # todos de formatação
+        for outputTypePath in fvar.list_FormattingPaths:
+            # [>] Cria uma pasta
+            pathlib.Path(fvar.folderpath_Result + "\\" + methodPath + "\\" + outputTypePath).mkdir(parents = True, exist_ok = True)
+
+#endregion
\ No newline at end of file
diff --git a/build/lib/pdfconverter/stringformat/__init__.py b/build/lib/pdfconverter/stringformat/__init__.py
new file mode 100644
index 0000000..5509a09
--- /dev/null
+++ b/build/lib/pdfconverter/stringformat/__init__.py
@@ -0,0 +1,238 @@
+"""
+---
+---
+---
+
+## Package: pdfconverter >> regex
+---
+---
+### Module Name: regex (Constructor, __init__)
+---
+### path: "pdfconverter\\\\\\\\regex\\\\\\\\__init__.py"
+---
+---
+Pacote e  módulo  que  guarda  algumas  funções  de  Expressões
+Regulares consigo.
+
+---
+---
+---
+"""
+
+
+# [>] Geral
+import re
+
+
+#region STRING FORMAT
+
+class stringformat:
+    """
+    Classe que manipula uma String podendo  realizar  validações  e
+    substituições.
+    """
+
+    #region CONSTRUCTOR
+
+    def __init__(self, String):
+        self.String = String
+        """Alterar Depois"""
+        self.FlagConfig = (
+            re.MULTILINE | # Faz com que os caracteres '^' e '$'  represen-
+                        # tem o início e o final da linha respectivamen-
+                        # te
+            re.VERBOSE     # Permite com que o REGEX possa ser lido com ma-
+                        # ior facilidade, com  comentários  e  separação
+                        # do mesmo por seções
+        )
+        """Configurações padrão de flag de Regex."""
+    
+    #endregion
+
+    #region PUBLIC METHODS
+
+    #region RETURN
+
+    def ReturnString(self):
+        return self.String
+
+    def ReturnFlagConfig(self):
+        return self.FlagConfig
+    
+    #endregion
+
+    #region REGEX
+
+    def RegexMatch(self, RegexPattern):
+        return re.match(RegexPattern, self.String, flags = self.FlagConfig)
+
+    def RegexSub(self, RegexPattern, NewStringValue = ""):
+        return re.sub(RegexPattern, NewStringValue, self.String, flags = self.FlagConfig)
+
+    def RegexFindall(self, RegexPattern):
+        return re.findall(RegexPattern, self.String, flags = self.FlagConfig)
+
+    #endregion
+
+    #region VALIDATION
+
+    def ValidatePageNumber(self):
+        """
+        ---
+        ---
+        ---
+
+        ### ValidatePageNumber (Public)
+        ---
+        Realiza a validação do valor como número de página.
+        
+        ---
+        ---
+        ---
+        """
+        return self.RegexMatch(
+            r"""
+                (?P<matchExactly>^
+                    (?P<matchPageNumber>
+                        (?P<singlePageNumber>\d{1,3})
+                        |
+                        (?P<multiplePageNumber>
+                            \d{1,3}
+                            -{1}
+                            \d{1,3}
+                        )
+                        |
+                        (?P<allPages>all{1})
+                    )
+                $)
+            """
+        )
+
+    def IsSmallTable(self):
+        """
+        ---
+        ---
+        ---
+        
+        ## Check (Public/Private)
+        ---
+        ---
+        Método que checa se o conteúdo:
+        - Começa com aspas duplas e termina com aspas duplas ou termina com quebra de linha;
+            - E ainda há menos que 3 aspas duplas ou menos que um ponto e vírgula
+        Retorna True
+        
+        Se a linha possui aspas duplas no início  e  no  final  e
+        ainda possui menos que duas colunas cancela o código
+
+        ### Returns
+        ---
+            [type]: [description]
+        
+        ---
+        ---
+        ---
+        """
+
+        if(
+            (
+                (
+                    self.String.startswith("\"")
+                )
+                and 
+                (
+                    self.String.endswith("\"") or self.String.endswith("\n")
+                )
+            )
+            and
+            (self.String.count("\"") <= 3 and self.String.count(";") <= 1)
+        ):
+            return True
+
+    #endregion
+
+    #region REPLACEMENT
+
+    # General
+    def Has3ColumnsOrMore(self):
+        """
+            Só escreve a linha se tiver pelo menos mais que 3 colunas
+            no arquivo fullClear
+        """
+        if (self.String.count("\"") > 6 and
+            self.String.count(";") > 2):
+            return True
+
+    # TableWithBlankCells
+    def EmptyHeader(self, NewStringValue = ""):
+        """Detecta os dados vazios que estão presentes no  cabeçalho "Unnamed: X;"."""
+
+        # return self.RegexSub(r"(\s?\"Unnamed:\s\d\d?\";?)", NewStringValue)
+        self.String = self.RegexSub(r"(\s?\"Unnamed:\s\d\d?\";?)", NewStringValue)
+
+    def MiddleLineBreak(self, NewStringValue = ""):
+        """
+            Remove quebras de linha caso seja no meio dos  dados,  ou
+            seja, caso não possua '"' atrás da quebra de linha e as subs-
+            titui por um espaço para manter o padrão
+        """
+        self.String = self.RegexSub(r"((?<!\")\n)", NewStringValue)
+
+    def EndLineSemicolon(self, NewStringValue = ""):
+        """Remove ponto e vírgula no final da linha."""
+        self.String = self.RegexSub(r"((?<=\");(?!.))", NewStringValue)
+
+    def StartLineEmptySpace(self, NewStringValue = ""):
+        """Remove todos os espaços no início de cada linha."""
+        self.String = self.RegexSub(r"(^\ *)", NewStringValue)
+
+    #  Main
+    def EmptyBody(self, NewStringValue = ""):
+        """Remove dados que estão vazios."""
+        self.String = self.RegexSub(r"(;\"\")|(\"\";)", NewStringValue)
+
+    def DoubleQuotesAdjacent(self, NewStringValue = ""):
+        """Faz uma quebra de linha caso tenha aspas duplas adjacentes"""
+        self.String = self.RegexSub(r"(?<=\")(?=\")", NewStringValue)
+
+    def SemicolonAdjacentSpace(self, NewStringValue = ""):
+        """
+            Caso tenha um ponto e vírgula seguido de um espaço  troca
+            por uma quebra de linha
+        """
+        self.String = self.RegexSub(r"((?<=\");\ )", NewStringValue)
+
+    def SpaceBetweenSeparatorAndDoubleQuote(self):
+        """
+            Caso tenha um espaço entre um separador e uma aspas dupla
+            remove o conteúdo que está atrás
+        """
+        self.String = self.RegexSub(r"((.*\";\ )(?=\"))")
+    
+    # FullClear
+    def LineNotStartsWithDoubleQuotes(self):
+        """Caso a linha não comece com aspas deleta"""
+        self.String = self.RegexSub(r"((^[^\"]).*)")
+
+    def LineNotEndsWithDoubleQuotes(self):
+        """Caso a linha não termine com aspas deleta"""
+        self.String = self.RegexSub(r"(.*([^\"\n]$))")
+
+    def LineWithLinebreakOrWithoutDoubleQuote(self):
+        # [>] Remove Linhas vazias que só possuem quebra de linha  '\n'
+        # ou não possuem uma aspas dupla em nenhum lugar, serão excluí-
+        # das 
+        lineRemovedQuotes = ""
+        lineRemovedQuotes = re.sub(r"\"", "", self.String)
+
+        # [i] Se a temporária permanece igual, ou seja, não teve  aspas
+        # duplas removidas pelo regex
+        if (self.String == lineRemovedQuotes):
+            # Quer dizer que ela ta errada e vai ser apagada
+            self.String = ""
+
+    #endregion
+
+    #endregion
+
+#endregion
\ No newline at end of file
diff --git a/build/lib/pdfconverter/terminalfile/__init__.py b/build/lib/pdfconverter/terminalfile/__init__.py
new file mode 100644
index 0000000..e3cb1a1
--- /dev/null
+++ b/build/lib/pdfconverter/terminalfile/__init__.py
@@ -0,0 +1,90 @@
+"""
+---
+---
+---
+
+## Package: pdfconverter >> terminalfile
+---
+---
+### Module Name: terminalfile (Constructor, __init__)
+---
+### path: "pdfconverter\\\\\\\\terminalfile\\\\\\\\__init__.py"
+---
+---
+Pacote e módulo responsável por realizar ações relacionadas  ao
+arquivo do terminal.
+
+---
+---
+---
+"""
+
+
+# [>] Geral
+import os
+import stat
+# [>] PDFConverter
+# [>] Variáveis
+from pdfconverter.__variables__ import fvar
+# [>] Arquivo do Terminal
+from pdfconverter.terminalfile.message import error
+
+
+#region PUBLIC METHODS
+
+def Open():
+    """Abre o arquivo do terminal dentro de uma variável global."""
+
+    fvar.file_TerminalFile = open(
+        fvar.filepath_TerminalFile,  # [i] Caminho do arquivo de saída do terminal
+        "a",                        # [i] Realiza uma adição de texto
+        encoding="UTF-8"            # [i] Codificação UTF-8
+    )
+
+def Close():
+    """
+    Realiza o fechamento do arquivo de saída do terminal. Caso ele
+    não tenha sido aberto ainda, dispara um erro pro terminal e
+    para a aplicação.
+    """
+
+    try:
+        # [>] Tenta fechar o arquivo do terminal
+        fvar.file_TerminalFile.close()
+    except AttributeError:
+        error.Show("O arquivo do terminal não pode ser fechado pois ele não foi aberto ainda.")
+    except Exception as ExceptionError:
+        error.Show("Ocorreu um erro desconhecido ao tentar realizar o  fechamento do arquivo do terminal.", ExceptionError = ExceptionError,)
+
+def Recreate():
+    """Método que recria o arquivo de saída do terminal do zero."""
+
+    try:
+        # [>] Cria e/ou limpa o arquivo de texto contendo  a  saída  do
+        # terminal
+        fvar.file_TerminalFile = open(
+            fvar.filepath_TerminalFile, # [i] Caminho do arquivo de saída do terminal
+            "w",                        # [i] Realiza uma sobrescrita de texto
+            encoding="UTF-8"            # [i] Codificação UTF-8
+        )
+    except PermissionError:
+        # [>] Caso esteja como READONLY, remove a propriedade
+        os.chmod(fvar.filepath_TerminalFile, stat.S_IWRITE)
+
+        # [>] Cria e/ou limpa o arquivo de texto contendo  a  saída  do
+        # terminal
+        fvar.file_TerminalFile = open(
+            fvar.filepath_TerminalFile, # [i] Caminho do arquivo de saída do terminal
+            "w",                        # [i] Realiza uma sobrescrita de texto
+            encoding="UTF-8"            # [i] Codificação UTF-8
+        )
+    except Exception as ExceptionError:
+        # [>] Retorna o erro
+        error.Show(
+            "Ocorreu um erro desconhecido ao tentar realizar a abertura do"
+            "arquivo de saída do terminal",
+            
+            ExceptionError = ExceptionError
+        )
+
+#endregion
\ No newline at end of file
diff --git a/build/lib/pdfconverter/terminalfile/message/__init__.py b/build/lib/pdfconverter/terminalfile/message/__init__.py
new file mode 100644
index 0000000..b131326
--- /dev/null
+++ b/build/lib/pdfconverter/terminalfile/message/__init__.py
@@ -0,0 +1,41 @@
+"""
+---
+---
+---
+
+## Package: pdfconverter >> terminalfile >> message
+---
+---
+### Module Name: message (Constructor, __init__)
+---
+### path: "pdfconverter\\\\\\\\terminalfile\\\\\\\\message\\\\\\\\__init__.py"
+---
+---
+Pacote e módulo responsável pelo envio de mensagens ao terminal.
+
+---
+---
+---
+"""
+
+
+# [>] PDFConverter
+# [i] Variáveis
+from pdfconverter.__variables__ import fvar
+# [i] Arquivo do Terminal
+from pdfconverter import terminalfile
+
+
+#region PUBLIC METHODS
+
+def Show(Message):
+    # [>] Abre o arquivo de saída do terminal
+    terminalfile.Open()
+
+    # [>] Exibe a mensagem pro arquivo do terminal
+    print(Message, file = fvar.file_TerminalFile)
+
+    # [>] Fecha o arquivo de saída do terminal
+    terminalfile.Close()
+
+#endregion
\ No newline at end of file
diff --git a/build/lib/pdfconverter/terminalfile/message/design.py b/build/lib/pdfconverter/terminalfile/message/design.py
new file mode 100644
index 0000000..7b2f94c
--- /dev/null
+++ b/build/lib/pdfconverter/terminalfile/message/design.py
@@ -0,0 +1,76 @@
+"""
+---
+---
+---
+
+## Package: pdfconverter >> terminalfile >> message
+---
+---
+### Module Name: design
+---
+### path: "pdfconverter\\\\\\\\terminalfile\\\\\\\\message\\\\\\\\design.py"
+---
+---
+Módulo responsável por armazenar alguns  itens  relacionados  à
+montagem de design do arquivo do terminal.
+
+---
+---
+---
+"""
+
+# [>] Geral
+import pandas
+# [>] PDFConverter
+# [i] Variáveis
+from pdfconverter.__variables__ import fvar, vvar
+# [i] Arquivo do Terminal
+from pdfconverter.terminalfile import message
+
+
+#region PUBLIC METHODS
+
+
+def PDFTitle(filefullname_PDF):
+    """Layout para exibição de conteúdo em forma de texto. \n\nRealiza a exibição do cabeçalho do PDF que está sendo lido. Necessário informar o nome do PDF para que o layout seja disponibilizado.
+
+    Args:
+        filefullname_PDF ([type]): [description]
+    """
+
+    # [>] Cria o título para leitura do arquivo no terminal
+    message.Show(
+        filefullname_PDF + vvar.GiantLine + "\n" +
+        vvar.GiantLine + "\n\n\n\n" +
+        vvar.BlankSpaces + "                          ----- + -----\n\n" +
+        vvar.BlankSpaces + "         LEITURA DE ARQUIVO - NÚMERO " + str(fvar.counter_PdfFile) + ", '" + filefullname_PDF + "'\n" +
+        vvar.BlankSpaces + "   O arquivo '" + fvar.filename_PDF + "' foi lido e está pronto pra ser convertido\n\n" +
+        vvar.BlankSpaces + "                          ----- + -----\n\n\n\n"
+    )
+
+
+def CloseLayout(LastLayout):
+    """Fecha o leiaute referente ao arquivo anterior.
+    """
+
+    # [>] Design de fechamento de layout
+    design = "\n" + vvar.GiantLine + "\n" + vvar.GiantLine
+
+    # [>] Se não for o último layout do terminal coloca 10  espaços
+    # para realizar a separação
+    if (not LastLayout): design += "\n\n\n\n\n\n\n\n\n\n"
+
+    # [>] Fecha o leiaute referente ao arquivo anterior
+    message.Show(design)
+
+def WithoutFormattingConversionTitle(ReadingMethod, TableDataFrame):
+    message.Show(
+            "\n\n"
+            "          A tabela nº"+ str(fvar.counter_DataFrame) + " do '" + fvar.filename_PDF + "' foi convertida usando '" + ReadingMethod + "'\n"
+            "\________________________________________________________________________________/\n" +
+            "Search this (Ctrl + F): '" + fvar.filename_PDF + " " + ReadingMethod + " tbl" + str(fvar.counter_DataFrame) + "'\n"
+            "\n" +
+            str(pandas.DataFrame(TableDataFrame))
+    )
+
+#endregion
\ No newline at end of file
diff --git a/build/lib/pdfconverter/terminalfile/message/error.py b/build/lib/pdfconverter/terminalfile/message/error.py
new file mode 100644
index 0000000..2c91f0e
--- /dev/null
+++ b/build/lib/pdfconverter/terminalfile/message/error.py
@@ -0,0 +1,62 @@
+"""
+---
+---
+---
+
+## Package: pdfconverter >> terminalfile >> message
+---
+---
+### Module Name: error
+---
+### path: "pdfconverter\\\\\\\\terminalfile\\\\\\\\message\\\\\\\\error.py"
+---
+---
+Módulo responsável por comportar funções que  mandam  relatório
+de erros formatados para o terminal.
+
+---
+---
+---
+"""
+# [>] PDFConverter
+# [i] Arquivo do Terminal
+from pdfconverter import terminalfile
+from pdfconverter.terminalfile import message
+# [i] Program
+from pdfconverter import program
+from pdfconverter.program import utilities
+
+
+#region PUBLIC METHODS
+
+def Show(ErrorMessage, ExceptionError = "", ExitProgram = True, RecreateTerminalFile = True):
+    # [>] Caso solicitado, recria o arquivo de saída do terminal
+    if (RecreateTerminalFile): terminalfile.Recreate()
+
+    # [>] Justifica o conteúdo da mensagem corretamente
+    ErrorMessage = utilities.JustifyText(ErrorMessage, 58)
+    # [>] Justifica o conteúdo da mensagem de exceção corretamente
+    ExceptionError = utilities.JustifyText(ExceptionError, 58)
+
+    # [>] Exibe a mensagem
+    message.Show(
+        "=============================================================\n"
+        "                                                             \n"
+        "                                                             \n"
+        "MENSAGEM DE RETORNO                                          \n"
+        "-------------------------------------------------------------\n"
+        "<d>" + ErrorMessage + "</d>\n"
+        ">>>>>>>>>>>>>>>>>>>>>>>>>>>>>> <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<\n"
+        "<e>" + ExceptionError + "</e>\n"
+        ">>>>>>>>>>>>>>>>>>>>>>>>>>>>>> <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<\n"
+        "-------------------------------------------------------------\n"
+        "                                                             \n"
+        "                                                             \n"
+        "=============================================================\n"
+    )
+
+    # [>] Caso solicitado, após exibir o erro para  a  execução  do
+    # programa
+    if (ExitProgram): program.Exit()
+
+#endregion
\ No newline at end of file
diff --git a/pdfconverter.py b/pdfconverter.py
index f91b9b7..670162b 100644
--- a/pdfconverter.py
+++ b/pdfconverter.py
@@ -1,26 +1,3 @@
-"""
----
----
----
-
-## Package: pdfconverter
----
----
-### Module Name: __main__
----
-### path: "pdfconverter\\\\\\\\__main__.py"
----
----
-Módulo delimitado como  escopo  do  projeto,  atualmente,  é  o
-módulo inicializado por padrão dentro do  Workspace  do  Visual
-Code, quando pressionada a tecla 'F5', por exemplo.
-
----
----
----
-"""
-
-
 # [>] Geral
 import pathlib
 # [>] PDFConverter
@@ -63,6 +40,7 @@
 # >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
 # -------------------------------------------------------------
 
+
 # [>] Executa  a   função   armazenada   dentro   da   variável
 # ConversionStart, a função foi atribuída no momento em que foi
 # realizada a validação do argumento 'ImportPath' no módulo  de
diff --git a/pdfconverter/__main__.py b/pdfconverter/__main__.py
index e69de29..430d216 100644
--- a/pdfconverter/__main__.py
+++ b/pdfconverter/__main__.py
@@ -0,0 +1,21 @@
+"""
+---
+---
+---
+
+## Package: pdfconverter
+---
+---
+### Module Name: __main__
+---
+### path: "pdfconverter\\\\\\\\__main__.py"
+---
+---
+Módulo delimitado como  escopo  do  projeto,  atualmente,  é  o
+módulo inicializado por padrão dentro do  Workspace  do  Visual
+Code, quando pressionada a tecla 'F5', por exemplo.
+
+---
+---
+---
+"""
\ No newline at end of file
diff --git a/pdfconverter/__pycache__/pdfconverter.cpython-39.pyc b/pdfconverter/__pycache__/pdfconverter.cpython-39.pyc
new file mode 100644
index 0000000..487322a
Binary files /dev/null and b/pdfconverter/__pycache__/pdfconverter.cpython-39.pyc differ
diff --git a/pdfconverter/__variables__.py b/pdfconverter/__variables__.py
index a23d58c..9700816 100644
--- a/pdfconverter/__variables__.py
+++ b/pdfconverter/__variables__.py
@@ -22,8 +22,6 @@
 
 #region VARIABLES
 
-#region MANAGEMENT
-
 class mvar:
     """
     ---
@@ -53,10 +51,6 @@ class mvar:
     argumentos "argument"
     """
 
-#endregion
-
-#region GENERAL
-
 class avar:
     """
     ---
@@ -74,6 +68,21 @@ class avar:
     ---
     """
 
+    patternColumnArgs = [
+        "Lote",
+        "Ordem",
+        "Codigo",
+        "Produto",
+        "Unidade",
+        "Quantidade",
+        "ValorMedio"
+    ]
+    """
+    Todos os argumentos que são relacionados à alterar  as  colunas
+    padrão dentro de uma array.
+    """
+
+    #region PARSER
     parser_Main = None
     """Variável que vai ser responsável por criar o parser."""
     parser_ArgsMain = None
@@ -81,6 +90,41 @@ class avar:
     Variável que vai ser responsável por fazer  a  manipulação  dos
     argumentos dados.
     """
+    #endregion
+
+    #region USER ARGS
+    path_ImportArg = ""
+    """
+    Caminho de importação com o valor fornecido pelo usuário.
+    """
+    path_ExportArg = ""
+    """
+    Caminho de exportação  com  o  valor  fornecido  pelo  usuário.
+    Atualmente esse valor apenas pode ser uma referência de pasta
+    """
+    readPDFPagesArg = "all"
+    """Páginas que vão ser lidas para realizar a conversão."""
+    FormattingMethodArg = ""
+    """Tipos de formatação escolhidos."""
+    #endregion
+
+    #region ARGS DEFAULT VALUES
+    argName = ""
+    """Nome do argumento."""
+    defaultValue = None
+    """Valor que vem por padrão no argumento."""
+    nargsValue = '?'
+    """
+    Variável  que  define  o  número  de  valores  suportado   pelo
+    argumento, além de poder definir um  número  que  representa  a
+    quantidade em si, também é possível definir:
+    - '+' == 1 ou mais;
+    - '*' == 0 ou mais;
+    - '?' == 0 or 1.
+    """
+    contentType = str
+    """Tipo de valor do argumento."""
+    #endregion
 
 class cvar:
     """
@@ -123,88 +167,120 @@ class fvar:
     ---
     """
 
-    filename_PDF = ""
+    #region CONFIG
+    folderpath_Script = ""
+    """Caminho da pasta do arquivo de script que está sendo executado."""
+    
+    file_TerminalFile = ""
+    """Variável que armazena o arquivo de saída do terminal em si."""
+    filepath_TerminalFile = ""
+    """Caminho para o arquivo do terminal."""
+
+    filepath_RelatoryFile = ""
+    """Caminho para o arquivo que mostrará o relatório preliminar."""
+    filepath_PatternColumns = ""
+    """Caminho para o arquivo que mostrará as colunas no padrão."""
+    #endregion
+
+    #region CONVERSION
+
+    #region START
+
+    #region FOLDER AND FILES INFO
+    folderpath_Import = ""
     """
-    Nome do arquivo PDF que vai ser convertido  (sem a extensão).
+    Caminho da pasta de importação onde os  arquivos  PDF  vão  ser
+    alocados.
     """
-    folderpath_Script = ""
+    folderpath_Export = ""
     """
-    Caminho atual para a raiz do projeto (os outros caminhos vão se
-    basear nele).
+    Caminho da pasta de exportação onde os arquivos  de  saída  vão
+    ser alocados.
     """
-    path_Import = ""
+    folderpath_Result = ""
+    """Caminho da pasta de resultados."""
+
+    quantity_ImportedFiles = ""
     """
-    Caminho da pasta de importação onde os  arquivos  PDF  vão  ser
-    alocados.
+    Variável  que  armazena  a  contagem  de  arquivos  que   serão
+    importados.
     """
-    path_Export = ""
+    quantity_ExportedFiles = ""
     """
-    Caminho da pasta onde os arquivos exportação vão ser alocados.
+    Variável  que  armazena  a  contagem  de  arquivos  que   serão
+    exportados.
     """
-    filepath_TerminalFile = ""
-    """Caminho para o arquivo do terminal."""
-    filepath_ExportTxt = ""
+    #endregion
+    
+    #endregion
+
+    #region RUNTIME
+
+    #region CURRENT PDF INFO
+    filename_PDF = ""
+    """
+    Nome do arquivo PDF que vai ser convertido  (sem a extensão).
+    """
+    counter_PdfFile = 0
+    """
+    Contador do 'For' que manipula a conversão  dos  arquivos  PDF.
+    Conta os arquivos PDFs convertidos.
+    """
+    #endregion
+
+    #region WITHOUT FORMATTING INFO
+    filepath_WithoutFormatting = ""
     """
     Caminho do arquivo de texto que vai ser gerado pelo PDF que vai
     ser convertido.
     """
-    file_TerminalFile = ""
-    """Variável que armazena o arquivo de saída do Terminal."""
-    readPDFPages = "all"
-    """Páginas que vão ser lidas para realizar a conversão."""
+    counter_DataFrame = 0
+    """
+    Contador do 'For' que manipula o DataFrame que vai ser  passado
+    para o arquivo sem formatação.
+    """
+    #endregion
 
-    
-    rootPath = "\\resultados"
+    #region FILE PATHS FORMATTING TYPES
+    filepath_TableWithBlankCells = ""
+    """Formatação TableWithBlankCells."""
+    filepath_Main = ""
+    """Formatação Main."""
+    filepath_FullClear = ""
+    """Formatação FullClear."""
+    #endregion
+
+    #endregion
+
+    #region FOLDER STRUCTURE
+    foldername_Result = "resultados"
     """
     Caminhos que indicam a localização das pastas raíz que irão ser
     geradas futuramente.
     """
-    list_readingPaths = [
-        "\\lattice",
-        "\\stream"
+    list_ReadingPaths = [
+        "lattice",
+        "stream"
     ]
     """
     Caminhos que indicam a localização das pastas  dos  métodos  de
     leitura que vão ser geradas  futuramente  dentro  da  pasta  de
     exportação.
     """
-    list_formattingPaths = [
-        "\\main",
-        "\\fullClear",
-        "\\tableWithBlankCells",
-        "\\withoutFormatting"
+    list_FormattingPaths = [
+        "main",
+        "fullClear",
+        "tableWithBlankCells",
+        "withoutFormatting"
     ]
     """
     Caminhos que indicam a localização das pastas  dos  métodos  de
     formatação que vão ser geradas futuramente  dentro  das  pastas
     de métodos de leitura, que estão dentro da pasta de exportação.
     """
+    #endregion
 
-    tableWithBlankCells_OutputTxt = ""
-    main_OutputTxt = ""
-    fullclear_OutputTxt = ""
-
-class ivar:
-    """
-    ---
-    ---
-    ---
-    
-    ## Index Variables (ivar)
-    ---
-    ---
-    Variáveis relacionadas à indexação que realizam  iterações  nos
-    loops.
-    
-    ---
-    ---
-    ---
-    """
-
-    DataFrame = 0
-    """Índice do 'For' que manipula o Data Frame."""
-    PdfFile = 0
-    """Índice do 'For' que manipula os arquivos PDF."""
+    #endregion
 
 class pvar:
     """
@@ -221,32 +297,38 @@ class pvar:
     ---
     ---
     """
-    
-    list_columnFieldsToChange = []
+
+    list_UserGivenColumnToChange = []
     """
     Variável que vai segurar e possuir todos os argumentos
     que o usuário quer que altere nas colunas.
     """
 
-    lote = [
+    #region COLUMN MAPPING
+
+    #region SORTED BY COLUMN
+    lote =\
+        [
         '--Lote',
         'lote'
-    ]
+        ]
     """Lote."""
-    ordem = [
+    ordem =\
+        [
         '--Ordem',
         'ordem',
         'item',
         'nº item'
-    ]
+        ]
     """Ordem (Sequencial)."""
-    codigo = [
+    codigo =\
+        [
         '--Codigo',
         'codigo',
         'código',
         'cód',
-        'cod. produto',
-    ]
+        'cod. produto'
+        ]
     """Código."""
     descricao = [
         '--Produto',
@@ -266,10 +348,10 @@ class pvar:
         'medicamento',
         'objeto/medicamento',
         'produto - especificação',
-        'especificações técnicas'
-    ]
+        'especificações técnicas']
     """Descrição."""
-    unidade = [
+    unidade =\
+        [
         '--Unidade',
         'unidade',
         'un',
@@ -280,9 +362,10 @@ class pvar:
         'u/m',
         'apresentação',
         'especificação'
-    ]
+        ]
     """Unidade."""
-    quantidade = [
+    quantidade =\
+        [
         '--Quantidade',
         'quantidade',
         'qtd',
@@ -293,9 +376,10 @@ class pvar:
         'qntd',
         'qntd.',
         'quant.'
-    ]
+        ]
     """Quantidade."""
-    valormedio = [
+    valormedio =\
+        [
         '--ValorMedio',
         'valormedio',
         'prev. custo unit. (r$)',
@@ -306,11 +390,13 @@ class pvar:
         'valor médio',
         'valor médio unitário r$',
         'estimado unitário'
-    ]
+        ]
     """Valor Médio."""
+    #endregion
 
+    #region ALL
     StoredColumns = []
-    """Todos as recomendações de colunas agrupadas."""
+    """Todas as recomendações de colunas agrupadas."""
     StoredColumns.extend((
         lote,
         ordem,
@@ -319,7 +405,10 @@ class pvar:
         unidade,
         quantidade,
         valormedio
-    )) 
+    ))
+    #endregion
+
+    #endregion
 
 class vvar:
     """
@@ -368,6 +457,4 @@ class vvar:
     Existem 168 espaços.
     """
 
-#endregion
-
 #endregion
\ No newline at end of file
diff --git a/pdfconverter/_backup/argument.py b/pdfconverter/_backup/argument.py
index 2235823..94eb6d4 100644
--- a/pdfconverter/_backup/argument.py
+++ b/pdfconverter/_backup/argument.py
@@ -1,66 +1,66 @@
-from terminalfile.message import error
-from program import utilities
-from __variables__ import fvar
+# from terminalfile.message import error
+# from program import utilities
+# from __variables__ import fvar
 
 
-def __ValidateImpExpPathsArgs():
-    """
-    ---
-    ---
-    ---
+# def __ValidateImpExpPathsArgs():
+#     """
+#     ---
+#     ---
+#     ---
     
-    ## __ValidateImpExpPathsArgs (Private)
-    ---
-    ---
-    Método que valida os caminhos de importação e exportação passa-
-    dos nos argumentos.
+#     ## __ValidateImpExpPathsArgs (Private)
+#     ---
+#     ---
+#     Método que valida os caminhos de importação e exportação passa-
+#     dos nos argumentos.
     
-    ---
-    ---
-    ---
-    """
+#     ---
+#     ---
+#     ---
+#     """
 
-    # [>] Valida os caminhos de importação e exportação fornecidos
-    for pathType in ("import", "export"):
-        # [>] Chama a variável de argumento de acordo com a ação reali-
-        # zada
-        # [i] Deve ser feito desse jeito pois a variável é uma variável
-        # de argumento
-        pathArgValue = getattr(avar.parser_ArgsMain, pathType.capitalize() + "Path")
+#     # [>] Valida os caminhos de importação e exportação fornecidos
+#     for pathType in ("import", "export"):
+#         # [>] Chama a variável de argumento de acordo com a ação reali-
+#         # zada
+#         # [i] Deve ser feito desse jeito pois a variável é uma variável
+#         # de argumento
+#         pathArgValue = getattr(avar.parser_ArgsMain, pathType.capitalize() + "Path")
 
-        try:
-            # [i] Caso a pasta de acordo com a ação realizada exista
-            if (utilities.CheckIfFolderExists(pathArgValue)):
-                # [>] Passa para as variáveis globais de acordo com a ação rea-
-                # lizada
-                setattr(fvar, "folderpath_" + pathType.capitalize(), pathArgValue)
-            # [i] Caso não foram passados valores nos argumentos..
-            elif (pathArgValue == None):
-                # [>] ..de importação
-                if (pathType == "import"):
-                    # [i] Exibe uma mensagem de erro mostrando que é obrigatório  a
-                    # inserção do caminho de importação
-                    error.Show(
-                        "É necessário colocar um valor para o caminho  de  importação,"
-                        "'--ImportPath <caminho_de_exportação>'.",
+#         try:
+#             # [i] Caso a pasta de acordo com a ação realizada exista
+#             if (utilities.CheckIfFolderExists(pathArgValue)):
+#                 # [>] Passa para as variáveis globais de acordo com a ação rea-
+#                 # lizada
+#                 setattr(fvar, "folderpath_" + pathType.capitalize(), pathArgValue)
+#             # [i] Caso não foram passados valores nos argumentos..
+#             elif (pathArgValue == None):
+#                 # [>] ..de importação
+#                 if (pathType == "import"):
+#                     # [i] Exibe uma mensagem de erro mostrando que é obrigatório  a
+#                     # inserção do caminho de importação
+#                     error.Show(
+#                         "É necessário colocar um valor para o caminho  de  importação,"
+#                         "'--ImportPath <caminho_de_exportação>'.",
                         
-                        ExitProgram = True
-                    )
-                # [>] ..de exportação
-                else:
-                    # [i] Recebe o caminho da pasta de importação  como  referência
-                    # para o caminho de exportação
-                    fvar.folderpath_Export = fvar.folderpath_Import
-            # Caso a pasta de acordo com a ação realizada não exista
-            else:
-                error.Show("A pasta de " + pathType + "ação ('" + pathArgValue + "') informada não existe.", ExitProgram = True)
-        # [>] Quando ocorre erro desconhecido
-        except Exception as ExceptionError:
-            # [>] Exibe uma mensagem de erro
-            error.Show(
-                "Ocorreu um erro desconhecido ao tentar receber os argumentos "
-                "dos caminhos de importação e exportação.",
+#                         ExitProgram = True
+#                     )
+#                 # [>] ..de exportação
+#                 else:
+#                     # [i] Recebe o caminho da pasta de importação  como  referência
+#                     # para o caminho de exportação
+#                     fvar.folderpath_Export = fvar.folderpath_Import
+#             # Caso a pasta de acordo com a ação realizada não exista
+#             else:
+#                 error.Show("A pasta de " + pathType + "ação ('" + pathArgValue + "') informada não existe.", ExitProgram = True)
+#         # [>] Quando ocorre erro desconhecido
+#         except Exception as ExceptionError:
+#             # [>] Exibe uma mensagem de erro
+#             error.Show(
+#                 "Ocorreu um erro desconhecido ao tentar receber os argumentos "
+#                 "dos caminhos de importação e exportação.",
 
-                ExceptionError = ExceptionError,
-                ExitProgram = True
-            )
\ No newline at end of file
+#                 ExceptionError = ExceptionError,
+#                 ExitProgram = True
+#             )
\ No newline at end of file
diff --git a/pdfconverter/_backup/code.py b/pdfconverter/_backup/code.py
index 9bca41e..c2b911f 100644
--- a/pdfconverter/_backup/code.py
+++ b/pdfconverter/_backup/code.py
@@ -1,53 +1,53 @@
-# [B] CHAMADA DE BIBLIOTECAS
-# -------------------------------------------------------------
-# Descrição:
-# Chamada de todas as bibliotecas do Script.
-# >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
-import os
-import re
-import sys
-import csv
-import stat
-import pandas
-import argparse
-import tabula
-from glob import glob
-from pathlib import Path
-# >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
-# -------------------------------------------------------------
+# # [B] CHAMADA DE BIBLIOTECAS
+# # -------------------------------------------------------------
+# # Descrição:
+# # Chamada de todas as bibliotecas do Script.
+# # >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
+# import os
+# import re
+# import sys
+# import csv
+# import stat
+# import pandas
+# import argparse
+# import tabula
+# from glob import glob
+# from pathlib import Path
+# # >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
+# # -------------------------------------------------------------
 
-# Caso tentar fazer a implementação desse tratamento de  volta,
-# olhar bem se da pra encaixar ou se precisa fazer alteração, e
-# não esquecer de remover o import atual
+# # Caso tentar fazer a implementação desse tratamento de  volta,
+# # olhar bem se da pra encaixar ou se precisa fazer alteração, e
+# # não esquecer de remover o import atual
 
-# [B] CHAMADA DA BIBLIOTECA TABULA
-# -------------------------------------------------------------
-# Descrição:
-# Tentativa de importação da biblioteca tabula.
-# >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
-# [>] Tentando importar a biblioteca externa Tabula
-try:
-    import tabula
-# [i] Caso haja algum erro relacionado à importação
-except ImportError as exceptionError:
-    from terminalfile.message import error
-    # [>] Exibe uma mensagem de erro
-    error.Show(
-        "Ocorreu um erro ao tentar importar a biblioteca tabula durant"
-        "e a inicialização do Script.\n"
-        "\n"
-        "Se você está executando ou chamando o Script PDFConverter pel"
-        "o executável, observe se a biblioteca tabula está em 'dist\pd"
-        "fconverter'.\n"
-        "Você pode copiar a pasta do tabula em:\n"
-        "'C:\\Users\\<YourUser>\\AppData\\Local\\Programs\\Python\\Pyt"
-        "hon39\\Lib\\site-packages'.\n"
-        "\n"
-        "Se você está chamando o Script diretamente pela extensão '.py"
-        "', então talvez você esqueceu de fazer referência à bibliotec"
-        "a ou de adicionar a mesma às variáveis ambiente?",
+# # [B] CHAMADA DA BIBLIOTECA TABULA
+# # -------------------------------------------------------------
+# # Descrição:
+# # Tentativa de importação da biblioteca tabula.
+# # >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
+# # [>] Tentando importar a biblioteca externa Tabula
+# try:
+#     import tabula
+# # [i] Caso haja algum erro relacionado à importação
+# except ImportError as exceptionError:
+#     from terminalfile.message import error
+#     # [>] Exibe uma mensagem de erro
+#     error.Show(
+#         "Ocorreu um erro ao tentar importar a biblioteca tabula durant"
+#         "e a inicialização do Script.\n"
+#         "\n"
+#         "Se você está executando ou chamando o Script PDFConverter pel"
+#         "o executável, observe se a biblioteca tabula está em 'dist\pd"
+#         "fconverter'.\n"
+#         "Você pode copiar a pasta do tabula em:\n"
+#         "'C:\\Users\\<YourUser>\\AppData\\Local\\Programs\\Python\\Pyt"
+#         "hon39\\Lib\\site-packages'.\n"
+#         "\n"
+#         "Se você está chamando o Script diretamente pela extensão '.py"
+#         "', então talvez você esqueceu de fazer referência à bibliotec"
+#         "a ou de adicionar a mesma às variáveis ambiente?",
     
-        exitProgram = True
-    )
-# >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
-# -------------------------------------------------------------
\ No newline at end of file
+#         exitProgram = True
+#     )
+# # >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
+# # -------------------------------------------------------------
\ No newline at end of file
diff --git a/pdfconverter/_backup/format.py b/pdfconverter/_backup/format.py
index b4f4475..26ff224 100644
--- a/pdfconverter/_backup/format.py
+++ b/pdfconverter/_backup/format.py
@@ -1,204 +1,204 @@
-"""
----
----
----
-
-## Package: pdfconverter >> conversion
----
----
-### Module Name: format
----
-### path: "pdfconverter\\\\\\\\conversion\\\\\\\\format.py"
----
----
-Módulo comportando funções relacionadas à formatação.
-
----
----
----
-"""
-
-# [>] Geral
-import re
-# [>] PDFConverter
-# [i] Variáveis
-from pdfconverter.__variables__ import fvar
-
-
-#region PUBLIC METHODS
-
-# [>] Inicia a formatação dos arquivos de texto
-def Start(ReadingMethod):
-    """
-    ---
-    ---
-    ---
-
-    ### Start (Public)
-    ---
-    Inicia a formatação dos arquivos de texto.
-
-    Args:
-        ReadingMethod ([type]): [description]
+# """
+# ---
+# ---
+# ---
+
+# ## Package: pdfconverter >> conversion
+# ---
+# ---
+# ### Module Name: format
+# ---
+# ### path: "pdfconverter\\\\\\\\conversion\\\\\\\\format.py"
+# ---
+# ---
+# Módulo comportando funções relacionadas à formatação.
+
+# ---
+# ---
+# ---
+# """
+
+# # [>] Geral
+# import re
+# # [>] PDFConverter
+# # [i] Variáveis
+# from pdfconverter.__variables__ import fvar
+
+
+# #region PUBLIC METHODS
+
+# # [>] Inicia a formatação dos arquivos de texto
+# def Start(ReadingMethod):
+#     """
+#     ---
+#     ---
+#     ---
+
+#     ### Start (Public)
+#     ---
+#     Inicia a formatação dos arquivos de texto.
+
+#     Args:
+#         ReadingMethod ([type]): [description]
  
-    ---
-    ---
-    ---
-    """
-
-    # [C] CAMINHOS
-    # -------------------------------------------------------------
-    # Descrição:
-    # Variáveis que armazenam caminhos dos tipos de formatação.
-    # >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
-    # [i] Formatação padrão, apenas exibindo caso e caso  tenha pe-
-    # lo menos um separador ";" na linha e removendo campos vazios
-    txtMainPath = fvar.folderpath_Export + fvar.rootPath + "\\" + ReadingMethod + "\\main\\" + fvar.filename_PDF + ".txt"
-    # [i] Formatação padrão, porém mantendo campos vazios
-    txtReturnBlankCellsPath = fvar.folderpath_Export + fvar.rootPath + "\\" + ReadingMethod + "\\tableWithBlankCells\\" + fvar.filename_PDF + ".txt"
-    # [i] Full Clear, formatação mais robusta
-    txtFullClearPath = fvar.folderpath_Export + fvar.rootPath + "\\" + ReadingMethod + "\\fullClear\\" + fvar.filename_PDF + ".txt"
-    # >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
-    # -------------------------------------------------------------
-
-    # >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
-    # -------------------------------------------------------------
-
-
-    # [i] Abre o arquivo original presente na pasta 'withoutFormat-
-    # ting' para criar formatações baseadas nele
-    with open(fvar.filepath_ExportTxt, "r", encoding="UTF-8") as txtFile:
-        # ARQUIVOS
-        # -------------------------------------------------------------
-        # Descrição:
-        # Arquivo para caso a tabela possua itens vazios  que  precisam
-        # ser computados (esse arquivo apenas não terá o regex que apa-
-        # ga dados vazios e similares)
-        # >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
-        # [>] Abre o arquivo de texto "tableWithBlankCells"
-        txtTableWithBlankCells = open(txtReturnBlankCellsPath, "a", encoding="UTF-8")
-        # [>] Abre o arquivo principal (ainda não totalmente pronto pa-
-        # ra ser jogado em uma tabela possui mais dados, porém estrutu-
-        # ra ainda não tão idealizada)
-        txtMainFile = open(txtMainPath, "a", encoding="UTF-8")
-        # >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
-        # -------------------------------------------------------------
-
-        # [i] Navega por cada linha do documento de texto
-        for line in txtFile:
-            # [>] Detecta os dados vazios que estão presentes no  cabeçalho
-            # "Unnamed: X;"
-            line = re.sub(r"(\s?\"Unnamed:\s\d\d?\";?)", "", line)
-
-            # [>] Remove quebras de linha caso seja no meio dos  dados,  ou
-            # seja, caso não possua '"' atrás da quebra de linha e as subs-
-            # titui por um espaço para manter o padrão
-            line = re.sub(r"((?<!\")\n)", " ", line)
-
-            # Condicional que impede o continuamento do processo caso a va-
-            # riável esteja vazia, ou seja, caso tenha  sido  apagada  pelo
-            # processo anterior de limpeza
-            if (line != ""):
-                # [>] Remove ponto e vírgula no final da linha
-                line = re.sub(r"((?<=\");(?!.))", "", line)
+#     ---
+#     ---
+#     ---
+#     """
+
+#     # [C] CAMINHOS
+#     # -------------------------------------------------------------
+#     # Descrição:
+#     # Variáveis que armazenam caminhos dos tipos de formatação.
+#     # >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
+#     # [i] Formatação padrão, apenas exibindo caso e caso  tenha pe-
+#     # lo menos um separador ";" na linha e removendo campos vazios
+#     txtMainPath = fvar.folderpath_Export + fvar.rootPath + "\\" + ReadingMethod + "\\main\\" + fvar.filename_PDF + ".txt"
+#     # [i] Formatação padrão, porém mantendo campos vazios
+#     txtReturnBlankCellsPath = fvar.folderpath_Export + fvar.rootPath + "\\" + ReadingMethod + "\\tableWithBlankCells\\" + fvar.filename_PDF + ".txt"
+#     # [i] Full Clear, formatação mais robusta
+#     txtFullClearPath = fvar.folderpath_Export + fvar.rootPath + "\\" + ReadingMethod + "\\fullClear\\" + fvar.filename_PDF + ".txt"
+#     # >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
+#     # -------------------------------------------------------------
+
+#     # >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
+#     # -------------------------------------------------------------
+
+
+#     # [i] Abre o arquivo original presente na pasta 'withoutFormat-
+#     # ting' para criar formatações baseadas nele
+#     with open(fvar.filepath_ExportTxt, "r", encoding="UTF-8") as txtFile:
+#         # ARQUIVOS
+#         # -------------------------------------------------------------
+#         # Descrição:
+#         # Arquivo para caso a tabela possua itens vazios  que  precisam
+#         # ser computados (esse arquivo apenas não terá o regex que apa-
+#         # ga dados vazios e similares)
+#         # >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
+#         # [>] Abre o arquivo de texto "tableWithBlankCells"
+#         txtTableWithBlankCells = open(txtReturnBlankCellsPath, "a", encoding="UTF-8")
+#         # [>] Abre o arquivo principal (ainda não totalmente pronto pa-
+#         # ra ser jogado em uma tabela possui mais dados, porém estrutu-
+#         # ra ainda não tão idealizada)
+#         txtMainFile = open(txtMainPath, "a", encoding="UTF-8")
+#         # >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
+#         # -------------------------------------------------------------
+
+#         # [i] Navega por cada linha do documento de texto
+#         for line in txtFile:
+#             # [>] Detecta os dados vazios que estão presentes no  cabeçalho
+#             # "Unnamed: X;"
+#             line = re.sub(r"(\s?\"Unnamed:\s\d\d?\";?)", "", line)
+
+#             # [>] Remove quebras de linha caso seja no meio dos  dados,  ou
+#             # seja, caso não possua '"' atrás da quebra de linha e as subs-
+#             # titui por um espaço para manter o padrão
+#             line = re.sub(r"((?<!\")\n)", " ", line)
+
+#             # Condicional que impede o continuamento do processo caso a va-
+#             # riável esteja vazia, ou seja, caso tenha  sido  apagada  pelo
+#             # processo anterior de limpeza
+#             if (line != ""):
+#                 # [>] Remove ponto e vírgula no final da linha
+#                 line = re.sub(r"((?<=\");(?!.))", "", line)
                 
-                # [>] Remove todos os espaços no início de cada linha
-                line = re.sub(r"(^\ *)", "", line)
-
-                # [i] Se a linha possui aspas duplas no início  e  no  final  e
-                # ainda possui menos que duas colunas cancela o código
-                if (
-                    (
-                        (
-                            line.startswith("\"")
-                        )
-                        and 
-                        (
-                            line.endswith("\"") or line.endswith("\n")
-                        )
-                    )
-                    and
-                    (line.count("\"") < 3 and line.count(";") < 1)
-                ):
-                    # [>] Não executa o código seguinte
-                    continue
-
-                # [e] Exportação para a pasta: \\tableWithBlankCells
-                txtTableWithBlankCells.write(line)
+#                 # [>] Remove todos os espaços no início de cada linha
+#                 line = re.sub(r"(^\ *)", "", line)
+
+#                 # [i] Se a linha possui aspas duplas no início  e  no  final  e
+#                 # ainda possui menos que duas colunas cancela o código
+#                 if (
+#                     (
+#                         (
+#                             line.startswith("\"")
+#                         )
+#                         and 
+#                         (
+#                             line.endswith("\"") or line.endswith("\n")
+#                         )
+#                     )
+#                     and
+#                     (line.count("\"") < 3 and line.count(";") < 1)
+#                 ):
+#                     # [>] Não executa o código seguinte
+#                     continue
+
+#                 # [e] Exportação para a pasta: \\tableWithBlankCells
+#                 txtTableWithBlankCells.write(line)
                 
-                # [>] Remove dados que estão vazios
-                line = re.sub(r"(;\"\")|(\"\";)", "", line)
-
-                # [>] Faz uma quebra de linha caso tenha aspas duplas  adjacen-
-                # tes
-                line = re.sub(r"(?<=\")(?=\")", "\n", line)
-
-                # [>] Caso tenha um ponto e vírgula seguido de um espaço  troca
-                # por uma quebra de linha
-                line = re.sub(r"((?<=\");\ )", "\n", line)
-
-                # [>] Caso tenha um espaço entre um separador e uma aspas dupla
-                # remove o conteúdo que está atrás
-                line = re.sub(r"((.*\";\ )(?=\"))", "", line)
-
-                # [i] Se a linha possui aspas duplas no início  e  no  final  e
-                # ainda possui menos que duas colunas cancela o código
-                if (
-                    (
-                        (
-                            line.startswith("\"")
-                        )
-                        and 
-                        (
-                            line.endswith("\"") or line.endswith("\n")
-                        )
-                    )
-                    and
-                    (line.count("\"") < 3 and line.count(";") < 1)
-                ):
-                    # [>] Não executa o código seguinte
-                    continue
-
-                # [e] Exportação para a pasta: \\main
-                txtMainFile.write(line)
+#                 # [>] Remove dados que estão vazios
+#                 line = re.sub(r"(;\"\")|(\"\";)", "", line)
+
+#                 # [>] Faz uma quebra de linha caso tenha aspas duplas  adjacen-
+#                 # tes
+#                 line = re.sub(r"(?<=\")(?=\")", "\n", line)
+
+#                 # [>] Caso tenha um ponto e vírgula seguido de um espaço  troca
+#                 # por uma quebra de linha
+#                 line = re.sub(r"((?<=\");\ )", "\n", line)
+
+#                 # [>] Caso tenha um espaço entre um separador e uma aspas dupla
+#                 # remove o conteúdo que está atrás
+#                 line = re.sub(r"((.*\";\ )(?=\"))", "", line)
+
+#                 # [i] Se a linha possui aspas duplas no início  e  no  final  e
+#                 # ainda possui menos que duas colunas cancela o código
+#                 if (
+#                     (
+#                         (
+#                             line.startswith("\"")
+#                         )
+#                         and 
+#                         (
+#                             line.endswith("\"") or line.endswith("\n")
+#                         )
+#                     )
+#                     and
+#                     (line.count("\"") < 3 and line.count(";") < 1)
+#                 ):
+#                     # [>] Não executa o código seguinte
+#                     continue
+
+#                 # [e] Exportação para a pasta: \\main
+#                 txtMainFile.write(line)
     
-    # [>] Fecha o arquivo 'tableWithBlankCells'
-    txtTableWithBlankCells.close()
-    # [>] Fecha o arquivo 'main'
-    txtMainFile.close()
-
-    # [>] Abre o arquivo principal presente na  pasta  'main'  para
-    # criar formatações baseadas nele
-    with open(txtMainPath, "r", encoding="UTF-8") as txtFile:
-        # [>] Abre o arquivo de texto para  realizar  a  exportação
-        # fullClear
-        txtFullClearFile = open(txtFullClearPath, "a", encoding="UTF-8")
-
-        # [i] Navega por cada linha do documento de texto
-        for line in txtFile:
-            # [>] Caso a linha não comece com aspas deleta
-            line = re.sub(r"((^[^\"]).*)", "", line)
+#     # [>] Fecha o arquivo 'tableWithBlankCells'
+#     txtTableWithBlankCells.close()
+#     # [>] Fecha o arquivo 'main'
+#     txtMainFile.close()
+
+#     # [>] Abre o arquivo principal presente na  pasta  'main'  para
+#     # criar formatações baseadas nele
+#     with open(txtMainPath, "r", encoding="UTF-8") as txtFile:
+#         # [>] Abre o arquivo de texto para  realizar  a  exportação
+#         # fullClear
+#         txtFullClearFile = open(txtFullClearPath, "a", encoding="UTF-8")
+
+#         # [i] Navega por cada linha do documento de texto
+#         for line in txtFile:
+#             # [>] Caso a linha não comece com aspas deleta
+#             line = re.sub(r"((^[^\"]).*)", "", line)
             
-            # [>] Caso a linha não termine com aspas deleta
-            line = re.sub('"(.*([^"\n]$))', "", line)
-
-            # [>] Remove Linhas vazias que só possuem quebra de linha  '\n'
-            # ou não possuem uma aspas dupla em nenhum lugar, serão excluí-
-            # das 
-            lineRemovedQuotes = ""
-            lineRemovedQuotes = re.sub(r"\"", "", line)
-
-            # [i] Se a temporária permanece igual, ou seja, não teve  aspas
-            # duplas removidas pelo regex
-            if (line == lineRemovedQuotes):
-                # Quer dizer que ela ta errada e vai ser apagada
-                line = ""
+#             # [>] Caso a linha não termine com aspas deleta
+#             line = re.sub('"(.*([^"\n]$))', "", line)
+
+#             # [>] Remove Linhas vazias que só possuem quebra de linha  '\n'
+#             # ou não possuem uma aspas dupla em nenhum lugar, serão excluí-
+#             # das 
+#             lineRemovedQuotes = ""
+#             lineRemovedQuotes = re.sub(r"\"", "", line)
+
+#             # [i] Se a temporária permanece igual, ou seja, não teve  aspas
+#             # duplas removidas pelo regex
+#             if (line == lineRemovedQuotes):
+#                 # Quer dizer que ela ta errada e vai ser apagada
+#                 line = ""
             
-            # [i] Só escreve a linha se tiver pelo menos mais que 3 colunas
-            # no arquivo fullClear
-            if (line.count("\"") > 6 and
-                line.count(";") > 2):
-                # [e] Exportação para a pasta: \\fullClear
-                txtFullClearFile.write(line)
-
-#endregion
\ No newline at end of file
+#             # [i] Só escreve a linha se tiver pelo menos mais que 3 colunas
+#             # no arquivo fullClear
+#             if (line.count("\"") > 6 and
+#                 line.count(";") > 2):
+#                 # [e] Exportação para a pasta: \\fullClear
+#                 txtFullClearFile.write(line)
+
+# #endregion
\ No newline at end of file
diff --git a/pdfconverter/_backup/pdfconverter.py b/pdfconverter/_backup/pdfconverter.py
index 9feb1de..c3eb09d 100644
--- a/pdfconverter/_backup/pdfconverter.py
+++ b/pdfconverter/_backup/pdfconverter.py
@@ -1,1334 +1,1334 @@
-# Sumário
-# _____________________________________________________________
-
-# [L] LEGENDA
-# -------------------------------------------------------------
-# Descrição:
-# Legenda que contém informações relacionadas à documentação do
-# Script.
-# >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
-#region
-
-# -------------------------------------------------------------
-# Grupos:
-# -------------------------------------------------------------
-# - REGIONS -
-# [G] - Grupo de funções (é delimitado por uma "region")
-# [L] - Grupo que contém a legenda (é delimitado por uma "regi-
-# on")
-# [V] - Grupo  de  variáveis  (pode  ser  delimitado  por   uma
-# "region" ou não)
-# - NÃO REGIONS -
-# [B] - Importação de bibliotecas
-# [C] - Conglomerado pequeno de variáveis 
-# [F] - Função
-# -------------------------------------------------------------
-#
-# -------------------------------------------------------------
-# Dicas:
-# -------------------------------------------------------------
-# [i] - Informação ou descrição abrangente
-# [>] - Execução de uma tarefa ou uma informação relacionada  à
-# ela
-# [e] - Exportação de um arquivo PDF convertido para CSV
-# -------------------------------------------------------------
-
-#endregion
-# >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
-# -------------------------------------------------------------
-
-# _____________________________________________________________
-
-
-
-
-
-# Escopo
-# _____________________________________________________________
-
-# [V] VARIÁVEIS
-# -------------------------------------------------------------
-# Descrição:
-# Grupo que contém todas as  variáveis  globais  utilizadas  no
-# Script.
-# >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
-#region
-
-# [C] ARQUIVOS
-# -------------------------------------------------------------
-# Descrição:
-# Variáveis que armazenam possuem realações com arquivos direta
-# e indiretamente.
-# >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
-# [i] Nome do arquivo PDF que vai ser convertido  (sem a exten-
-# são)
-filename_PDF = ""
-# [i] Caminho atual para a raiz do projeto (os outros  caminhos
-# vão se basear nele)
-folderpath_Script = ""
-# [i] Caminho da pasta de importação onde os arquivos  PDF  vão
-# ser alocados
-folderpath_Import = ""
-# [i] Caminho da pasta onde os arquivos exportação vão ser alo-
-# cados
-folderpath_Export = ""
-# [i] Caminho para o arquivo do terminal
-filepath_TerminalFile = ""
-# [i] Caminho do arquivo de texto que vai ser gerado  pelo  PDF
-# que vai ser convertido
-filepath_ExportTxt = ""
-# [i] Variável que armazena o arquivo de saída do Terminal
-file_TerminalFile = ""
-# [i] Páginas que vão ser lidas para realizar a conversão
-readPDFPages = ""
-# >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
-# -------------------------------------------------------------
-
-# [C] CONTADORES
-# -------------------------------------------------------------
-# Descrição:
-# Variáveis auxiliares que atuam como contadores.
-# >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
-# [i] Índice do 'For' que manipula o Data Frame
-index_DataFrame = 0
-# [i] Índice do 'For' que manipula os arquivos PDF
-index_PdfFile = 1
-# >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
-# -------------------------------------------------------------
-
-# [C] VISUAL DO TERMINAL
-# -------------------------------------------------------------
-# Descrição:
-# Variáveis relacionadas ao visual de alguma parte  do  Script,
-# normalmente essas partes visuais estão diretamente relaciona-
-# das com a saída do terminal.
-# >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
-# [i] Linha gigante que vai ficar disposta  em  alguns  lugares
-# como divisão no terminal
-visual_GiantLine = (
-    "_________________________________________"
-    "_________________________________________"
-    "_________________________________________"
-    "_________________________________________"
-    "_________________________________________"
-    "_________________________________________"
-    "_________________________________________"
-    "_________________________________________"
-    "_________________________________________"
-    "_________________________________"
-)
-# [i] Variável que contém um espaço gigante usado em alguns la-
-# youts
-visual_BlankSpaces = (
-    "                                         "
-    "                                         "
-    "                                         "
-    "                                         "
-    "    "
-)
-# >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
-# -------------------------------------------------------------
-
-# [C] ARGUMENTOS
-# -------------------------------------------------------------
-# Descrição:
-# Variáveis relacionadas à alguma ação ou função relacionada  à
-# argumentos
-# >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
-# [i] Variável que vai ser responsável por criar o parser.
-parser_Main = None
-# [i] Variável que vai ser responsável por fazer a  manipulação
-# dos argumentos dados.
-parser_ArgsMain = None
-# >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
-# -------------------------------------------------------------
-
-# [C] LISTAS
-# -------------------------------------------------------------
-# Descrição:
-# Variáveis que fazem gerenciamento de listas.
-# >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
-# [i] Variável que vai conter a lista de DataFrames de  um  de-
-# terminado arquivo PDF baseado em um método de leitura,  pode-
-# ndo ser lattice ou stream
-list_DataFrames = []
-# >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
-# -------------------------------------------------------------
-
-#endregion
-# >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
-# -------------------------------------------------------------
-
-# _____________________________________________________________
-
-
-
-
-
-# Funções
-# _____________________________________________________________
-
-# [G] FUNÇÃO PRINCIPAL
-# -------------------------------------------------------------
-# Descrição:
-# Grupo que executa a função principal que faz operações  bási-
-# cas realiza a chamada de outras funções.
-# >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
-#region
-
-# [F] FUNÇÃO PRINCIPAL
-# -------------------------------------------------------------
-# Descrição:
-# Função que executa funcionalidades principais e chama  outras
-# funções
-# >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
-def Main():
-    # [V] VARIÁVEIS
-    # -------------------------------------------------------------
-    # Descrição:
-    # Grupo contendo variáveis utilizadas na função atual.
-    # >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
-
-    # [C] REFERENCIAMENTO DE VARIÁVEIS GLOBAIS    
-    # -------------------------------------------------------------
-    # Descrição:
-    # Referenciamento de variáveis globais (suas  descrições  estão
-    # no grupo de variáveis globais localizadas no escopo do início
-    # do Script).
-    # >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
-    global filename_PDF
-    global index_DataFrame
-    global list_DataFrames
-    global folderpath_Import
-    global folderpath_Export
-    global index_PdfFile
-    global readPDFPages
-    # >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
-    # -------------------------------------------------------------
-
-    # >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
-    # -------------------------------------------------------------
-
-
-    # CONFIGURAÇÕES INICIAIS
-    # -------------------------------------------------------------
-    # Descrição:
-    # Contém todas as chamadas de funções que realizam as  configu-
-    # rações iniciais para o funcionamento do Script.
-    # >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
-    # [>] Realiza as configurações da biblioteca Pandas
-    SetPandasSettings()
-    # [>] Cria o parser para manipular os argumentos
-    CreateParser()
-    # [>] Valida os argumentos
-    ValidateArguments()
-    # >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
-    # -------------------------------------------------------------
+# # Sumário
+# # _____________________________________________________________
+
+# # [L] LEGENDA
+# # -------------------------------------------------------------
+# # Descrição:
+# # Legenda que contém informações relacionadas à documentação do
+# # Script.
+# # >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
+# #region
+
+# # -------------------------------------------------------------
+# # Grupos:
+# # -------------------------------------------------------------
+# # - REGIONS -
+# # [G] - Grupo de funções (é delimitado por uma "region")
+# # [L] - Grupo que contém a legenda (é delimitado por uma "regi-
+# # on")
+# # [V] - Grupo  de  variáveis  (pode  ser  delimitado  por   uma
+# # "region" ou não)
+# # - NÃO REGIONS -
+# # [B] - Importação de bibliotecas
+# # [C] - Conglomerado pequeno de variáveis 
+# # [F] - Função
+# # -------------------------------------------------------------
+# #
+# # -------------------------------------------------------------
+# # Dicas:
+# # -------------------------------------------------------------
+# # [i] - Informação ou descrição abrangente
+# # [>] - Execução de uma tarefa ou uma informação relacionada  à
+# # ela
+# # [e] - Exportação de um arquivo PDF convertido para CSV
+# # -------------------------------------------------------------
+
+# #endregion
+# # >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
+# # -------------------------------------------------------------
+
+# # _____________________________________________________________
+
+
+
+
+
+# # Escopo
+# # _____________________________________________________________
+
+# # [V] VARIÁVEIS
+# # -------------------------------------------------------------
+# # Descrição:
+# # Grupo que contém todas as  variáveis  globais  utilizadas  no
+# # Script.
+# # >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
+# #region
+
+# # [C] ARQUIVOS
+# # -------------------------------------------------------------
+# # Descrição:
+# # Variáveis que armazenam possuem realações com arquivos direta
+# # e indiretamente.
+# # >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
+# # [i] Nome do arquivo PDF que vai ser convertido  (sem a exten-
+# # são)
+# filename_PDF = ""
+# # [i] Caminho atual para a raiz do projeto (os outros  caminhos
+# # vão se basear nele)
+# folderpath_Script = ""
+# # [i] Caminho da pasta de importação onde os arquivos  PDF  vão
+# # ser alocados
+# folderpath_Import = ""
+# # [i] Caminho da pasta onde os arquivos exportação vão ser alo-
+# # cados
+# folderpath_Export = ""
+# # [i] Caminho para o arquivo do terminal
+# filepath_TerminalFile = ""
+# # [i] Caminho do arquivo de texto que vai ser gerado  pelo  PDF
+# # que vai ser convertido
+# filepath_ExportTxt = ""
+# # [i] Variável que armazena o arquivo de saída do Terminal
+# file_TerminalFile = ""
+# # [i] Páginas que vão ser lidas para realizar a conversão
+# readPDFPages = ""
+# # >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
+# # -------------------------------------------------------------
+
+# # [C] CONTADORES
+# # -------------------------------------------------------------
+# # Descrição:
+# # Variáveis auxiliares que atuam como contadores.
+# # >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
+# # [i] Índice do 'For' que manipula o Data Frame
+# index_DataFrame = 0
+# # [i] Índice do 'For' que manipula os arquivos PDF
+# index_PdfFile = 1
+# # >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
+# # -------------------------------------------------------------
+
+# # [C] VISUAL DO TERMINAL
+# # -------------------------------------------------------------
+# # Descrição:
+# # Variáveis relacionadas ao visual de alguma parte  do  Script,
+# # normalmente essas partes visuais estão diretamente relaciona-
+# # das com a saída do terminal.
+# # >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
+# # [i] Linha gigante que vai ficar disposta  em  alguns  lugares
+# # como divisão no terminal
+# visual_GiantLine = (
+#     "_________________________________________"
+#     "_________________________________________"
+#     "_________________________________________"
+#     "_________________________________________"
+#     "_________________________________________"
+#     "_________________________________________"
+#     "_________________________________________"
+#     "_________________________________________"
+#     "_________________________________________"
+#     "_________________________________"
+# )
+# # [i] Variável que contém um espaço gigante usado em alguns la-
+# # youts
+# visual_BlankSpaces = (
+#     "                                         "
+#     "                                         "
+#     "                                         "
+#     "                                         "
+#     "    "
+# )
+# # >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
+# # -------------------------------------------------------------
+
+# # [C] ARGUMENTOS
+# # -------------------------------------------------------------
+# # Descrição:
+# # Variáveis relacionadas à alguma ação ou função relacionada  à
+# # argumentos
+# # >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
+# # [i] Variável que vai ser responsável por criar o parser.
+# parser_Main = None
+# # [i] Variável que vai ser responsável por fazer a  manipulação
+# # dos argumentos dados.
+# parser_ArgsMain = None
+# # >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
+# # -------------------------------------------------------------
+
+# # [C] LISTAS
+# # -------------------------------------------------------------
+# # Descrição:
+# # Variáveis que fazem gerenciamento de listas.
+# # >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
+# # [i] Variável que vai conter a lista de DataFrames de  um  de-
+# # terminado arquivo PDF baseado em um método de leitura,  pode-
+# # ndo ser lattice ou stream
+# list_DataFrames = []
+# # >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
+# # -------------------------------------------------------------
+
+# #endregion
+# # >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
+# # -------------------------------------------------------------
+
+# # _____________________________________________________________
+
+
+
+
+
+# # Funções
+# # _____________________________________________________________
+
+# # [G] FUNÇÃO PRINCIPAL
+# # -------------------------------------------------------------
+# # Descrição:
+# # Grupo que executa a função principal que faz operações  bási-
+# # cas realiza a chamada de outras funções.
+# # >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
+# #region
+
+# # [F] FUNÇÃO PRINCIPAL
+# # -------------------------------------------------------------
+# # Descrição:
+# # Função que executa funcionalidades principais e chama  outras
+# # funções
+# # >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
+# def Main():
+#     # [V] VARIÁVEIS
+#     # -------------------------------------------------------------
+#     # Descrição:
+#     # Grupo contendo variáveis utilizadas na função atual.
+#     # >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
+
+#     # [C] REFERENCIAMENTO DE VARIÁVEIS GLOBAIS    
+#     # -------------------------------------------------------------
+#     # Descrição:
+#     # Referenciamento de variáveis globais (suas  descrições  estão
+#     # no grupo de variáveis globais localizadas no escopo do início
+#     # do Script).
+#     # >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
+#     global filename_PDF
+#     global index_DataFrame
+#     global list_DataFrames
+#     global folderpath_Import
+#     global folderpath_Export
+#     global index_PdfFile
+#     global readPDFPages
+#     # >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
+#     # -------------------------------------------------------------
+
+#     # >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
+#     # -------------------------------------------------------------
+
+
+#     # CONFIGURAÇÕES INICIAIS
+#     # -------------------------------------------------------------
+#     # Descrição:
+#     # Contém todas as chamadas de funções que realizam as  configu-
+#     # rações iniciais para o funcionamento do Script.
+#     # >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
+#     # [>] Realiza as configurações da biblioteca Pandas
+#     SetPandasSettings()
+#     # [>] Cria o parser para manipular os argumentos
+#     CreateParser()
+#     # [>] Valida os argumentos
+#     ValidateArguments()
+#     # >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
+#     # -------------------------------------------------------------
     
 
-    if (folderpath_Import != ""):
-        # [>] Direciona o sistema para a pasta indicada
-        os.chdir(folderpath_Import)
-        # [>] Filtra pelos PDFs na pasta onde foi indicada para o  sis-
-        # tema pelo "chdir"
-        for str_PdfFileFullName in glob("*.pdf"):
-            # [i] Se já não é mais o primeiro arquivo
-            if (index_PdfFile > 1):
-                # [>] Fecha o leiaute referente ao arquivo anterior
-                SetTerminalFile(True)
-                print(
-                    "\n" +
-                    visual_GiantLine + "\n" +
-                    visual_GiantLine + "\n"
-                    "\n\n\n\n\n\n\n\n\n",
+#     if (folderpath_Import != ""):
+#         # [>] Direciona o sistema para a pasta indicada
+#         os.chdir(folderpath_Import)
+#         # [>] Filtra pelos PDFs na pasta onde foi indicada para o  sis-
+#         # tema pelo "chdir"
+#         for str_PdfFileFullName in glob("*.pdf"):
+#             # [i] Se já não é mais o primeiro arquivo
+#             if (index_PdfFile > 1):
+#                 # [>] Fecha o leiaute referente ao arquivo anterior
+#                 SetTerminalFile(True)
+#                 print(
+#                     "\n" +
+#                     visual_GiantLine + "\n" +
+#                     visual_GiantLine + "\n"
+#                     "\n\n\n\n\n\n\n\n\n",
                     
-                    file = file_TerminalFile
-                )
-                SetTerminalFile(False)
-            # [>] Se é o primeiro arquivo ainda
-            else:
-                # [>] Define a estrutura inicial do projeto
-                SetProjectStructure()
+#                     file = file_TerminalFile
+#                 )
+#                 SetTerminalFile(False)
+#             # [>] Se é o primeiro arquivo ainda
+#             else:
+#                 # [>] Define a estrutura inicial do projeto
+#                 SetProjectStructure()
                 
 
-            # [>] Remove extensão do arquivo  (pegando  apenas  o  nome)  e
-            # atribui para a temporária
-            filename_PDF = str_PdfFileFullName[:-4]
-
-            # [>] Cria o título para leitura do arquivo no terminal
-            SetTerminalFile(True)
-            print(
-                str_PdfFileFullName + visual_GiantLine + "\n" +
-                visual_GiantLine + "\n\n\n\n" +
-                visual_BlankSpaces + "                          ----- + -----\n\n" +
-                visual_BlankSpaces + "         LEITURA DE ARQUIVO - NÚMERO " + str(index_PdfFile) + ", '" + str_PdfFileFullName + "'\n" +
-                visual_BlankSpaces + "   O arquivo '" + filename_PDF + "' foi lido e está pronto pra ser convertido\n\n" +
-                visual_BlankSpaces + "                          ----- + -----\n\n\n\n",
+#             # [>] Remove extensão do arquivo  (pegando  apenas  o  nome)  e
+#             # atribui para a temporária
+#             filename_PDF = str_PdfFileFullName[:-4]
+
+#             # [>] Cria o título para leitura do arquivo no terminal
+#             SetTerminalFile(True)
+#             print(
+#                 str_PdfFileFullName + visual_GiantLine + "\n" +
+#                 visual_GiantLine + "\n\n\n\n" +
+#                 visual_BlankSpaces + "                          ----- + -----\n\n" +
+#                 visual_BlankSpaces + "         LEITURA DE ARQUIVO - NÚMERO " + str(index_PdfFile) + ", '" + str_PdfFileFullName + "'\n" +
+#                 visual_BlankSpaces + "   O arquivo '" + filename_PDF + "' foi lido e está pronto pra ser convertido\n\n" +
+#                 visual_BlankSpaces + "                          ----- + -----\n\n\n\n",
                 
-                file = file_TerminalFile
-            )
-            SetTerminalFile(False)
-
-
-
-            # MÉTODOS DE LEITURA E CONVERSÃO
-            # -------------------------------------------------------------
-            # Descrição:
-            # Primeiro faz a leitura e conversão pra Lattice e após  faz  o
-            # mesmo para o Stream
-            # >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
-            for method in range(2):
-                # [i] Define o método de leitura Lattice
-                if (method == 0):
-                    boolLattice = True
-                    conversionMethod = "lattice"
-                # [i] Define o método de leitura Stream
-                elif (method == 1):
-                    boolLattice = False
-                    conversionMethod = "stream"
-
-                # LEITURA
-                # -------------------------------------------------------------
-                # Descrição:
-                # Realiza a leitura.
-                # >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
-                try:
-                    # [>] Realiza a leitura usando um método de  leitura  fornecido
-                    # pelo "For"
-                    list_DataFrames = tabula.read_pdf(
-                        str_PdfFileFullName,
-                        guess = True,
-                        lattice = boolLattice,
-                        multiple_tables = True,
-                        pages = readPDFPages,
-                        pandas_options = {"dtype": "str"},
-                        silent = True
-                    )
-                # [i] Quando ocorre um problema desconhecido na hora de  reali-
-                # zar a leitura
-                except Exception as exceptionError:
-                    # [>] Exibe a mensagem de erro
-                    ShowError(
-                        "Arquivo: " + str_PdfFileFullName + "\n"
-                        "Método de Conversão: " + conversionMethod + "\n"
-                        "\n"
-                        "Ocorreu um erro ao tentar realizar a leitura do arquivo '" + str_PdfFileFullName +  "' "
-                        "usando o método '" + conversionMethod + "'.",
+#                 file = file_TerminalFile
+#             )
+#             SetTerminalFile(False)
+
+
+
+#             # MÉTODOS DE LEITURA E CONVERSÃO
+#             # -------------------------------------------------------------
+#             # Descrição:
+#             # Primeiro faz a leitura e conversão pra Lattice e após  faz  o
+#             # mesmo para o Stream
+#             # >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
+#             for method in range(2):
+#                 # [i] Define o método de leitura Lattice
+#                 if (method == 0):
+#                     boolLattice = True
+#                     conversionMethod = "lattice"
+#                 # [i] Define o método de leitura Stream
+#                 elif (method == 1):
+#                     boolLattice = False
+#                     conversionMethod = "stream"
+
+#                 # LEITURA
+#                 # -------------------------------------------------------------
+#                 # Descrição:
+#                 # Realiza a leitura.
+#                 # >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
+#                 try:
+#                     # [>] Realiza a leitura usando um método de  leitura  fornecido
+#                     # pelo "For"
+#                     list_DataFrames = tabula.read_pdf(
+#                         str_PdfFileFullName,
+#                         guess = True,
+#                         lattice = boolLattice,
+#                         multiple_tables = True,
+#                         pages = readPDFPages,
+#                         pandas_options = {"dtype": "str"},
+#                         silent = True
+#                     )
+#                 # [i] Quando ocorre um problema desconhecido na hora de  reali-
+#                 # zar a leitura
+#                 except Exception as exceptionError:
+#                     # [>] Exibe a mensagem de erro
+#                     ShowError(
+#                         "Arquivo: " + str_PdfFileFullName + "\n"
+#                         "Método de Conversão: " + conversionMethod + "\n"
+#                         "\n"
+#                         "Ocorreu um erro ao tentar realizar a leitura do arquivo '" + str_PdfFileFullName +  "' "
+#                         "usando o método '" + conversionMethod + "'.",
                         
-                        exceptionError
-                    )
-                # >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
-                # -------------------------------------------------------------
-
-
-                # CONVERSÃO
-                # -------------------------------------------------------------
-                # Descrição:
-                # Realizando a conversão com o método indicado.
-                # >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
-                # [>] Reseta a variável
-                index_DataFrame = 1
-                # [>] Itera os DataFrames contidos na lista de  DataFrames  gerados
-                # pela leitura do tabula
-                for tableDataFrame in list_DataFrames:
-                    # [>] Remove as aspas duplas do que estiverem no DataFrame para
-                    # evitar possíveis erros pois os dados normalmente são  separa-
-                    # dos por pontos e vírgula e aspas duplas
-                    tableDataFrame = tableDataFrame.replace("\"", "", regex = True)
-
-                    # [>] Inicia a função que realiza a conversão com o método  in-
-                    # dicado
-                    ConversionStart(conversionMethod, tableDataFrame)
-                try:
-                    # [>] Chama a função que formata o arquivo de texto gerado pela
-                    # conversão
-                    FormatTextFile(conversionMethod)
-                except FileNotFoundError:
-                    ShowError(
-                        "A pasta de resultados foi apagada durante a conversão, a mesm"
-                        "a será encerrada.",
+#                         exceptionError
+#                     )
+#                 # >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
+#                 # -------------------------------------------------------------
+
+
+#                 # CONVERSÃO
+#                 # -------------------------------------------------------------
+#                 # Descrição:
+#                 # Realizando a conversão com o método indicado.
+#                 # >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
+#                 # [>] Reseta a variável
+#                 index_DataFrame = 1
+#                 # [>] Itera os DataFrames contidos na lista de  DataFrames  gerados
+#                 # pela leitura do tabula
+#                 for tableDataFrame in list_DataFrames:
+#                     # [>] Remove as aspas duplas do que estiverem no DataFrame para
+#                     # evitar possíveis erros pois os dados normalmente são  separa-
+#                     # dos por pontos e vírgula e aspas duplas
+#                     tableDataFrame = tableDataFrame.replace("\"", "", regex = True)
+
+#                     # [>] Inicia a função que realiza a conversão com o método  in-
+#                     # dicado
+#                     ConversionStart(conversionMethod, tableDataFrame)
+#                 try:
+#                     # [>] Chama a função que formata o arquivo de texto gerado pela
+#                     # conversão
+#                     FormatTextFile(conversionMethod)
+#                 except FileNotFoundError:
+#                     ShowError(
+#                         "A pasta de resultados foi apagada durante a conversão, a mesm"
+#                         "a será encerrada.",
                     
-                        exitProgram = True,
-                        recreateTerminalFile = True
-                    )
-                except Exception as exceptionError:
-                    ShowError (
-                        "Ocorreu um erro desconhecido ao tentar realizar a formatação "
-                        "da conversão, a mesma será encerrada.",
+#                         exitProgram = True,
+#                         recreateTerminalFile = True
+#                     )
+#                 except Exception as exceptionError:
+#                     ShowError (
+#                         "Ocorreu um erro desconhecido ao tentar realizar a formatação "
+#                         "da conversão, a mesma será encerrada.",
                         
-                        exceptionError,
-                        exitProgram = True
-                    )
-                # >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
-                # -------------------------------------------------------------
-            # >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
-            # -------------------------------------------------------------
-
-            # [>] Atribuindo mais um ao índice para indicar que  o  arquivo
-            # PDF foi convertido
-            index_PdfFile += 1
-        else:
-            # [i] Se até o término da operação algum  PDF  foi  convertido,
-            # fecha o leiaute do terminal
-            if (index_PdfFile > 1):
-                # [>] Fecha o leiaute e pula 5 linhas
-                SetTerminalFile(True)
-                print(
-                    "\n" +
-                    visual_GiantLine + "\n" +
-                    visual_GiantLine,
+#                         exceptionError,
+#                         exitProgram = True
+#                     )
+#                 # >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
+#                 # -------------------------------------------------------------
+#             # >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
+#             # -------------------------------------------------------------
+
+#             # [>] Atribuindo mais um ao índice para indicar que  o  arquivo
+#             # PDF foi convertido
+#             index_PdfFile += 1
+#         else:
+#             # [i] Se até o término da operação algum  PDF  foi  convertido,
+#             # fecha o leiaute do terminal
+#             if (index_PdfFile > 1):
+#                 # [>] Fecha o leiaute e pula 5 linhas
+#                 SetTerminalFile(True)
+#                 print(
+#                     "\n" +
+#                     visual_GiantLine + "\n" +
+#                     visual_GiantLine,
                 
-                    file = file_TerminalFile
-                )
-                SetTerminalFile(False)
-            # [i] Se ainda até o término da operação nenhum PDF foi conver-
-            # tido exibe um erro
-            else:
-                # [>] Exibe o erro
-                ShowError("Não há arquivos de PDF para serem convertidos.")
-    else:
-        ShowError("É necessário indicar um caminho de importação")
-# >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
-# -------------------------------------------------------------
-
-#endregion
-# >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
-# -------------------------------------------------------------
-
-# [G] CONFIGURAÇÕES INICIAIS
-# -------------------------------------------------------------
-# Descrição:
-# Grupo que executa as configurações iniciais e ao decorrer  do
-# exercício das tarefas do Script.
-# Há funções com diversos objetivos, dentre eles,  encontrar  o
-# caminho do arquivo de onde está sendo executado o Script, de-
-# finir o caminho onde será utilizado para criar a estrutura de
-# pastas, criar a estrutura de pastas onde serão  colocados  os
-# arquivos PDF e onde serão gerados os arquivos  exportados
-# e configurações adicionais da biblioteca Pandas
-# >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
-#region
-
-# [F] FUNÇÃO QUE DEFINE O LOCAL DA RAÍZ DO PROJETO
-# -------------------------------------------------------------
-# Descrição:
-# Define o local da raíz do projeto, onde  os  outros  caminhos
-# irão se basear
-# >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
-def SetCurrentPath():
-    # [V] VARIÁVEIS
-    # -------------------------------------------------------------
-    # Descrição:
-    # Grupo contendo variáveis utilizadas na função atual.
-    # >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
-
-    # [C] REFERENCIAMENTO DE VARIÁVEIS GLOBAIS    
-    # -------------------------------------------------------------
-    # Descrição:
-    # Referenciamento de variáveis globais (suas  descrições  estão
-    # no grupo de variáveis globais localizadas no escopo do início
-    # do Script).
-    # >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
-    global filepath_TerminalFile
-    global folderpath_Script
-    global file_TerminalFile
-    # >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
-    # -------------------------------------------------------------
-
-    # >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
-    # -------------------------------------------------------------
+#                     file = file_TerminalFile
+#                 )
+#                 SetTerminalFile(False)
+#             # [i] Se ainda até o término da operação nenhum PDF foi conver-
+#             # tido exibe um erro
+#             else:
+#                 # [>] Exibe o erro
+#                 ShowError("Não há arquivos de PDF para serem convertidos.")
+#     else:
+#         ShowError("É necessário indicar um caminho de importação")
+# # >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
+# # -------------------------------------------------------------
+
+# #endregion
+# # >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
+# # -------------------------------------------------------------
+
+# # [G] CONFIGURAÇÕES INICIAIS
+# # -------------------------------------------------------------
+# # Descrição:
+# # Grupo que executa as configurações iniciais e ao decorrer  do
+# # exercício das tarefas do Script.
+# # Há funções com diversos objetivos, dentre eles,  encontrar  o
+# # caminho do arquivo de onde está sendo executado o Script, de-
+# # finir o caminho onde será utilizado para criar a estrutura de
+# # pastas, criar a estrutura de pastas onde serão  colocados  os
+# # arquivos PDF e onde serão gerados os arquivos  exportados
+# # e configurações adicionais da biblioteca Pandas
+# # >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
+# #region
+
+# # [F] FUNÇÃO QUE DEFINE O LOCAL DA RAÍZ DO PROJETO
+# # -------------------------------------------------------------
+# # Descrição:
+# # Define o local da raíz do projeto, onde  os  outros  caminhos
+# # irão se basear
+# # >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
+# def SetCurrentPath():
+#     # [V] VARIÁVEIS
+#     # -------------------------------------------------------------
+#     # Descrição:
+#     # Grupo contendo variáveis utilizadas na função atual.
+#     # >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
+
+#     # [C] REFERENCIAMENTO DE VARIÁVEIS GLOBAIS    
+#     # -------------------------------------------------------------
+#     # Descrição:
+#     # Referenciamento de variáveis globais (suas  descrições  estão
+#     # no grupo de variáveis globais localizadas no escopo do início
+#     # do Script).
+#     # >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
+#     global filepath_TerminalFile
+#     global folderpath_Script
+#     global file_TerminalFile
+#     # >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
+#     # -------------------------------------------------------------
+
+#     # >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
+#     # -------------------------------------------------------------
     
 
-    # [i] Pegando o caminho até o executável ou script atual  e  a-
-    # tribuindo para a variável folderpath_Script
-    folderpath_Script = str(Path(__file__).parent.absolute())
-
-    # [>] Passa para a variável global o caminho do arquivo de tex-
-    # to do terminal
-    filepath_TerminalFile = folderpath_Script + "\\output.txt"
-
-    RecreateTerminalFile()
-# >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
-# -------------------------------------------------------------
-
-# [F] FUNÇÃO QUE CRIA O ARQUIVO DE SAÍDA DO TERMINAL
-# -------------------------------------------------------------
-# Descrição:
-# Função responsável por limpar ou criar o arquivo de saída  do
-# terminal.
-# >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
-def RecreateTerminalFile():
-    # [V] VARIÁVEIS
-    # -------------------------------------------------------------
-    # Descrição:
-    # Grupo contendo variáveis utilizadas na função atual.
-    # >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
-
-    # [C] REFERENCIAMENTO DE VARIÁVEIS GLOBAIS    
-    # -------------------------------------------------------------
-    # Descrição:
-    # Referenciamento de variáveis globais (suas  descrições  estão
-    # no grupo de variáveis globais localizadas no escopo do início
-    # do Script).
-    # >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
-    global file_TerminalFile
-    # >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
-    # -------------------------------------------------------------
-
-    # >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
-    # -------------------------------------------------------------
-
-
-    try:
-        # [>] Cria e/ou limpa o arquivo de texto contendo  a  saída  do
-        # terminal
-        file_TerminalFile = open(filepath_TerminalFile, "w", encoding="UTF-8")
-    except PermissionError:
-        # [>] Caso esteja como READONLY, remove a propriedade
-        os.chmod(filepath_TerminalFile, stat.S_IWRITE)
-
-        # [>] Cria e/ou limpa o arquivo de texto contendo  a  saída  do
-        # terminal
-        file_TerminalFile = open(filepath_TerminalFile, "w", encoding="UTF-8")
-# >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
-# -------------------------------------------------------------
-
-# [F] FUNÇÃO QUE DEFINE A ESTRUTURA DE PASTAS DO PROJETO
-# -------------------------------------------------------------
-# Descrição:
-# Faz a verificação da existência das pastas a seguir e as cria
-# caso elas ainda não existam.
-# >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
-def SetProjectStructure():
-    # [V] VARIÁVEIS
-    # -------------------------------------------------------------
-    # Descrição:
-    # Grupo contendo variáveis utilizadas na função atual.
-    # >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
-
-    # [C] REFERENCIAMENTO DE VARIÁVEIS GLOBAIS    
-    # -------------------------------------------------------------
-    # Descrição:
-    # Listas que possuem os caminhos das pastas que vão  ser  gera-
-    # das.
-    # >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
-    # [C] CAMINHOS
-    # [i] Caminhos que indicam a localização das  pastas  raíz  que
-    # irão ser geradas futuramente.
-    rootPath = "\\resultados"
-    # [i] Caminhos que indicam a localização das pastas dos métodos
-    # de leitura que vão ser geradas futuramente dentro da pasta de
-    # exportação.
-    list_readingPaths = [
-        "\\lattice",
-        "\\stream"
-    ]
-    # [i] Caminhos que indicam a localização das pastas dos métodos
-    # de formatação que vão ser geradas futuramente dentro das pas-
-    # tas de métodos de leitura, que estão dentro da pasta  de  ex-
-    # portação.
-    list_formattingPaths = [
-        "\\main",
-        "\\fullClear",
-        "\\tableWithBlankCells",
-        "\\withoutFormatting"
-    ]
-    # >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
-    # -------------------------------------------------------------
-
-    # >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
-    # -------------------------------------------------------------
+#     # [i] Pegando o caminho até o executável ou script atual  e  a-
+#     # tribuindo para a variável folderpath_Script
+#     folderpath_Script = str(Path(__file__).parent.absolute())
+
+#     # [>] Passa para a variável global o caminho do arquivo de tex-
+#     # to do terminal
+#     filepath_TerminalFile = folderpath_Script + "\\output.txt"
+
+#     RecreateTerminalFile()
+# # >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
+# # -------------------------------------------------------------
+
+# # [F] FUNÇÃO QUE CRIA O ARQUIVO DE SAÍDA DO TERMINAL
+# # -------------------------------------------------------------
+# # Descrição:
+# # Função responsável por limpar ou criar o arquivo de saída  do
+# # terminal.
+# # >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
+# def RecreateTerminalFile():
+#     # [V] VARIÁVEIS
+#     # -------------------------------------------------------------
+#     # Descrição:
+#     # Grupo contendo variáveis utilizadas na função atual.
+#     # >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
+
+#     # [C] REFERENCIAMENTO DE VARIÁVEIS GLOBAIS    
+#     # -------------------------------------------------------------
+#     # Descrição:
+#     # Referenciamento de variáveis globais (suas  descrições  estão
+#     # no grupo de variáveis globais localizadas no escopo do início
+#     # do Script).
+#     # >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
+#     global file_TerminalFile
+#     # >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
+#     # -------------------------------------------------------------
+
+#     # >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
+#     # -------------------------------------------------------------
+
+
+#     try:
+#         # [>] Cria e/ou limpa o arquivo de texto contendo  a  saída  do
+#         # terminal
+#         file_TerminalFile = open(filepath_TerminalFile, "w", encoding="UTF-8")
+#     except PermissionError:
+#         # [>] Caso esteja como READONLY, remove a propriedade
+#         os.chmod(filepath_TerminalFile, stat.S_IWRITE)
+
+#         # [>] Cria e/ou limpa o arquivo de texto contendo  a  saída  do
+#         # terminal
+#         file_TerminalFile = open(filepath_TerminalFile, "w", encoding="UTF-8")
+# # >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
+# # -------------------------------------------------------------
+
+# # [F] FUNÇÃO QUE DEFINE A ESTRUTURA DE PASTAS DO PROJETO
+# # -------------------------------------------------------------
+# # Descrição:
+# # Faz a verificação da existência das pastas a seguir e as cria
+# # caso elas ainda não existam.
+# # >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
+# def SetProjectStructure():
+#     # [V] VARIÁVEIS
+#     # -------------------------------------------------------------
+#     # Descrição:
+#     # Grupo contendo variáveis utilizadas na função atual.
+#     # >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
+
+#     # [C] REFERENCIAMENTO DE VARIÁVEIS GLOBAIS    
+#     # -------------------------------------------------------------
+#     # Descrição:
+#     # Listas que possuem os caminhos das pastas que vão  ser  gera-
+#     # das.
+#     # >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
+#     # [C] CAMINHOS
+#     # [i] Caminhos que indicam a localização das  pastas  raíz  que
+#     # irão ser geradas futuramente.
+#     rootPath = "\\resultados"
+#     # [i] Caminhos que indicam a localização das pastas dos métodos
+#     # de leitura que vão ser geradas futuramente dentro da pasta de
+#     # exportação.
+#     list_readingPaths = [
+#         "\\lattice",
+#         "\\stream"
+#     ]
+#     # [i] Caminhos que indicam a localização das pastas dos métodos
+#     # de formatação que vão ser geradas futuramente dentro das pas-
+#     # tas de métodos de leitura, que estão dentro da pasta  de  ex-
+#     # portação.
+#     list_formattingPaths = [
+#         "\\main",
+#         "\\fullClear",
+#         "\\tableWithBlankCells",
+#         "\\withoutFormatting"
+#     ]
+#     # >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
+#     # -------------------------------------------------------------
+
+#     # >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
+#     # -------------------------------------------------------------
 
     
-    # [>] Cria uma nova pasta, caso já tenha uma chamada resultados
-    int_indexFolderCreation = 0
-    folderSufix = ""
-    # [i] Enquanto houver uma pasta de resultados existente
-    while (os.path.isdir(folderpath_Export + rootPath + folderSufix)):
-        # [>] Adiciona +1 ao contador
-        int_indexFolderCreation += 1
-        # [>] Arruma o nome do arquivo com o valor do contador
-        folderSufix = " (" + str(int_indexFolderCreation) + ")"
-    # [>] Atualiza o nome da pasta
-    rootPath = rootPath + folderSufix
-
-
-    # [>] Criando pasta raíz
-    Path(
-        folderpath_Export +
-        rootPath
-    ).mkdir(parents = True, exist_ok = True)
-
-    # [i] Para cada método, presente na lista de métodos
-    for methodPath in list_readingPaths:
-        # [>] Cria uma pasta
-        Path(
-            folderpath_Export +
-            rootPath +
-            methodPath
-        ).mkdir(parents = True, exist_ok = True)
-
-        # [>] Criando pastas para métodos de formatação
-        for outputTypePath in list_formattingPaths:
-            Path(
-                folderpath_Export +
-                rootPath +
-                methodPath +
-                outputTypePath
-            ).mkdir(parents = True, exist_ok = True)
-
-
-    # [>] Cria arquivo para exibir a saída do terminal, se já exis-
-    # tir o arquivo, limpa o mesmo
-    open(filepath_TerminalFile, "w").close()
-# >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
-# -------------------------------------------------------------
-
-# [F] FUNÇÃO QUE DEFINE E EXECUTA CONFIGURAÇÕES DO PANDAS
-# -------------------------------------------------------------
-# Descrição:
-# Configurações do Pandas que afetam o DataFrame e a  conversão
-# para texto.
-# >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
-def SetPandasSettings():
-    # [>] Configuração que evita com que dados sejam  quebrados  no
-    # arquivo exportado
-    pandas.options.display.max_colwidth = None
-    # [>] Configuração que evita com que os dados acabem sendo que-
-    # brados na saída do terminal
-    pandas.options.display.expand_frame_repr = False
-    # [>] Configuração que define  o  padrão  de  codificação  para
-    # UTF-8 com BOM
-    pandas.options.display.encoding = "UTF-8-sig"
-    # [>] Configuração que faz com que caso exista um ";"  ele  não
-    # passe os dados pra outra célula
-    pandas.options.display.latex.multicolumn = False
-# >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
-# -------------------------------------------------------------
-
-#endregion
-# >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
-# -------------------------------------------------------------
-
-# [G] SAÍDAS DE AVISOS
-# -------------------------------------------------------------
-# Descrição:
-# Grupo o que contém funções que executam a exibição de  avisos
-# relacionados ao arquivo que é gerado contendo informações que
-# são mostradas no terminal.
-# >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
-#region
-
-# [F] DEFINE O ESTADO DO TERMINAL
-# -------------------------------------------------------------
-# Descrição:
-# Define quando o terminal vai ser aberto ou quando vai ser fe-
-# chado.
-# >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
-def SetTerminalFile(asOpen = True):
-    # [V] VARIÁVEIS
-    # -------------------------------------------------------------
-    # Descrição:
-    # Grupo contendo variáveis utilizadas na função atual.
-    # >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
-
-    # [C] REFERENCIAMENTO DE VARIÁVEIS GLOBAIS    
-    # -------------------------------------------------------------
-    # Descrição:
-    # Referenciamento de variáveis globais (suas  descrições  estão
-    # no grupo de variáveis globais localizadas no escopo do início
-    # do Script).
-    # >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
-    global file_TerminalFile
-    # >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
-    # -------------------------------------------------------------
-
-    # >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
-    # -------------------------------------------------------------
-
-
-    # [i] Caso o programador decida abrir o arquivo
-    if (asOpen):
-        # [>] Abre o arquivo de saída do terminal com "append"
-        file_TerminalFile = open(filepath_TerminalFile, "a", encoding="UTF-8")
-    # [i] Caso o programador decida fechar o arquivo
-    else:
-        # [>] Fecha o arquivo de saída do terminal
-        file_TerminalFile.close()
-# >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
-# -------------------------------------------------------------
-
-# [F] EXIBE UMA MENSAGEM DE ERRO
-# -------------------------------------------------------------
-# Descrição:
-# Função responsável por exibir mensagens de erros  disponíveis
-# nas Exceptions.
-# >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
-def ShowError(errorMessage, exceptionError = "", exitProgram = False, recreateTerminalFile = False):
-    # [>] Se desejado, recriar o arquivo de saída do terminal
-    if (recreateTerminalFile):
-        # [>] Recria o arquivo de saída do terminal
-        RecreateTerminalFile()
+#     # [>] Cria uma nova pasta, caso já tenha uma chamada resultados
+#     int_indexFolderCreation = 0
+#     folderSufix = ""
+#     # [i] Enquanto houver uma pasta de resultados existente
+#     while (os.path.isdir(folderpath_Export + rootPath + folderSufix)):
+#         # [>] Adiciona +1 ao contador
+#         int_indexFolderCreation += 1
+#         # [>] Arruma o nome do arquivo com o valor do contador
+#         folderSufix = " (" + str(int_indexFolderCreation) + ")"
+#     # [>] Atualiza o nome da pasta
+#     rootPath = rootPath + folderSufix
+
+
+#     # [>] Criando pasta raíz
+#     Path(
+#         folderpath_Export +
+#         rootPath
+#     ).mkdir(parents = True, exist_ok = True)
+
+#     # [i] Para cada método, presente na lista de métodos
+#     for methodPath in list_readingPaths:
+#         # [>] Cria uma pasta
+#         Path(
+#             folderpath_Export +
+#             rootPath +
+#             methodPath
+#         ).mkdir(parents = True, exist_ok = True)
+
+#         # [>] Criando pastas para métodos de formatação
+#         for outputTypePath in list_formattingPaths:
+#             Path(
+#                 folderpath_Export +
+#                 rootPath +
+#                 methodPath +
+#                 outputTypePath
+#             ).mkdir(parents = True, exist_ok = True)
+
+
+#     # [>] Cria arquivo para exibir a saída do terminal, se já exis-
+#     # tir o arquivo, limpa o mesmo
+#     open(filepath_TerminalFile, "w").close()
+# # >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
+# # -------------------------------------------------------------
+
+# # [F] FUNÇÃO QUE DEFINE E EXECUTA CONFIGURAÇÕES DO PANDAS
+# # -------------------------------------------------------------
+# # Descrição:
+# # Configurações do Pandas que afetam o DataFrame e a  conversão
+# # para texto.
+# # >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
+# def SetPandasSettings():
+#     # [>] Configuração que evita com que dados sejam  quebrados  no
+#     # arquivo exportado
+#     pandas.options.display.max_colwidth = None
+#     # [>] Configuração que evita com que os dados acabem sendo que-
+#     # brados na saída do terminal
+#     pandas.options.display.expand_frame_repr = False
+#     # [>] Configuração que define  o  padrão  de  codificação  para
+#     # UTF-8 com BOM
+#     pandas.options.display.encoding = "UTF-8-sig"
+#     # [>] Configuração que faz com que caso exista um ";"  ele  não
+#     # passe os dados pra outra célula
+#     pandas.options.display.latex.multicolumn = False
+# # >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
+# # -------------------------------------------------------------
+
+# #endregion
+# # >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
+# # -------------------------------------------------------------
+
+# # [G] SAÍDAS DE AVISOS
+# # -------------------------------------------------------------
+# # Descrição:
+# # Grupo o que contém funções que executam a exibição de  avisos
+# # relacionados ao arquivo que é gerado contendo informações que
+# # são mostradas no terminal.
+# # >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
+# #region
+
+# # [F] DEFINE O ESTADO DO TERMINAL
+# # -------------------------------------------------------------
+# # Descrição:
+# # Define quando o terminal vai ser aberto ou quando vai ser fe-
+# # chado.
+# # >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
+# def SetTerminalFile(asOpen = True):
+#     # [V] VARIÁVEIS
+#     # -------------------------------------------------------------
+#     # Descrição:
+#     # Grupo contendo variáveis utilizadas na função atual.
+#     # >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
+
+#     # [C] REFERENCIAMENTO DE VARIÁVEIS GLOBAIS    
+#     # -------------------------------------------------------------
+#     # Descrição:
+#     # Referenciamento de variáveis globais (suas  descrições  estão
+#     # no grupo de variáveis globais localizadas no escopo do início
+#     # do Script).
+#     # >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
+#     global file_TerminalFile
+#     # >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
+#     # -------------------------------------------------------------
+
+#     # >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
+#     # -------------------------------------------------------------
+
+
+#     # [i] Caso o programador decida abrir o arquivo
+#     if (asOpen):
+#         # [>] Abre o arquivo de saída do terminal com "append"
+#         file_TerminalFile = open(filepath_TerminalFile, "a", encoding="UTF-8")
+#     # [i] Caso o programador decida fechar o arquivo
+#     else:
+#         # [>] Fecha o arquivo de saída do terminal
+#         file_TerminalFile.close()
+# # >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
+# # -------------------------------------------------------------
+
+# # [F] EXIBE UMA MENSAGEM DE ERRO
+# # -------------------------------------------------------------
+# # Descrição:
+# # Função responsável por exibir mensagens de erros  disponíveis
+# # nas Exceptions.
+# # >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
+# def ShowError(errorMessage, exceptionError = "", exitProgram = False, recreateTerminalFile = False):
+#     # [>] Se desejado, recriar o arquivo de saída do terminal
+#     if (recreateTerminalFile):
+#         # [>] Recria o arquivo de saída do terminal
+#         RecreateTerminalFile()
     
-    # [>] Justifica o conteúdo da mensagem corretamente
-    errorMessage = '\n'.join(re.findall('.{1,%i}' % 58, errorMessage))
-    # [>] Justifica a Exception corretamente
-    exceptionError = '\n'.join(re.findall('.{1,%i}' % 58, str(exceptionError)))
-
-    # [>] Abre o arquivo de saída do terminal
-    SetTerminalFile(asOpen = True)
-    # [>] Monta a caixa de mensagem
-    print(
-        "=============================================================\n"
-        "                                                             \n"
-        "                                                             \n"
-        "MENSAGEM DE RETORNO                                          \n"
-        "-------------------------------------------------------------\n"
-        "<d>" + errorMessage + "</d>\n"
-        ">>>>>>>>>>>>>>>>>>>>>>>>>>>>>> <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<\n"
-        "<e>" + str(exceptionError) + "</e>\n"
-        ">>>>>>>>>>>>>>>>>>>>>>>>>>>>>> <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<\n"
-        "-------------------------------------------------------------\n"
-        "                                                             \n"
-        "                                                             \n"
-        "=============================================================\n",
+#     # [>] Justifica o conteúdo da mensagem corretamente
+#     errorMessage = '\n'.join(re.findall('.{1,%i}' % 58, errorMessage))
+#     # [>] Justifica a Exception corretamente
+#     exceptionError = '\n'.join(re.findall('.{1,%i}' % 58, str(exceptionError)))
+
+#     # [>] Abre o arquivo de saída do terminal
+#     SetTerminalFile(asOpen = True)
+#     # [>] Monta a caixa de mensagem
+#     print(
+#         "=============================================================\n"
+#         "                                                             \n"
+#         "                                                             \n"
+#         "MENSAGEM DE RETORNO                                          \n"
+#         "-------------------------------------------------------------\n"
+#         "<d>" + errorMessage + "</d>\n"
+#         ">>>>>>>>>>>>>>>>>>>>>>>>>>>>>> <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<\n"
+#         "<e>" + str(exceptionError) + "</e>\n"
+#         ">>>>>>>>>>>>>>>>>>>>>>>>>>>>>> <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<\n"
+#         "-------------------------------------------------------------\n"
+#         "                                                             \n"
+#         "                                                             \n"
+#         "=============================================================\n",
         
-        file = file_TerminalFile
-    )
-    # [>] Fecha o arquivo de saída do terminal
-    SetTerminalFile(asOpen = False)
-
-    # [>] Se desejado sair do programa
-    if (exitProgram):
-        # [>] Para o programa ao exibir o erro
-        sys.exit()
-# >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
-# -------------------------------------------------------------
-
-#endregion
-# >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
-# -------------------------------------------------------------
-
-# [G] CONVERSÃO
-# -------------------------------------------------------------
-# Descrição:
-# Grupo que contém funções que realizam a conversão dos  arqui-
-# vos PDF e toda a formatação necessária.
-# >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
-#region
-
-# TORNANDO O CABEÇALHO EM UMA LINHA COMUM
-# -------------------------------------------------------------
-# Descrição:
-# Isso é necessário para fazer com que não haja quebra de linha
-# onde o DataFrame identifica como cabeçalho (título) da tabela
-# caso o conteúdo delas seja muito grande.
-# Isso acontece porque o título tem uma formatação gerada  pelo
-# DataFrame que difere-se do corpo, o que acaba permitindo  que
-# isso ocorra. O trabalho dessa função é transformar o  cabeça-
-# lho em um texto de campo comum.
-# >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
-def TurnHeaderInSimpleRow(tableDataFrame):
-    # [>] Cria e limpa uma lista que vai ser usada para manipular o
-    # cabeçalho no DataFrame
-    tableDataFrameHeader = []
-
-    # [>] Pegando o cabeçalho da tabela e passando ela  como  lista
-    # para a temporária
-    tableDataFrameHeader = [*tableDataFrame]
-
-    # [i] Checando se a lista com o cabeçalho veio preenchida e  se
-    # o cabeçalho não possui campos vazios
-    if (tableDataFrameHeader and not "Unnamed" in tableDataFrameHeader[0]):
-        # [>] Removendo o cabeçalho do DataFrame atual
-        tableDataFrame = tableDataFrame.T.reset_index().T.reset_index(drop=True)
-
-        # [>] Adicionando a lista como primeira linha do corpo do Data-
-        # Frame temporário
-        tableDataFrameHeader.insert(1, tableDataFrameHeader)
-
-        # [>] Concatenando tabela temporária à tabela principal
-        pandas.concat([pandas.DataFrame(tableDataFrameHeader), tableDataFrame], ignore_index=True)
-# >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
-# -------------------------------------------------------------
-
-# [F] REALIZA A CONVERSÃO DO ARQUIVO
-# -------------------------------------------------------------
-# Descrição:
-# Realiza a conversão do arquivo PDF para CSV como  arquivo  de
-# texto.
-# >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
-def ConversionStart(conversionMethod, tableDataFrame):
-    # [V] VARIÁVEIS
-    # -------------------------------------------------------------
-    # Descrição:
-    # Grupo contendo variáveis utilizadas na função atual.
-    # >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
-
-    # [C] REFERENCIAMENTO DE VARIÁVEIS GLOBAIS    
-    # -------------------------------------------------------------
-    # Descrição:
-    # Referenciamento de variáveis globais (suas  descrições  estão
-    # no grupo de variáveis globais localizadas no escopo do início
-    # do Script).
-    # >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
-    global filepath_ExportTxt
-    global index_DataFrame
-    # >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
-    # -------------------------------------------------------------
-
-    # >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
-    # -------------------------------------------------------------
-
-
-    try:
-        # [>] Deleta todas as linhas que estão completamente vazias
-        tableDataFrame = tableDataFrame.dropna(how="all")
+#         file = file_TerminalFile
+#     )
+#     # [>] Fecha o arquivo de saída do terminal
+#     SetTerminalFile(asOpen = False)
+
+#     # [>] Se desejado sair do programa
+#     if (exitProgram):
+#         # [>] Para o programa ao exibir o erro
+#         sys.exit()
+# # >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
+# # -------------------------------------------------------------
+
+# #endregion
+# # >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
+# # -------------------------------------------------------------
+
+# # [G] CONVERSÃO
+# # -------------------------------------------------------------
+# # Descrição:
+# # Grupo que contém funções que realizam a conversão dos  arqui-
+# # vos PDF e toda a formatação necessária.
+# # >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
+# #region
+
+# # TORNANDO O CABEÇALHO EM UMA LINHA COMUM
+# # -------------------------------------------------------------
+# # Descrição:
+# # Isso é necessário para fazer com que não haja quebra de linha
+# # onde o DataFrame identifica como cabeçalho (título) da tabela
+# # caso o conteúdo delas seja muito grande.
+# # Isso acontece porque o título tem uma formatação gerada  pelo
+# # DataFrame que difere-se do corpo, o que acaba permitindo  que
+# # isso ocorra. O trabalho dessa função é transformar o  cabeça-
+# # lho em um texto de campo comum.
+# # >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
+# def TurnHeaderInSimpleRow(tableDataFrame):
+#     # [>] Cria e limpa uma lista que vai ser usada para manipular o
+#     # cabeçalho no DataFrame
+#     tableDataFrameHeader = []
+
+#     # [>] Pegando o cabeçalho da tabela e passando ela  como  lista
+#     # para a temporária
+#     tableDataFrameHeader = [*tableDataFrame]
+
+#     # [i] Checando se a lista com o cabeçalho veio preenchida e  se
+#     # o cabeçalho não possui campos vazios
+#     if (tableDataFrameHeader and not "Unnamed" in tableDataFrameHeader[0]):
+#         # [>] Removendo o cabeçalho do DataFrame atual
+#         tableDataFrame = tableDataFrame.T.reset_index().T.reset_index(drop=True)
+
+#         # [>] Adicionando a lista como primeira linha do corpo do Data-
+#         # Frame temporário
+#         tableDataFrameHeader.insert(1, tableDataFrameHeader)
+
+#         # [>] Concatenando tabela temporária à tabela principal
+#         pandas.concat([pandas.DataFrame(tableDataFrameHeader), tableDataFrame], ignore_index=True)
+# # >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
+# # -------------------------------------------------------------
+
+# # [F] REALIZA A CONVERSÃO DO ARQUIVO
+# # -------------------------------------------------------------
+# # Descrição:
+# # Realiza a conversão do arquivo PDF para CSV como  arquivo  de
+# # texto.
+# # >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
+# def ConversionStart(conversionMethod, tableDataFrame):
+#     # [V] VARIÁVEIS
+#     # -------------------------------------------------------------
+#     # Descrição:
+#     # Grupo contendo variáveis utilizadas na função atual.
+#     # >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
+
+#     # [C] REFERENCIAMENTO DE VARIÁVEIS GLOBAIS    
+#     # -------------------------------------------------------------
+#     # Descrição:
+#     # Referenciamento de variáveis globais (suas  descrições  estão
+#     # no grupo de variáveis globais localizadas no escopo do início
+#     # do Script).
+#     # >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
+#     global filepath_ExportTxt
+#     global index_DataFrame
+#     # >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
+#     # -------------------------------------------------------------
+
+#     # >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
+#     # -------------------------------------------------------------
+
+
+#     try:
+#         # [>] Deleta todas as linhas que estão completamente vazias
+#         tableDataFrame = tableDataFrame.dropna(how="all")
         
-        # [>] Deleta todas as colunas que estão  completamente  va-
-        # zias
-        tableDataFrame = tableDataFrame.dropna(how="all", axis=1)
-
-        # [>] Chama a função que transforma o cabeçalho em  uma li-
-        # nha comum
-        TurnHeaderInSimpleRow(tableDataFrame)
-
-        # [>] Remove quebras de linha do  DataFrame  que  acontecem
-        # por conta do corpo ser muito grande
-        tableDataFrame.replace({r"\r": " "}, inplace=True, regex=True)
-
-        # [>] Troca ponto e vírgula dentro do DataFrame para evitar
-        # conflitos
-        tableDataFrame.replace({r";": ","}, inplace=True, regex=True)
-
-        # [>] Define o caminho do arquivo  atual  para  a  variável
-        # global filepath_ExportTxt
-        filepath_ExportTxt = folderpath_Export + "\\resultados\\" + conversionMethod + "\\withoutFormatting\\" + filename_PDF + ".txt"
-
-        # [>] Converte o arquivo para .txt no formato de um CSV
-        tableDataFrame.to_csv(
-            filepath_ExportTxt,
-            index = False,
-            index_label = False,
-            header = True,
-            line_terminator = "\n", # [i] Define a quebra de linha como '\n' para evitar conflito com o terminal que gera \r
-            mode = "a",
-            sep = ";",
-            quoting = csv.QUOTE_ALL
-        )
-
-        # [>] Indica ao terminal que uma tabela foi convertida  com
-        # sucesso
-        SetTerminalFile(True)
-        print(
-            "\n\n"
-            "          A tabela nº"+ str(index_DataFrame) + " do '" + filename_PDF + "' foi convertida usando '" + conversionMethod + "'\n"
-            "\________________________________________________________________________________/\n" +
-            "Search this (Ctrl + F): '" + filename_PDF + " " + conversionMethod + " tbl" + str(index_DataFrame) + "'\n",
+#         # [>] Deleta todas as colunas que estão  completamente  va-
+#         # zias
+#         tableDataFrame = tableDataFrame.dropna(how="all", axis=1)
+
+#         # [>] Chama a função que transforma o cabeçalho em  uma li-
+#         # nha comum
+#         TurnHeaderInSimpleRow(tableDataFrame)
+
+#         # [>] Remove quebras de linha do  DataFrame  que  acontecem
+#         # por conta do corpo ser muito grande
+#         tableDataFrame.replace({r"\r": " "}, inplace=True, regex=True)
+
+#         # [>] Troca ponto e vírgula dentro do DataFrame para evitar
+#         # conflitos
+#         tableDataFrame.replace({r";": ","}, inplace=True, regex=True)
+
+#         # [>] Define o caminho do arquivo  atual  para  a  variável
+#         # global filepath_ExportTxt
+#         filepath_ExportTxt = folderpath_Export + "\\resultados\\" + conversionMethod + "\\withoutFormatting\\" + filename_PDF + ".txt"
+
+#         # [>] Converte o arquivo para .txt no formato de um CSV
+#         tableDataFrame.to_csv(
+#             filepath_ExportTxt,
+#             index = False,
+#             index_label = False,
+#             header = True,
+#             line_terminator = "\n", # [i] Define a quebra de linha como '\n' para evitar conflito com o terminal que gera \r
+#             mode = "a",
+#             sep = ";",
+#             quoting = csv.QUOTE_ALL
+#         )
+
+#         # [>] Indica ao terminal que uma tabela foi convertida  com
+#         # sucesso
+#         SetTerminalFile(True)
+#         print(
+#             "\n\n"
+#             "          A tabela nº"+ str(index_DataFrame) + " do '" + filename_PDF + "' foi convertida usando '" + conversionMethod + "'\n"
+#             "\________________________________________________________________________________/\n" +
+#             "Search this (Ctrl + F): '" + filename_PDF + " " + conversionMethod + " tbl" + str(index_DataFrame) + "'\n",
             
-            file = file_TerminalFile
-        )
-
-        # [>] Imprime o DataFrame
-        print(pandas.DataFrame(tableDataFrame), file = file_TerminalFile)
-        SetTerminalFile(False)
-
-        index_DataFrame += 1
-    # [>] Caso haja um erro desconhecido na hora de realizar a con-
-    # versão
-    except Exception as exceptionError:
-        # [>] Exibe uma mensagem de erro
-        ShowError(
-            "Arquivo: " + filename_PDF + "\n"
-            "Método de Conversão: " + conversionMethod + "\n"
-            "\n"
-            "Ocorreu um erro, ao tentar converter o "
-            "arquivo '" + filename_PDF + ".pdf' usando o "
-            "método " + conversionMethod + ".",
+#             file = file_TerminalFile
+#         )
+
+#         # [>] Imprime o DataFrame
+#         print(pandas.DataFrame(tableDataFrame), file = file_TerminalFile)
+#         SetTerminalFile(False)
+
+#         index_DataFrame += 1
+#     # [>] Caso haja um erro desconhecido na hora de realizar a con-
+#     # versão
+#     except Exception as exceptionError:
+#         # [>] Exibe uma mensagem de erro
+#         ShowError(
+#             "Arquivo: " + filename_PDF + "\n"
+#             "Método de Conversão: " + conversionMethod + "\n"
+#             "\n"
+#             "Ocorreu um erro, ao tentar converter o "
+#             "arquivo '" + filename_PDF + ".pdf' usando o "
+#             "método " + conversionMethod + ".",
             
-            exceptionError
-        )
-        return
-# >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
-# -------------------------------------------------------------
-
-# [F] LIMPA O ARQUIVO DE TEXTO CONVERTIDO
-# -------------------------------------------------------------
-# Descrição:
-# Limpa o arquivo de texto removendo todas as  linhas  que  não
-# contenham um separador (;), ou seja,  linhas  que  não  fazem
-# parte de uma tabela.
-# >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
-def FormatTextFile(conversionMethod):
-    # [V] VARIÁVEIS
-    # -------------------------------------------------------------
-    # Descrição:
-    # Grupo contendo variáveis utilizadas na função atual.
-    # >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
-
-    # [C] REFERENCIAMENTO DE VARIÁVEIS GLOBAIS    
-    # -------------------------------------------------------------
-    # Descrição:
-    # Referenciamento de variáveis globais (suas  descrições  estão
-    # no grupo de variáveis globais localizadas no escopo do início
-    # do Script).
-    # >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
-    global filepath_ExportTxt
-    # >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
-    # -------------------------------------------------------------
-
-    # [C] CAMINHOS
-    # -------------------------------------------------------------
-    # Descrição:
-    # Variáveis que armazenam caminhos dos tipos de formatação.
-    # >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
-    # [i] Formatação padrão, apenas exibindo caso e caso  tenha pe-
-    # lo menos um separador ";" na linha e removendo campos vazios
-    txtMainPath = folderpath_Export + "\\resultados\\" + conversionMethod + "\\main\\" + filename_PDF + ".txt"
-    # [i] Formatação padrão, porém mantendo campos vazios
-    txtReturnBlankCellsPath = folderpath_Export + "\\resultados\\" + conversionMethod + "\\tableWithBlankCells\\" + filename_PDF + ".txt"
-    # [i] Full Clear, formatação mais robusta
-    txtFullClearPath = folderpath_Export + "\\resultados\\" + conversionMethod + "\\fullClear\\" + filename_PDF + ".txt"
-    # >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
-    # -------------------------------------------------------------
-
-    # >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
-    # -------------------------------------------------------------
-
-
-    # [i] Abre o arquivo original presente na pasta 'withoutFormat-
-    # ting' para criar formatações baseadas nele
-    with open(filepath_ExportTxt, "r", encoding="UTF-8") as txtFile:
-        # ARQUIVOS
-        # -------------------------------------------------------------
-        # Descrição:
-        # Arquivo para caso a tabela possua itens vazios  que  precisam
-        # ser computados (esse arquivo apenas não terá o regex que apa-
-        # ga dados vazios e similares)
-        # >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
-        # [>] Abre o arquivo de texto "tableWithBlankCells"
-        txtTableWithBlankCells = open(txtReturnBlankCellsPath, "a", encoding="UTF-8")
-        # [>] Abre o arquivo principal (ainda não totalmente pronto pa-
-        # ra ser jogado em uma tabela possui mais dados, porém estrutu-
-        # ra ainda não tão idealizada)
-        txtMainFile = open(txtMainPath, "a", encoding="UTF-8")
-        # >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
-        # -------------------------------------------------------------
-
-        # [i] Navega por cada linha do documento de texto
-        for line in txtFile:
-            # [>] Detecta os dados vazios que estão presentes no  cabeçalho
-            # "Unnamed: X;"
-            line = re.sub(r"(\s?\"Unnamed:\s\d\d?\";?)", "", line)
-
-            # [>] Remove quebras de linha caso seja no meio dos  dados,  ou
-            # seja, caso não possua '"' atrás da quebra de linha e as subs-
-            # titui por um espaço para manter o padrão
-            line = re.sub(r"((?<!\")\n)", " ", line)
-
-            # Condicional que impede o continuamento do processo caso a va-
-            # riável esteja vazia, ou seja, caso tenha  sido  apagada  pelo
-            # processo anterior de limpeza
-            if (line != ""):
-                # [>] Remove ponto e vírgula no final da linha
-                line = re.sub(r"((?<=\");(?!.))", "", line)
+#             exceptionError
+#         )
+#         return
+# # >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
+# # -------------------------------------------------------------
+
+# # [F] LIMPA O ARQUIVO DE TEXTO CONVERTIDO
+# # -------------------------------------------------------------
+# # Descrição:
+# # Limpa o arquivo de texto removendo todas as  linhas  que  não
+# # contenham um separador (;), ou seja,  linhas  que  não  fazem
+# # parte de uma tabela.
+# # >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
+# def FormatTextFile(conversionMethod):
+#     # [V] VARIÁVEIS
+#     # -------------------------------------------------------------
+#     # Descrição:
+#     # Grupo contendo variáveis utilizadas na função atual.
+#     # >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
+
+#     # [C] REFERENCIAMENTO DE VARIÁVEIS GLOBAIS    
+#     # -------------------------------------------------------------
+#     # Descrição:
+#     # Referenciamento de variáveis globais (suas  descrições  estão
+#     # no grupo de variáveis globais localizadas no escopo do início
+#     # do Script).
+#     # >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
+#     global filepath_ExportTxt
+#     # >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
+#     # -------------------------------------------------------------
+
+#     # [C] CAMINHOS
+#     # -------------------------------------------------------------
+#     # Descrição:
+#     # Variáveis que armazenam caminhos dos tipos de formatação.
+#     # >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
+#     # [i] Formatação padrão, apenas exibindo caso e caso  tenha pe-
+#     # lo menos um separador ";" na linha e removendo campos vazios
+#     txtMainPath = folderpath_Export + "\\resultados\\" + conversionMethod + "\\main\\" + filename_PDF + ".txt"
+#     # [i] Formatação padrão, porém mantendo campos vazios
+#     txtReturnBlankCellsPath = folderpath_Export + "\\resultados\\" + conversionMethod + "\\tableWithBlankCells\\" + filename_PDF + ".txt"
+#     # [i] Full Clear, formatação mais robusta
+#     txtFullClearPath = folderpath_Export + "\\resultados\\" + conversionMethod + "\\fullClear\\" + filename_PDF + ".txt"
+#     # >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
+#     # -------------------------------------------------------------
+
+#     # >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
+#     # -------------------------------------------------------------
+
+
+#     # [i] Abre o arquivo original presente na pasta 'withoutFormat-
+#     # ting' para criar formatações baseadas nele
+#     with open(filepath_ExportTxt, "r", encoding="UTF-8") as txtFile:
+#         # ARQUIVOS
+#         # -------------------------------------------------------------
+#         # Descrição:
+#         # Arquivo para caso a tabela possua itens vazios  que  precisam
+#         # ser computados (esse arquivo apenas não terá o regex que apa-
+#         # ga dados vazios e similares)
+#         # >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
+#         # [>] Abre o arquivo de texto "tableWithBlankCells"
+#         txtTableWithBlankCells = open(txtReturnBlankCellsPath, "a", encoding="UTF-8")
+#         # [>] Abre o arquivo principal (ainda não totalmente pronto pa-
+#         # ra ser jogado em uma tabela possui mais dados, porém estrutu-
+#         # ra ainda não tão idealizada)
+#         txtMainFile = open(txtMainPath, "a", encoding="UTF-8")
+#         # >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
+#         # -------------------------------------------------------------
+
+#         # [i] Navega por cada linha do documento de texto
+#         for line in txtFile:
+#             # [>] Detecta os dados vazios que estão presentes no  cabeçalho
+#             # "Unnamed: X;"
+#             line = re.sub(r"(\s?\"Unnamed:\s\d\d?\";?)", "", line)
+
+#             # [>] Remove quebras de linha caso seja no meio dos  dados,  ou
+#             # seja, caso não possua '"' atrás da quebra de linha e as subs-
+#             # titui por um espaço para manter o padrão
+#             line = re.sub(r"((?<!\")\n)", " ", line)
+
+#             # Condicional que impede o continuamento do processo caso a va-
+#             # riável esteja vazia, ou seja, caso tenha  sido  apagada  pelo
+#             # processo anterior de limpeza
+#             if (line != ""):
+#                 # [>] Remove ponto e vírgula no final da linha
+#                 line = re.sub(r"((?<=\");(?!.))", "", line)
                 
-                # [>] Remove todos os espaços no início de cada linha
-                line = re.sub(r"(^\ *)", "", line)
-
-                # [i] Se a linha possui aspas duplas no início  e  no  final  e
-                # ainda possui menos que duas colunas cancela o código
-                if (
-                    (
-                        (
-                            line.startswith("\"")
-                        )
-                        and 
-                        (
-                            line.endswith("\"") or line.endswith("\n")
-                        )
-                    )
-                    and
-                    (line.count("\"") < 3 and line.count(";") < 1)
-                ):
-                    # [>] Não executa o código seguinte
-                    continue
-
-                # [e] Exportação para a pasta: \\tableWithBlankCells
-                txtTableWithBlankCells.write(line)
+#                 # [>] Remove todos os espaços no início de cada linha
+#                 line = re.sub(r"(^\ *)", "", line)
+
+#                 # [i] Se a linha possui aspas duplas no início  e  no  final  e
+#                 # ainda possui menos que duas colunas cancela o código
+#                 if (
+#                     (
+#                         (
+#                             line.startswith("\"")
+#                         )
+#                         and 
+#                         (
+#                             line.endswith("\"") or line.endswith("\n")
+#                         )
+#                     )
+#                     and
+#                     (line.count("\"") < 3 and line.count(";") < 1)
+#                 ):
+#                     # [>] Não executa o código seguinte
+#                     continue
+
+#                 # [e] Exportação para a pasta: \\tableWithBlankCells
+#                 txtTableWithBlankCells.write(line)
                 
-                # [>] Remove dados que estão vazios
-                line = re.sub(r"(;\"\")|(\"\";)", "", line)
-
-                # [>] Faz uma quebra de linha caso tenha aspas duplas  adjacen-
-                # tes
-                line = re.sub(r"(?<=\")(?=\")", "\n", line)
-
-                # [>] Caso tenha um ponto e vírgula seguido de um espaço  troca
-                # por uma quebra de linha
-                line = re.sub(r"((?<=\");\ )", "\n", line)
-
-                # [>] Caso tenha um espaço entre um separador e uma aspas dupla
-                # remove o conteúdo que está atrás
-                line = re.sub(r"((.*\";\ )(?=\"))", "", line)
-
-                # [i] Se a linha possui aspas duplas no início  e  no  final  e
-                # ainda possui menos que duas colunas cancela o código
-                if (
-                    (
-                        (
-                            line.startswith("\"")
-                        )
-                        and 
-                        (
-                            line.endswith("\"") or line.endswith("\n")
-                        )
-                    )
-                    and
-                    (line.count("\"") < 3 and line.count(";") < 1)
-                ):
-                    # [>] Não executa o código seguinte
-                    continue
-
-                # [e] Exportação para a pasta: \\main
-                txtMainFile.write(line)
+#                 # [>] Remove dados que estão vazios
+#                 line = re.sub(r"(;\"\")|(\"\";)", "", line)
+
+#                 # [>] Faz uma quebra de linha caso tenha aspas duplas  adjacen-
+#                 # tes
+#                 line = re.sub(r"(?<=\")(?=\")", "\n", line)
+
+#                 # [>] Caso tenha um ponto e vírgula seguido de um espaço  troca
+#                 # por uma quebra de linha
+#                 line = re.sub(r"((?<=\");\ )", "\n", line)
+
+#                 # [>] Caso tenha um espaço entre um separador e uma aspas dupla
+#                 # remove o conteúdo que está atrás
+#                 line = re.sub(r"((.*\";\ )(?=\"))", "", line)
+
+#                 # [i] Se a linha possui aspas duplas no início  e  no  final  e
+#                 # ainda possui menos que duas colunas cancela o código
+#                 if (
+#                     (
+#                         (
+#                             line.startswith("\"")
+#                         )
+#                         and 
+#                         (
+#                             line.endswith("\"") or line.endswith("\n")
+#                         )
+#                     )
+#                     and
+#                     (line.count("\"") < 3 and line.count(";") < 1)
+#                 ):
+#                     # [>] Não executa o código seguinte
+#                     continue
+
+#                 # [e] Exportação para a pasta: \\main
+#                 txtMainFile.write(line)
     
-    # [>] Fecha o arquivo 'tableWithBlankCells'
-    txtTableWithBlankCells.close()
-    # [>] Fecha o arquivo 'main'
-    txtMainFile.close()
-
-    # [>] Abre o arquivo principal presente na  pasta  'main'  para
-    # criar formatações baseadas nele
-    with open(txtMainPath, "r", encoding="UTF-8") as txtFile:
-        # [>] Abre o arquivo de texto para  realizar  a  exportação
-        # fullClear
-        txtFullClearFile = open(txtFullClearPath, "a", encoding="UTF-8")
-
-        # [i] Navega por cada linha do documento de texto
-        for line in txtFile:
-            # [>] Caso a linha não comece com aspas deleta
-            line = re.sub(r"((^[^\"]).*)", "", line)
+#     # [>] Fecha o arquivo 'tableWithBlankCells'
+#     txtTableWithBlankCells.close()
+#     # [>] Fecha o arquivo 'main'
+#     txtMainFile.close()
+
+#     # [>] Abre o arquivo principal presente na  pasta  'main'  para
+#     # criar formatações baseadas nele
+#     with open(txtMainPath, "r", encoding="UTF-8") as txtFile:
+#         # [>] Abre o arquivo de texto para  realizar  a  exportação
+#         # fullClear
+#         txtFullClearFile = open(txtFullClearPath, "a", encoding="UTF-8")
+
+#         # [i] Navega por cada linha do documento de texto
+#         for line in txtFile:
+#             # [>] Caso a linha não comece com aspas deleta
+#             line = re.sub(r"((^[^\"]).*)", "", line)
             
-            # [>] Caso a linha não termine com aspas deleta
-            line = re.sub('"(.*([^"\n]$))', "", line)
-
-            # [>] Remove Linhas vazias que só possuem quebra de linha  '\n'
-            # ou não possuem uma aspas dupla em nenhum lugar, serão excluí-
-            # das 
-            lineRemovedQuotes = ""
-            lineRemovedQuotes = re.sub(r"\"", "", line)
-
-            # [i] Se a temporária permanece igual, ou seja, não teve  aspas
-            # duplas removidas pelo regex
-            if (line == lineRemovedQuotes):
-                # Quer dizer que ela ta errada e vai ser apagada
-                line = ""
+#             # [>] Caso a linha não termine com aspas deleta
+#             line = re.sub('"(.*([^"\n]$))', "", line)
+
+#             # [>] Remove Linhas vazias que só possuem quebra de linha  '\n'
+#             # ou não possuem uma aspas dupla em nenhum lugar, serão excluí-
+#             # das 
+#             lineRemovedQuotes = ""
+#             lineRemovedQuotes = re.sub(r"\"", "", line)
+
+#             # [i] Se a temporária permanece igual, ou seja, não teve  aspas
+#             # duplas removidas pelo regex
+#             if (line == lineRemovedQuotes):
+#                 # Quer dizer que ela ta errada e vai ser apagada
+#                 line = ""
             
-            # [i] Só escreve a linha se tiver pelo menos mais que 3 colunas
-            # no arquivo fullClear
-            if (line.count("\"") > 6 and
-                line.count(";") > 2):
-                # [e] Exportação para a pasta: \\fullClear
-                txtFullClearFile.write(line)
-# >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
-# -------------------------------------------------------------
-
-#endregion
-# >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
-# -------------------------------------------------------------
-
-
-# [G] MANIPULAÇÃO DE ARGUMENTOS
-# -------------------------------------------------------------
-# Descrição:
-# Grupo que contém funções que realizam a manipulação da bibli-
-# oteca que manipula argumentos, a 'argparse'.
-# >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
-#region
-
-# [F] CRIA O PARSER
-# -------------------------------------------------------------
-# Descrição:
-# Função que cria o parser que vai manipular os argumentos for-
-# necidos pelo usuário.
-# >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
-def CreateParser():
-    # [V] VARIÁVEIS
-    # -------------------------------------------------------------
-    # Descrição:
-    # Grupo contendo variáveis utilizadas na função atual.
-    # >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
-
-    # [C] REFERENCIAMENTO DE VARIÁVEIS GLOBAIS    
-    # -------------------------------------------------------------
-    # Descrição:
-    # Referenciamento de variáveis globais (suas  descrições  estão
-    # no grupo de variáveis globais localizadas no escopo do início
-    # do Script).
-    # >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
-    global parser_Main
-    global parser_ArgsMain
-    # >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
-    # -------------------------------------------------------------
-
-    # >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
-    # -------------------------------------------------------------
-
-
-    # [>] Criando parser sem permitir abreviação
-    parser_Main = argparse.ArgumentParser(allow_abbrev=False)
-
-
-    # ARGUMENTOS UTILIZADOS NO PARSER
-    # -------------------------------------------------------------
-    # Descrição:
-    # Aqui estão dispostos os argumentos que vão ser passados  para
-    # o parser mais tarde.
-    # >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
-    # [i] Argumento   que   conterá   o  caminho   de    importação
-    # (Obrigatório)
-    parser_Main.add_argument(
-        "--importPath",
-        required = False,
-        default = "C:\\users\\dvp10\\desktop",
-        type = str
-    )
-    # [i] Argumento que conterá o caminho de exportação (Opcional)
-    parser_Main.add_argument(
-        "--exportPath",
-        required = False,
-        default = "C:\\users\\dvp10\\desktop",
-        type = str
-    )
-    # >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
-    # -------------------------------------------------------------
-
-
-    try:
-        # [>] Adiciona os argumentos informados anteriormente na região
-        # anterior ao parser
-        parser_ArgsMain = parser_Main.parse_args()
-    except:
-        # [>] Exibe mensagem de erro caso não tenha sido informado  um
-        # caminho de importação
-        ShowError("É necessário informar um caminho de importação.")
-# >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
-# -------------------------------------------------------------
-
-# [F] CHECA SE A PASTA PASSADA NO PARÂMETRO EXISTE
-# -------------------------------------------------------------
-# Descrição:
-# Função que faz uma validação de existência de uma pasta  pas-
-# sada como argumento.
-# >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
-def CheckIfFolderExists(folderThatWillBeChecked = ""):
-    # [>] Instancia a variável como não existente
-    currentFolderExists = False
-    # [i] Se a pasta fornecida existe
-    if (os.path.isdir(str(folderThatWillBeChecked))):
-        # [>] Define a mesma como existente na variável
-        currentFolderExists = True
-    # [>] Retorna pra função
-    return currentFolderExists
-# >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
-# -------------------------------------------------------------
-
-def ValidateArguments():
-    global folderpath_Import
-    global folderpath_Export
-    global readPDFPages
+#             # [i] Só escreve a linha se tiver pelo menos mais que 3 colunas
+#             # no arquivo fullClear
+#             if (line.count("\"") > 6 and
+#                 line.count(";") > 2):
+#                 # [e] Exportação para a pasta: \\fullClear
+#                 txtFullClearFile.write(line)
+# # >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
+# # -------------------------------------------------------------
+
+# #endregion
+# # >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
+# # -------------------------------------------------------------
+
+
+# # [G] MANIPULAÇÃO DE ARGUMENTOS
+# # -------------------------------------------------------------
+# # Descrição:
+# # Grupo que contém funções que realizam a manipulação da bibli-
+# # oteca que manipula argumentos, a 'argparse'.
+# # >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
+# #region
+
+# # [F] CRIA O PARSER
+# # -------------------------------------------------------------
+# # Descrição:
+# # Função que cria o parser que vai manipular os argumentos for-
+# # necidos pelo usuário.
+# # >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
+# def CreateParser():
+#     # [V] VARIÁVEIS
+#     # -------------------------------------------------------------
+#     # Descrição:
+#     # Grupo contendo variáveis utilizadas na função atual.
+#     # >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
+
+#     # [C] REFERENCIAMENTO DE VARIÁVEIS GLOBAIS    
+#     # -------------------------------------------------------------
+#     # Descrição:
+#     # Referenciamento de variáveis globais (suas  descrições  estão
+#     # no grupo de variáveis globais localizadas no escopo do início
+#     # do Script).
+#     # >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
+#     global parser_Main
+#     global parser_ArgsMain
+#     # >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
+#     # -------------------------------------------------------------
+
+#     # >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
+#     # -------------------------------------------------------------
+
+
+#     # [>] Criando parser sem permitir abreviação
+#     parser_Main = argparse.ArgumentParser(allow_abbrev=False)
+
+
+#     # ARGUMENTOS UTILIZADOS NO PARSER
+#     # -------------------------------------------------------------
+#     # Descrição:
+#     # Aqui estão dispostos os argumentos que vão ser passados  para
+#     # o parser mais tarde.
+#     # >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
+#     # [i] Argumento   que   conterá   o  caminho   de    importação
+#     # (Obrigatório)
+#     parser_Main.add_argument(
+#         "--importPath",
+#         required = False,
+#         default = "C:\\users\\dvp10\\desktop",
+#         type = str
+#     )
+#     # [i] Argumento que conterá o caminho de exportação (Opcional)
+#     parser_Main.add_argument(
+#         "--exportPath",
+#         required = False,
+#         default = "C:\\users\\dvp10\\desktop",
+#         type = str
+#     )
+#     # >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
+#     # -------------------------------------------------------------
+
+
+#     try:
+#         # [>] Adiciona os argumentos informados anteriormente na região
+#         # anterior ao parser
+#         parser_ArgsMain = parser_Main.parse_args()
+#     except:
+#         # [>] Exibe mensagem de erro caso não tenha sido informado  um
+#         # caminho de importação
+#         ShowError("É necessário informar um caminho de importação.")
+# # >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
+# # -------------------------------------------------------------
+
+# # [F] CHECA SE A PASTA PASSADA NO PARÂMETRO EXISTE
+# # -------------------------------------------------------------
+# # Descrição:
+# # Função que faz uma validação de existência de uma pasta  pas-
+# # sada como argumento.
+# # >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
+# def CheckIfFolderExists(folderThatWillBeChecked = ""):
+#     # [>] Instancia a variável como não existente
+#     currentFolderExists = False
+#     # [i] Se a pasta fornecida existe
+#     if (os.path.isdir(str(folderThatWillBeChecked))):
+#         # [>] Define a mesma como existente na variável
+#         currentFolderExists = True
+#     # [>] Retorna pra função
+#     return currentFolderExists
+# # >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
+# # -------------------------------------------------------------
+
+# def ValidateArguments():
+#     global folderpath_Import
+#     global folderpath_Export
+#     global readPDFPages
 
     
-    # Abre o arquivo de saída do terminal
-    SetTerminalFile(True)
-
-
-    # Se for recebido dois valores
-    if("frstPage" == "isNumberAndNotEmpty" and "scndPage" == "isNumberAndNotEmpty"):
-        # Procura no intervalo de páginas
-        readPDFPages = "frstPage" + "-" + "scndPage"
-    # Se for recebido um valor apenas
-    elif("frstPage" == "isNumberAndNotEmpty"):
-        # Procura na página solicitada
-        return
-    # Se não for recebido nenhum valor
-    elif("frstPage" == "empty" and "scndPage" == "empty"):
-        # Procura todas as páginas
-        return
-    # Se não encaixar nas outras condicionais
-    else:
-        print("erro")
-        # Retorna erro
-        return
-
-    readPDFPages = "all"
+#     # Abre o arquivo de saída do terminal
+#     SetTerminalFile(True)
+
+
+#     # Se for recebido dois valores
+#     if("frstPage" == "isNumberAndNotEmpty" and "scndPage" == "isNumberAndNotEmpty"):
+#         # Procura no intervalo de páginas
+#         readPDFPages = "frstPage" + "-" + "scndPage"
+#     # Se for recebido um valor apenas
+#     elif("frstPage" == "isNumberAndNotEmpty"):
+#         # Procura na página solicitada
+#         return
+#     # Se não for recebido nenhum valor
+#     elif("frstPage" == "empty" and "scndPage" == "empty"):
+#         # Procura todas as páginas
+#         return
+#     # Se não encaixar nas outras condicionais
+#     else:
+#         print("erro")
+#         # Retorna erro
+#         return
+
+#     readPDFPages = "all"
 
 
     
 
-    # VALIDAÇÃO DO CAMINHO DA PASTA DE IMPORTAÇÃO
-    # -------------------------------------------------------------
-    # Descrição:
-    # Faz a validação da existência do caminho que leva  as  pastas
-    # de importação. É obrigatória a inserção desse campo pelo usu-
-    # ário.
-    # >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
-    # [IMPORTAÇÃO - Obrigatório]
-    try:
-        # [i] Caso a pasta de importação exista
-        if (CheckIfFolderExists(parser_ArgsMain.importPath)):
-            # [>] Leva o caminho para a variável que segura os caminhos  de
-            # importação
-            folderpath_Import = parser_ArgsMain.importPath
-        # [i] Caso o usuário não tenha informado o caminho da pasta  de
-        # importação
-        elif (parser_ArgsMain.importPath == None):
-            # [>] Exibe uma mensagem de erro
-            ShowError("É necessário informar um caminho de importação com '--importPath <caminho>'.")
-            # [>] Encerra a operação
-            return
-        # [i] Caso a pasta de importação não exista
-        elif (CheckIfFolderExists(parser_ArgsMain.importPath) == False):
-            # [>] Exibe uma mensagem de erro
-            ShowError("O caminho de importação informado não existe.")
-            return
-        # [i] Caso apareça um erro não tratado
-        else:
-            # [>] Exibe uma mensagem de erro
-            ShowError("Ocorreu um erro desconhecido na hora de receber o caminho de importação.")
-    except Exception as exceptionError:
-        # [>] Exibe uma mensagem de erro
-        ShowError("O caminho de importação não pode ficar vazio.")
-    # >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
-
-
-    # -------------------------------------------------------------
-    # VALIDAÇÃO DO CAMINHO DA PASTA DE EXPORTAÇÃO
-    # -------------------------------------------------------------
-    # Descrição:
-    # Faz a validação da existência do caminho que leva  as  pastas
-    # de exportação. A inserção desse caminho não é obrigatória,  e
-    # caso não seja preenchida, escolhe a mesma pasta na qual  está
-    # localizada o Script atual.
-    # >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
-    try:
-        # [i] Caso o usuário tenha fornecido  o  caminho  da  pasta  de
-        # exportação faz a verificação.
-        if (CheckIfFolderExists(parser_ArgsMain.exportPath)):
-            # [i] Caso a verificação seja um sucesso, ou seja, e caso o ca-
-            # minho exista, atribui o caminho para a variável.
-            folderpath_Export = parser_ArgsMain.exportPath
-        # [i] Caso o usuário não tenha fornecido o caminho da pasta  de
-        # exportação, escolhe a pasta do Script como local para  alocar
-        # a pasta
-        elif (parser_ArgsMain.exportPath == None):
-            folderpath_Export = folderpath_Script
-        # [i] Caso o caminho não exista
-        elif (CheckIfFolderExists(parser_ArgsMain.exportPath) == False):
-            # [>] Exibe uma mensagem de erro
-            ShowError("O caminho de exportação informado não existe.")
-            # [>] Informa que o caminho de exportação não existe
-            exportFolderDoesntExist = True
-            return
-        # [i] Caso apareça um erro não tratado
-        else:
-            # [>] Exibe uma mensagem de erro
-            ShowError("Ocorreu um erro desconhecido na hora de receber o caminho de exportação.")
-    except:
-        # [i] Caso o usuário não tenha fornecido o caminho da pasta  de
-        # exportação, escolhe a pasta do Script como local para  alocar
-        # a pasta
-        folderpath_Export = folderpath_Script    
-    # >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
-    # -------------------------------------------------------------
-
-    # Fecha o arquivo de saída do terminal
-    SetTerminalFile(False)
-    return
-
-#endregion
-# >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
-# -------------------------------------------------------------
-
-# _____________________________________________________________
-
-
-
-
-
-# Início do Script
-# _____________________________________________________________
-
-# [G] INÍCIO DO SCRIPT
-# -------------------------------------------------------------
-# Descrição:
-# Início da aplicação.
-# >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
-#region
-
-# [B] CHAMADA DE BIBLIOTECAS
-# -------------------------------------------------------------
-# Descrição:
-# Chamada de todas as bibliotecas do Script.
-# >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
-# [>] Importando bibliotecas
-import os
-import re
-import sys
-import csv
-import stat
-import pandas
-import argparse
-from glob import glob
-from pathlib import Path
-# >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
-# -------------------------------------------------------------
-
-
-# [>] Pega o caminho do Script atual e define o caminho do  ar-
-# quivo de saída do terminal
-SetCurrentPath()
-
-
-# [B] CHAMADA DA BIBLIOTECA TABULA
-# -------------------------------------------------------------
-# Descrição:
-# Tentativa de importação da biblioteca tabula.
-# >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
-# [>] Tentando importar a biblioteca externa Tabula
-try:
-    import tabula
-# [i] Caso haja algum erro relacionado à importação
-except ImportError as exceptionError:
-    # [>] Exibe uma mensagem de erro
-    ShowError(
-        "Ocorreu um erro ao tentar importar a biblioteca tabula durant"
-        "e a inicialização do Script.\n"
-        "\n"
-        "Se você está executando ou chamando o Script PDFConverter pel"
-        "o executável, observe se a biblioteca tabula está em 'dist\pd"
-        "fconverter'.\n"
-        "Você pode copiar a pasta do tabula em:\n"
-        "'C:\\Users\\<YourUser>\\AppData\\Local\\Programs\\Python\\Pyt"
-        "hon39\\Lib\\site-packages'.\n"
-        "\n"
-        "Se você está chamando o Script diretamente pela extensão '.py"
-        "', então talvez você esqueceu de fazer referência à bibliotec"
-        "a ou de adicionar a mesma às variáveis ambiente?",
+#     # VALIDAÇÃO DO CAMINHO DA PASTA DE IMPORTAÇÃO
+#     # -------------------------------------------------------------
+#     # Descrição:
+#     # Faz a validação da existência do caminho que leva  as  pastas
+#     # de importação. É obrigatória a inserção desse campo pelo usu-
+#     # ário.
+#     # >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
+#     # [IMPORTAÇÃO - Obrigatório]
+#     try:
+#         # [i] Caso a pasta de importação exista
+#         if (CheckIfFolderExists(parser_ArgsMain.importPath)):
+#             # [>] Leva o caminho para a variável que segura os caminhos  de
+#             # importação
+#             folderpath_Import = parser_ArgsMain.importPath
+#         # [i] Caso o usuário não tenha informado o caminho da pasta  de
+#         # importação
+#         elif (parser_ArgsMain.importPath == None):
+#             # [>] Exibe uma mensagem de erro
+#             ShowError("É necessário informar um caminho de importação com '--importPath <caminho>'.")
+#             # [>] Encerra a operação
+#             return
+#         # [i] Caso a pasta de importação não exista
+#         elif (CheckIfFolderExists(parser_ArgsMain.importPath) == False):
+#             # [>] Exibe uma mensagem de erro
+#             ShowError("O caminho de importação informado não existe.")
+#             return
+#         # [i] Caso apareça um erro não tratado
+#         else:
+#             # [>] Exibe uma mensagem de erro
+#             ShowError("Ocorreu um erro desconhecido na hora de receber o caminho de importação.")
+#     except Exception as exceptionError:
+#         # [>] Exibe uma mensagem de erro
+#         ShowError("O caminho de importação não pode ficar vazio.")
+#     # >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
+
+
+#     # -------------------------------------------------------------
+#     # VALIDAÇÃO DO CAMINHO DA PASTA DE EXPORTAÇÃO
+#     # -------------------------------------------------------------
+#     # Descrição:
+#     # Faz a validação da existência do caminho que leva  as  pastas
+#     # de exportação. A inserção desse caminho não é obrigatória,  e
+#     # caso não seja preenchida, escolhe a mesma pasta na qual  está
+#     # localizada o Script atual.
+#     # >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
+#     try:
+#         # [i] Caso o usuário tenha fornecido  o  caminho  da  pasta  de
+#         # exportação faz a verificação.
+#         if (CheckIfFolderExists(parser_ArgsMain.exportPath)):
+#             # [i] Caso a verificação seja um sucesso, ou seja, e caso o ca-
+#             # minho exista, atribui o caminho para a variável.
+#             folderpath_Export = parser_ArgsMain.exportPath
+#         # [i] Caso o usuário não tenha fornecido o caminho da pasta  de
+#         # exportação, escolhe a pasta do Script como local para  alocar
+#         # a pasta
+#         elif (parser_ArgsMain.exportPath == None):
+#             folderpath_Export = folderpath_Script
+#         # [i] Caso o caminho não exista
+#         elif (CheckIfFolderExists(parser_ArgsMain.exportPath) == False):
+#             # [>] Exibe uma mensagem de erro
+#             ShowError("O caminho de exportação informado não existe.")
+#             # [>] Informa que o caminho de exportação não existe
+#             exportFolderDoesntExist = True
+#             return
+#         # [i] Caso apareça um erro não tratado
+#         else:
+#             # [>] Exibe uma mensagem de erro
+#             ShowError("Ocorreu um erro desconhecido na hora de receber o caminho de exportação.")
+#     except:
+#         # [i] Caso o usuário não tenha fornecido o caminho da pasta  de
+#         # exportação, escolhe a pasta do Script como local para  alocar
+#         # a pasta
+#         folderpath_Export = folderpath_Script    
+#     # >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
+#     # -------------------------------------------------------------
+
+#     # Fecha o arquivo de saída do terminal
+#     SetTerminalFile(False)
+#     return
+
+# #endregion
+# # >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
+# # -------------------------------------------------------------
+
+# # _____________________________________________________________
+
+
+
+
+
+# # Início do Script
+# # _____________________________________________________________
+
+# # [G] INÍCIO DO SCRIPT
+# # -------------------------------------------------------------
+# # Descrição:
+# # Início da aplicação.
+# # >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
+# #region
+
+# # [B] CHAMADA DE BIBLIOTECAS
+# # -------------------------------------------------------------
+# # Descrição:
+# # Chamada de todas as bibliotecas do Script.
+# # >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
+# # [>] Importando bibliotecas
+# import os
+# import re
+# import sys
+# import csv
+# import stat
+# import pandas
+# import argparse
+# from glob import glob
+# from pathlib import Path
+# # >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
+# # -------------------------------------------------------------
+
+
+# # [>] Pega o caminho do Script atual e define o caminho do  ar-
+# # quivo de saída do terminal
+# SetCurrentPath()
+
+
+# # [B] CHAMADA DA BIBLIOTECA TABULA
+# # -------------------------------------------------------------
+# # Descrição:
+# # Tentativa de importação da biblioteca tabula.
+# # >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
+# # [>] Tentando importar a biblioteca externa Tabula
+# try:
+#     import tabula
+# # [i] Caso haja algum erro relacionado à importação
+# except ImportError as exceptionError:
+#     # [>] Exibe uma mensagem de erro
+#     ShowError(
+#         "Ocorreu um erro ao tentar importar a biblioteca tabula durant"
+#         "e a inicialização do Script.\n"
+#         "\n"
+#         "Se você está executando ou chamando o Script PDFConverter pel"
+#         "o executável, observe se a biblioteca tabula está em 'dist\pd"
+#         "fconverter'.\n"
+#         "Você pode copiar a pasta do tabula em:\n"
+#         "'C:\\Users\\<YourUser>\\AppData\\Local\\Programs\\Python\\Pyt"
+#         "hon39\\Lib\\site-packages'.\n"
+#         "\n"
+#         "Se você está chamando o Script diretamente pela extensão '.py"
+#         "', então talvez você esqueceu de fazer referência à bibliotec"
+#         "a ou de adicionar a mesma às variáveis ambiente?",
     
-        exitProgram = True
-    )
-# >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
-# -------------------------------------------------------------
+#         exitProgram = True
+#     )
+# # >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
+# # -------------------------------------------------------------
 
-# [>] Executa o Script
-Main()
-# [>] Garante a finalização da execução do Script
-sys.exit()
+# # [>] Executa o Script
+# Main()
+# # [>] Garante a finalização da execução do Script
+# sys.exit()
 
-#endregion
-# >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
-# -------------------------------------------------------------
+# #endregion
+# # >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
+# # -------------------------------------------------------------
 
-# _____________________________________________________________
\ No newline at end of file
+# # _____________________________________________________________
\ No newline at end of file
diff --git a/pdfconverter/argument/__init__.py b/pdfconverter/argument/__init__.py
index 36d7cd9..7314392 100644
--- a/pdfconverter/argument/__init__.py
+++ b/pdfconverter/argument/__init__.py
@@ -21,19 +21,14 @@
 
 
 # [>] Geral
-import os.path
 import argparse
 # [>] PDFConverter
 # [i] Variáveis
-from pdfconverter.__variables__ import mvar, avar, fvar, pvar
+from pdfconverter.__variables__ import avar, pvar
+# [i] Argumentos
+from pdfconverter.argument.validateargs import validateargs
 # [i] Arquivo do Terminal
 from pdfconverter.terminalfile.message import error
-# [i] Conversão
-from pdfconverter import conversion
-# [i] Formatação de String
-from pdfconverter.stringformat import stringformat
-# [i] Programa
-from pdfconverter.program import utilities
 
 
 #region PUBLIC METHODS
@@ -66,10 +61,10 @@ def Set():
     __AddArgs(
         # ARGUMENTOS DE CONFIGURAÇÕES INICIAIS
         "ImportPath", # [i] Argumento   que   conterá   o  caminho   de    importação
-                        # (Obrigatório)
+                      # (Obrigatório)
         "ExportPath", # [i] Argumento que conterá o caminho de exportação (Opcional)
         "PageNumber", # [i] Argumento que recebe o número de páginas para realizar  a
-                        # leitura do arquivo PDF
+                      # leitura do arquivo PDF
         # ARGUMENTOS REFERENTES AS COLUNAS
         "Lote",       # [i] Lote
         "Ordem",      # [i] Ordem
@@ -77,12 +72,13 @@ def Set():
         "Produto",    # [i] Produto
         "Unidade",    # [i] Unidade
         "Quantidade", # [i] Quantidade
-        "ValorMedio"  # [i] Valor Médio
+        "ValorMedio", # [i] Valor Médio
+        # ARGUMENTOS ADICIONAIS DE CONFIGURAÇÃO
+        "FormattingMethod"
     )
 
-    
-    # [>] Valida os argumentos
-    __ValidateArgs()
+    # [>] Valida os argumentos adicionados
+    validateargs().All()
 
 #endregion
 
@@ -114,7 +110,8 @@ def __AddArgs(*args):
     ---
     """
     
-    # [>] Para cada argumento passado no parâmetro do método
+    # [>] Para cada argumento passado no parâmetro do  método  para
+    # ser adicionado a variável principal de argumentos
     for arg in args:
         # VALORES PADRÃO
         # -------------------------------------------------------------
@@ -123,17 +120,17 @@ def __AddArgs(*args):
         # >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
         # [i] Nome do argumento
         # [>] Adiciona o prefixo no argumento
-        argName = "--" + arg
+        avar.argName = "--" + arg
         # [i] Valor do argumento que vem por padrão
-        defaultValue = None
+        avar.defaultValue = None
         # [i] Número de valores suportado pelo argumento
-        nargsValue = '?'
+        avar.nargsValue = '?'
         """
-        # '+' == 1 or more.
-        # '*' == 0 or more.
-        # '?' == 0 or 1.
+        '+' == 1 or more.
+        '*' == 0 or more.
+        '?' == 0 or 1.
         """
-        contentType = str
+        avar.contentType = str
         # >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
         # -------------------------------------------------------------
 
@@ -142,12 +139,9 @@ def __AddArgs(*args):
         # Descrição: Aqui dentro da condicional, podem ser alterados os
         # valores padrão caso necessário.
         # >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
-        if (arg in "--PageNumber"):
-            defaultValue = "all"
-        if ("Path" not in arg # Se não for um
-            and
-            "PageNumber" != arg):
-            nargsValue = '*'
+        if (avar.argName == "--PageNumber"): avar.defaultValue = "all"
+        elif (avar.argName in avar.patternColumnArgs): avar.nargsValue = '*'
+        elif (avar.argName == "--FormattingMethod"): avar.defaultValue = "MFT"
         # >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
         # -------------------------------------------------------------
 
@@ -156,33 +150,29 @@ def __AddArgs(*args):
         # mento que tiver sido passado no parâmetro.
         avar.parser_Main.add_argument(
             # [i] Valores passíveis de alteração
-            argName,
-            default = defaultValue,
-            nargs = nargsValue,
-            type = contentType,
+            avar.argName,
+            default = avar.defaultValue,
+            nargs = avar.nargsValue,
+            type = avar.contentType,
             # [i] Valores Padrão
             required = False
         )
     
     try:
-        avar.parser_ArgsMain = avar.parser_Main.parse_args()
+        # [>] Passa os argumentos depois de interpretados para uma nova
+        # variável
+        avar.parser_ArgsMain = avar.parser_Main.parse_args(_ParseArgsProgramatically())
     except Exception as ExceptionError:
         # [>] Exibe mensagem de erro caso não tenha sido informado  um
         # caminho de importação
-        error.Show(
-            "Ocorreu um erro desconhecido ao tentar adicionar os argumentos"
-            " ao parse args.",
-            
-            ExceptionError = ExceptionError,
-            ExitProgram = True
-        )
+        error.Show("Ocorreu um erro desconhecido ao tentar adicionar os argumentos ao parse args.", ExceptionError)
 
     # [>] Atualiza a variável que segura a lista com os  argumentos
     # relacionados ao campos de colunas que foram  preenchidos  com
     # algum valor
-    __StoreArgs()
+    __GetUserGivenPatternColumnsArgs()
 
-def __StoreArgs():
+def __GetUserGivenPatternColumnsArgs():
     """
     ---
     ---
@@ -200,190 +190,61 @@ def __StoreArgs():
     ---
     """
 
-
-    # [>] Todos os argumentos que são  relacionados  à  alterar  as
-    # colunas padrão dentro de uma array.
-    patternColumnArgs = [
-        "Lote",
-        "Ordem",
-        "Codigo",
-        "Produto",
-        "Unidade",
-        "Quantidade",
-        "ValorMedio"
-    ]
-
-    # ADICIONA OS VALORES À ARRAY
-    # -------------------------------------------------------------
-    # Descrição: Adiciona o nome e o valor dos argumentos do  orde-
-    # nador de colunas no padrão para a array quando  eles  possuem
-    # algum valor
-    # >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
-    listCounter = 0
-    for argName in patternColumnArgs:
-        # [>] Recebe o valor do argumento atual
+    counter_ArgListIterator = 0
+    for argName in avar.patternColumnArgs:
+        # [>] Recebe o valor do argumento atual baseado  na  lista  que
+        # possui as colunas padrão
         argValue = vars(avar.parser_ArgsMain)[argName]
         # [>] Se o argumento da lista de colunas padrão tiver algum va-
         # lor
         if (argValue != None):
-            # [>] Adiciona uma nova linha na lista de colunas
-            pvar.list_columnFieldsToChange.append([])
-
-            # [>] Adiciona o nome do argumento
-            pvar.list_columnFieldsToChange[listCounter].append(argName)
+            # [>] Adiciona um novo container na lista de colunas
+            pvar.list_UserGivenColumnToChange.append([])
+            # [>] Adiciona o título do argumento
+            pvar.list_UserGivenColumnToChange[counter_ArgListIterator].append(argName)
 
+            # [i] Caso tenha vindo uma lista de valores
             if isinstance(argValue, list):
-                for value in argValue:
-                    # [>] Adiciona o valor do argumento
-                    pvar.list_columnFieldsToChange[listCounter].append(value)
-            else: pvar.list_columnFieldsToChange[listCounter].append(argValue)
-
+                # [>] Para cada valor na lista de valores passados na variável,
+                # adiciona o valor na lista
+                for value in argValue: pvar.list_UserGivenColumnToChange[counter_ArgListIterator].append(value)
+            # [i] Caso contrário, adiciona o valor do argumento  direto  na
+            # lista
+            else: pvar.list_UserGivenColumnToChange[counter_ArgListIterator].append(argValue)
 
             # [>] Adiciona +1 ao contador da lista
-            listCounter += 1
-    # >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
-    # -------------------------------------------------------------
+            counter_ArgListIterator += 1
+
+#endregion
 
-#region VALIDATION
+#region METHODS FOR TESTING
 
-def __ValidateArgs():
+def _ParseArgsProgramatically():
     """
     ---
     ---
     ---
     
-    ## __ValidateArgs (Private)
+    ## ParseArgsProgramatically Public
     ---
     ---
-    Método que chama outros métodos que realizam validação de argu-
-    mentos.
+    Método que passa os argumentos que normalmente são passados pe-
+    lo terminal programaticamente. O método deve ser colocado  den-
+    tro da variável avar.parser_Main.parse_args.
     
+    ### Returns
     ---
-    ---
-    ---
-    """
-
-    __ValidateImportPath()
-    __ValidateExportPath()
-    __ValidatePageNumberArg()
-
-#region SPECIFIC VALIDATIONS
-
-def __ValidateImportPath():
-    try:
-        # [>] Pega dos argumentos o caminho de importação
-        ImportPath = avar.parser_ArgsMain.ImportPath
-
-        if (ImportPath == None):
-            # [i] Exibe uma mensagem de erro mostrando que é obrigatório  a
-            # inserção do caminho de importação
-            error.Show(
-                "É necessário colocar um valor para o caminho  de  importação,"
-                "'--ImportPath <caminho_de_exportação>'.",
-                
-                ExitProgram = True
-            )
-        elif (os.path.isfile(ImportPath)):
-            if (utilities.IsPDF(ImportPath)):
-                fvar.path_Import = ImportPath
-                # [>] Lá na frente, vai executar a função que realizará a  con-
-                # versão do arquivo individual que foi indicado
-                functionName = "IndividualConversion"
-            else:
-                error.Show("O arquivo informado no argumento de importação, precisa ser uma pasta ou um arquivo PDF.", ExitProgram = True)
-        elif (os.path.isdir(ImportPath)):
-            fvar.path_Import = ImportPath
-            # [>] Lá na frente, vai executar a função que realizará  a  con-
-            # versão de todos os PDFs indicados na pasta de importação
-            functionName = "MultipleConversion"
-        else:
-            error.Show("O argumento ('" + ImportPath + "') passado como caminho de importação não é válido.", ExitProgram = True)
-
-        # [>] Atribui o objeto que referencia a função com  o  nome  da
-        # função passada nas validações acima
-        mvar.ConversionStart = getattr(conversion, functionName)
-    except Exception as ExceptionError:
-        # [>] Exibe uma mensagem de erro
-        error.Show(
-            "Ocorreu um erro desconhecido ao tentar receber os  argumentos"
-            "dos caminhos de importação.",
-
-            ExceptionError = ExceptionError,
-            ExitProgram = True
-        )
-
-def __ValidateExportPath():
-    try:
-        # [>] Pega dos argumentos o caminho de importação
-        ExportPath = avar.parser_ArgsMain.ExportPath
-
-        if (ExportPath == None):
-            # [i] Recebe o caminho da pasta de importação  como  referência
-            # para o caminho de exportação
-            fvar.path_Export = fvar.path_Import
-        # [>] Se o caminho fornecido for um diretório,  passa  para  as
-        # variáveis globais de acordo com a ação realizada
-        elif (os.path.isdir(ExportPath)): fvar.path_Export = ExportPath
-        # [>] Usuário não informou valor para o caminho de exportação
-        # Caso a pasta de acordo com a ação realizada não exista
-        else: error.Show("A pasta de exportação ('" + ExportPath + "') informada não existe.", ExitProgram = True)
-    except Exception as ExceptionError:
-        # [>] Exibe uma mensagem de erro
-        error.Show(
-            "Ocorreu um erro desconhecido ao tentar receber os  argumentos"
-            "dos caminhos de exportação.",
-
-            ExceptionError = ExceptionError,
-            ExitProgram = True
-        )
-
-def __ValidatePageNumberArg():
-    """
-    ---
-    ---
-    ---
-    
-    ## __ValidatePageNumberArg (Private)
-    ---
-    ---
-    Método que valida o número de página, ou  números  de  páginas,
-    passados no argumentos.
+        list: Variável que segura os valores da lista de argumentos.
     
     ---
     ---
     ---
     """
-
-    try:
-        # [>] Recebe o número de página passado no argumento
-        argPageNumber = stringformat(avar.parser_ArgsMain.PageNumber)
-        # [>] Se o valor digitado como número de página é valido
-        if (argPageNumber.ValidatePageNumber()):
-            # [>] Passa o valor para uma variável
-            fvar.readPDFPages = avar.parser_ArgsMain.PageNumber
-        # [>] Se é inválido
-        else:
-            # [>] Exibe uma mensagem de erro
-            error.Show(
-                "O valor '" + avar.parser_ArgsMain.PageNumber + "' não é um va"
-                "lor de número de página válido para --PageNumber.",
-                
-                ExitProgram = True
-            )
-    # [>] Quando ocorre erro desconhecido
-    except Exception as ExceptionError:
-        # [>] Exibe uma mensagem de erro
-        error.Show(
-            "Ocorreu um erro desconhecido ao validar o número de páginas.\n"
-            "\n" +
-            str(argPageNumber),
-
-            ExceptionError = ExceptionError,
-            ExitProgram = True
-        )
-
-#endregion
-
-#endregion
+    
+    ArgsList = ["--ImportPath", "C:\\users\\dvp10\\desktop\\EDITAL (2).pdf"]
+    ArgsList = [""]
+    ArgsList = ["--ImportPath", "C:\\users\\dvp10\\desktop\\", "--ExportPath", "C:\\users\\dvp10\\desktop"]
+    ArgsList = ["--ImportPath", "C:\\users\\dvp10\\desktop\\EDITAL (2).pdf", "--ExportPath", "C:\\users\\dvp10\\desktop", "--FormattingMethod", "F"]
+    return ArgsList
 
 #endregion
\ No newline at end of file
diff --git a/pdfconverter/argument/__pycache__/validateargs.cpython-39.pyc b/pdfconverter/argument/__pycache__/validateargs.cpython-39.pyc
new file mode 100644
index 0000000..89e7454
Binary files /dev/null and b/pdfconverter/argument/__pycache__/validateargs.cpython-39.pyc differ
diff --git a/pdfconverter/argument/validateargs.py b/pdfconverter/argument/validateargs.py
new file mode 100644
index 0000000..ca8f86f
--- /dev/null
+++ b/pdfconverter/argument/validateargs.py
@@ -0,0 +1,165 @@
+# [>] Geral
+import os.path
+# [>] PDFConverter
+# [i] Variáveis
+from pdfconverter.__variables__ import mvar, avar, fvar
+# [i] Arquivo do Terminal
+from pdfconverter.terminalfile.message import error
+# [i] Conversão
+from pdfconverter import conversion
+# [i] Formatação de String
+from pdfconverter.stringformat import stringformat
+# [i] Programa
+from pdfconverter.program import utilities
+from pdfconverter.program.exceptions import InvalidFormattingType, RepeatedFormattingType
+
+
+#region VALIDATE ARGS
+
+class validateargs:
+    """Classe que realiza algumas validações de argumentos."""
+
+    #region CONSTRUCTOR
+
+    def __init__(self): pass
+
+    #endregion
+
+    #region PUBLIC METHODS
+
+    def All(self):
+        self.ImportPath()
+        self.ExportPath()
+        self.PageNumber()
+        self.FormattingMethod()
+
+    @staticmethod
+    def ImportPath():
+        try:
+            # [>] Pega dos argumentos o caminho de importação
+            ImportPathArg = avar.parser_ArgsMain.ImportPath
+
+            # [i] Caso o usuário não tenha preenchido o caminho de importa-
+            # ção, exibe uma mensagem de erro mostrando que  é  obrigatório
+            # a inserção do caminho de importação
+            if (ImportPathArg == None): error.Show("É necessário colocar um valor para o caminho de importação, '--ImportPath <caminho_de_exportação>'.")
+            # [i] Caso seja percebido que o valor do argumento de  importa-
+            # ção se refere à um arquivo
+            elif (os.path.isfile(ImportPathArg)):
+                # [i] E esse arquivo referido seja um PDF
+                if (utilities.IsPDF(ImportPathArg)):
+                    # [>] Passa o valor para a classe de variáveis
+                    avar.path_ImportArg = ImportPathArg
+                    fvar.folderpath_Import = os.path.dirname(ImportPathArg)
+                    # [>] Lá na frente, vai executar a função que realizará a  con-
+                    # versão do arquivo individual que foi indicado
+                    functionName = "IndividualConversion"
+                # [i] Caso tenha sido indicado um arquivo que não seja  um  PDF
+                # exibe uma mensagem de erro
+                else: error.Show("O arquivo informado no argumento de importação, precisa ser uma pasta ou um arquivo PDF.")
+            # [i] Caso seja percebido que o valor do argumento de  importa-
+            # ção se refere à uma pasta
+            elif (os.path.isdir(ImportPathArg)):
+                # [>] Passa o valor para a classe de variáveis
+                avar.path_ImportArg = ImportPathArg
+                fvar.folderpath_Import = ImportPathArg
+                # [>] Lá na frente, vai executar a função que realizará  a  con-
+                # versão de todos os PDFs indicados na pasta
+                functionName = "MultipleConversion"
+            # [i] Exibe um erro caso o argument o não tenha passado nas va-
+            # lidações
+            else: error.Show("O argumento ('" + ImportPathArg + "') passado como caminho de importação não é válido.")
+
+            # [>] Atribui o objeto que referencia a função com  o  nome  da
+            # função passada nas validações acima
+            mvar.ConversionStart = getattr(conversion, functionName)
+        # [>] Caso ocorra um erro desconhecido exibe uma mensagem
+        except Exception as ExceptionError:
+            error.Show("Ocorreu um erro desconhecido ao tentar receber os argumentos dos caminhos de importação.", ExceptionError)
+
+    @staticmethod
+    def ExportPath():
+        try:
+            # [>] Pega dos argumentos o caminho de importação
+            ExportPath = avar.parser_ArgsMain.ExportPath
+
+            # [i] Caso o caminho de exportação não tenha sido informado pe-
+            # lo usuário, informa o caminho da pasta de importação como re-
+            # ferência para o caminho de exportação
+            if (ExportPath == None): fvar.folderpath_Export = fvar.folderpath_Import
+            # [i] Se o caminho fornecido for um diretório,  passa  para  as
+            # variáveis globais o valor fornecido no argumento
+            elif (os.path.isdir(ExportPath)): fvar.folderpath_Export = ExportPath
+            # [i] Caso a pasta de acordo com a ação realizada não exista
+            else: error.Show("A pasta de exportação ('" + ExportPath + "') informada não existe.")
+        # [>] Caso ocorra um erro desconhecido exibe uma mensagem
+        except Exception as ExceptionError:
+            error.Show("Ocorreu um erro desconhecido ao tentar receber os  argumentos dos caminhos de exportação.", ExceptionError)
+
+    @staticmethod
+    def PageNumber():
+        """
+        ---
+        ---
+        ---
+        
+        ## __ValidatePageNumberArg (Private)
+        ---
+        ---
+        Método que valida o número de página, ou  números  de  páginas,
+        passados no argumentos.
+        
+        ---
+        ---
+        ---
+        """
+
+
+        try:
+            # [i] Se o valor digitado é válido como número de página  passa
+            # o número de páginas do argumento para uma variável dentro  da
+            # classe de variáveis
+            if (stringformat(avar.parser_ArgsMain.PageNumber).ValidatePageNumber()): avar.readPDFPagesArg = avar.parser_ArgsMain.PageNumber
+            # [i] Se o número de páginas é inválido, exibe uma mensagem  de
+            # erro
+            else: error.Show("O valor '" + avar.parser_ArgsMain.PageNumber + "' não é um valor de número de página válido para --PageNumber.")
+        # [>] Caso ocorra um erro desconhecido exibe uma mensagem
+        except Exception as ExceptionError:
+            error.Show("Ocorreu um erro desconhecido ao validar o número de páginas.\n", ExceptionError)
+
+    @staticmethod
+    def FormattingMethod():
+        FormattingMethod = avar.parser_ArgsMain.FormattingMethod
+
+        try:
+            for letter in FormattingMethod:
+                # [i] Verifica se há letras repetidas no argumento que  informa
+                # os métodos de formatação
+                if (str(FormattingMethod).count(letter)) > 1: raise RepeatedFormattingType
+                
+                # [i] Verifica se há alguma letra que não faz parte dos métodos
+                # de formatação existentes
+                if (letter != "T" and letter != "M" and letter != "F"): raise InvalidFormattingType
+        except InvalidFormattingType as ExceptionError:
+            error.Show("Ocorreu um erro na hora de realizar as formatações em 'ConversionStart()'.", ExceptionError)
+        except RepeatedFormattingType as ExceptionError:
+            error.Show("O tipo de formatação '" + letter + "' foi repetido mais de uma vez em '" + FormattingMethod + "'.", ExceptionError)
+        except Exception as ExceptionError:
+            error.Show("Ocorreu um erro desconhecido ao tentar realizar as formatações requisitadas em 'ConversionStart()'.", ExceptionError)
+
+        # [>] Após a validação, traz para a variável os métodos de for-
+        # matação que serão realizados
+        avar.FormattingMethodArg = FormattingMethod
+
+        # [>] Traz para a variável a quantidade de arquivos  que  serão
+        # exportados
+        # [>] Por enquanto o cálculo está fixo com a quantidade de  mé-
+        # todos de formatações escolhidos, adicionado 1 que seria o ar-
+        # quivo sem formatação, e mutiplicado por 2, pois são dois  mé-
+        # todos de leitura nos quais as formatações se baseiam (lattice
+        # e stream)
+        fvar.quantity_ExportedFiles = (len(FormattingMethod) + 1) * 2
+
+    #endregion
+
+#endregion
\ No newline at end of file
diff --git a/pdfconverter/conversion/__init__.py b/pdfconverter/conversion/__init__.py
index 0e8ad06..ac074a1 100644
--- a/pdfconverter/conversion/__init__.py
+++ b/pdfconverter/conversion/__init__.py
@@ -25,7 +25,7 @@
 from glob import glob
 # [>] PDFConverter
 # [i] Variáveis
-from pdfconverter.__variables__ import cvar, fvar, ivar
+from pdfconverter.__variables__ import avar, cvar, fvar
 # [i] Arquivo do Terminal
 from pdfconverter.terminalfile.message import design, error
 # [i] Configurações
@@ -33,8 +33,6 @@
 # [i] Conversão
 from pdfconverter.conversion import withoutformatting
 from pdfconverter.conversion.format import tablewithblankcells, main, fullclear
-# [i] Colunas Padrão
-from pdfconverter import patterncolumns
 # [i] Programa
 from pdfconverter.program.exceptions import InvalidFormattingType, RepeatedFormattingType
 
@@ -42,30 +40,41 @@
 #region PUBLIC METHODS
 
 def IndividualConversion():
-    # [>] Inicia a conversão
-    ConversionStart(fvar.path_Import, "M")
-    LastLatticeMainConvertedFile = fvar.main_OutputTxt.replace("stream", "lattice", 1)
+    # [>] Como a modalidade de conversão será  individual,  informa
+    # que apenas um PDF será convertido
+    fvar.quantity_ImportedFiles = 1
 
-    patterncolumns.RecognizePattern(LastLatticeMainConvertedFile)
+    # [>] Inicia a conversão
+    ConversionStart(avar.path_ImportArg)
+    
+    # [>] Fecha o layout do terminal quando a conversão é finaliza-
+    # da
+    design.CloseLayout(LastLayout = True)
 
 def MultipleConversion():
+    # [>] Recebe um caminho que à frente será usado para obter  in-
+    # formação referente à todos os arquivos PDFs presentes na pas-
+    # ta de importação
+    referencepath_AllPDFFiles = fvar.folderpath_Import + "\\*.pdf"
+
+    # [>] Recebe a quantidade de arquivos que serão importados
+    fvar.quantity_ImportedFiles = len(glob(referencepath_AllPDFFiles))
+
     # [>] Filtra pelos PDFs na pasta onde foi indicada para o  sis-
     # tema pelo "chdir"
-    for PDF in glob(fvar.path_Import + "\\*.pdf"):
-        ConversionStart(PDF, "MFT")
+    for PDF in glob(referencepath_AllPDFFiles):
+        # [>] Inicia a conversão
+        ConversionStart(PDF)
     else:
-        # [i] Se até o término da operação algum  PDF  foi  convertido
-        if (ivar.PdfFile > 1):
-            # [>] Fecha o layout do terminal
-            design.CloseLayout(LastLayout = True)
+        # [i] Se até o término da operação algum  PDF  foi  convertido,
+        # fecha o layout do terminal
+        if (fvar.counter_PdfFile > 0): design.CloseLayout(LastLayout = True)
         # [i] Se ainda até o término da operação nenhum PDF foi conver-
-        # tido
-        else:
-            # [>] Exibe erro mostrando que não há arquivos para serem  con-
-            # vertidos
-            error.Show("Não há arquivos de PDF para serem convertidos.")
+        # tido, exibe erro mostrando que não  há  arquivos  para  serem
+        # convertidos
+        else: error.Show("Não há arquivos de PDF para serem convertidos.")
 
-def ConversionStart(fullfilepath_PDF, Formatting = ""):
+def ConversionStart(fullfilepath_PDF):
     """
     ---
     ---
@@ -103,17 +112,44 @@ def ConversionStart(fullfilepath_PDF, Formatting = ""):
 
     # [>] Configura o terminal ou o projeto de acordo com a  situa-
     # ção
-    # [i] Se não é o primeiro arquivo
-    if (ivar.PdfFile >= 1):
-        # [>] Fecha o layout pulando algumas linhas
-        design.CloseLayout(LastLayout = False)
-    # [i] Se é o primeiro arquivo ainda
+    # [i] Se não é o primeiro arquivo fecha o layout pulando  algu-
+    # mas linhas
+    if (fvar.counter_PdfFile >= 1): design.CloseLayout(LastLayout = False)
+    # [i] Se é o primeiro arquivo ainda define a estrutura  inicial
+    # do projeto
     else:
-        # [>] Define a estrutura inicial do projeto
         project.SetFolderStructure()
+        def MakeRelatoryFile():
+            import json
+            from pdfconverter.terminalfile import error
+
+
+            # [>] Configura o caminho para o relatório
+            fvar.filepath_RelatoryFile = fvar.folderpath_Result + "\\startreport.txt"
+
+
+            try:
+                with open(fvar.filepath_RelatoryFile, mode = "w", encoding = "UTF-8") as TextFile:
+                    TextFile.write(
+                        json.dumps(
+                        {
+                            "resultsFolder": {
+                                "nameResultsFolder": fvar.foldername_Result,
+                                "pathResultsFolder": fvar.folderpath_Result
+                            },
+                            "quantityImportedFiles": fvar.quantity_ImportedFiles,
+                            "quantityExportedFiles": fvar.quantity_ExportedFiles
+                        },
+                        
+                        indent = 4
+                        )
+                    )
+            except Exception as ExceptionError:
+                error.Show("Ocorreu um erro desconhecido ao tentar gerar o arquivo com as informações preliminares da conversão.", ExceptionError)
+        MakeRelatoryFile()
     # [>] Atribuindo mais um ao índice para indicar  que  um  certo
     # arquivo PDF está sendo convertido
-    ivar.PdfFile += 1
+    fvar.counter_PdfFile += 1
 
     # [>] Remove extensão do arquivo  (pegando  apenas  o  nome)  e
     # atribui para a variável
@@ -126,18 +162,17 @@ def ConversionStart(fullfilepath_PDF, Formatting = ""):
     # MÉTODOS DE LEITURA E CONVERSÃO
     # -------------------------------------------------------------
     # Descrição:
-    # Primeiro faz a leitura e conversão pra Lattice e após  faz  o
-    # mesmo para o Stream
+    # [i] Primeiro faz a leitura e conversão pra Lattice e após faz
+    # o mesmo para o Stream
     # >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
     for ReadingMethod in ("lattice", "stream"):
         # [>] Realiza a leitura do arquivo PDF
         cvar.list_DataFrames = ReadPDF(ReadingMethod, fullfilepath_PDF)
 
         # [>] Caso a lista de DataFrames vier vazia
-        if (len(cvar.list_DataFrames) <= 0 or cvar.list_DataFrames == None):
+        if (cvar.list_DataFrames == None or len(cvar.list_DataFrames) <= 0):
             # [>] Dispara um erro no arquivo do terminal
-            error.Show("Não foram encontradas tabelas para realizar a conversão.")
-
+            error.Show("Não foram encontradas tabelas para realizar a conversão.", ExitProgram = False, RecreateTerminalFile = False)
             # [>] Passa para o próximo arquivo sem continuar  os  processos
             # posteriores
             continue
@@ -147,7 +182,7 @@ def ConversionStart(fullfilepath_PDF, Formatting = ""):
         cvar.list_DataFrames = [DataFrame for DataFrame in cvar.list_DataFrames if not DataFrame.empty]
 
         # [>] Reseta a variável
-        ivar.DataFrame = 1
+        fvar.counter_DataFrame = 1
         # [>] Itera os DataFrames contidos na lista de  DataFrames  gerados
         # pela leitura do tabula
         for TableDataFrame in cvar.list_DataFrames:
@@ -155,14 +190,13 @@ def ConversionStart(fullfilepath_PDF, Formatting = ""):
             # dicado
             withoutformatting.AppendToFile(ReadingMethod, TableDataFrame)
             # [>] Avança o contador de DataFrames em um
-            ivar.DataFrame += 1
-
+            fvar.counter_DataFrame += 1
         # [>]
-        __MakeFormattedFiles(ReadingMethod, Formatting)
+        __MakeFormattedFiles(ReadingMethod, avar.FormattingMethodArg)
     # >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
     # -------------------------------------------------------------
 
-def ReadPDF(ReadingMethod, filefullname_PDF):    
+def ReadPDF(ReadingMethod, filefullname_PDF):
     """
     ---
     ---
@@ -200,7 +234,7 @@ def ReadPDF(ReadingMethod, filefullname_PDF):
             filefullname_PDF,                                          # [i] Caminho do arquivo PDF
             lattice = True if (ReadingMethod == "lattice") else False, # [>] Define como True caso o método de conversão  esteja  como
                                                                        # lattice, caso contrário define como False
-            pages = fvar.readPDFPages,                                 # [i] Páginas do arquivo PDF a serem lidas
+            pages = avar.readPDFPagesArg,                              # [i] Páginas do arquivo PDF a serem lidas
             # VALORES PADRÃO
             guess = True,                                              # [i] Tenta adivinhar uma porção da página para ler
             multiple_tables = True,                                    # [i] Se o arquivo PDF tem mais de uma tabela
@@ -218,7 +252,9 @@ def ReadPDF(ReadingMethod, filefullname_PDF):
             "Ocorreu um erro ao tentar realizar a leitura do arquivo '" + filefullname_PDF +  "' "
             "usando o método '" + ReadingMethod + "'.",
             
-            ExceptionError = ExceptionError
+            ExceptionError = ExceptionError,
+            ExitProgram = False,
+            RecreateTerminalFile = False
         )
     # >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
     # -------------------------------------------------------------
@@ -232,37 +268,15 @@ def __MakeFormattedFiles(ReadingMethod, Formatting):
         for letter in Formatting:
             if (str(Formatting).count(letter)) > 1: raise RepeatedFormattingType
 
-            if (letter == "T"):
-                tablewithblankcells.MakeFile(ReadingMethod)
-            elif (letter == "M"):
-                main.MakeFile(ReadingMethod)
-            elif (letter == "F"):
-                fullclear.MakeFile(ReadingMethod)
+            if (letter == "T"): tablewithblankcells.MakeFile(ReadingMethod)
+            elif (letter == "M"): main.MakeFile(ReadingMethod)
+            elif (letter == "F"): fullclear.MakeFile(ReadingMethod)
             else: raise InvalidFormattingType
     except InvalidFormattingType as ExceptionError:
-        error.Show(
-            "Ocorreu um erro na hora de realizar as formatações em 'ConversionStart()'.",
-            
-            ExitProgram = True,
-            ExceptionError = ExceptionError,
-            RecreateTerminalFile = True
-        )
+        error.Show("Ocorreu um erro na hora de realizar as formatações em 'ConversionStart()'.", ExceptionError)
     except RepeatedFormattingType as ExceptionError:
-        error.Show(
-            "O tipo de formatação '" + letter + "' foi repetido mais de uma vez em '" + Formatting + "'.",
-            
-            ExitProgram = True,
-            ExceptionError = ExceptionError,
-            RecreateTerminalFile = True    
-        )
+        error.Show("O tipo de formatação '" + letter + "' foi repetido mais de uma vez em '" + Formatting + "'.", ExceptionError)
     except Exception as ExceptionError:
-        error.Show(
-            "Ocorreu um erro desconhecido ao tentar realizar as formataçõe"
-            "s requisitadas em 'ConversionStart()'.",
-            
-            ExitProgram = True,
-            ExceptionError = ExceptionError,
-            RecreateTerminalFile = True
-        )
+        error.Show("Ocorreu um erro desconhecido ao tentar realizar as formatações requisitadas em 'ConversionStart()'.", ExceptionError)
 
 #endregion
\ No newline at end of file
diff --git a/pdfconverter/conversion/format/fullclear.py b/pdfconverter/conversion/format/fullclear.py
index 20b86a9..34ece2e 100644
--- a/pdfconverter/conversion/format/fullclear.py
+++ b/pdfconverter/conversion/format/fullclear.py
@@ -22,6 +22,8 @@
 # [>] PDFConverter
 # [i] Variáveis
 from pdfconverter.__variables__ import fvar
+# [i] Arquivo do terminal
+from pdfconverter.terminalfile.message import error
 # [i] Conversão
 from pdfconverter.conversion.format import main, tablewithblankcells
 # [i] Formatação de String
@@ -31,13 +33,16 @@
 #region PUBLIC METHODS
 
 def MakeFile(ReadingMethod):
-    fvar.fullclear_OutputTxt = fvar.path_Export + fvar.rootPath + "\\" + ReadingMethod + "\\fullClear\\" + fvar.filename_PDF + ".txt"
-    # [>] Abre o arquivo principal (ainda não totalmente pronto pa-
-    # ra ser jogado em uma tabela possui mais dados, porém estrutu-
-    # ra ainda não tão idealizada)
-    with open(fvar.fullclear_OutputTxt, "a", encoding="UTF-8") as TextFile:
-        # [>] Formata o arquivo e escreve um novo arquivo de saída
-        TextFile.write(FormatTextFile(fvar.filepath_ExportTxt))
+    try:
+        fvar.filepath_FullClear = fvar.folderpath_Result + "\\" + ReadingMethod + "\\fullClear\\" + fvar.filename_PDF + ".txt"
+        # [>] Abre o arquivo principal (ainda não totalmente pronto pa-
+        # ra ser jogado em uma tabela possui mais dados, porém estrutu-
+        # ra ainda não tão idealizada)
+        with open(fvar.filepath_FullClear, "a", encoding="UTF-8") as TextFile:
+            # [>] Formata o arquivo e escreve um novo arquivo de saída
+            TextFile.write(FormatTextFile(fvar.filepath_WithoutFormatting))
+    except Exception as ExceptionError:
+        error.Show("Ocorreu um erro desconhecido ao criar o arquivo com formatação 'fullclear'.", ExceptionError)
 
 def FormatTextFile(TextFilePath):
     newString = ""
@@ -48,10 +53,13 @@ def FormatTextFile(TextFilePath):
         for line in TextFile:
             # [>] Realiza as formatações já existentes em tableWithBlankCells
             line = tablewithblankcells.FormatString(line)
+            if line == ("" or None): continue
             # [>] Realiza as formatações já existentes em main
             line = main.FormatString(line)
+            if line == ("" or None): continue
             # [>] Realiza a formatação do módulo vigente
             line = FormatString(line)
+            if line == ("" or None): continue
 
             # [>] Adiciona à nova String
             newString += line
@@ -75,8 +83,6 @@ def FormatString(String):
     
     # [i] Só escreve a linha se tiver pelo menos mais que 3 colunas
     # no arquivo fullClear
-    if (formatString.IsSmallTable()): return ""
-    
-    return formatString.String
+    if (formatString.Has3ColumnsOrMore()): return formatString.String
 
 #endregion
\ No newline at end of file
diff --git a/pdfconverter/conversion/format/main.py b/pdfconverter/conversion/format/main.py
index f6d44b4..96b2049 100644
--- a/pdfconverter/conversion/format/main.py
+++ b/pdfconverter/conversion/format/main.py
@@ -22,7 +22,9 @@
 # [>] PDFConverter
 # [i] Variáveis
 from pdfconverter.__variables__ import fvar
-# [>] Conversão
+# [i] Arquivo do terminal
+from pdfconverter.terminalfile.message import error
+# [i] Conversão
 from pdfconverter.conversion.format import tablewithblankcells
 # [i] Formatação de String
 from pdfconverter.stringformat import stringformat
@@ -31,34 +33,16 @@
 #region PUBLIC METHODS
 
 def MakeFile(ReadingMethod):
-    """
-    ---
-    ---
-    ---
-    
-    ## MakeFile (Public)
-    ---
-    ---
-    Método gera o arquivo com as formatações  realizadas  referente
-    ao módulo vigente.
-    
-    ### Args
-    ---
-    - ReadingMethod ([str]):
-        - Método de leitura utilizado para fazer a geração do arquivo.
-    
-    ---
-    ---
-    ---
-    """
-
-    fvar.main_OutputTxt = fvar.path_Export + fvar.rootPath + "\\" + ReadingMethod + "\\main\\" + fvar.filename_PDF + ".txt"
-    # [>] Abre o arquivo principal (ainda não totalmente pronto pa-
-    # ra ser jogado em uma tabela possui mais dados, porém estrutu-
-    # ra ainda não tão idealizada)
-    with open(fvar.main_OutputTxt, "a", encoding="UTF-8") as TextFile:
-        # [>] Formata o arquivo e escreve um novo arquivo de saída
-        TextFile.write(FormatTextFile(fvar.filepath_ExportTxt))
+    try:
+        fvar.filepath_Main= fvar.folderpath_Result + "\\" + ReadingMethod + "\\main\\" + fvar.filename_PDF + ".txt"
+        # [>] Abre o arquivo principal (ainda não totalmente pronto pa-
+        # ra ser jogado em uma tabela possui mais dados, porém estrutu-
+        # ra ainda não tão idealizada)
+        with open(fvar.filepath_Main, "a", encoding="UTF-8") as TextFile:
+            # [>] Formata o arquivo e escreve um novo arquivo de saída
+            TextFile.write(FormatTextFile(fvar.filepath_WithoutFormatting))
+    except Exception as ExceptionError:
+        error.Show("Ocorreu um erro desconhecido ao criar o arquivo com formatação 'main'.", ExceptionError)
     
 def FormatTextFile(TextFilePath):
     """
@@ -89,8 +73,10 @@ def FormatTextFile(TextFilePath):
         for line in TextFile:
             # [>] Realiza as formatações já existentes em tableWithBlankCells
             line = tablewithblankcells.FormatString(line)
+            if line == ("" or None): continue
             # [>] Realiza a formatação do módulo vigente
             line = FormatString(line)
+            if line == ("" or None): continue
 
             # [>] Adiciona à nova String
             newString += line
diff --git a/pdfconverter/conversion/format/tablewithblankcells.py b/pdfconverter/conversion/format/tablewithblankcells.py
index 64cf868..25920e2 100644
--- a/pdfconverter/conversion/format/tablewithblankcells.py
+++ b/pdfconverter/conversion/format/tablewithblankcells.py
@@ -21,6 +21,8 @@
 
 # [>] PDFConverter
 from pdfconverter.stringformat import stringformat
+# [i] Arquivo do terminal
+from pdfconverter.terminalfile.message import error
 # [i] Variáveis
 from pdfconverter.__variables__ import fvar
 
@@ -28,11 +30,14 @@
 #region PUBLIC METHODS
 
 def MakeFile(ReadingMethod):
-    fvar.tableWithBlankCells_OutputTxt = fvar.path_Export + fvar.rootPath + "\\" + ReadingMethod + "\\tableWithBlankCells\\" + fvar.filename_PDF + ".txt"
-    # [>] Abre o arquivo de texto "tableWithBlankCells"
-    with open(fvar.tableWithBlankCells_OutputTxt, "a", encoding="UTF-8") as TextFile:
-        # [>] Formata o arquivo e escreve um novo arquivo de saída
-        TextFile.write(FormatTextFile(fvar.filepath_ExportTxt))
+    try:
+        fvar.filepath_TableWithBlankCells = fvar.folderpath_Result + "\\" + ReadingMethod + "\\tableWithBlankCells\\" + fvar.filename_PDF + ".txt"
+        # [>] Abre o arquivo de texto "tableWithBlankCells"
+        with open(fvar.filepath_TableWithBlankCells, "a", encoding="UTF-8") as TextFile:
+            # [>] Formata o arquivo e escreve um novo arquivo de saída
+            TextFile.write(FormatTextFile(fvar.filepath_WithoutFormatting))
+    except Exception as ExceptionError:
+        error.Show("Ocorreu um erro desconhecido ao criar o arquivo com formatação 'tablewithblankcells'.", ExceptionError)
             
 def FormatTextFile(TextFilePath):
     newString = ""
@@ -43,6 +48,7 @@ def FormatTextFile(TextFilePath):
         for line in TextFile:
             # [>] Realiza a formatação do módulo vigente
             line = FormatString(line)
+            if line == ("" or None): continue
 
             # [>] Adiciona à nova String
             newString += line
diff --git a/pdfconverter/conversion/withoutformatting.py b/pdfconverter/conversion/withoutformatting.py
index 5ee2a11..4161530 100644
--- a/pdfconverter/conversion/withoutformatting.py
+++ b/pdfconverter/conversion/withoutformatting.py
@@ -31,7 +31,7 @@
 
 #region PUBLIC METHODS
 
-def AppendToFile(ReadingMethod, TableDataFrame):    
+def AppendToFile(ReadingMethod, TableDataFrame):
     """
     ---
     ---
@@ -57,11 +57,11 @@ def AppendToFile(ReadingMethod, TableDataFrame):
 
         # [>] Define o caminho do arquivo  atual  para  a  variável
         # global filepath_ExportTxt
-        fvar.filepath_ExportTxt = fvar.path_Export + fvar.rootPath + "\\" +  ReadingMethod + "\\withoutFormatting\\" + fvar.filename_PDF + ".txt"
+        fvar.filepath_WithoutFormatting = fvar.folderpath_Result + "\\" +  ReadingMethod + "\\withoutFormatting\\" + fvar.filename_PDF + ".txt"
 
         # [>] Converte o arquivo para .txt no formato de um CSV
         TableDataFrame.to_csv(
-            fvar.filepath_ExportTxt,
+            fvar.filepath_WithoutFormatting,
             index = False,
             index_label = False,
             header = False,
@@ -86,7 +86,9 @@ def AppendToFile(ReadingMethod, TableDataFrame):
             "arquivo '" + fvar.filename_PDF + ".pdf' usando o "
             "método " + ReadingMethod + ".",
             
-            ExceptionError = ExceptionError
+            ExceptionError = ExceptionError,
+            ExitProgram = False,
+            RecreateTerminalFile = False
         )
         return
 
diff --git a/pdfconverter/patterncolumns/__init__.py b/pdfconverter/patterncolumns/__init__.py
index c2fbd58..4d88134 100644
--- a/pdfconverter/patterncolumns/__init__.py
+++ b/pdfconverter/patterncolumns/__init__.py
@@ -26,8 +26,8 @@
 # [>] PDFConverter
 # [i] Variáveis
 from pdfconverter.__variables__ import fvar, pvar
-# [i] Programa
-from pdfconverter.program.utilities.temporaryfile import temporaryfile
+# [i] Arquivo do Terminal
+from pdfconverter.terminalfile.message import error
 
 
 #region GLOBAL VARIABLES
@@ -51,13 +51,8 @@
 
 def SetHeaderToPattern(String):
     newString = ""
-
-    # [i] Regex que faz a verificação se o conteúdo da  li-
-    # nha é um cabeçalho
-    headerMatch = re.match(r"(^\"[a-zA-Z].*)", String)
-
     # [>] Se a linha for um cabeçalho
-    if headerMatch is not None:
+    if IsAHeader(String):
         # [>] Enxerga cada item do cabeçalho de cada tabela utilizando-
         # se de  uma  expressão regular e passa para uma lista
         list_CSVColumns = re.findall(
@@ -79,7 +74,7 @@ def SetHeaderToPattern(String):
             # suário
             foundInArg = False
             # [i] Contador das colunas do CSV
-            argContainerIterator = 0
+            counter_ArgsContainerIterator = 0
             # [>] Ele olha cada container de argumentos na lista  de  argu-
             # mentos que o usuário forneceu, contendo os valores de colunas
             # que ele quer alterar
@@ -87,11 +82,10 @@ def SetHeaderToPattern(String):
                 # [>] Verifica se a coluna atual do CSV ta dentro do container
                 if (column in argContainer):
                     # [>] Se estiver, olha cada valor do container atual
-                    for lineitem in range(len(pvar.list_columnFieldsToChange[argContainerIterator])):
-                        # [>] Caso seja o primeiro index
-                        if lineitem == 0:
-                            # [>] Pega como nome do argumento
-                            argName = argContainer[lineitem]
+                    for lineitem in range(len(pvar.list_columnFieldsToChange[counter_ArgsContainerIterator])):
+                        # [>] Caso seja o primeiro index, pega ele como título do argu-
+                        # mento
+                        if lineitem == 0: argName = argContainer[lineitem]
                         # [>] Caso não seja o primeiro index
                         else:
                             # [>] Pega como valor do argumento
@@ -105,47 +99,29 @@ def SetHeaderToPattern(String):
                                 foundInArg = True
                                 # [>] Para o for
                                 break
-                            # [>] Se não for igual da coluna
-                            else:
-                                # [>] Parte para o próximo item da array até achar
-                                continue
-                # [>] Se a linha atual nao tiver dentro do container
-                else:
-                    # [>] Passa pro proximo container
-                    continue
-                argContainerIterator += 1
+                # [>] Avança um no contador do container
+                counter_ArgsContainerIterator += 1
                 # [>] Caso a linha tenha sua correspondência encontrada  dentro
-                # do container atual
-                if foundInArg is True:
-                    # [>] Para a operação e parte para a próxima coluna
-                    break
-            # [>] Se ao término da operação
+                # do container atual para a operação e parte para a próxima co-
+                # luna
+                if foundInArg is True: break
+            # [i] Se ao término da operaçã
             else:
-                # [>] For percebido que a coluna não foi mencionada pelo  usuá-
-                # rio
-                if not foundInArg:
-                    # [i] Adiciona ela na String do jeito que ela tá
-                    newString += '"' + column + '"'
+                # [i] Se a coluna não conseguiu ser alterada
+                if not foundInArg: error.Show("Não foi possível alterar o valor da coluna '" + column + "' com os valores fornecidos em '" + str(pvar.list_columnFieldsToChange) + "'.")
             columnIterator += 1
 
             # [>] Pra cada coluna que for adicionada, se não for  a  última
             # coluna bota ';' na frente e se for coloca um '\n'
             newString += ';' if columnIterator < len(list_CSVColumns) else '\n'
-    # [>] Se a linha não for um cabeçalho
-    else:
-        # [>] Devolve a String como estava
-        newString = String
+    # [>] Se a linha não for um cabeçalho, devolve a string como estava
+    else: newString = String
 
     return newString
 
 def RecognizePattern(FileToReadPath):
-    patterncolumnspath = fvar.path_Export + fvar.rootPath + "\pattercolumns.txt"
-    LogDict = {
-        'info': {
-            'export_path': FileToReadPath,
-            'pattern_path': patterncolumnspath 
-        }
-    }
+    fvar.filepath_PatternColumns = fvar.folderpath_Result + "\\pattercolumns.txt"
+    LogDict = { }
 
     with open(FileToReadPath, "r", encoding = "UTF-8") as FileToRead:
         for line in FileToRead:
@@ -190,9 +166,15 @@ def RecognizePattern(FileToReadPath):
 
         # [>] O arquivo com as colunas padrão está sendo atualmente ge-
         # rado na pasta de resultados
-        with open(patterncolumnspath, mode = "w", encoding = "UTF-8") as TextFile:
+        with open(fvar.filepath_PatternColumns, mode = "w", encoding = "UTF-8") as TextFile:
             # [>] Transforma o dicionário de log em um JSON e escreve  den-
             # tro do arquivo
             TextFile.write(json.dumps(LogDict, indent = 4))
 
+#endregion
+
+#region PRIVATE METHODS
+
+def IsAHeader(String): return True if re.match(r"(^\"[a-zA-Z].*)", String) is not None else False
+
 #endregion
\ No newline at end of file
diff --git a/pdfconverter/program/__pycache__/exceptions.cpython-39.pyc b/pdfconverter/program/__pycache__/exceptions.cpython-39.pyc
index 5adf672..a09b785 100644
Binary files a/pdfconverter/program/__pycache__/exceptions.cpython-39.pyc and b/pdfconverter/program/__pycache__/exceptions.cpython-39.pyc differ
diff --git a/pdfconverter/program/utilities/__pycache__/temporaryfile.cpython-39.pyc b/pdfconverter/program/utilities/__pycache__/temporaryfile.cpython-39.pyc
deleted file mode 100644
index e3a0bf0..0000000
Binary files a/pdfconverter/program/utilities/__pycache__/temporaryfile.cpython-39.pyc and /dev/null differ
diff --git a/pdfconverter/program/utilities/__pycache__/time.cpython-39.pyc b/pdfconverter/program/utilities/__pycache__/time.cpython-39.pyc
deleted file mode 100644
index d1bd6ea..0000000
Binary files a/pdfconverter/program/utilities/__pycache__/time.cpython-39.pyc and /dev/null differ
diff --git a/pdfconverter/settings/project.py b/pdfconverter/settings/project.py
index 28ae3ca..471fc8d 100644
--- a/pdfconverter/settings/project.py
+++ b/pdfconverter/settings/project.py
@@ -21,7 +21,7 @@
 
 
 # [>] Geral
-import os
+import os.path
 import pathlib
 # [>] PDFConverter
 from pdfconverter.__variables__ import fvar
@@ -34,39 +34,32 @@ def SetFolderStructure():
 
     # [>] Cria uma nova pasta, caso já tenha uma chamada resultados
     int_indexFolderCreation = 0
-    folderSufix = ""
+    FolderSufix = ""
+    foldername_OldResult = fvar.foldername_Result
+    # [>] Caminho da pasta de resultados sem o sufixo
+    fvar.folderpath_Result = fvar.folderpath_Export + "\\" + fvar.foldername_Result
     # [i] Enquanto houver uma pasta de resultados existente
-    while (os.path.isdir(fvar.path_Export + fvar.rootPath + folderSufix)):
-        # [>] Adiciona +1 ao contador
+    while (os.path.isdir(fvar.folderpath_Result)):
         int_indexFolderCreation += 1
-        # [>] Arruma o nome do arquivo com o valor do contador
-        folderSufix = " (" + str(int_indexFolderCreation) + ")"
-    # [>] Atualiza o nome da pasta com o sufixo
-    fvar.rootPath += folderSufix
-
+        # [>] Atualiza a pasta de resultados com o novo índice
+        FolderSufix = " (" + str(int_indexFolderCreation) + ")"
+        fvar.foldername_Result = foldername_OldResult + FolderSufix
+        # [>] Passa o caminho da pasta de resultados, onde serão expor-
+        # tados os arquivos com um novo sufixo
+        fvar.folderpath_Result = fvar.folderpath_Export + "\\" + fvar.foldername_Result
 
     # [>] Criando pasta raíz
-    pathlib.Path(
-        fvar.path_Export +
-        fvar.rootPath
-    ).mkdir(parents = True, exist_ok = True)
-
-    # [i] Para cada método, presente na lista de métodos
-    for methodPath in fvar.list_readingPaths:
+    pathlib.Path(fvar.folderpath_Result).mkdir(parents = True, exist_ok = True)
+    
+    # [i] Para cada método de leitura, presente na lista de métodos
+    # de leitura
+    for methodPath in fvar.list_ReadingPaths:
         # [>] Cria uma pasta
-        pathlib.Path(
-            fvar.path_Export +
-            fvar.rootPath +
-            methodPath
-        ).mkdir(parents = True, exist_ok = True)
-
-        # [>] Criando pastas para métodos de formatação
-        for outputTypePath in fvar.list_formattingPaths:
-            pathlib.Path(
-                fvar.path_Export +
-                fvar.rootPath +
-                methodPath +
-                outputTypePath
-            ).mkdir(parents = True, exist_ok = True)
+        pathlib.Path(fvar.folderpath_Result + "\\" + methodPath).mkdir(parents = True, exist_ok = True)
+        # [i] Para cada método de formatação, presente na lista de  mé-
+        # todos de formatação
+        for outputTypePath in fvar.list_FormattingPaths:
+            # [>] Cria uma pasta
+            pathlib.Path(fvar.folderpath_Result + "\\" + methodPath + "\\" + outputTypePath).mkdir(parents = True, exist_ok = True)
 
 #endregion
\ No newline at end of file
diff --git a/pdfconverter/stringformat/__init__.py b/pdfconverter/stringformat/__init__.py
index 0711a83..5509a09 100644
--- a/pdfconverter/stringformat/__init__.py
+++ b/pdfconverter/stringformat/__init__.py
@@ -27,7 +27,10 @@
 #region STRING FORMAT
 
 class stringformat:
-    """Classe que manipula uma string."""
+    """
+    Classe que manipula uma String podendo  realizar  validações  e
+    substituições.
+    """
 
     #region CONSTRUCTOR
 
@@ -142,7 +145,7 @@ def IsSmallTable(self):
                 )
             )
             and
-            (self.String.count("\"") < 3 and self.String.count(";") < 1)
+            (self.String.count("\"") <= 3 and self.String.count(";") <= 1)
         ):
             return True
 
diff --git a/pdfconverter/terminalfile/__init__.py b/pdfconverter/terminalfile/__init__.py
index 2914815..e3cb1a1 100644
--- a/pdfconverter/terminalfile/__init__.py
+++ b/pdfconverter/terminalfile/__init__.py
@@ -54,13 +54,7 @@ def Close():
     except AttributeError:
         error.Show("O arquivo do terminal não pode ser fechado pois ele não foi aberto ainda.")
     except Exception as ExceptionError:
-        error.Show(
-            "Ocorreu um erro desconhecido ao tentar realizar o  fechamento"
-            "do arquivo do terminal.",
-
-            ExceptionError = ExceptionError,
-            ExitProgram = True
-        )
+        error.Show("Ocorreu um erro desconhecido ao tentar realizar o  fechamento do arquivo do terminal.", ExceptionError = ExceptionError,)
 
 def Recreate():
     """Método que recria o arquivo de saída do terminal do zero."""
@@ -70,8 +64,8 @@ def Recreate():
         # terminal
         fvar.file_TerminalFile = open(
             fvar.filepath_TerminalFile, # [i] Caminho do arquivo de saída do terminal
-            "w",                       # [i] Realiza uma sobrescrita de texto
-            encoding="UTF-8"           # [i] Codificação UTF-8
+            "w",                        # [i] Realiza uma sobrescrita de texto
+            encoding="UTF-8"            # [i] Codificação UTF-8
         )
     except PermissionError:
         # [>] Caso esteja como READONLY, remove a propriedade
diff --git a/pdfconverter/terminalfile/message/design.py b/pdfconverter/terminalfile/message/design.py
index d6fd3a5..7b2f94c 100644
--- a/pdfconverter/terminalfile/message/design.py
+++ b/pdfconverter/terminalfile/message/design.py
@@ -23,7 +23,7 @@
 import pandas
 # [>] PDFConverter
 # [i] Variáveis
-from pdfconverter.__variables__ import fvar, ivar, vvar
+from pdfconverter.__variables__ import fvar, vvar
 # [i] Arquivo do Terminal
 from pdfconverter.terminalfile import message
 
@@ -43,7 +43,7 @@ def PDFTitle(filefullname_PDF):
         filefullname_PDF + vvar.GiantLine + "\n" +
         vvar.GiantLine + "\n\n\n\n" +
         vvar.BlankSpaces + "                          ----- + -----\n\n" +
-        vvar.BlankSpaces + "         LEITURA DE ARQUIVO - NÚMERO " + str(ivar.PdfFile) + ", '" + filefullname_PDF + "'\n" +
+        vvar.BlankSpaces + "         LEITURA DE ARQUIVO - NÚMERO " + str(fvar.counter_PdfFile) + ", '" + filefullname_PDF + "'\n" +
         vvar.BlankSpaces + "   O arquivo '" + fvar.filename_PDF + "' foi lido e está pronto pra ser convertido\n\n" +
         vvar.BlankSpaces + "                          ----- + -----\n\n\n\n"
     )
@@ -66,9 +66,9 @@ def CloseLayout(LastLayout):
 def WithoutFormattingConversionTitle(ReadingMethod, TableDataFrame):
     message.Show(
             "\n\n"
-            "          A tabela nº"+ str(ivar.DataFrame) + " do '" + fvar.filename_PDF + "' foi convertida usando '" + ReadingMethod + "'\n"
+            "          A tabela nº"+ str(fvar.counter_DataFrame) + " do '" + fvar.filename_PDF + "' foi convertida usando '" + ReadingMethod + "'\n"
             "\________________________________________________________________________________/\n" +
-            "Search this (Ctrl + F): '" + fvar.filename_PDF + " " + ReadingMethod + " tbl" + str(ivar.DataFrame) + "'\n"
+            "Search this (Ctrl + F): '" + fvar.filename_PDF + " " + ReadingMethod + " tbl" + str(fvar.counter_DataFrame) + "'\n"
             "\n" +
             str(pandas.DataFrame(TableDataFrame))
     )
diff --git a/pdfconverter/terminalfile/message/error.py b/pdfconverter/terminalfile/message/error.py
index e572c51..2c91f0e 100644
--- a/pdfconverter/terminalfile/message/error.py
+++ b/pdfconverter/terminalfile/message/error.py
@@ -29,19 +29,17 @@
 
 #region PUBLIC METHODS
 
-def Show(ErrorMessage, ExceptionError = "", ExitProgram = False, RecreateTerminalFile = False):
-    # [>] Se desejado, recriar o arquivo de saída do terminal
-    if (RecreateTerminalFile):
-        # [>] Recria o arquivo de saída do terminal
-        terminalfile.Recreate()
+def Show(ErrorMessage, ExceptionError = "", ExitProgram = True, RecreateTerminalFile = True):
+    # [>] Caso solicitado, recria o arquivo de saída do terminal
+    if (RecreateTerminalFile): terminalfile.Recreate()
 
     # [>] Justifica o conteúdo da mensagem corretamente
     ErrorMessage = utilities.JustifyText(ErrorMessage, 58)
     # [>] Justifica o conteúdo da mensagem de exceção corretamente
     ExceptionError = utilities.JustifyText(ExceptionError, 58)
 
-    # [>] Conteúdo da mensagem de erro
-    Message = (
+    # [>] Exibe a mensagem
+    message.Show(
         "=============================================================\n"
         "                                                             \n"
         "                                                             \n"
@@ -57,12 +55,8 @@ def Show(ErrorMessage, ExceptionError = "", ExitProgram = False, RecreateTermina
         "=============================================================\n"
     )
 
-    # [>] Exibe a mensagem
-    message.Show(Message)
-
-    # [>] Se desejado sair do programa
-    if (ExitProgram):
-        # [>] Para o programa ao exibir o erro
-        program.Exit()
+    # [>] Caso solicitado, após exibir o erro para  a  execução  do
+    # programa
+    if (ExitProgram): program.Exit()
 
 #endregion
\ No newline at end of file
diff --git a/pdfconverter_script.pyproj b/pdfconverter_script.pyproj
index 94ec6c5..0b0a261 100644
--- a/pdfconverter_script.pyproj
+++ b/pdfconverter_script.pyproj
@@ -3,7 +3,7 @@
   <PropertyGroup>
     <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
     <SchemaVersion>2.0</SchemaVersion>
-    <ProjectGuid>1069a380-394f-4275-85fe-f377525fff6a</ProjectGuid>
+    <ProjectGuid>{f39ef143-fe7f-449d-8ef8-354c2b1c8c71}</ProjectGuid>
     <ProjectHome>.</ProjectHome>
     <StartupFile>
     </StartupFile>
@@ -35,6 +35,7 @@
     <Content Include=".vscode\extensions.json" />
     <Content Include=".vscode\launch.json" />
     <Content Include="LICENSE" />
+    <Content Include="pdfconverter\argument\__pycache__\validateargs.cpython-39.pyc" />
     <Content Include="pdfconverter\argument\__pycache__\__init__.cpython-39.pyc" />
     <Content Include="pdfconverter\conversion\format\__pycache__\fullclear.cpython-39.pyc" />
     <Content Include="pdfconverter\conversion\format\__pycache__\main.cpython-39.pyc" />
@@ -46,6 +47,7 @@
     <Content Include="pdfconverter\conversion\__pycache__\__init__.cpython-39.pyc.2330617629136" />
     <Content Include="pdfconverter\patterncolumns\__pycache__\__init__.cpython-39.pyc" />
     <Content Include="pdfconverter\program\utilities\__pycache__\__init__.cpython-39.pyc" />
+    <Content Include="pdfconverter\program\__pycache__\exceptions.cpython-39.pyc" />
     <Content Include="pdfconverter\program\__pycache__\utilities.cpython-39.pyc" />
     <Content Include="pdfconverter\program\__pycache__\__init__.cpython-39.pyc" />
     <Content Include="pdfconverter\settings\__pycache__\pandassettings.cpython-39.pyc" />
@@ -60,6 +62,7 @@
     <Content Include="pdfconverter\_projfiles\doc\method.mustache" />
     <Content Include="pdfconverter\_projfiles\doc\module.mustache" />
     <Content Include="pdfconverter\_projfiles\doc\variable.mustache" />
+    <Content Include="pdfconverter\__pycache__\pdfconverter.cpython-39.pyc" />
     <Content Include="pdfconverter\__pycache__\__init__.cpython-39.pyc" />
     <Content Include="pdfconverter\__pycache__\__main__.cpython-39.pyc" />
     <Content Include="pdfconverter\__pycache__\__variables__.cpython-39.pyc" />
@@ -67,6 +70,19 @@
   </ItemGroup>
   <ItemGroup>
     <Folder Include=".vscode\" />
+    <Folder Include="build\" />
+    <Folder Include="build\lib\" />
+    <Folder Include="build\lib\pdfconverter\" />
+    <Folder Include="build\lib\pdfconverter\argument\" />
+    <Folder Include="build\lib\pdfconverter\conversion\" />
+    <Folder Include="build\lib\pdfconverter\conversion\format\" />
+    <Folder Include="build\lib\pdfconverter\patterncolumns\" />
+    <Folder Include="build\lib\pdfconverter\program\" />
+    <Folder Include="build\lib\pdfconverter\program\utilities\" />
+    <Folder Include="build\lib\pdfconverter\settings\" />
+    <Folder Include="build\lib\pdfconverter\stringformat\" />
+    <Folder Include="build\lib\pdfconverter\terminalfile\" />
+    <Folder Include="build\lib\pdfconverter\terminalfile\message\" />
     <Folder Include="pdfconverter\" />
     <Folder Include="pdfconverter\argument\" />
     <Folder Include="pdfconverter\argument\__pycache__\" />
@@ -94,6 +110,33 @@
     <Folder Include="pdfconverter\__pycache__\" />
   </ItemGroup>
   <ItemGroup>
+    <Compile Include="build\lib\pdfconverter\argument\validateargs.py" />
+    <Compile Include="build\lib\pdfconverter\argument\__init__.py" />
+    <Compile Include="build\lib\pdfconverter\conversion\format\fullclear.py" />
+    <Compile Include="build\lib\pdfconverter\conversion\format\main.py" />
+    <Compile Include="build\lib\pdfconverter\conversion\format\tablewithblankcells.py" />
+    <Compile Include="build\lib\pdfconverter\conversion\format\__init__.py" />
+    <Compile Include="build\lib\pdfconverter\conversion\withoutformatting.py" />
+    <Compile Include="build\lib\pdfconverter\conversion\__init__.py" />
+    <Compile Include="build\lib\pdfconverter\patterncolumns\__init__.py" />
+    <Compile Include="build\lib\pdfconverter\program\exceptions.py" />
+    <Compile Include="build\lib\pdfconverter\program\utilities\temporaryfile.py" />
+    <Compile Include="build\lib\pdfconverter\program\utilities\time.py" />
+    <Compile Include="build\lib\pdfconverter\program\utilities\__init__.py" />
+    <Compile Include="build\lib\pdfconverter\program\__init__.py" />
+    <Compile Include="build\lib\pdfconverter\settings\pandassettings.py" />
+    <Compile Include="build\lib\pdfconverter\settings\project.py" />
+    <Compile Include="build\lib\pdfconverter\settings\__init__.py" />
+    <Compile Include="build\lib\pdfconverter\stringformat\__init__.py" />
+    <Compile Include="build\lib\pdfconverter\terminalfile\message\design.py" />
+    <Compile Include="build\lib\pdfconverter\terminalfile\message\error.py" />
+    <Compile Include="build\lib\pdfconverter\terminalfile\message\__init__.py" />
+    <Compile Include="build\lib\pdfconverter\terminalfile\__init__.py" />
+    <Compile Include="build\lib\pdfconverter\__init__.py" />
+    <Compile Include="build\lib\pdfconverter\__main__.py" />
+    <Compile Include="build\lib\pdfconverter\__variables__.py" />
+    <Compile Include="pdfconverter.py" />
+    <Compile Include="pdfconverter\argument\validateargs.py" />
     <Compile Include="pdfconverter\argument\__init__.py" />
     <Compile Include="pdfconverter\conversion\format\fullclear.py" />
     <Compile Include="pdfconverter\conversion\format\main.py" />
@@ -122,6 +165,7 @@
     <Compile Include="pdfconverter\__init__.py" />
     <Compile Include="pdfconverter\__main__.py" />
     <Compile Include="pdfconverter\__variables__.py" />
+    <Compile Include="setup.py" />
   </ItemGroup>
   <Import Condition="Exists($(PtvsTargetsFile))" Project="$(PtvsTargetsFile)" />
   <Import Condition="!Exists($(PtvsTargetsFile))" Project="$(MSBuildToolsPath)\Microsoft.Common.targets" />
diff --git a/setup.py b/setup.py
new file mode 100644
index 0000000..38a9e51
--- /dev/null
+++ b/setup.py
@@ -0,0 +1,63 @@
+import os
+from setuptools import setup, find_packages
+
+def read(FileName):
+    """
+    ---
+    ---
+    ---
+    
+    ## read (Public)
+    ---
+    ---
+    Método que retorna a leitura de um arquivo.
+    
+    ### Args
+    ---
+    - FileName (str):
+        - Nome do arquivo que irá ser lido.
+    
+    ### Returns
+    ---
+        [type]: [description]
+    
+    ---
+    ---
+    ---
+    """
+    return open(os.path.join(os.path.dirname(__file__), FileName)).read()
+
+setup(
+    #region DESCRIÇÃO
+    name = "pdfconverter",
+    description = "Projeto que tem como objetivo realizar a leitura (utilizando-"
+                  "se de bibliotecas externas) de arquivos PDF, identificar tabe"
+                  "las e realizar a conversão para um arquivo CSV formatado.",
+    #endregion
+    #region AUTORIA
+    author = "Vinícius Gabriel Marques de Melo",
+    author_email = "vinicius_gabriel258@hotmail.com",
+    url = "https://github.com/monambike",
+    
+    #endregion
+    #region DESCRIÇÃO TÉCNICA E REQUERIMENTOS
+    version = "1.0",
+    license = "CC0",
+    packages = find_packages(include=["pdfconverter", "pdfconverter.*"]),
+    classifiers = [
+        "Development Status :: 2 - Pre-Alpha",
+        "Environment :: Console",
+        "Intended Audience :: Customer Service",
+        "License :: Free for non-commercial use",
+        "Natural Language :: Portuguese (Brazilian)",
+        "Programming Language :: Python :: 3.9",
+        "Topic :: Utilities"
+    ],
+    install_requires = [
+        "numpy==1.20.2",
+        "pandas==1.2.3",
+        "pdfminer.six==20201018",
+        "tabula-py==2.3.0"
+    ]
+    #endregion
+)
\ No newline at end of file