"dis" --- Disassembler de bytecode do Python
********************************************

**Código-fonte:** Lib/dis.py

======================================================================

O módulo "dis" oferece suporte à análise de *bytecode* do CPython,
desmontando-o. O bytecode do CPython que o módulo leva como entrada é
definido no arquivo "Include/opcode.h" e usado pelo compilador e pelo
interpretador.

**Detalhes da implementação do CPython:** O bytecode é um detalhe de
implementação do interpretador CPython. Não há garantias de que
bytecodes não serão adicionados, removidos ou alterados entre as
versões do Python. O uso deste módulo não deve ser considerado que
funcionará em todas as VMs do Python ou mesmo versões do Python.

Alterado na versão 3.6: Cada instrução ocupa 2 bytes. Anteriormente, o
número de bytes variava de acordo com a instrução.

Alterado na versão 3.10: O argumento para instruções de pulo,
tratamento de exceção e laço é agora o deslocamento em instruções, ao
invés de em bytes.

Alterado na versão 3.11: Algumas instruções vêm acompanhadas de uma ou
mais entradas de cache em linha, as quais assumem a forma de
instruções "CACHE". Tais instruções são escondidas por padrão, mas
podem ser visualizadas passando "show_caches=True" para qualquer
utilidade do "dis". Além disso, o interpretador agora adapta o
bytecode para especializá-lo a diferentes condições de tempo de
execução. O bytecode adaptativo pode ser visualizado passando
"adaptive=True".

Alterado na versão 3.12: O argumento de um pulo é o deslocamento da
instrução alvo relativo à instrução que aparece imediatamente após as
entradas "CACHE" da instrução de pulo.Como consequência, a presença de
instruções "CACHE" é transparente para pulos adiante, mas precisa ser
considerada ao lidar com pulos para trás.

Alterado na versão 3.13: A saída agora mostra rótulos lógicos ao invés
dos deslocamentos das instruções para alvos de pulos e de tratadores
de exceções. A opção de linha de comando "-O" e o argumento
"show_offsets" foram adicionados.

Exemplo: Dada a função "myfunc()":

   def myfunc(alist):
       return len(alist)

o comando a seguir pode ser usado para mostrar a desconstrução de
"myfunc()":

   >>> dis.dis(myfunc)
     2           RESUME                   0

     3           LOAD_GLOBAL              1 (len + NULL)
                 LOAD_FAST                0 (alist)
                 CALL                     1
                 RETURN_VALUE

(O "2" é o número da linha).


Interface de linha de comando
=============================

O módulo "dis" pode ser invocado como um script na linha de comando:

   python -m dis [-h] [-C] [-O] [infile]

As seguintes opções são aceitas:

-h, --help

   Exibe o modo de usar e sai.

-C, --show-caches

   Mostra caches em linha

-O, --show-offsets

   Mostra os deslocamentos das instruções

Se "infile" for especificada, o seu código desmontado será escrito no
stdout. Caso contrário, será feito o desmonte da compilação do código-
fonte recebido do stdin.


Análise de bytecode
===================

Adicionado na versão 3.4.

A API de análise de bytecode permite que partes do código Python sejam
encapsuladas em um objeto "Bytecode" que facilite o acesso aos
detalhes do código compilado.

class dis.Bytecode(x, *, first_line=None, current_offset=None, show_caches=False, adaptive=False, show_offsets=False)

   Analisa o bytecode correspondente a uma função, um gerador, um
   gerador assíncrono, uma corrotina, um método, uma string de código-
   fonte, ou um objeto de código (conforme retornado por "compile()").

   Esta é uma utilidade de conveniência que encapsula muitas das
   funções listadas abaixo, principalmente a "get_instructions()", já
   que iterar sobre sobre uma instância de "Bytecode" produz operações
   bytecode como instâncias de "Instruction".

   Se *first_line* não for "None", ele indica o número de linha que
   deve ser reportado para a primeira linha de código-fonte no código
   desmontado.  Caso contrário, a informação de linha de código-fonte
   (se houver) é extraída diretamente da desconstrução do objeto de
   código.

   Se *current_offset* não for "None", ele é um deslocamento em
   instruções no código desconstruído. Definir este argumento
   significa que o "dis()" vai mostrar um marcador de "instrução
   atual" sobre o opcode especificado.

   Se *show_caches* for "True", o "dis()" vai exibir entradas de cache
   em linha usadas pelo interpretador para especializar o bytecode.

   Se *adaptive* for "True", o "dis()" vai exibir bytecode
   especializado que pode ser diferente do bytecode original.

   Se *show_offsets* for "True", o "dis()" vai incluir deslocamentos
   em instruções na saída.

   classmethod from_traceback(tb, *, show_caches=False)

      Constrói uma instância de "Bytecode" a partir do traceback
      fornecido, definindo *current_offset* apontando para a instrução
      responsável pela exceção.

   codeobj

      O objeto de código compilado.

   first_line

      A primeira linha de código-fonte do objeto de código (caso
      disponível).

   dis()

      Retorna uma visualização formatada das operações em bytecode (as
      mesmas que seriam impressas pela "dis.dis()", mas retornadas
      como uma string multilinha).

   info()

      Retorna uma string multilinha formatada com informação detalhada
      sobre o objeto de código, como "code_info()".

   Alterado na versão 3.7: Este método agora lida com objetos de
   corrotina e de gerador assíncrono.

   Alterado na versão 3.11: Adicionados os parâmetros *show_caches* e
   *adaptive*.

Exemplo:

   >>> bytecode = dis.Bytecode(myfunc)
   >>> for instr in bytecode:
   ...     print(instr.opname)
   ...
   RESUME
   LOAD_GLOBAL
   LOAD_FAST
   CALL
   RETURN_VALUE


Funções de análise
==================

O módulo "dis" também define as seguintes funções que convertem a
entrada diretamente para a saída desejada. Elas podem ser úteis se
somente uma única operação está sendo feita, de forma que o objeto de
análise intermediário não é útil:

dis.code_info(x)

   Retorna uma string multilinha formatada com informação detalhada
   sobre o objeto de código correspondente à função, gerador, gerador
   assíncrono, corrotina, método, string de código-fonte ou objeto de
   código fornecido.

   Observe que o conteúdo exato de strings de informação de código são
   altamente dependentes da implementação e podem mudar de forma
   arbitrária através de VMs Python ou lançamentos do Python.

   Adicionado na versão 3.2.

   Alterado na versão 3.7: Este método agora lida com objetos de
   corrotina e de gerador assíncrono.

dis.show_code(x, *, file=None)

   Imprime no arquivo *file* (ou "sys.stdout" caso *file* não seja
   especificado) informações detalhadas sobre o objeto de código
   correspondente à função, método, string de código-fonte fornecido.

   Este é um atalho conveniente para "print(code_info(x), file=file)",
   destinado à exploração interativa no prompt do interpretador.

   Adicionado na versão 3.2.

   Alterado na versão 3.4: Adicionado o parâmetro *file*.

