Conjunto de instruções do 6502: por que ele é adequado como primeira linguagem assembly

• Assembly se conecta diretamente à arquitetura da CPU, então a primeira plataforma de estudo é importante; o 6502 é uma plataforma introdutória com estrutura simples e um ecossistema real
• Com apenas 6 registradores e 56 instruções originais, é possível aprender rapidamente conceitos básicos como registradores, load/store, operações lógicas e aritméticas, e desvios
• Como foi uma CPU real usada no Apple II, Commodore VIC 20, Commodore 64, BBC micro e outros, é fácil fazer aprendizado prático com emuladores, recriações de hardware e materiais gratuitos
• O Easy 6502 oferece um assembler e simulador em JavaScript que permite escrever código direto na web, ótimo para pegar o jeito em pouco tempo
• Z80, RISC moderno e x86-x64 também valem a pena estudar, mas no primeiro passo o 6502 reduz a carga de aprendizado por ter menor complexidade

---

Por que o 6502 é adequado para iniciantes

• Programação em assembly tem uma ligação com o hardware mais forte do que linguagens de alto nível, então a primeira CPU com que se tem contato influencia bastante a dificuldade do aprendizado
• Assembly de 6502 não é, hoje, um ambiente confortável para escrever aplicações de uso prático
  • A menos que haja interesse em programação retrô em si, não é necessário permanecer muito tempo no 6502
• Como plataforma introdutória, suas vantagens são a simplicidade e a concretude
  • A estrutura simples permite aprender rapidamente os conceitos básicos
  • Há muitos equipamentos reais, emuladores, livros e materiais online, o que facilita traçar um caminho de estudo

• Registradores e instruções permanecem enxutos

  • O 6502 tem apenas 6 registradores
    • 1 acumulador
    • 2 registradores de índice
    • registrador de status
    • registrador de pilha
    • contador de programa
  • O único registrador de 16 bits no 6502 é o contador de programa
  • O número reduzido de registradores é uma limitação na escrita de aplicações reais, mas ajuda a entender o papel e o funcionamento dos registradores
  • O conjunto original de instruções do 6502 inclui apenas 56 instruções
  • Mesmo com esse conjunto pequeno, dá para aprender os principais tipos de instrução
    • load/store
    • operações lógicas
    • operações aritméticas
    • desvios
  • Esses tipos continuam presentes, de alguma forma, nas CPUs modernas
  • No x86-x64, contar registradores e instruções já não é algo simples, e mesmo conjuntos de instruções RISC modernos como ARM dificilmente podem ser vistos como pequenos e simples

Ecossistema real e outras opções

• Um ecossistema antigo, mas vivo

  • O 6502 foi introduzido pela MOS Technology em meados dos anos 1970 como uma versão mais barata e simplificada do Motorola 6800
    • A mesma equipe havia desenvolvido anteriormente o Motorola 6800
  • Depois, ganhou popularidade rapidamente e foi usado em vários microcomputadores famosos
    • Apple II
    • Commodore VIC 20
    • Commodore 64
    • BBC micro
  • É fácil encontrar emuladores desses equipamentos, e alguns também têm recriações modernas de hardware
  • Sucessores do 6502 ainda são produzidos no momento em que o texto foi escrito, e dispositivos novos como o Neo6502 da Olimex também executam variantes da família 6502
  • Há muitos materiais gratuitos de estudo na internet, e boa parte pode ser encontrada em 6502.org

• Materiais de estudo para praticar imediatamente

  • Easy 6502 é um livro eletrônico de Nick Morgan, adequado para quem quer ter um primeiro contato rápido com o 6502
  • Além de texto e imagens, inclui um assembler e simulador de 6502 escritos em JavaScript
    • Na página web, é possível escrever imediatamente um código simples em assembly 6502
  • Visual6502.org está mais para um recurso que mostra visualmente a simplicidade do 6502 do que para uma ferramenta de aprendizado de assembly

