// Aby uruchomic program dla maszyny turinga nalezy podjac nastepujace kroki:
// 1. Wstawic pocztkowy stan maszyny w komorke wskazywana przez current_state
// 2. Stan koncowy w komorke finish_state
// 3. Wpisac program z instrukcjami w formacie:
//     -aktualny stan,
//     -zeskanowy symbol,
//     -drukowany symbol,
//     -przesuniecie,
//     -nowy stan
//    w dowolne miejsce w pamieci (pamietajac, ze pierwsze 11 komorek jest
//    zarezerwowanych dla zmiennych symulatora). Adres pierwszej komorki
//    nalezy wpisac w komorke wskazywana przez program.
//  4. Wpisac adres ostatniej komorki programu + 1 w komorke program_end
//  5. Wpisac adres tasmy w komorke tape (moze to byc ta sama liczba co
//     w program_end).
//  6. Ewentualnie mozna ustawic stan pocztkowy tasmy wpisujac odpowiednie
//     wartosci pod adresem wskazywanym przez tape.
//  Glowica maszyny wskazuje domyslnie druga komorke tasmy.

//  Etykiety
current_state=0
finish_state=1
program=2
program_end=3
tape=4
left_shift=5
right_shift=6
current_pos=7
pc=8
n=9
p=10
q=11
C0=12
C1=13
C2=14
C3=15
C4=16
C5=17
absolute_pos=18
absolute_pos_mod=19

// C0...5=0...5
Z(C0)
Z(C1)
S(C1)
Z(C2)
S(C2)
S(C2)
T(C2,C3)
S(C3)
T(C3,C4)
S(C4)
T(C4,C5)
S(C5)

// left_shift=1; right_shift=2; current_pos=tape+2
T(C1,left_shift)
T(C2,right_shift)
T(tape,current_pos)
S(current_pos)
S(current_pos)

while:
I(current_state,finish_state,end)
T(program,pc)

for:
I(pc,program_end,undefined_state)
I([pc],current_state,state_ok)
I(0,0,continue)

state_ok:
T(pc,n)
S(n)
I([n],[current_pos],found_instruction)

continue:
S(pc)
S(pc)
S(pc)
S(pc)
S(pc)
I(0,0,for)

found_instruction:
// Drukuj symbol
S(n)
T([n],[current_pos])

S(n)

// absolute_pos = current_pos - tape
// absolute_pos_mod = absolute_pos % 2
Z(p)
Z(absolute_pos)
Z(absolute_pos_mod)
T(tape,p)
subtract_pos_loop:
I(p,current_pos,subtract_pos_end)
S(p)
S(absolute_pos)
S(absolute_pos_mod)
// if(absolute_pos_mod==2) absolute_pos_mod=0;
I(absolute_pos_mod,C2,zero_mod)
I(0,0,subtract_pos_loop)
zero_mod:
Z(absolute_pos_mod)
I(0,0,subtract_pos_loop)
subtract_pos_end:

// Czy ruch w lewo?
I([n],left_shift,move_left)
I(0,0,check_right)

// Ruch w lewo
move_left:
I(absolute_pos,C0,add_one)
I(absolute_pos_mod,C0,subtract_two)
I(absolute_pos_mod,C1,add_two)

check_right:
I([n],right_shift,move_right)
I(0,0,change_state)

move_right:
I(absolute_pos,C1,subtract_two)
I(absolute_pos_mod,C0,add_two)
T(tape,current_pos)
I(0,0,change_state)

// Odejmij 2 od current_pos
subtract_two:
Z(p)
T(C2,q)
subtract_two_loop:
I(q,current_pos,subtract_two_end)
S(p)
S(q)
I(0,0,subtract_two_loop)
subtract_two_end:
T(p,current_pos)
I(0,0,change_state)

// Dodaj 1 do current_pos
add_one:
S(current_pos)
I(0,0,change_state)

// Dodaj 2 do current_pos
add_two:
S(current_pos)
S(current_pos)
I(0,0,change_state)

// Ustaw nowy stan maszyny
change_state:
S(n)
T([n],current_state)

// Powrot do glownej petli
I(0,0,while)

// Koniec
end:
undefined_state:
T(0,0)