dis.dis(x=None, *, file=None, depth=None, show_caches=False, adaptive=False)

   Desmonta o objeto *x*.  *x* pode denotar um módulo, uma classe, um
   método, uma função, um gerador, um gerador assíncrono, uma
   corrotina, um objeto de código, uma string de código-fonte ou uma
   sequência de bytes contendo bytecode bruto. Para um módulo, são
   desmontadas todas as funções. Para uma classe, são desmontados
   todos os métodos (incluindo métodos de classe e estáticos). Para um
   objeto de código ou sequência de bytecodes brutos, é impressa uma
   linha para cada instrução de bytecode. Além disso, objetos de
   código aninhados são desmontados recursivamente. Estes podem
   incluir expressões geradoras, funções aninhadas, corpos de classes
   aninhadas, e objetos de código usados para escopos de anotação.
   Strings são compiladas para objetos de código com a função embutida
   "compile()" antes de serem desmontadas.  Se nenhum objeto for
   fornecido, o último traceback é desmontado.

   O resultado é escrito como texto no arquivo *file* caso tenha sido
   fornecido como argumento, ou para "sys.stdout" caso contrário.

   A profundidade máxima de recursão é limitada por *depth* a menos
   que seja "None". "depth=0" significa não fazer recursão.

   Se *show_caches* for "True", essa função vai exibir entradas de
   cache em linha usadas pelo interpretador para especializar o
   bytecode.

   Se *adaptive* for "True", essa função vai exibir bytecode
   especializado que pode ser diferente do bytecode original.

   Alterado na versão 3.4: Adicionado o parâmetro *file*.

   Alterado na versão 3.7: Foi implementada a desmontagem recursiva, e
   adicionado o parâmetro *depth*.

   Alterado na versão 3.7: Este método agora lida com objetos de
   corrotina e de gerador assíncrono.

   Alterado na versão 3.11: Adicionados os parâmetros *show_caches* e
   *adaptive*.

distb(tb=None, *, file=None, show_caches=False, adaptive=False,
show_offset=False)

   Desmonta a função no topo da pilha de um traceback, usando o último
   traceback caso nenhum tenha sido passado.  A instrução que causou a
   exceção é indicada.

   O resultado é escrito como texto no arquivo *file* caso tenha sido
   fornecido como argumento, ou para "sys.stdout" caso contrário.

   Alterado na versão 3.4: Adicionado o parâmetro *file*.

   Alterado na versão 3.11: Adicionados os parâmetros *show_caches* e
   *adaptive*.

   Alterado na versão 3.13: Foi adicionado o parâmetro *show_offsets*.

dis.disassemble(code, lasti=-1, *, file=None, show_caches=False, adaptive=False)
disco(code, lasti=-1, *, file=None, show_caches=False, adaptive=False,
show_offsets=False)

   Desmonta um objeto de código, indicando a última instrução se
   *lasti* tiver sido fornecido.  A saída é dividida em colunas da
   seguinte forma:

   1. o número da linha, para a primeira instrução de cada linha

   2. a instrução atual, indicada por "-->",

   3. um rótulo da instrução, indicado com ">>",

   4. o endereço da instrução

   5. o nome do código da operação,

   6. os parâmetros da operação, e

   7. a interpretação dos parâmetros, em parênteses.

   A interpretação dos parâmetros reconhece nomes de variáveis locais
   e globais, valores de constantes, alvos de ramificações, e
   operadores de comparação.

   O resultado é escrito como texto no arquivo *file* caso tenha sido
   fornecido como argumento, ou para "sys.stdout" caso contrário.

   Alterado na versão 3.4: Adicionado o parâmetro *file*.

   Alterado na versão 3.11: Adicionados os parâmetros *show_caches* e
   *adaptive*.

   Alterado na versão 3.13: Foi adicionado o parâmetro *show_offsets*.

dis.get_instructions(x, *, first_line=None, show_caches=False, adaptive=False)

   Retorna um iterador sobre as instruções na função, método, string
   de código-fonte ou objeto de código fornecido.

   O iterador gera uma série de tuplas nomeadas "Instruction" contendo
   detalhes de cada operação no código fornecido.

   Se *first_line* não for "None", ele indica o número de linha que
   deve ser reportado para a primeira linha de código-fonte no código
   desmontado.  Caso contrário, a informação de linha de código-fonte
   (se houver) é extraída diretamente da desconstrução do objeto de
   código.

   O parâmetro *adaptive* funciona assim como na função "dis()".

   Adicionado na versão 3.4.

   Alterado na versão 3.11: Adicionados os parâmetros *show_caches* e
   *adaptive*.

   Alterado na versão 3.13: O parâmetro *show_caches* foi
   descontinuado e não tem mais efeito. O iterador gera as instâncias
   da "Instruction" com o campo *cache_info* populado
   (independentemente do valor de *show_caches*) e não gera mais items
   separados para as entradas de cache.

dis.findlinestarts(code)

   Essa função geradora usa o método "co_lines()" do objeto de código
   *code* para encontrar as posições que correspondem aos inícios de
   cada linha do código-fonte.  Elas são geradas em pares "(offset,
   lineno)".

   Alterado na versão 3.6: Números de linhas podem ser decrescentes.
   Antes, eles eram sempre crescentes.

   Alterado na versão 3.10: O método "co_lines()" da **PEP 626** é
   usado ao invés dos atributos "co_firstlineno" e "co_lnotab" do
   objeto de código.

   Alterado na versão 3.13: Números de linha podem ser "None" para
   bytecode que não corresponde a um código-fonte.

dis.findlabels(code)

   Detecta todas as posições na string de bytecode compilado bruto
   *code* que são alvos de pulos, e as retorna em uma lista.

dis.stack_effect(opcode, oparg=None, *, jump=None)

   Calcula o efeito que o *opcode* com argumento *oparg* tem na pilha.

   Se a operação tiver um alvo de pulo e *jump* for "True",
   "stack_effect()" vai retornar o efeito na pilha de realizar o pulo.
   Se *jump* for "False", ela vai retornar o efeito na pilha de não
   pular. E se *jump* for "None" (o padrão), vai retornar o efeito
   máximo na pilha dentre os dois casos.

   Adicionado na versão 3.4.

   Alterado na versão 3.8: Adicionado o parâmetro *jump*.

   Alterado na versão 3.13: Se "oparg" for omitido (ou "None"), agora
   é retornado o efeito na pilha para o caso "oparg=0". Anteriormente
   isso era um erro caso o opcode usasse o seu argumento. Além disso,
   agora não é mais um erro passar um inteiro como "oparg" quando o
   "opcode" não o usa; o "oparg" nesse caso é ignorado.


Instruções em bytecode do Python
================================

A função "get_instructions()" e a classe "Bytecode" fornecem detalhes
de instruções de bytecode como instâncias de "Instruction":