• Diferenças em relação a outros candidatos para iniciantes

  • CPUs virtuais criadas para fins educacionais podem ter conjuntos de instruções limpos e “perfeitos”, mas dificilmente terão materiais de estudo e comunidade tão ricos quanto o 6502
  • CPUs retrô como Z80, 6809 e 68000 também são boas opções
    • As três são consideradas melhores que o 6502 para programação séria
    • Para aprender os conceitos básicos, a simplicidade do 6502 é mais vantajosa
  • O Z80 tem muito mais registradores que o 6502 e ainda conta com um conjunto alternativo de registradores, o que torna o início menos fácil
  • Arquiteturas RISC modernas como ARM, MIPS e RISC-V são coisas que um programador de assembly sério precisa aprender em algum momento
    • Ainda assim, não são ideais para iniciantes
    • A simplicidade delas está mais próxima da implementação interna do chip do que do conjunto de instruções em si
  • A maioria dos microprocessadores modernos é programada principalmente com linguagens de alto nível, e a experiência de escrever instruções assembly diretamente não é prioridade alta no projeto dessas CPUs
  • No ARM64, para carregar uma constante de 64 bits em um registrador, podem ser necessárias 4 instruções com deslocamento de bits
    • Em comparação, o processo de carregar uma constante em um registrador no 6502 é simples
  • O x86-x64 pode ser visto como o conjunto de instruções mais popular em desktops e servidores modernos, com o ARM correndo atrás
    • Como não sofre a limitação de tamanho de 32 bits e tem instruções ricas com número variável de operandos, em alguns aspectos pode ser mais fácil de codificar do que ARM
    • Ainda assim, continua muito complexo para iniciantes, e 40 anos de história não tornaram o x86-x64 mais simples

[GN⁺]

Comentários do Hacker News

• É difícil concordar que a simplicidade do 6502 seja melhor que a do 68000.
  O 68000 tem mais registradores e larguras de tipos de dados maiores, mas sua estrutura é uniforme. Na prática, há dois tipos, A e D, repetidos como D0~D7 e A0~A7; o que dá para fazer em D0 também dá para fazer em D3. A simplicidade da estrutura precisa ser equilibrada com a simplicidade de programação, e no 6502, mesmo ao escrever um programa só um pouco mais complexo, você continua esbarrando em limitações.
  A melhor forma de aprender a contornar as limitações de uma máquina pequena é, na verdade, ignorar essas limitações e se tornar um engenheiro de software experiente. Para iniciantes, é melhor começar por algo com mais modos de endereçamento, que facilite lidar com arrays grandes e tenha registradores e larguras de inteiros mais folgados.

  • Vejo de forma parecida, mas por outro ângulo. Nas últimas décadas, trabalhei principalmente com 6502, 68k, z80 e x86/64 na área de demos, e até fiquei pensando se esse texto não teria sido escrito por IA.
    O argumento é que o 6502 é simples por ter 6 registradores, mas, depois de mexer no 6502 por apenas uma semana, você percebe que na prática está lidando com três registradores. Daí também vem o apelido de CPU semáforo.
    O 6502 é divertido e elegante, mas não é adequado se você quer uma abordagem moderna. Se quiser seguir o caminho glorioso dos anos 90, é melhor começar por MIPS, ou simplesmente por Neon. Também há margem para dizer que o Z80, considerando seus registradores e sua complexidade, se parece mais com o que encontramos hoje.
    Assembly moderno, por si só, não é inerentemente complicado. Começando pelo FASM, não é difícil, mas uma abordagem de baixo nível sempre fica complexa rapidamente. Aí você começa a criar macros e, no fim, acaba colocando por cima algo como uma versão pobre de C feita por você mesmo.
  • Aprender a contornar as limitações de uma máquina pequena é uma boa etapa para se tornar um engenheiro de software/hardware experiente.
    A vantagem de sistemas pequenos é que você consegue entender tudo por completo, do silício ao sistema operacional e ao software.
    O 6809 é mais simples que o 68K, mais poderoso que o 6502 e tem boa ortogonalidade, mas não possui a mesma base de software. Acho que a Motorola tomou um rumo bastante bom com o 6809 e o 68K em termos de conjunto de instruções e arquitetura do ponto de vista do programador. Também me lembro do PDP-11/VAX e do NS32K como relativamente ortogonais de forma semelhante.
  • O 6502 é melhor que o Z80 para assembly de brinquedo, mas isso não quer dizer muita coisa. Também é difícil dizer que ele seja claramente melhor que o conjunto de instruções AVR de 8 bits.
    Pensando em uma plataforma mais moderna, há um argumento forte para ensinar RISC-V em vez de MC68k. Considerando apenas o conjunto básico de instruções inteiras, o RISC-V é muito simples e elegante, além de se parecer com arquiteturas modernas como ARM, Aarch-64 e MIPS. Há versões de 32 e 64 bits, e a documentação oficial também é acessível.
    O MC68k tem peculiaridades demais que hoje não são muito relevantes. Seus pontos fortes são ter sido usado em várias plataformas de hardware e ainda contar com uma comunidade retrô ativa, mas isso está mais para fator de interesse do que para relevância prática.
  • O 68K também é um pouco incômodo por causa do barramento de 24 bits, das restrições de alinhamento e do suporte meio ambíguo a indexação de arrays. A ausência de fator de escala também incomoda.
    O 68020 chega muito perto do máximo que uma arquitetura de conjunto de instruções poderia se aproximar de C, e a experiência de uso é muito boa.
  • Aprendi a programar no 6510, mas concordo que o conjunto de instruções do 68000 era muito melhor e mais fácil de ler e aprender. Eu também escolheria o 68000.
    Dito isso, usar o 65XX nos primeiros computadores Commodore era muito gratificante. Como não havia proteção de memória, dava para alterar diretamente a memória de vídeo, mexer em sprites, fontes, bordas e interrupções, e também escrever código automodificável. Assembly 68000 no Amiga era um ambiente mais seguro e controlado.

