b'\n_START_ARTICLE_\nSUBLEQ\n_START_SECTION_\nSintassi\n_START_PARAGRAPH_\nsubleq a, b, c   ; Mem[b] = Mem[b] - Mem[a]_NEWLINE_                 ; if (Mem[b] \xe2\x89\xa4 0) goto c_NEWLINE_L\'istruzione richiede 3 operatori, tutti indirizzi di memoria: il contenuto del primo viene sottratto al contenuto del secondo, e se il risultato \xc3\xa8 minore o uguale a zero, setta il program counter al terzo (effettua un JUMP). Ipoteticamente, si considera un array di memoria infinito, anche se per sviluppare un emulatore occorrono dei limiti. _NEWLINE_Il listato in codice macchina \xc3\xa8 dato nella forma _NEWLINE_16 -1 3 _NEWLINE_15 0 6 _NEWLINE_15 10 9 _NEWLINE_29 16 -1 _NEWLINE_..._NEWLINE_Le istruzioni sono codificate tramite numeri interi, positivi o negativi. Un particolare significato riveste l\'indirizzo -1:_NEWLINE_l\'istruzione data prima_NEWLINE_16 -1 3_NEWLINE_significherebbe sottrarre il contenuto della 16\xe1\xb5\x83 cella dalla cella -1, ovviamente inesistente: questa istruzione viene interpretata come l\'invio della 16\xe1\xb5\x83 cella all\'output e prosegue alla 3\xe1\xb5\x83 istruzione. Similmente l\'istruzione_NEWLINE_-1 16 3_NEWLINE_legge dallo standard input un carattere e ne immette il valore nella cella 16._NEWLINE_Il salto ad un valore negativo, qualunque esso sia, termina il programma._NEWLINE_Un emulatore in C \xc3\xa8 del tipo_NEWLINE_int Mem[MAX_ADDR]; /* MAX_ADDR = Dimensione massima della memoria */int a,b,c;int main (int argc, char* argv[]){ _NEWLINE_  int program_counter = 0;_NEWLINE__NEWLINE_  leggi_memoria(Mem); /* carica il codice macchina */ _NEWLINE_  _NEWLINE_  while ((program_counter >= 0) && (program_counter < MAX_ADDR))_NEWLINE_  {_NEWLINE_    a =  Mem[program_counter];_NEWLINE_    b =  Mem[program_counter + 1];_NEWLINE_    c =  Mem[program_counter + 2];_NEWLINE__NEWLINE_    /* casi particolari */_NEWLINE_    if ( a == -1 ) /* leggi valore */_NEWLINE_    { _NEWLINE_       leggi_valore(Mem + program_counter + 1);_NEWLINE_       program_counter=c;_NEWLINE_    }_NEWLINE_    else_NEWLINE_    if ( b == -1 ) /* stampa valore */_NEWLINE_    { _NEWLINE_       stampa_valore(Mem[a]);_NEWLINE_       program_counter=c;_NEWLINE_    }_NEWLINE_    else  /* effettua subleq a, b, c*/_NEWLINE_    Mem[b] = Mem[b] - Mem[a];_NEWLINE_    if ( Mem[b] <= 0 ) _NEWLINE_    { _NEWLINE_       program_counter=c; /* valore negativo, salta */_NEWLINE_    } _NEWLINE_    else /* vai all\'istruzione successiva*/_NEWLINE_    { _NEWLINE_       program_counter=program_counter + 3;_NEWLINE_    } _NEWLINE_  }_NEWLINE_  return 0;}_NEWLINE_Nel codice sopra mancano le procedure di stampa, input e lettura.\n_START_SECTION_\nHello World!\n_START_PARAGRAPH_\nIl classico programma che stampa "Hello World!":_NEWLINE_ciclo: _NEWLINE_  ciao (-1)                  ; Stampa il primo carattere_NEWLINE_  m1   ciclo                 ; Incrementa il puntatore (ciclo \xc3\xa8 una [[label]])_NEWLINE_  m1   fine+1                ; Incrementa il puntatore per il controllo fine:   _NEWLINE_Z ciao (-1)                  ; Se il carattere \xc3\xa8 zero, fermati Z Z ciclo                    ; Vai a ciclo; Datim1: -1                       ; per incrementare, sottraggo -1  ciao: "Hello, World!\\n" Z: 0 ; Stringa da scrivere\n_START_SECTION_\nIstruzioni derivate\n_START_PARAGRAPH_\nVediamo come si simulano le istruzioni in pseudo-assembler. Per effettuare un JMP assoluto si usa _NEWLINE_Z Z addr   ; Mem [Z] si suppone pari a zero_NEWLINE_           ; 0-0=0 e dunque salta all\'indirizzo addr_NEWLINE_Per simulare un\'addizione (ADD A B) si ricorre al seguente codice_NEWLINE_; Effettua Mem[b]=Mem[b]+Mem[a]; Mem [Z] si suppone pari a zeroA Z    ; Mem [Z] = -Mem[a]Z B    ; Mem [B] = Mem [B] - (-Mem[a])Z Z    ; resetta Mem [Z]_NEWLINE_Omettere il terzo operatore significa saltare comunque all\'istruzione successiva. _NEWLINE_Per simulare una MOV A B, basta azzerare preventivamente B, e sommare._NEWLINE_; Effettua Mem[b] = Mem[a]; Mem [Z] si suppone pari a zeroB B    ; Mem [B] = 0A Z    ; Mem [Z] = -Mem[a]Z B    ; Mem [B] = - (-Mem[a])Z Z    ; resetta Mem [Z]_NEWLINE_Per effettuare una moltiplicazione, occorre sommarre n volte:_NEWLINE_Z Z loop; costantiZ:0 m1:-1 one:1; variabiliA:5      ; primo numeroB:9      ; secondo numeroACC:0    ; Accumulatoreloop:; aggiunge A ad accumulatore     A Z         _NEWLINE_Z ACC       _NEWLINE_Z Z         _NEWLINE_one B end  ; dec B, se 0 fineZ Z loopend:Z Z (-1)_NEWLINE_Una divisione viene invece effettuata per sottrazioni successive:_NEWLINE_; Divisione con resto; B: B / A; Il resto viene poi copiato in AZ   Z   start; costantiZ:0 m1:-1 one:1; VariabiliA: 10 B: 64       ;divisore  e dividendoC:0start:_NEWLINE_  B Z             ;copia B in C_NEWLINE_  Z C_NEWLINE_  Z Z_NEWLINE_  B B             ;azzera B_NEWLINE_  _NEWLINE_  loop:  _NEWLINE_    A  C   end    ; C -= A, se C < =0 fine_NEWLINE_    m1 B          ; B += 1_NEWLINE_    Z  Z   loop_NEWLINE__NEWLINE_  end: _NEWLINE_  C Z resto_nullo ; se C = 0 non somma     _NEWLINE_  C C             ; risistema Z= -C, azzera C_NEWLINE_  Z C             ; C - Z_NEWLINE_  Z Z             ; Z = 0_NEWLINE_  A Z             ; C += A_NEWLINE_  Z C_NEWLINE_  Z Zresto_nullo:_NEWLINE_  B B             ; B=R _NEWLINE_  R Z_NEWLINE_  Z B_NEWLINE_  Z Z_NEWLINE_  _NEWLINE_  A A             ; A=C(resto)_NEWLINE_  C Z_NEWLINE_  Z A_NEWLINE_  Z Zstop:_NEWLINE_  Z Z (-1)       ; STOP_NEWLINE_Istruzioni con uno stack, tipo push e pop, sono possibili, usando un doppio riferimento indiretto.'