class dis.Instruction

   Detalhes de uma operação em bytecode

   opcode

      código numérico da operação, correspondendo aos valores dos
      opcodes listados abaixo e aos valores dos bytecodes nas Opcode
      collections.

   opname

      nome legível por humanos para a operação

   baseopcode

      código numérico para a operação base caso a operação seja
      especializada; caso contrário, igual ao "opcode"

   baseopname

      nome legível por humanos para a operação base caso a operação
      seja especializada; caso contrário, igual ao "opname"

   arg

      argumento numérico para a operação (se houver), caso contrário
      "None"

   oparg

      apelido para "arg"

   argval

      valor resolvido do argumento (se houver), caso contrário "None"

   argrepr

      descrição legível por humanos do argumento da operação (se
      houver), caso contrário uma string vazia.

   offset

      índice de início da operação dentro da sequência de bytecodes

   start_offset

      índice de início da operação dentro da sequência de bytecodes,
      incluindo as operações de "EXTENDED_ARG" prefixadas, caso
      presentes; caso contrário, igual a "offset"

   cache_offset

      índice de início das entradas de cache que seguem a operação

   end_offset

      índice de fim das entradas de cache que seguem a operação

   starts_line

      "True" se esse opcode inicia uma linha, "False" caso contrário

   line_number

      linha de código-fonte associada a esse opcode (se houver), senão
      "None"

   is_jump_target

      "True" se algum outro código pula para cá, senão "False"

   jump_target

      índice do bytecode que é alvo do pulo caso essa seja uma
      operação de pulo, caso contrário "None"

   positions

      objeto "dis.Positions" contendo os pontos de início e fim
      cobertos por esta instrução.

   Adicionado na versão 3.4.

   Alterado na versão 3.11: Adicionado o campo "positions".

   Alterado na versão 3.13: Alterado o campo "starts_line".Adicionados
   os campos "start_offset", "cache_offset", "end_offset",
   "baseopname", "baseopcode", "jump_target", "oparg", "line_number" e
   "cache_info".

class dis.Positions

   Caso a informação não esteja disponível, alguns campos podem ser
   "None".

   lineno

   end_lineno

   col_offset

   end_col_offset

   Adicionado na versão 3.11.

O compilador de Python atualmente gera as seguintes instruções de
bytecode.

**Instruções gerais**

A seguir, vamos usar "STACK" para nos referirmos à pilha do
interpretador, e vamos descrever operações nela como se ela fosse uma
lista do Python. Nessa linguagem, "STACK[-1]" é o topo da pilha.

NOP

   Código para não fazer nada.  Usado como espaço reservado pelo
   otimizador de bytecode, e para gerar eventos de rastreamento de
   linha.

POP_TOP

   Remove o item no topo da pilha:

      STACK.pop()

END_FOR

   Remove o item no topo da pilha. Equivalente a "POP_TOP". Usado como
   limpeza ao final de laços, o que explica o nome.

   Adicionado na versão 3.12.

END_SEND

   Implementa "del STACK[-2]". Usado como limpeza quando um gerador
   termina.

   Adicionado na versão 3.12.

COPY(i)

   Coloca o i-ésimo item no topo da pilha sem removê-lo da sua posição
   original:

      assert i > 0
      STACK.append(STACK[-i])

   Adicionado na versão 3.11.

SWAP(i)

   Troca o topo da pilha de lugar com o i-ésimo elemento.

      STACK[-i], STACK[-1] = STACK[-1], STACK[-i]

   Adicionado na versão 3.11.

CACHE

   Rather than being an actual instruction, this opcode is used to
   mark extra space for the interpreter to cache useful data directly
   in the bytecode itself. It is automatically hidden by all "dis"
   utilities, but can be viewed with "show_caches=True".

   Logically, this space is part of the preceding instruction. Many
   opcodes expect to be followed by an exact number of caches, and
   will instruct the interpreter to skip over them at runtime.

   Populated caches can look like arbitrary instructions, so great
   care should be taken when reading or modifying raw, adaptive
   bytecode containing quickened data.

   Adicionado na versão 3.11.

**Unary operations**

Unary operations take the top of the stack, apply the operation, and
push the result back on the stack.

UNARY_NEGATIVE

   Implements "STACK[-1] = -STACK[-1]".

UNARY_NOT

   Implements "STACK[-1] = not STACK[-1]".

   Alterado na versão 3.13: This instruction now requires an exact
   "bool" operand.

UNARY_INVERT

   Implements "STACK[-1] = ~STACK[-1]".

GET_ITER

   Implements "STACK[-1] = iter(STACK[-1])".

GET_YIELD_FROM_ITER

   If "STACK[-1]" is a *generator iterator* or *coroutine* object it
   is left as is.  Otherwise, implements "STACK[-1] =
   iter(STACK[-1])".

   Adicionado na versão 3.5.

TO_BOOL

   Implements "STACK[-1] = bool(STACK[-1])".

   Adicionado na versão 3.13.

**Binary and in-place operations**

Binary operations remove the top two items from the stack ("STACK[-1]"
and "STACK[-2]"). They perform the operation, then put the result back
on the stack.

In-place operations are like binary operations, but the operation is
done in-place when "STACK[-2]" supports it, and the resulting
"STACK[-1]" may be (but does not have to be) the original "STACK[-2]".

BINARY_OP(op)

   Implements the binary and in-place operators (depending on the
   value of *op*):

      rhs = STACK.pop()
      lhs = STACK.pop()
      STACK.append(lhs op rhs)

   Adicionado na versão 3.11.

BINARY_SUBSCR

   Implements:

      key = STACK.pop()
      container = STACK.pop()
      STACK.append(container[key])

STORE_SUBSCR

   Implements:

      key = STACK.pop()
      container = STACK.pop()
      value = STACK.pop()
      container[key] = value

DELETE_SUBSCR

   Implements:

      key = STACK.pop()
      container = STACK.pop()
      del container[key]

BINARY_SLICE

   Implements:

      end = STACK.pop()
      start = STACK.pop()
      container = STACK.pop()
      STACK.append(container[start:end])

   Adicionado na versão 3.12.

STORE_SLICE

   Implements:

      end = STACK.pop()
      start = STACK.pop()
      container = STACK.pop()
      values = STACK.pop()
      container[start:end] = value

   Adicionado na versão 3.12.

**Coroutine opcodes**

GET_AWAITABLE(where)

   Implements "STACK[-1] = get_awaitable(STACK[-1])", where
   "get_awaitable(o)" returns "o" if "o" is a coroutine object or a
   generator object with the "CO_ITERABLE_COROUTINE" flag, or resolves
   "o.__await__".

      If the "where" operand is nonzero, it indicates where the
      instruction occurs:

      * "1": After a call to "__aenter__"

      * "2": After a call to "__aexit__"

   Adicionado na versão 3.5.

   Alterado na versão 3.11: Previously, this instruction did not have
   an oparg.