• Na minha visão, o 6502 não é uma boa escolha como primeiro conjunto de instruções para aprender assembly. Você acaba gastando muito tempo lidando com as peculiaridades de uma arquitetura engenhosa, mas profundamente defeituosa.
  Esses idiomas de contorno não se transferem bem para arquiteturas melhores que não estavam presas às limitações de ferramentas e orçamento que a MOS tinha na época.
  Se quiser aprender um conjunto de instruções pequeno, mas poderoso e com algumas peculiaridades, ARM v6M é uma opção melhor. Ele ainda é produzido de forma relevante hoje, e tem bom suporte a debugger, compilador, assembler e linker em toolchains open source modernos.
  Se você valoriza a abertura da arquitetura e consegue tolerar uma plataforma ainda menos madura, escolha um MCU RISC-V. Se não conseguir decidir, escolha o RP2350.
  O conjunto de instruções ARMv6M é pequeno e, se você usar carregamentos relativos ao PC para carregar constantes, como a documentação recomenda, não precisa de sequências longas e tediosas de instruções. Também não é preciso usar código automodificável nem indexar memória pela zero page, e a largura dos registradores é igual ao espaço de endereçamento. Por ser 32 bits, ele é até mais fácil de aprender e ensinar do que a maioria dos conjuntos de instruções de 8/16 bits. Se isso parece entediante, não se preocupe: o ARMv6 também tem peculiaridades suficientes para usar em code golf.

  • Gosto da arquitetura 6502, mas, se um iniciante interessado em computadores antigos não tiver experiência prévia com assembly, em geral eu o encaminho para outro lado.
    Comecei com assembly PIC16 e mexi um pouco com várias arquiteturas, mas, em termos de limpeza, a que mais me agradou foi MIPS32.
    Como um pequeno complemento, ainda dá para comprar 6502 novos, MCUs com core 6502 e chips periféricos da Western Design Center. Eles são vendidos até em lugares como a Mouser.
    https://www.mouser.com/c/?m=Western%20Design%20Center%20%28W...
  • Usei bastante assembly 6502 no passado, e gastava bastante tempo lidando com uma arquitetura de 8 bits.
    Só multiplicar dois números de 16 bits já exige um bloco de código. Não me parece útil fazer um novo programador lutar com esse tipo de coisa.
    Como foi dito, os conjuntos de instruções ARM iniciais são uma boa escolha.
  • ARM também tem alguns pontos dolorosos para iniciantes por causa da forma como valores imediatos entram na instrução. Pode não ser intuitivo por que certos imediatos ou offsets funcionam e outros não.
    Claro que isso é um problema comum a várias linguagens assembly, mas, no começo, seria bom começar por um conjunto de instruções que não tenha esse tipo de problema.
  • Nem consigo imaginar direito a que se refere “profundamente defeituosa”.
  • Isso continua me fazendo lembrar da série em protoboard com o 65C02 do Ben Eater[1]. Haveria uma forma de reproduzir com uma CPU ARM o que ele faz nesses vídeos?
    [1] https://youtube.com/playlist?list=PLowKtXNTBypFbtuVMUVXNR0z1...