GET_AITER

   Implements "STACK[-1] = STACK[-1].__aiter__()".

   Adicionado na versão 3.5.

   Alterado na versão 3.7: Returning awaitable objects from
   "__aiter__" is no longer supported.

GET_ANEXT

   Implement "STACK.append(get_awaitable(STACK[-1].__anext__()))" to
   the stack. See "GET_AWAITABLE" for details about "get_awaitable".

   Adicionado na versão 3.5.

END_ASYNC_FOR

   Terminates an "async for" loop.  Handles an exception raised when
   awaiting a next item. The stack contains the async iterable in
   "STACK[-2]" and the raised exception in "STACK[-1]". Both are
   popped. If the exception is not "StopAsyncIteration", it is re-
   raised.

   Adicionado na versão 3.8.

   Alterado na versão 3.11: Exception representation on the stack now
   consist of one, not three, items.

CLEANUP_THROW

   Handles an exception raised during a "throw()" or "close()" call
   through the current frame.  If "STACK[-1]" is an instance of
   "StopIteration", pop three values from the stack and push its
   "value" member.  Otherwise, re-raise "STACK[-1]".

   Adicionado na versão 3.12.

BEFORE_ASYNC_WITH

   Resolves "__aenter__" and "__aexit__" from "STACK[-1]". Pushes
   "__aexit__" and result of "__aenter__()" to the stack:

      STACK.extend((__aexit__, __aenter__())

   Adicionado na versão 3.5.

**Miscellaneous opcodes**

SET_ADD(i)

   Implements:

      item = STACK.pop()
      set.add(STACK[-i], item)

   Used to implement set comprehensions.

LIST_APPEND(i)

   Implements:

      item = STACK.pop()
      list.append(STACK[-i], item)

   Used to implement list comprehensions.

MAP_ADD(i)

   Implements:

      value = STACK.pop()
      key = STACK.pop()
      dict.__setitem__(STACK[-i], key, value)

   Used to implement dict comprehensions.

   Adicionado na versão 3.1.

   Alterado na versão 3.8: Map value is "STACK[-1]" and map key is
   "STACK[-2]". Before, those were reversed.

For all of the "SET_ADD", "LIST_APPEND" and "MAP_ADD" instructions,
while the added value or key/value pair is popped off, the container
object remains on the stack so that it is available for further
iterations of the loop.

RETURN_VALUE

   Returns with "STACK[-1]" to the caller of the function.

RETURN_CONST(consti)

   Returns with "co_consts[consti]" to the caller of the function.

   Adicionado na versão 3.12.

YIELD_VALUE

   Yields "STACK.pop()" from a *generator*.

   Alterado na versão 3.11: oparg set to be the stack depth.

   Alterado na versão 3.12: oparg set to be the exception block depth,
   for efficient closing of generators.

   Alterado na versão 3.13: oparg is "1" if this instruction is part
   of a yield-from or await, and "0" otherwise.

SETUP_ANNOTATIONS

   Checks whether "__annotations__" is defined in "locals()", if not
   it is set up to an empty "dict". This opcode is only emitted if a
   class or module body contains *variable annotations* statically.

   Adicionado na versão 3.6.

POP_EXCEPT

   Pops a value from the stack, which is used to restore the exception
   state.

   Alterado na versão 3.11: Exception representation on the stack now
   consist of one, not three, items.

RERAISE

   Re-raises the exception currently on top of the stack. If oparg is
   non-zero, pops an additional value from the stack which is used to
   set "f_lasti" of the current frame.

   Adicionado na versão 3.9.

   Alterado na versão 3.11: Exception representation on the stack now
   consist of one, not three, items.

PUSH_EXC_INFO

   Pops a value from the stack. Pushes the current exception to the
   top of the stack. Pushes the value originally popped back to the
   stack. Used in exception handlers.

   Adicionado na versão 3.11.

CHECK_EXC_MATCH

   Performs exception matching for "except". Tests whether the
   "STACK[-2]" is an exception matching "STACK[-1]". Pops "STACK[-1]"
   and pushes the boolean result of the test.

   Adicionado na versão 3.11.

CHECK_EG_MATCH

   Performs exception matching for "except*". Applies
   "split(STACK[-1])" on the exception group representing "STACK[-2]".

   In case of a match, pops two items from the stack and pushes the
   non-matching subgroup ("None" in case of full match) followed by
   the matching subgroup. When there is no match, pops one item (the
   match type) and pushes "None".

   Adicionado na versão 3.11.

WITH_EXCEPT_START

   Calls the function in position 4 on the stack with arguments (type,
   val, tb) representing the exception at the top of the stack. Used
   to implement the call "context_manager.__exit__(*exc_info())" when
   an exception has occurred in a "with" statement.

   Adicionado na versão 3.9.

   Alterado na versão 3.11: The "__exit__" function is in position 4
   of the stack rather than 7. Exception representation on the stack
   now consist of one, not three, items.

LOAD_ASSERTION_ERROR

   Pushes "AssertionError" onto the stack.  Used by the "assert"
   statement.

   Adicionado na versão 3.9.

LOAD_BUILD_CLASS

   Pushes "builtins.__build_class__()" onto the stack.  It is later
   called to construct a class.

BEFORE_WITH

   This opcode performs several operations before a with block starts.
   First, it loads "__exit__()" from the context manager and pushes it
   onto the stack for later use by "WITH_EXCEPT_START".  Then,
   "__enter__()" is called. Finally, the result of calling the
   "__enter__()" method is pushed onto the stack.

   Adicionado na versão 3.11.

GET_LEN

   Perform "STACK.append(len(STACK[-1]))".

   Adicionado na versão 3.10.

MATCH_MAPPING

   If "STACK[-1]" is an instance of "collections.abc.Mapping" (or,
   more technically: if it has the "Py_TPFLAGS_MAPPING" flag set in
   its "tp_flags"), push "True" onto the stack.  Otherwise, push
   "False".

   Adicionado na versão 3.10.

MATCH_SEQUENCE

   If "STACK[-1]" is an instance of "collections.abc.Sequence" and is
   *not* an instance of "str"/"bytes"/"bytearray" (or, more
   technically: if it has the "Py_TPFLAGS_SEQUENCE" flag set in its
   "tp_flags"), push "True" onto the stack.  Otherwise, push "False".

   Adicionado na versão 3.10.

MATCH_KEYS

   "STACK[-1]" is a tuple of mapping keys, and "STACK[-2]" is the
   match subject. If "STACK[-2]" contains all of the keys in
   "STACK[-1]", push a "tuple" containing the corresponding values.
   Otherwise, push "None".

   Adicionado na versão 3.10.

   Alterado na versão 3.11: Previously, this instruction also pushed a
   boolean value indicating success ("True") or failure ("False").

STORE_NAME(namei)

   Implements "name = STACK.pop()". *namei* is the index of *name* in
   the attribute "co_names" of the code object. The compiler tries to
   use "STORE_FAST" or "STORE_GLOBAL" if possible.

DELETE_NAME(namei)

   Implements "del name", where *namei* is the index into "co_names"
   attribute of the code object.

UNPACK_SEQUENCE(count)

   Unpacks "STACK[-1]" into *count* individual values, which are put
   onto the stack right-to-left. Require there to be exactly *count*
   values.:

      assert(len(STACK[-1]) == count)
      STACK.extend(STACK.pop()[:-count-1:-1])

UNPACK_EX(counts)

   Implements assignment with a starred target: Unpacks an iterable in
   "STACK[-1]" into individual values, where the total number of
   values can be smaller than the number of items in the iterable: one
   of the new values will be a list of all leftover items.

   The number of values before and after the list value is limited to
   255.

   The number of values before the list value is encoded in the
   argument of the opcode. The number of values after the list if any
   is encoded using an "EXTENDED_ARG". As a consequence, the argument
   can be seen as a two bytes values where the low byte of *counts* is
   the number of values before the list value, the high byte of
   *counts* the number of values after it.

   The extracted values are put onto the stack right-to-left, i.e. "a,
   *b, c = d" will be stored after execution as "STACK.extend((a, b,
   c))".

STORE_ATTR(namei)

   Implements:

      obj = STACK.pop()
      value = STACK.pop()
      obj.name = value

   where *namei* is the index of name in "co_names" of the code
   object.

DELETE_ATTR(namei)

   Implements:

      obj = STACK.pop()
      del obj.name

   where *namei* is the index of name into "co_names" of the code
   object.

STORE_GLOBAL(namei)

   Works as "STORE_NAME", but stores the name as a global.

DELETE_GLOBAL(namei)

   Works as "DELETE_NAME", but deletes a global name.

LOAD_CONST(consti)

   Pushes "co_consts[consti]" onto the stack.

LOAD_NAME(namei)

   Pushes the value associated with "co_names[namei]" onto the stack.
   The name is looked up within the locals, then the globals, then the
   builtins.

LOAD_LOCALS

   Pushes a reference to the locals dictionary onto the stack.  This
   is used to prepare namespace dictionaries for
   "LOAD_FROM_DICT_OR_DEREF" and "LOAD_FROM_DICT_OR_GLOBALS".

   Adicionado na versão 3.12.

LOAD_FROM_DICT_OR_GLOBALS(i)

   Pops a mapping off the stack and looks up the value for
   "co_names[namei]". If the name is not found there, looks it up in
   the globals and then the builtins, similar to "LOAD_GLOBAL". This
   is used for loading global variables in annotation scopes within
   class bodies.

   Adicionado na versão 3.12.

BUILD_TUPLE(count)

   Creates a tuple consuming *count* items from the stack, and pushes
   the resulting tuple onto the stack.:

      assert count > 0
      STACK, values = STACK[:-count], STACK[-count:]
      STACK.append(tuple(values))

BUILD_LIST(count)

   Works as "BUILD_TUPLE", but creates a list.

BUILD_SET(count)

   Works as "BUILD_TUPLE", but creates a set.

BUILD_MAP(count)

   Pushes a new dictionary object onto the stack.  Pops "2 * count"
   items so that the dictionary holds *count* entries: "{...,
   STACK[-4]: STACK[-3], STACK[-2]: STACK[-1]}".

   Alterado na versão 3.5: The dictionary is created from stack items
   instead of creating an empty dictionary pre-sized to hold *count*
   items.