• Falando como alguém que ensinou assembly por vários anos a alunos de graduação, concordo que o 6502 é bom para iniciantes. Mas o motivo não está apenas nas qualidades da linguagem do 6502 em si.
  Já ensinei 68K, MIPS, ARM, x86 etc., e o principal motivo de os alunos terem reagido bem quando ensinei 6502 foi o contexto ao redor da CPU. Com o 6502, programávamos uma máquina real fácil de entender: o Nintendo Entertainment System.
  Entrada e saída básicas mapeadas em memória, sem sistema operacional, sem instruções de pipeline, sem delay slots, sem rede, sem ruído desnecessário. É quase uma caixa simples com um clock, uma CPU, alguns endereços de memória, chips auxiliares e E/S mapeada em endereços de memória. O 6502 não é o conjunto de instruções mais simples, mas essa simplicidade do sistema ajuda muito.
  As limitações do 6502 também foram importantes para os alunos entenderem por que as instruções têm aquela forma. A CPU foi projetada e cabeada dentro das restrições da época, e isso se reflete na forma de programar.
  Escolher o 6502 e o NES para ensinar iniciantes foi um sucesso. Não tanto por ser o 6502, mas porque o 6502 forçava o próprio sistema que move bits a permanecer simples.
  Depois que os alunos mexiam no 6502 e viam tiles do NES se movendo na tela, era fácil expandir naturalmente para como o 68000 trata as coisas de outra forma, como o MIPS surgiu, como usar pipelining e delay slots, e como comparar as diferenças entre RISC e CISC. Com a base estabelecida, avançar fica muito simples.

• Se não for para aprender um conjunto de instruções usado atualmente, fico um pouco surpreso que o assembler do PDP-11 quase nunca seja mencionado como um bom ponto de partida.
  Talvez seja porque o primeiro que aprendi de verdade foi o PDP-11, mas todos os primeiros microprocessadores me pareceram um passo para trás. Usei assembly Z80 por alguns anos, mas hoje não recomendaria. Ele não é um conjunto de instruções ortogonal, e o 6502 tem registradores de menos para dar uma boa sensação de como é escrever assembly.

  • Hoje em dia é bem difícil conseguir um PDP-11, e também não é fácil obter sistema operacional, compiladores etc.
    Se você gosta do PDP-11, no MSP430 dá para obter vantagens parecidas em uma forma um pouco limitada, e no 68000 em uma forma um pouco reforçada.
    Mas, na verdade, o melhor é esquecer essas relíquias e aprender RISC-V. Ou então escolher uma das várias variantes de Arm. Pessoalmente, tenho um apego emocional ao ARM7TDMI, com que mexi bastante em meados dos anos 2000. O modo Thumb talvez seja um pouco mais fácil de aprender do que o modo Arm original, mas nenhum dos dois é tão satisfatório quanto RISC-V.
  • Concordo. O PDP-11 é muito mais agradável, nem há comparação.
    Dá para argumentar que os modos de endereçamento são conceitualmente mais complexos que os de RISC, mas, na prática, os modos de endereçamento do 6502 provavelmente são mais difíceis de entender que os do PDP-11.
  • Ao aprender assembly PDP-11, você também entende por que alguns idiomas de C são como são. Por exemplo, ponteiro para ponteiro corresponde diretamente a um modo de endereçamento nativo da arquitetura.
  • O conjunto de instruções do -11 é uma obra-prima de engenharia. A DEC tinha tudo de que precisava para dominar completamente o mercado de microcomputadores.
    Mas a DEC ignorou essa oportunidade, e a IBM tomou esse lugar com o conjunto de instruções 8086, pesado e desajeitado.
    Hoje, não há mais motivo para aprender o -11.