BUILD_CONST_KEY_MAP(count)

   The version of "BUILD_MAP" specialized for constant keys. Pops the
   top element on the stack which contains a tuple of keys, then
   starting from "STACK[-2]", pops *count* values to form values in
   the built dictionary.

   Adicionado na versão 3.6.

BUILD_STRING(count)

   Concatenates *count* strings from the stack and pushes the
   resulting string onto the stack.

   Adicionado na versão 3.6.

LIST_EXTEND(i)

   Implements:

      seq = STACK.pop()
      list.extend(STACK[-i], seq)

   Used to build lists.

   Adicionado na versão 3.9.

SET_UPDATE(i)

   Implements:

      seq = STACK.pop()
      set.update(STACK[-i], seq)

   Used to build sets.

   Adicionado na versão 3.9.

DICT_UPDATE(i)

   Implements:

      map = STACK.pop()
      dict.update(STACK[-i], map)

   Used to build dicts.

   Adicionado na versão 3.9.

DICT_MERGE(i)

   Like "DICT_UPDATE" but raises an exception for duplicate keys.

   Adicionado na versão 3.9.

LOAD_ATTR(namei)

   If the low bit of "namei" is not set, this replaces "STACK[-1]"
   with "getattr(STACK[-1], co_names[namei>>1])".

   If the low bit of "namei" is set, this will attempt to load a
   method named "co_names[namei>>1]" from the "STACK[-1]" object.
   "STACK[-1]" is popped. This bytecode distinguishes two cases: if
   "STACK[-1]" has a method with the correct name, the bytecode pushes
   the unbound method and "STACK[-1]". "STACK[-1]" will be used as the
   first argument ("self") by "CALL" or "CALL_KW" when calling the
   unbound method. Otherwise, "NULL" and the object returned by the
   attribute lookup are pushed.

   Alterado na versão 3.12: If the low bit of "namei" is set, then a
   "NULL" or "self" is pushed to the stack before the attribute or
   unbound method respectively.

LOAD_SUPER_ATTR(namei)

   This opcode implements "super()", both in its zero-argument and
   two-argument forms (e.g. "super().method()", "super().attr" and
   "super(cls, self).method()", "super(cls, self).attr").

   It pops three values from the stack (from top of stack down):

   * "self": the first argument to the current method

   * "cls": the class within which the current method was defined

   * the global "super"

   With respect to its argument, it works similarly to "LOAD_ATTR",
   except that "namei" is shifted left by 2 bits instead of 1.

   The low bit of "namei" signals to attempt a method load, as with
   "LOAD_ATTR", which results in pushing "NULL" and the loaded method.
   When it is unset a single value is pushed to the stack.

   The second-low bit of "namei", if set, means that this was a two-
   argument call to "super()" (unset means zero-argument).

   Adicionado na versão 3.12.

COMPARE_OP(opname)

   Performs a Boolean operation.  The operation name can be found in
   "cmp_op[opname >> 5]". If the fifth-lowest bit of "opname" is set
   ("opname & 16"), the result should be coerced to "bool".

   Alterado na versão 3.13: The fifth-lowest bit of the oparg now
   indicates a forced conversion to "bool".

IS_OP(invert)

   Performs "is" comparison, or "is not" if "invert" is 1.

   Adicionado na versão 3.9.

CONTAINS_OP(invert)

   Performs "in" comparison, or "not in" if "invert" is 1.

   Adicionado na versão 3.9.