• Não entendo bem como se chega a essa conclusão. Quando estudantes têm o primeiro contato com programação de computadores, pode fazer sentido começar por uma linguagem de brinquedo/pequena, sem uso prático real. Mas assembly não deveria ser a primeira linguagem a aprender
  Assembly é uma ferramenta muito prática e normalmente é bastante usada em depuração e engenharia reversa. Então por que gastar tempo com o assembly de uma plataforma que desapareceu há muito tempo?
  A melhor forma de aprender assembly é experimentando. Você pode escrever código na sua linguagem favorita e ver a saída intermediária em assembly, ou olhar por dentro com objdump ou gdb. Também dá para modificar e ver o que acontece
  Também é possível fazer isso com emuladores de computadores antigos, mas é mais difícil. Mesmo para imprimir um único texto na tela, é preciso aprender a arquitetura daquele computador, o hardware e até as funções da ROM, e esse conhecimento quase não se aplica ao Linux ou Windows em x86-64

  • Eu penava para entender C até aprender hexadecimal e programação em assembly no 68HC11, e só então as coisas se abriram
    Para um iniciante completo, conceitos como ponteiros eram abstratos e difíceis demais, mas ao aprender endereçamento indireto em assembly ficou subitamente claro por que C tem ponteiros e como eles funcionam
    Antes eu usava principalmente Python, que era muito mais abstraído. As pessoas às vezes esquecem que recursos como ponteiros existem por causa de restrições de hardware e desempenho. Sem saber o que a CPU realmente faz por dentro e por quê, a compreensão intuitiva fica limitada
  • Depois de passar alguns meses mexendo com hardware e programando em assembly, você passa a entender o funcionamento básico do computador de uma forma totalmente diferente das linguagens de alto nível
    Desde o ensino médio eu não escrevi nem uma linha de assembly, mas a compreensão básica de como as operações são executadas e de como os registradores funcionam tornou muito mais fácil entender os motivos, condições e exceções da programação e da otimização. Também passei a valorizar mais código limpo e eficiente
  • Nós nos saímos muito bem, mesmo aos dez anos, tendo isso como segunda linguagem depois de uma revista em quadrinhos/livro ilustrado de programação em BASIC
    Se quiser sentir um gostinho do passado, está aqui
    https://www.atariarchives.org/
  • Há basicamente dois caminhos para aprender programação: o método top-down, que desce de conceitos abstratos para a implementação real, como no SICP, e o método bottom-up, que começa com código concreto de baixo nível e deixa as abstrações surgirem naturalmente
    Como estudei eletrônica, naturalmente comecei por assembly (Motorola HC11). Perto do fim do curso, todos tinham criado independentemente macros para coisas como loops for, e dali a transição para C foi natural. No fim do curso de C, a orientação a objetos ao estilo C também apareceu naturalmente, levando ao curso seguinte de C++
    A desvantagem dessa abordagem é que não há um caminho gradual que leve ao paradigma funcional ou a paradigmas geralmente não imperativos. Além disso, você desenvolve o hábito de ficar pensando em como a linguagem funciona internamente, o que às vezes pode ser contraproducente. Mesmo ao tentar aprender Haskell, minha cabeça queria primeiro entender como o interpretador funcionava
    Aprender assembly não é só aprender a linguagem, mas entender como a máquina funciona: barramentos, periféricos mapeados em memória etc. Em plataformas antigas, essa parte é muito mais simples. Por isso, mesmo que as instruções ARM sejam mais fáceis de aprender do que as instruções CISC do HC11, todo o restante é mais amigável para iniciantes no HC11
  • No compilador dmd, ao compilar com -vasm, ele mostra o assembly gerado durante a compilação. Houve quem achasse isso pouco útil, dizendo que bastaria usar objdump ou -S, mas, quando você usa de fato, entende por que é conveniente. É porque ele imprime diretamente só o assembly, sem o enorme boilerplate necessário para criar um arquivo objeto
    Por exemplo, estou trabalhando no gerador de código AArch64, mais especificamente na geração de código de ponto flutuante, e tenho uma função assim
    float test(float a, float b) { return a * b; }
    Ao compilar com dmd -c test.c -arm -vasm, são exibidos o endereço, a instrução em hexadecimal, o mnemônico da instrução e a URL da especificação da instrução
    Sei que o código não está totalmente correto. Eu disse que ainda está em andamento :-)