IMPORT_NAME(namei)

   Imports the module "co_names[namei]".  "STACK[-1]" and "STACK[-2]"
   are popped and provide the *fromlist* and *level* arguments of
   "__import__()". The module object is pushed onto the stack.  The
   current namespace is not affected: for a proper import statement, a
   subsequent "STORE_FAST" instruction modifies the namespace.

IMPORT_FROM(namei)

   Loads the attribute "co_names[namei]" from the module found in
   "STACK[-1]". The resulting object is pushed onto the stack, to be
   subsequently stored by a "STORE_FAST" instruction.

JUMP_FORWARD(delta)

   Increments bytecode counter by *delta*.

JUMP_BACKWARD(delta)

   Decrements bytecode counter by *delta*. Checks for interrupts.

   Adicionado na versão 3.11.

JUMP_BACKWARD_NO_INTERRUPT(delta)

   Decrements bytecode counter by *delta*. Does not check for
   interrupts.

   Adicionado na versão 3.11.

POP_JUMP_IF_TRUE(delta)

   If "STACK[-1]" is true, increments the bytecode counter by *delta*.
   "STACK[-1]" is popped.

   Alterado na versão 3.11: The oparg is now a relative delta rather
   than an absolute target. This opcode is a pseudo-instruction,
   replaced in final bytecode by the directed versions
   (forward/backward).

   Alterado na versão 3.12: This is no longer a pseudo-instruction.

   Alterado na versão 3.13: This instruction now requires an exact
   "bool" operand.

POP_JUMP_IF_FALSE(delta)

   If "STACK[-1]" is false, increments the bytecode counter by
   *delta*. "STACK[-1]" is popped.

   Alterado na versão 3.11: The oparg is now a relative delta rather
   than an absolute target. This opcode is a pseudo-instruction,
   replaced in final bytecode by the directed versions
   (forward/backward).

   Alterado na versão 3.12: This is no longer a pseudo-instruction.

   Alterado na versão 3.13: This instruction now requires an exact
   "bool" operand.

POP_JUMP_IF_NOT_NONE(delta)

   If "STACK[-1]" is not "None", increments the bytecode counter by
   *delta*. "STACK[-1]" is popped.

   This opcode is a pseudo-instruction, replaced in final bytecode by
   the directed versions (forward/backward).

   Adicionado na versão 3.11.

   Alterado na versão 3.12: This is no longer a pseudo-instruction.

POP_JUMP_IF_NONE(delta)

   If "STACK[-1]" is "None", increments the bytecode counter by
   *delta*. "STACK[-1]" is popped.

   This opcode is a pseudo-instruction, replaced in final bytecode by
   the directed versions (forward/backward).

   Adicionado na versão 3.11.

   Alterado na versão 3.12: This is no longer a pseudo-instruction.

FOR_ITER(delta)

   "STACK[-1]" is an *iterator*.  Call its "__next__()" method. If
   this yields a new value, push it on the stack (leaving the iterator
   below it).  If the iterator indicates it is exhausted then the byte
   code counter is incremented by *delta*.

   Alterado na versão 3.12: Up until 3.11 the iterator was popped when
   it was exhausted.

LOAD_GLOBAL(namei)

   Loads the global named "co_names[namei>>1]" onto the stack.

   Alterado na versão 3.11: If the low bit of "namei" is set, then a
   "NULL" is pushed to the stack before the global variable.

LOAD_FAST(var_num)

   Pushes a reference to the local "co_varnames[var_num]" onto the
   stack.

   Alterado na versão 3.12: This opcode is now only used in situations
   where the local variable is guaranteed to be initialized. It cannot
   raise "UnboundLocalError".

LOAD_FAST_CHECK(var_num)

   Pushes a reference to the local "co_varnames[var_num]" onto the
   stack, raising an "UnboundLocalError" if the local variable has not
   been initialized.

   Adicionado na versão 3.12.

LOAD_FAST_AND_CLEAR(var_num)

   Pushes a reference to the local "co_varnames[var_num]" onto the
   stack (or pushes "NULL" onto the stack if the local variable has
   not been initialized) and sets "co_varnames[var_num]" to "NULL".

   Adicionado na versão 3.12.

STORE_FAST(var_num)

   Stores "STACK.pop()" into the local "co_varnames[var_num]".

DELETE_FAST(var_num)

   Deletes local "co_varnames[var_num]".

MAKE_CELL(i)

   Creates a new cell in slot "i".  If that slot is nonempty then that
   value is stored into the new cell.

   Adicionado na versão 3.11.

LOAD_DEREF(i)

   Loads the cell contained in slot "i" of the "fast locals" storage.
   Pushes a reference to the object the cell contains on the stack.

   Alterado na versão 3.11: "i" is no longer offset by the length of
   "co_varnames".

LOAD_FROM_DICT_OR_DEREF(i)

   Pops a mapping off the stack and looks up the name associated with
   slot "i" of the "fast locals" storage in this mapping. If the name
   is not found there, loads it from the cell contained in slot "i",
   similar to "LOAD_DEREF". This is used for loading free variables in
   class bodies (which previously used "LOAD_CLASSDEREF") and in
   annotation scopes within class bodies.

   Adicionado na versão 3.12.

STORE_DEREF(i)

   Stores "STACK.pop()" into the cell contained in slot "i" of the
   "fast locals" storage.

   Alterado na versão 3.11: "i" is no longer offset by the length of
   "co_varnames".

DELETE_DEREF(i)

   Empties the cell contained in slot "i" of the "fast locals"
   storage. Used by the "del" statement.

   Adicionado na versão 3.2.

   Alterado na versão 3.11: "i" is no longer offset by the length of
   "co_varnames".

COPY_FREE_VARS(n)

   Copies the "n" free variables from the closure into the frame.
   Removes the need for special code on the caller's side when calling
   closures.

   Adicionado na versão 3.11.

RAISE_VARARGS(argc)

   Raises an exception using one of the 3 forms of the "raise"
   statement, depending on the value of *argc*:

   * 0: "raise" (re-raise previous exception)

   * 1: "raise STACK[-1]" (raise exception instance or type at
     "STACK[-1]")

   * 2: "raise STACK[-2] from STACK[-1]" (raise exception instance or
     type at "STACK[-2]" with "__cause__" set to "STACK[-1]")

CALL(argc)

   Calls a callable object with the number of arguments specified by
   "argc". On the stack are (in ascending order):

   * The callable

   * "self" or "NULL"

   * The remaining positional arguments

   "argc" is the total of the positional arguments, excluding "self".

   "CALL" pops all arguments and the callable object off the stack,
   calls the callable object with those arguments, and pushes the
   return value returned by the callable object.

   Adicionado na versão 3.11.

   Alterado na versão 3.13: The callable now always appears at the
   same position on the stack.

   Alterado na versão 3.13: Calls with keyword arguments are now
   handled by "CALL_KW".

CALL_KW(argc)

   Calls a callable object with the number of arguments specified by
   "argc", including one or more named arguments. On the stack are (in
   ascending order):

   * The callable

   * "self" or "NULL"

   * The remaining positional arguments

   * The named arguments

   * A "tuple" of keyword argument names

   "argc" is the total of the positional and named arguments,
   excluding "self". The length of the tuple of keyword argument names
   is the number of named arguments.

   "CALL_KW" pops all arguments, the keyword names, and the callable
   object off the stack, calls the callable object with those
   arguments, and pushes the return value returned by the callable
   object.

   Adicionado na versão 3.13.

CALL_FUNCTION_EX(flags)

   Calls a callable object with variable set of positional and keyword
   arguments.  If the lowest bit of *flags* is set, the top of the
   stack contains a mapping object containing additional keyword
   arguments. Before the callable is called, the mapping object and
   iterable object are each "unpacked" and their contents passed in as
   keyword and positional arguments respectively. "CALL_FUNCTION_EX"
   pops all arguments and the callable object off the stack, calls the
   callable object with those arguments, and pushes the return value
   returned by the callable object.

   Adicionado na versão 3.6.

PUSH_NULL

   Pushes a "NULL" to the stack. Used in the call sequence to match
   the "NULL" pushed by "LOAD_METHOD" for non-method calls.

   Adicionado na versão 3.11.

MAKE_FUNCTION

   Pushes a new function object on the stack built from the code
   object at "STACK[1]".

   Alterado na versão 3.10: Flag value "0x04" is a tuple of strings
   instead of dictionary

   Alterado na versão 3.11: Qualified name at "STACK[-1]" was removed.

   Alterado na versão 3.13: Extra function attributes on the stack,
   signaled by oparg flags, were removed. They now use
   "SET_FUNCTION_ATTRIBUTE".

SET_FUNCTION_ATTRIBUTE(flag)

   Sets an attribute on a function object. Expects the function at
   "STACK[-1]" and the attribute value to set at "STACK[-2]"; consumes
   both and leaves the function at "STACK[-1]". The flag determines
   which attribute to set:

   * "0x01" a tuple of default values for positional-only and
     positional-or-keyword parameters in positional order

   * "0x02" a dictionary of keyword-only parameters' default values

   * "0x04" a tuple of strings containing parameters' annotations

   * "0x08" a tuple containing cells for free variables, making a
     closure

   Adicionado na versão 3.13.

BUILD_SLICE(argc)

   Pushes a slice object on the stack.  *argc* must be 2 or 3.  If it
   is 2, implements:

      end = STACK.pop()
      start = STACK.pop()
      STACK.append(slice(start, stop))

   if it is 3, implements:

      step = STACK.pop()
      end = STACK.pop()
      start = STACK.pop()
      STACK.append(slice(start, end, step))

   See the "slice()" built-in function for more information.

EXTENDED_ARG(ext)

   Prefixes any opcode which has an argument too big to fit into the
   default one byte. *ext* holds an additional byte which act as
   higher bits in the argument. For each opcode, at most three
   prefixal "EXTENDED_ARG" are allowed, forming an argument from two-
   byte to four-byte.

CONVERT_VALUE(oparg)

   Convert value to a string, depending on "oparg":

      value = STACK.pop()
      result = func(value)
      STACK.append(result)

   * "oparg == 1": call "str()" on *value*

   * "oparg == 2": call "repr()" on *value*

   * "oparg == 3": call "ascii()" on *value*

   Used for implementing formatted literal strings (f-strings).

   Adicionado na versão 3.13.

FORMAT_SIMPLE

   Formats the value on top of stack:

      value = STACK.pop()
      result = value.__format__("")
      STACK.append(result)

   Used for implementing formatted literal strings (f-strings).

   Adicionado na versão 3.13.

FORMAT_SPEC

   Formats the given value with the given format spec:

      spec = STACK.pop()
      value = STACK.pop()
      result = value.__format__(spec)
      STACK.append(result)

   Used for implementing formatted literal strings (f-strings).

   Adicionado na versão 3.13.

MATCH_CLASS(count)

   "STACK[-1]" is a tuple of keyword attribute names, "STACK[-2]" is
   the class being matched against, and "STACK[-3]" is the match
   subject.  *count* is the number of positional sub-patterns.

   Pop "STACK[-1]", "STACK[-2]", and "STACK[-3]". If "STACK[-3]" is an
   instance of "STACK[-2]" and has the positional and keyword
   attributes required by *count* and "STACK[-1]", push a tuple of
   extracted attributes. Otherwise, push "None".

   Adicionado na versão 3.10.

   Alterado na versão 3.11: Previously, this instruction also pushed a
   boolean value indicating success ("True") or failure ("False").

RESUME(context)

   A no-op. Performs internal tracing, debugging and optimization
   checks.

   The "context" oparand consists of two parts. The lowest two bits
   indicate where the "RESUME" occurs:

   * "0" The start of a function, which is neither a generator,
     coroutine nor an async generator

   * "1" Depois de uma expressão "yield"

   * "2" After a "yield from" expression

   * "3" Depois de uma expressão "await"

   The next bit is "1" if the RESUME is at except-depth "1", and "0"
   otherwise.

   Adicionado na versão 3.11.

   Alterado na versão 3.13: The oparg value changed to include
   information about except-depth

RETURN_GENERATOR

   Create a generator, coroutine, or async generator from the current
   frame. Used as first opcode of in code object for the above
   mentioned callables. Clear the current frame and return the newly
   created generator.

   Adicionado na versão 3.11.

SEND(delta)

   Equivalent to "STACK[-1] = STACK[-2].send(STACK[-1])". Used in
   "yield from" and "await" statements.

   If the call raises "StopIteration", pop the top value from the
   stack, push the exception's "value" attribute, and increment the
   bytecode counter by *delta*.

   Adicionado na versão 3.11.

HAVE_ARGUMENT

   This is not really an opcode.  It identifies the dividing line
   between opcodes in the range [0,255] which don't use their argument
   and those that do ("< HAVE_ARGUMENT" and ">= HAVE_ARGUMENT",
   respectively).

   If your application uses pseudo instructions or specialized
   instructions, use the "hasarg" collection instead.

   Alterado na versão 3.6: Now every instruction has an argument, but
   opcodes "< HAVE_ARGUMENT" ignore it. Before, only opcodes ">=
   HAVE_ARGUMENT" had an argument.

   Alterado na versão 3.12: Pseudo instructions were added to the
   "dis" module, and for them it is not true that comparison with
   "HAVE_ARGUMENT" indicates whether they use their arg.

   Obsoleto desde a versão 3.13: Use "hasarg" instead.