• Para mim, o conjunto de instruções 6502 foi uma boa primeira linguagem assembly
  Em 1977, eu morava em uma pequena cabana no Oregon e comprei um Apple II para me distrair. Em menos de um ano, acabei trabalhando no programa que mais tarde se tornaria o Apple Writer, escrito inteiramente em assembly
  https://en.wikipedia.org/wiki/Apple_Writer
  Aqui dizem que o assembly do 6502 era bem tosco e difícil de escrever, e olhando para trás eu concordo. Só que, em 1977, eu não tinha base de comparação
  Como o Apple II não tinha uma linguagem de alto nível rápida, meu pequeno programa virou um produto da Apple graças à falta de alternativas
  Pensando bem, o Apple Writer cabia em 8 KB de RAM, mas de fato fazia o trabalho. Havia até uma linguagem de macros que as pessoas usavam para processar listas de endereços
  Recentemente aumentei meu sistema principal para 96 GB de RAM para rodar o DeepSeek localmente com mais facilidade, e também tenho uma RTX 4090. De repente percebi que, com essa RAM, daria para armazenar quase 12 milhões de Apple Writers
  É bastante surreal, mas desde 1977 já tive várias ocasiões para dizer coisas assim

• Como linguagem assembly inicial, prefiro RISC-V. O projeto é bom e mais intuitivo, há suporte de ferramentas e linguagens modernas como GCC, LLVM e Rust, e ela roda no QEMU e em hardware real que dá para comprar

  • ARMv7 também atende a esses critérios e é agradável de usar. Pode ser usado inline dentro do BBC Basic do Acorn Archimedes
  • Da última vez que verifiquei, o RISC-V ainda não tinha um macro assembler digno do nome
  • Se a questão é “hardware real que dá para comprar”, da última vez que verifiquei o 65C02 também ainda estava sendo fabricado e vendido
    Ele pode até operar a incríveis 14 MHz

• O tema da simplicidade do conjunto de instruções do 6502 é algo que, pessoalmente, me incomoda. Quem acha que essa simplicidade é boa parece nunca ter ido além de um Hello World
  Programar algo de complexidade intermediária no 6502 é difícil. 8 bits é limitado demais — basta ver, por exemplo, o endereçamento de tela do Commodore 64. Multiplicação e divisão precisam ser implementadas manualmente, e mesmo soma/subtração de 16 bits, embora sejam simples, estão longe de ser triviais se você quiser fazê-las de forma eficiente
  Se o objetivo é aprender assembly básico, a plataforma 8086+DOS é muito mais fácil de lidar em comparação

  • No contexto de um primeiro contato com assembly, ter que implementar multiplicação/divisão manualmente é, na verdade, algo positivo
    Traduzir vários algoritmos de multiplicação e divisão para assembly é uma ótima forma de aprender
  • As restrições fazem parte da diversão. Assembly 8086 não é tão divertido assim
    Se de qualquer forma você vai aprender algo que não é relevante hoje, por não ser x86-64, RISC-V ou ARM, não sei bem qual seria a vantagem do 8086
  • O assembly que mais usei provavelmente foi 8086 — mais precisamente, o 80286 em modo real
    Gostei de cada momento, e os registradores de segmento também não me incomodavam muito

• Estudo em uma escola técnica focada em ciência da computação, e um professor de informática que gosta de retrô e adora mostrar sua máquina de arcade acabou focando no 6502 em vez do assembly 8808 previsto no plano de aula
  Sinceramente, foi uma das melhores experiências de aprendizado da minha vida, e eu não gostaria que tivesse sido de outro jeito. Ele até nos fez montar o computador em protoboard do Ben Eater, o que deu uma sensação especialmente prática e foi realmente fascinante

• Meu primeiro contato com linguagem assembly foi no PDP-10, e tudo o que eu tinha era o manual do processador DEC-10
  Foi uma confusão total. Havia centenas de instruções, e as explicações eram obscuras. Eu não fazia ideia do que eram registradores, acumuladores, endereços ou pilha. David Rolfe escreveu algumas sub-rotinas necessárias para a minha versão em Fortran de Empire, o que ajudou um pouco, mas eu continuava perdido
  Um dia, perguntei ao meu amigo Shal Farley o que era uma pilha, e ele disse: “Imagine uma pilha de pratos. Você coloca um prato em cima (push) e tira um (pop)”. Naquele momento, foi como se uma luz acendesse, e eu entendi na hora
  Depois disso, comecei a mexer com o microprocessador 6800 em uma plaquinha. Ele tinha algo como 40 instruções, e todas cabiam em um único cartão. As 40 instruções eram fáceis de aprender, e de repente tudo fez sentido
  Quando voltei ao manual do -10, tudo começou a fazer sentido