CALL_INTRINSIC_1

   Calls an intrinsic function with one argument. Passes "STACK[-1]"
   as the argument and sets "STACK[-1]" to the result. Used to
   implement functionality that is not performance critical.

   The operand determines which intrinsic function is called:

   +-------------------------------------+-------------------------------------+
   | Operand                             | Descrição                           |
   |=====================================|=====================================|
   | "INTRINSIC_1_INVALID"               | Not valid                           |
   +-------------------------------------+-------------------------------------+
   | "INTRINSIC_PRINT"                   | Prints the argument to standard     |
   |                                     | out. Used in the REPL.              |
   +-------------------------------------+-------------------------------------+
   | "INTRINSIC_IMPORT_STAR"             | Performs "import *" for the named   |
   |                                     | module.                             |
   +-------------------------------------+-------------------------------------+
   | "INTRINSIC_STOPITERATION_ERROR"     | Extracts the return value from a    |
   |                                     | "StopIteration" exception.          |
   +-------------------------------------+-------------------------------------+
   | "INTRINSIC_ASYNC_GEN_WRAP"          | Wraps an aync generator value       |
   +-------------------------------------+-------------------------------------+
   | "INTRINSIC_UNARY_POSITIVE"          | Performs the unary "+" operation    |
   +-------------------------------------+-------------------------------------+
   | "INTRINSIC_LIST_TO_TUPLE"           | Converts a list to a tuple          |
   +-------------------------------------+-------------------------------------+
   | "INTRINSIC_TYPEVAR"                 | Cria um "typing.TypeVar"            |
   +-------------------------------------+-------------------------------------+
   | "INTRINSIC_PARAMSPEC"               | Cria um "typing.ParamSpec"          |
   +-------------------------------------+-------------------------------------+
   | "INTRINSIC_TYPEVARTUPLE"            | Cria um "typing.TypeVarTuple"       |
   +-------------------------------------+-------------------------------------+
   | "INTRINSIC_SUBSCRIPT_GENERIC"       | Returns "typing.Generic"            |
   |                                     | subscripted with the argument       |
   +-------------------------------------+-------------------------------------+
   | "INTRINSIC_TYPEALIAS"               | Creates a "typing.TypeAliasType";   |
   |                                     | used in the "type" statement. The   |
   |                                     | argument is a tuple of the type     |
   |                                     | alias's name, type parameters, and  |
   |                                     | value.                              |
   +-------------------------------------+-------------------------------------+

   Adicionado na versão 3.12.

CALL_INTRINSIC_2

   Calls an intrinsic function with two arguments. Used to implement
   functionality that is not performance critical:

      arg2 = STACK.pop()
      arg1 = STACK.pop()
      result = intrinsic2(arg1, arg2)
      STACK.append(result)

   The operand determines which intrinsic function is called:

   +------------------------------------------+-------------------------------------+
   | Operand                                  | Descrição                           |
   |==========================================|=====================================|
   | "INTRINSIC_2_INVALID"                    | Not valid                           |
   +------------------------------------------+-------------------------------------+
   | "INTRINSIC_PREP_RERAISE_STAR"            | Calculates the "ExceptionGroup" to  |
   |                                          | raise from a "try-except*".         |
   +------------------------------------------+-------------------------------------+
   | "INTRINSIC_TYPEVAR_WITH_BOUND"           | Creates a "typing.TypeVar" with a   |
   |                                          | bound.                              |
   +------------------------------------------+-------------------------------------+
   | "INTRINSIC_TYPEVAR_WITH_CONSTRAINTS"     | Creates a "typing.TypeVar" with     |
   |                                          | constraints.                        |
   +------------------------------------------+-------------------------------------+
   | "INTRINSIC_SET_FUNCTION_TYPE_PARAMS"     | Sets the "__type_params__"          |
   |                                          | attribute of a function.            |
   +------------------------------------------+-------------------------------------+

   Adicionado na versão 3.12.

**Pseudo-instructions**

These opcodes do not appear in Python bytecode. They are used by the
compiler but are replaced by real opcodes or removed before bytecode
is generated.

SETUP_FINALLY(target)

   Set up an exception handler for the following code block. If an
   exception occurs, the value stack level is restored to its current
   state and control is transferred to the exception handler at
   "target".

SETUP_CLEANUP(target)

   Like "SETUP_FINALLY", but in case of an exception also pushes the
   last instruction ("lasti") to the stack so that "RERAISE" can
   restore it. If an exception occurs, the value stack level and the
   last instruction on the frame are restored to their current state,
   and control is transferred to the exception handler at "target".

SETUP_WITH(target)

   Like "SETUP_CLEANUP", but in case of an exception one more item is
   popped from the stack before control is transferred to the
   exception handler at "target".

   This variant is used in "with" and "async with" constructs, which
   push the return value of the context manager's "__enter__()" or
   "__aenter__()" to the stack.

POP_BLOCK

   Marks the end of the code block associated with the last
   "SETUP_FINALLY", "SETUP_CLEANUP" or "SETUP_WITH".

JUMP

JUMP_NO_INTERRUPT

   Undirected relative jump instructions which are replaced by their
   directed (forward/backward) counterparts by the assembler.

LOAD_CLOSURE(i)

   Pushes a reference to the cell contained in slot "i" of the "fast
   locals" storage.

   Note that "LOAD_CLOSURE" is replaced with "LOAD_FAST" in the
   assembler.

   Alterado na versão 3.13: This opcode is now a pseudo-instruction.

LOAD_METHOD

   Optimized unbound method lookup. Emitted as a "LOAD_ATTR" opcode
   with a flag set in the arg.


Opcode collections
==================

These collections are provided for automatic introspection of bytecode
instructions:

Alterado na versão 3.12: The collections now contain pseudo
instructions and instrumented instructions as well. These are opcodes
with values ">= MIN_PSEUDO_OPCODE" and ">= MIN_INSTRUMENTED_OPCODE".

dis.opname

   Sequence of operation names, indexable using the bytecode.

dis.opmap

   Dictionary mapping operation names to bytecodes.

dis.cmp_op

   Sequence of all compare operation names.

dis.hasarg

   Sequence of bytecodes that use their argument.

   Adicionado na versão 3.12.

dis.hasconst

   Sequence of bytecodes that access a constant.

dis.hasfree

   Sequence of bytecodes that access a free variable. 'free' in this
   context refers to names in the current scope that are referenced by
   inner scopes or names in outer scopes that are referenced from this
   scope.  It does *not* include references to global or builtin
   scopes.

dis.hasname

   Sequence of bytecodes that access an attribute by name.

dis.hasjump

   Sequence of bytecodes that have a jump target. All jumps are
   relative.

   Adicionado na versão 3.13.

dis.haslocal

   Sequence of bytecodes that access a local variable.

dis.hascompare

   Sequence of bytecodes of Boolean operations.

dis.hasexc

   Sequence of bytecodes that set an exception handler.

   Adicionado na versão 3.12.

dis.hasjrel

   Sequence of bytecodes that have a relative jump target.

   Obsoleto desde a versão 3.13: All jumps are now relative. Use
   "hasjump".

dis.hasjabs

   Sequence of bytecodes that have an absolute jump target.

   Obsoleto desde a versão 3.13: All jumps are now relative. This list
   is empty.
