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

// 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;
T(C1,left_shift)
T(C2,right_shift)

// program=25
Z(program)
S(program)
S(program)
S(program)
S(program)
S(program)
S(program)
S(program)
S(program)
S(program)
S(program)
S(program)
S(program)
S(program)
S(program)
S(program)
S(program)
S(program)
S(program)
S(program)
S(program)
S(program)
S(program)
S(program)
S(program)
S(program)

// tape=95
Z(tape)
S(tape)
S(tape)
S(tape)
S(tape)
S(tape)
S(tape)
S(tape)
S(tape)
S(tape)
S(tape)
S(tape)
S(tape)
S(tape)
S(tape)
S(tape)
S(tape)
S(tape)
S(tape)
S(tape)
S(tape)
S(tape)
S(tape)
S(tape)
S(tape)
S(tape)
S(tape)
S(tape)
S(tape)
S(tape)
S(tape)
S(tape)
S(tape)
S(tape)
S(tape)
S(tape)
S(tape)
S(tape)
S(tape)
S(tape)
S(tape)
S(tape)
S(tape)
S(tape)
S(tape)
S(tape)
S(tape)
S(tape)
S(tape)
S(tape)
S(tape)
S(tape)
S(tape)
S(tape)
S(tape)
S(tape)
S(tape)
S(tape)
S(tape)
S(tape)
S(tape)
S(tape)
S(tape)
S(tape)
S(tape)
S(tape)
S(tape)
S(tape)
S(tape)
S(tape)
S(tape)
S(tape)
S(tape)
S(tape)
S(tape)
S(tape)
S(tape)
S(tape)
S(tape)
S(tape)
S(tape)
S(tape)
S(tape)
S(tape)
S(tape)
S(tape)
S(tape)
S(tape)
S(tape)
S(tape)
S(tape)
S(tape)
S(tape)
S(tape)
S(tape)
S(tape)
T(tape,current_pos)
S(current_pos)
S(current_pos)

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

I(0,0,get_symbol)

for:
I(pc,program_end,undefined_state)

I(25,current_state,state_ok_25)
I(0,0,continue_25)
	
state_ok_25:
I(26,current_symbol,found_instruction_25)
I(0,0,continue_25)
found_instruction_25:

// Zapamietaj pozycje glowicy
T(current_pos,put_symbol_to)

// 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_25:
I(p,current_pos,subtract_pos_end_25)
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_25)
I(0,0,subtract_pos_loop_25)
zero_mod_25:
Z(absolute_pos_mod)
I(0,0,subtract_pos_loop_25)
subtract_pos_end_25:

// Czy ruch w lewo?
I(28,left_shift,move_left_25)
I(0,0,check_right_25)

// Ruch w lewo
move_left_25:
I(absolute_pos,C0,add_one_25)
I(absolute_pos_mod,C0,subtract_two_25)
I(absolute_pos_mod,C1,add_two_25)

check_right_25:
I(28,right_shift,move_right_25)
I(0,0,change_state_25)

move_right_25:
I(absolute_pos,C1,subtract_two_25)
I(absolute_pos_mod,C0,add_two_25)
T(tape,current_pos)
I(0,0,change_state_25)

// Odejmij 2 od current_pos
subtract_two_25:
Z(p)
T(C2,q)
subtract_two_loop_25:
I(q,current_pos,subtract_two_end_25)
S(p)
S(q)
I(0,0,subtract_two_loop_25)
subtract_two_end_25:
T(p,current_pos)
I(0,0,change_state_25)

// Dodaj 1 do current_pos
add_one_25:
S(current_pos)
I(0,0,change_state_25)

// Dodaj 2 do current_pos
add_two_25:
S(current_pos)
S(current_pos)
I(0,0,change_state_25)

// Ustaw nowy stan maszyny
change_state_25:
T(29,current_state)

// Drukuj symbol i wroc do glownej petli
T(27,current_symbol)
I(0,0,put_symbol)
continue_25:
S(pc)
S(pc)
S(pc)
S(pc)
S(pc)
I(pc,program_end,undefined_state)

I(30,current_state,state_ok_30)
I(0,0,continue_30)
	
state_ok_30:
I(31,current_symbol,found_instruction_30)
I(0,0,continue_30)
found_instruction_30:

// Zapamietaj pozycje glowicy
T(current_pos,put_symbol_to)

// 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_30:
I(p,current_pos,subtract_pos_end_30)
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_30)
I(0,0,subtract_pos_loop_30)
zero_mod_30:
Z(absolute_pos_mod)
I(0,0,subtract_pos_loop_30)
subtract_pos_end_30:

// Czy ruch w lewo?
I(33,left_shift,move_left_30)
I(0,0,check_right_30)

// Ruch w lewo
move_left_30:
I(absolute_pos,C0,add_one_30)
I(absolute_pos_mod,C0,subtract_two_30)
I(absolute_pos_mod,C1,add_two_30)

check_right_30:
I(33,right_shift,move_right_30)
I(0,0,change_state_30)

move_right_30:
I(absolute_pos,C1,subtract_two_30)
I(absolute_pos_mod,C0,add_two_30)
T(tape,current_pos)
I(0,0,change_state_30)

// Odejmij 2 od current_pos
subtract_two_30:
Z(p)
T(C2,q)
subtract_two_loop_30:
I(q,current_pos,subtract_two_end_30)
S(p)
S(q)
I(0,0,subtract_two_loop_30)
subtract_two_end_30:
T(p,current_pos)
I(0,0,change_state_30)

// Dodaj 1 do current_pos
add_one_30:
S(current_pos)
I(0,0,change_state_30)

// Dodaj 2 do current_pos
add_two_30:
S(current_pos)
S(current_pos)
I(0,0,change_state_30)

// Ustaw nowy stan maszyny
change_state_30:
T(34,current_state)

// Drukuj symbol i wroc do glownej petli
T(32,current_symbol)
I(0,0,put_symbol)
continue_30:
S(pc)
S(pc)
S(pc)
S(pc)
S(pc)
I(pc,program_end,undefined_state)

I(35,current_state,state_ok_35)
I(0,0,continue_35)
	
state_ok_35:
I(36,current_symbol,found_instruction_35)
I(0,0,continue_35)
found_instruction_35:

// Zapamietaj pozycje glowicy
T(current_pos,put_symbol_to)

// 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_35:
I(p,current_pos,subtract_pos_end_35)
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_35)
I(0,0,subtract_pos_loop_35)
zero_mod_35:
Z(absolute_pos_mod)
I(0,0,subtract_pos_loop_35)
subtract_pos_end_35:

// Czy ruch w lewo?
I(38,left_shift,move_left_35)
I(0,0,check_right_35)

// Ruch w lewo
move_left_35:
I(absolute_pos,C0,add_one_35)
I(absolute_pos_mod,C0,subtract_two_35)
I(absolute_pos_mod,C1,add_two_35)

check_right_35:
I(38,right_shift,move_right_35)
I(0,0,change_state_35)

move_right_35:
I(absolute_pos,C1,subtract_two_35)
I(absolute_pos_mod,C0,add_two_35)
T(tape,current_pos)
I(0,0,change_state_35)

// Odejmij 2 od current_pos
subtract_two_35:
Z(p)
T(C2,q)
subtract_two_loop_35:
I(q,current_pos,subtract_two_end_35)
S(p)
S(q)
I(0,0,subtract_two_loop_35)
subtract_two_end_35:
T(p,current_pos)
I(0,0,change_state_35)

// Dodaj 1 do current_pos
add_one_35:
S(current_pos)
I(0,0,change_state_35)

// Dodaj 2 do current_pos
add_two_35:
S(current_pos)
S(current_pos)
I(0,0,change_state_35)

// Ustaw nowy stan maszyny
change_state_35:
T(39,current_state)

// Drukuj symbol i wroc do glownej petli
T(37,current_symbol)
I(0,0,put_symbol)
continue_35:
S(pc)
S(pc)
S(pc)
S(pc)
S(pc)
I(pc,program_end,undefined_state)

I(40,current_state,state_ok_40)
I(0,0,continue_40)
	
state_ok_40:
I(41,current_symbol,found_instruction_40)
I(0,0,continue_40)
found_instruction_40:

// Zapamietaj pozycje glowicy
T(current_pos,put_symbol_to)

// 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_40:
I(p,current_pos,subtract_pos_end_40)
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_40)
I(0,0,subtract_pos_loop_40)
zero_mod_40:
Z(absolute_pos_mod)
I(0,0,subtract_pos_loop_40)
subtract_pos_end_40:

// Czy ruch w lewo?
I(43,left_shift,move_left_40)
I(0,0,check_right_40)

// Ruch w lewo
move_left_40:
I(absolute_pos,C0,add_one_40)
I(absolute_pos_mod,C0,subtract_two_40)
I(absolute_pos_mod,C1,add_two_40)

check_right_40:
I(43,right_shift,move_right_40)
I(0,0,change_state_40)

move_right_40:
I(absolute_pos,C1,subtract_two_40)
I(absolute_pos_mod,C0,add_two_40)
T(tape,current_pos)
I(0,0,change_state_40)

// Odejmij 2 od current_pos
subtract_two_40:
Z(p)
T(C2,q)
subtract_two_loop_40:
I(q,current_pos,subtract_two_end_40)
S(p)
S(q)
I(0,0,subtract_two_loop_40)
subtract_two_end_40:
T(p,current_pos)
I(0,0,change_state_40)

// Dodaj 1 do current_pos
add_one_40:
S(current_pos)
I(0,0,change_state_40)

// Dodaj 2 do current_pos
add_two_40:
S(current_pos)
S(current_pos)
I(0,0,change_state_40)

// Ustaw nowy stan maszyny
change_state_40:
T(44,current_state)

// Drukuj symbol i wroc do glownej petli
T(42,current_symbol)
I(0,0,put_symbol)
continue_40:
S(pc)
S(pc)
S(pc)
S(pc)
S(pc)
I(pc,program_end,undefined_state)

I(45,current_state,state_ok_45)
I(0,0,continue_45)
	
state_ok_45:
I(46,current_symbol,found_instruction_45)
I(0,0,continue_45)
found_instruction_45:

// Zapamietaj pozycje glowicy
T(current_pos,put_symbol_to)

// 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_45:
I(p,current_pos,subtract_pos_end_45)
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_45)
I(0,0,subtract_pos_loop_45)
zero_mod_45:
Z(absolute_pos_mod)
I(0,0,subtract_pos_loop_45)
subtract_pos_end_45:

// Czy ruch w lewo?
I(48,left_shift,move_left_45)
I(0,0,check_right_45)

// Ruch w lewo
move_left_45:
I(absolute_pos,C0,add_one_45)
I(absolute_pos_mod,C0,subtract_two_45)
I(absolute_pos_mod,C1,add_two_45)

check_right_45:
I(48,right_shift,move_right_45)
I(0,0,change_state_45)

move_right_45:
I(absolute_pos,C1,subtract_two_45)
I(absolute_pos_mod,C0,add_two_45)
T(tape,current_pos)
I(0,0,change_state_45)

// Odejmij 2 od current_pos
subtract_two_45:
Z(p)
T(C2,q)
subtract_two_loop_45:
I(q,current_pos,subtract_two_end_45)
S(p)
S(q)
I(0,0,subtract_two_loop_45)
subtract_two_end_45:
T(p,current_pos)
I(0,0,change_state_45)

// Dodaj 1 do current_pos
add_one_45:
S(current_pos)
I(0,0,change_state_45)

// Dodaj 2 do current_pos
add_two_45:
S(current_pos)
S(current_pos)
I(0,0,change_state_45)

// Ustaw nowy stan maszyny
change_state_45:
T(49,current_state)

// Drukuj symbol i wroc do glownej petli
T(47,current_symbol)
I(0,0,put_symbol)
continue_45:
S(pc)
S(pc)
S(pc)
S(pc)
S(pc)
I(pc,program_end,undefined_state)

I(50,current_state,state_ok_50)
I(0,0,continue_50)
	
state_ok_50:
I(51,current_symbol,found_instruction_50)
I(0,0,continue_50)
found_instruction_50:

// Zapamietaj pozycje glowicy
T(current_pos,put_symbol_to)

// 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_50:
I(p,current_pos,subtract_pos_end_50)
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_50)
I(0,0,subtract_pos_loop_50)
zero_mod_50:
Z(absolute_pos_mod)
I(0,0,subtract_pos_loop_50)
subtract_pos_end_50:

// Czy ruch w lewo?
I(53,left_shift,move_left_50)
I(0,0,check_right_50)

// Ruch w lewo
move_left_50:
I(absolute_pos,C0,add_one_50)
I(absolute_pos_mod,C0,subtract_two_50)
I(absolute_pos_mod,C1,add_two_50)

check_right_50:
I(53,right_shift,move_right_50)
I(0,0,change_state_50)

move_right_50:
I(absolute_pos,C1,subtract_two_50)
I(absolute_pos_mod,C0,add_two_50)
T(tape,current_pos)
I(0,0,change_state_50)

// Odejmij 2 od current_pos
subtract_two_50:
Z(p)
T(C2,q)
subtract_two_loop_50:
I(q,current_pos,subtract_two_end_50)
S(p)
S(q)
I(0,0,subtract_two_loop_50)
subtract_two_end_50:
T(p,current_pos)
I(0,0,change_state_50)

// Dodaj 1 do current_pos
add_one_50:
S(current_pos)
I(0,0,change_state_50)

// Dodaj 2 do current_pos
add_two_50:
S(current_pos)
S(current_pos)
I(0,0,change_state_50)

// Ustaw nowy stan maszyny
change_state_50:
T(54,current_state)

// Drukuj symbol i wroc do glownej petli
T(52,current_symbol)
I(0,0,put_symbol)
continue_50:
S(pc)
S(pc)
S(pc)
S(pc)
S(pc)
I(pc,program_end,undefined_state)

I(55,current_state,state_ok_55)
I(0,0,continue_55)
	
state_ok_55:
I(56,current_symbol,found_instruction_55)
I(0,0,continue_55)
found_instruction_55:

// Zapamietaj pozycje glowicy
T(current_pos,put_symbol_to)

// 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_55:
I(p,current_pos,subtract_pos_end_55)
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_55)
I(0,0,subtract_pos_loop_55)
zero_mod_55:
Z(absolute_pos_mod)
I(0,0,subtract_pos_loop_55)
subtract_pos_end_55:

// Czy ruch w lewo?
I(58,left_shift,move_left_55)
I(0,0,check_right_55)

// Ruch w lewo
move_left_55:
I(absolute_pos,C0,add_one_55)
I(absolute_pos_mod,C0,subtract_two_55)
I(absolute_pos_mod,C1,add_two_55)

check_right_55:
I(58,right_shift,move_right_55)
I(0,0,change_state_55)

move_right_55:
I(absolute_pos,C1,subtract_two_55)
I(absolute_pos_mod,C0,add_two_55)
T(tape,current_pos)
I(0,0,change_state_55)

// Odejmij 2 od current_pos
subtract_two_55:
Z(p)
T(C2,q)
subtract_two_loop_55:
I(q,current_pos,subtract_two_end_55)
S(p)
S(q)
I(0,0,subtract_two_loop_55)
subtract_two_end_55:
T(p,current_pos)
I(0,0,change_state_55)

// Dodaj 1 do current_pos
add_one_55:
S(current_pos)
I(0,0,change_state_55)

// Dodaj 2 do current_pos
add_two_55:
S(current_pos)
S(current_pos)
I(0,0,change_state_55)

// Ustaw nowy stan maszyny
change_state_55:
T(59,current_state)

// Drukuj symbol i wroc do glownej petli
T(57,current_symbol)
I(0,0,put_symbol)
continue_55:
S(pc)
S(pc)
S(pc)
S(pc)
S(pc)
I(pc,program_end,undefined_state)

I(60,current_state,state_ok_60)
I(0,0,continue_60)
	
state_ok_60:
I(61,current_symbol,found_instruction_60)
I(0,0,continue_60)
found_instruction_60:

// Zapamietaj pozycje glowicy
T(current_pos,put_symbol_to)

// 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_60:
I(p,current_pos,subtract_pos_end_60)
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_60)
I(0,0,subtract_pos_loop_60)
zero_mod_60:
Z(absolute_pos_mod)
I(0,0,subtract_pos_loop_60)
subtract_pos_end_60:

// Czy ruch w lewo?
I(63,left_shift,move_left_60)
I(0,0,check_right_60)

// Ruch w lewo
move_left_60:
I(absolute_pos,C0,add_one_60)
I(absolute_pos_mod,C0,subtract_two_60)
I(absolute_pos_mod,C1,add_two_60)

check_right_60:
I(63,right_shift,move_right_60)
I(0,0,change_state_60)

move_right_60:
I(absolute_pos,C1,subtract_two_60)
I(absolute_pos_mod,C0,add_two_60)
T(tape,current_pos)
I(0,0,change_state_60)

// Odejmij 2 od current_pos
subtract_two_60:
Z(p)
T(C2,q)
subtract_two_loop_60:
I(q,current_pos,subtract_two_end_60)
S(p)
S(q)
I(0,0,subtract_two_loop_60)
subtract_two_end_60:
T(p,current_pos)
I(0,0,change_state_60)

// Dodaj 1 do current_pos
add_one_60:
S(current_pos)
I(0,0,change_state_60)

// Dodaj 2 do current_pos
add_two_60:
S(current_pos)
S(current_pos)
I(0,0,change_state_60)

// Ustaw nowy stan maszyny
change_state_60:
T(64,current_state)

// Drukuj symbol i wroc do glownej petli
T(62,current_symbol)
I(0,0,put_symbol)
continue_60:
S(pc)
S(pc)
S(pc)
S(pc)
S(pc)
I(pc,program_end,undefined_state)

I(65,current_state,state_ok_65)
I(0,0,continue_65)
	
state_ok_65:
I(66,current_symbol,found_instruction_65)
I(0,0,continue_65)
found_instruction_65:

// Zapamietaj pozycje glowicy
T(current_pos,put_symbol_to)

// 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_65:
I(p,current_pos,subtract_pos_end_65)
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_65)
I(0,0,subtract_pos_loop_65)
zero_mod_65:
Z(absolute_pos_mod)
I(0,0,subtract_pos_loop_65)
subtract_pos_end_65:

// Czy ruch w lewo?
I(68,left_shift,move_left_65)
I(0,0,check_right_65)

// Ruch w lewo
move_left_65:
I(absolute_pos,C0,add_one_65)
I(absolute_pos_mod,C0,subtract_two_65)
I(absolute_pos_mod,C1,add_two_65)

check_right_65:
I(68,right_shift,move_right_65)
I(0,0,change_state_65)

move_right_65:
I(absolute_pos,C1,subtract_two_65)
I(absolute_pos_mod,C0,add_two_65)
T(tape,current_pos)
I(0,0,change_state_65)

// Odejmij 2 od current_pos
subtract_two_65:
Z(p)
T(C2,q)
subtract_two_loop_65:
I(q,current_pos,subtract_two_end_65)
S(p)
S(q)
I(0,0,subtract_two_loop_65)
subtract_two_end_65:
T(p,current_pos)
I(0,0,change_state_65)

// Dodaj 1 do current_pos
add_one_65:
S(current_pos)
I(0,0,change_state_65)

// Dodaj 2 do current_pos
add_two_65:
S(current_pos)
S(current_pos)
I(0,0,change_state_65)

// Ustaw nowy stan maszyny
change_state_65:
T(69,current_state)

// Drukuj symbol i wroc do glownej petli
T(67,current_symbol)
I(0,0,put_symbol)
continue_65:
S(pc)
S(pc)
S(pc)
S(pc)
S(pc)
I(pc,program_end,undefined_state)

I(70,current_state,state_ok_70)
I(0,0,continue_70)
	
state_ok_70:
I(71,current_symbol,found_instruction_70)
I(0,0,continue_70)
found_instruction_70:

// Zapamietaj pozycje glowicy
T(current_pos,put_symbol_to)

// 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_70:
I(p,current_pos,subtract_pos_end_70)
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_70)
I(0,0,subtract_pos_loop_70)
zero_mod_70:
Z(absolute_pos_mod)
I(0,0,subtract_pos_loop_70)
subtract_pos_end_70:

// Czy ruch w lewo?
I(73,left_shift,move_left_70)
I(0,0,check_right_70)

// Ruch w lewo
move_left_70:
I(absolute_pos,C0,add_one_70)
I(absolute_pos_mod,C0,subtract_two_70)
I(absolute_pos_mod,C1,add_two_70)

check_right_70:
I(73,right_shift,move_right_70)
I(0,0,change_state_70)

move_right_70:
I(absolute_pos,C1,subtract_two_70)
I(absolute_pos_mod,C0,add_two_70)
T(tape,current_pos)
I(0,0,change_state_70)

// Odejmij 2 od current_pos
subtract_two_70:
Z(p)
T(C2,q)
subtract_two_loop_70:
I(q,current_pos,subtract_two_end_70)
S(p)
S(q)
I(0,0,subtract_two_loop_70)
subtract_two_end_70:
T(p,current_pos)
I(0,0,change_state_70)

// Dodaj 1 do current_pos
add_one_70:
S(current_pos)
I(0,0,change_state_70)

// Dodaj 2 do current_pos
add_two_70:
S(current_pos)
S(current_pos)
I(0,0,change_state_70)

// Ustaw nowy stan maszyny
change_state_70:
T(74,current_state)

// Drukuj symbol i wroc do glownej petli
T(72,current_symbol)
I(0,0,put_symbol)
continue_70:
S(pc)
S(pc)
S(pc)
S(pc)
S(pc)
I(pc,program_end,undefined_state)

I(75,current_state,state_ok_75)
I(0,0,continue_75)
	
state_ok_75:
I(76,current_symbol,found_instruction_75)
I(0,0,continue_75)
found_instruction_75:

// Zapamietaj pozycje glowicy
T(current_pos,put_symbol_to)

// 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_75:
I(p,current_pos,subtract_pos_end_75)
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_75)
I(0,0,subtract_pos_loop_75)
zero_mod_75:
Z(absolute_pos_mod)
I(0,0,subtract_pos_loop_75)
subtract_pos_end_75:

// Czy ruch w lewo?
I(78,left_shift,move_left_75)
I(0,0,check_right_75)

// Ruch w lewo
move_left_75:
I(absolute_pos,C0,add_one_75)
I(absolute_pos_mod,C0,subtract_two_75)
I(absolute_pos_mod,C1,add_two_75)

check_right_75:
I(78,right_shift,move_right_75)
I(0,0,change_state_75)

move_right_75:
I(absolute_pos,C1,subtract_two_75)
I(absolute_pos_mod,C0,add_two_75)
T(tape,current_pos)
I(0,0,change_state_75)

// Odejmij 2 od current_pos
subtract_two_75:
Z(p)
T(C2,q)
subtract_two_loop_75:
I(q,current_pos,subtract_two_end_75)
S(p)
S(q)
I(0,0,subtract_two_loop_75)
subtract_two_end_75:
T(p,current_pos)
I(0,0,change_state_75)

// Dodaj 1 do current_pos
add_one_75:
S(current_pos)
I(0,0,change_state_75)

// Dodaj 2 do current_pos
add_two_75:
S(current_pos)
S(current_pos)
I(0,0,change_state_75)

// Ustaw nowy stan maszyny
change_state_75:
T(79,current_state)

// Drukuj symbol i wroc do glownej petli
T(77,current_symbol)
I(0,0,put_symbol)
continue_75:
S(pc)
S(pc)
S(pc)
S(pc)
S(pc)
I(pc,program_end,undefined_state)

I(80,current_state,state_ok_80)
I(0,0,continue_80)
	
state_ok_80:
I(81,current_symbol,found_instruction_80)
I(0,0,continue_80)
found_instruction_80:

// Zapamietaj pozycje glowicy
T(current_pos,put_symbol_to)

// 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_80:
I(p,current_pos,subtract_pos_end_80)
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_80)
I(0,0,subtract_pos_loop_80)
zero_mod_80:
Z(absolute_pos_mod)
I(0,0,subtract_pos_loop_80)
subtract_pos_end_80:

// Czy ruch w lewo?
I(83,left_shift,move_left_80)
I(0,0,check_right_80)

// Ruch w lewo
move_left_80:
I(absolute_pos,C0,add_one_80)
I(absolute_pos_mod,C0,subtract_two_80)
I(absolute_pos_mod,C1,add_two_80)

check_right_80:
I(83,right_shift,move_right_80)
I(0,0,change_state_80)

move_right_80:
I(absolute_pos,C1,subtract_two_80)
I(absolute_pos_mod,C0,add_two_80)
T(tape,current_pos)
I(0,0,change_state_80)

// Odejmij 2 od current_pos
subtract_two_80:
Z(p)
T(C2,q)
subtract_two_loop_80:
I(q,current_pos,subtract_two_end_80)
S(p)
S(q)
I(0,0,subtract_two_loop_80)
subtract_two_end_80:
T(p,current_pos)
I(0,0,change_state_80)

// Dodaj 1 do current_pos
add_one_80:
S(current_pos)
I(0,0,change_state_80)

// Dodaj 2 do current_pos
add_two_80:
S(current_pos)
S(current_pos)
I(0,0,change_state_80)

// Ustaw nowy stan maszyny
change_state_80:
T(84,current_state)

// Drukuj symbol i wroc do glownej petli
T(82,current_symbol)
I(0,0,put_symbol)
continue_80:
S(pc)
S(pc)
S(pc)
S(pc)
S(pc)
I(pc,program_end,undefined_state)

I(85,current_state,state_ok_85)
I(0,0,continue_85)
	
state_ok_85:
I(86,current_symbol,found_instruction_85)
I(0,0,continue_85)
found_instruction_85:

// Zapamietaj pozycje glowicy
T(current_pos,put_symbol_to)

// 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_85:
I(p,current_pos,subtract_pos_end_85)
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_85)
I(0,0,subtract_pos_loop_85)
zero_mod_85:
Z(absolute_pos_mod)
I(0,0,subtract_pos_loop_85)
subtract_pos_end_85:

// Czy ruch w lewo?
I(88,left_shift,move_left_85)
I(0,0,check_right_85)

// Ruch w lewo
move_left_85:
I(absolute_pos,C0,add_one_85)
I(absolute_pos_mod,C0,subtract_two_85)
I(absolute_pos_mod,C1,add_two_85)

check_right_85:
I(88,right_shift,move_right_85)
I(0,0,change_state_85)

move_right_85:
I(absolute_pos,C1,subtract_two_85)
I(absolute_pos_mod,C0,add_two_85)
T(tape,current_pos)
I(0,0,change_state_85)

// Odejmij 2 od current_pos
subtract_two_85:
Z(p)
T(C2,q)
subtract_two_loop_85:
I(q,current_pos,subtract_two_end_85)
S(p)
S(q)
I(0,0,subtract_two_loop_85)
subtract_two_end_85:
T(p,current_pos)
I(0,0,change_state_85)

// Dodaj 1 do current_pos
add_one_85:
S(current_pos)
I(0,0,change_state_85)

// Dodaj 2 do current_pos
add_two_85:
S(current_pos)
S(current_pos)
I(0,0,change_state_85)

// Ustaw nowy stan maszyny
change_state_85:
T(89,current_state)

// Drukuj symbol i wroc do glownej petli
T(87,current_symbol)
I(0,0,put_symbol)
continue_85:
S(pc)
S(pc)
S(pc)
S(pc)
S(pc)
I(pc,program_end,undefined_state)

I(90,current_state,state_ok_90)
I(0,0,continue_90)
	
state_ok_90:
I(91,current_symbol,found_instruction_90)
I(0,0,continue_90)
found_instruction_90:

// Zapamietaj pozycje glowicy
T(current_pos,put_symbol_to)

// 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_90:
I(p,current_pos,subtract_pos_end_90)
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_90)
I(0,0,subtract_pos_loop_90)
zero_mod_90:
Z(absolute_pos_mod)
I(0,0,subtract_pos_loop_90)
subtract_pos_end_90:

// Czy ruch w lewo?
I(93,left_shift,move_left_90)
I(0,0,check_right_90)

// Ruch w lewo
move_left_90:
I(absolute_pos,C0,add_one_90)
I(absolute_pos_mod,C0,subtract_two_90)
I(absolute_pos_mod,C1,add_two_90)

check_right_90:
I(93,right_shift,move_right_90)
I(0,0,change_state_90)

move_right_90:
I(absolute_pos,C1,subtract_two_90)
I(absolute_pos_mod,C0,add_two_90)
T(tape,current_pos)
I(0,0,change_state_90)

// Odejmij 2 od current_pos
subtract_two_90:
Z(p)
T(C2,q)
subtract_two_loop_90:
I(q,current_pos,subtract_two_end_90)
S(p)
S(q)
I(0,0,subtract_two_loop_90)
subtract_two_end_90:
T(p,current_pos)
I(0,0,change_state_90)

// Dodaj 1 do current_pos
add_one_90:
S(current_pos)
I(0,0,change_state_90)

// Dodaj 2 do current_pos
add_two_90:
S(current_pos)
S(current_pos)
I(0,0,change_state_90)

// Ustaw nowy stan maszyny
change_state_90:
T(94,current_state)

// Drukuj symbol i wroc do glownej petli
T(92,current_symbol)
I(0,0,put_symbol)
continue_90:
S(pc)
S(pc)
S(pc)
S(pc)
S(pc)
I(0,0,undefined_state)

get_symbol:
T(tape,n)
I(n,current_pos,get_symbol_ok_95)
I(0,0,get_symbol_next_95)

get_symbol_ok_95:
T(95,current_symbol)
I(0,0,for)

get_symbol_next_95:
S(n)
I(n,current_pos,get_symbol_ok_96)
I(0,0,get_symbol_next_96)

get_symbol_ok_96:
T(96,current_symbol)
I(0,0,for)

get_symbol_next_96:
S(n)
I(n,current_pos,get_symbol_ok_97)
I(0,0,get_symbol_next_97)

get_symbol_ok_97:
T(97,current_symbol)
I(0,0,for)

get_symbol_next_97:
S(n)
I(n,current_pos,get_symbol_ok_98)
I(0,0,get_symbol_next_98)

get_symbol_ok_98:
T(98,current_symbol)
I(0,0,for)

get_symbol_next_98:
S(n)
I(n,current_pos,get_symbol_ok_99)
I(0,0,get_symbol_next_99)

get_symbol_ok_99:
T(99,current_symbol)
I(0,0,for)

get_symbol_next_99:
S(n)
I(n,current_pos,get_symbol_ok_100)
I(0,0,get_symbol_next_100)

get_symbol_ok_100:
T(100,current_symbol)
I(0,0,for)

get_symbol_next_100:
S(n)
I(n,current_pos,get_symbol_ok_101)
I(0,0,get_symbol_next_101)

get_symbol_ok_101:
T(101,current_symbol)
I(0,0,for)

get_symbol_next_101:
S(n)
I(n,current_pos,get_symbol_ok_102)
I(0,0,get_symbol_next_102)

get_symbol_ok_102:
T(102,current_symbol)
I(0,0,for)

get_symbol_next_102:
S(n)
I(n,current_pos,get_symbol_ok_103)
I(0,0,get_symbol_next_103)

get_symbol_ok_103:
T(103,current_symbol)
I(0,0,for)

get_symbol_next_103:
S(n)
I(n,current_pos,get_symbol_ok_104)
I(0,0,get_symbol_next_104)

get_symbol_ok_104:
T(104,current_symbol)
I(0,0,for)

get_symbol_next_104:
S(n)
I(n,current_pos,get_symbol_ok_105)
I(0,0,get_symbol_next_105)

get_symbol_ok_105:
T(105,current_symbol)
I(0,0,for)

get_symbol_next_105:
S(n)
I(n,current_pos,get_symbol_ok_106)
I(0,0,get_symbol_next_106)

get_symbol_ok_106:
T(106,current_symbol)
I(0,0,for)

get_symbol_next_106:
S(n)
I(n,current_pos,get_symbol_ok_107)
I(0,0,get_symbol_next_107)

get_symbol_ok_107:
T(107,current_symbol)
I(0,0,for)

get_symbol_next_107:
S(n)
I(n,current_pos,get_symbol_ok_108)
I(0,0,get_symbol_next_108)

get_symbol_ok_108:
T(108,current_symbol)
I(0,0,for)

get_symbol_next_108:
S(n)
I(n,current_pos,get_symbol_ok_109)
I(0,0,get_symbol_next_109)

get_symbol_ok_109:
T(109,current_symbol)
I(0,0,for)

get_symbol_next_109:
S(n)
I(n,current_pos,get_symbol_ok_110)
I(0,0,get_symbol_next_110)

get_symbol_ok_110:
T(110,current_symbol)
I(0,0,for)

get_symbol_next_110:
S(n)
I(0,0,undefined_state)

put_symbol:
T(tape,n)
I(n,put_symbol_to,put_symbol_ok_95)
I(0,0,put_symbol_next_95)

put_symbol_ok_95:
T(current_symbol,95)
I(0,0,while)

put_symbol_next_95:
S(n)
I(n,put_symbol_to,put_symbol_ok_96)
I(0,0,put_symbol_next_96)

put_symbol_ok_96:
T(current_symbol,96)
I(0,0,while)

put_symbol_next_96:
S(n)
I(n,put_symbol_to,put_symbol_ok_97)
I(0,0,put_symbol_next_97)

put_symbol_ok_97:
T(current_symbol,97)
I(0,0,while)

put_symbol_next_97:
S(n)
I(n,put_symbol_to,put_symbol_ok_98)
I(0,0,put_symbol_next_98)

put_symbol_ok_98:
T(current_symbol,98)
I(0,0,while)

put_symbol_next_98:
S(n)
I(n,put_symbol_to,put_symbol_ok_99)
I(0,0,put_symbol_next_99)

put_symbol_ok_99:
T(current_symbol,99)
I(0,0,while)

put_symbol_next_99:
S(n)
I(n,put_symbol_to,put_symbol_ok_100)
I(0,0,put_symbol_next_100)

put_symbol_ok_100:
T(current_symbol,100)
I(0,0,while)

put_symbol_next_100:
S(n)
I(n,put_symbol_to,put_symbol_ok_101)
I(0,0,put_symbol_next_101)

put_symbol_ok_101:
T(current_symbol,101)
I(0,0,while)

put_symbol_next_101:
S(n)
I(n,put_symbol_to,put_symbol_ok_102)
I(0,0,put_symbol_next_102)

put_symbol_ok_102:
T(current_symbol,102)
I(0,0,while)

put_symbol_next_102:
S(n)
I(n,put_symbol_to,put_symbol_ok_103)
I(0,0,put_symbol_next_103)

put_symbol_ok_103:
T(current_symbol,103)
I(0,0,while)

put_symbol_next_103:
S(n)
I(n,put_symbol_to,put_symbol_ok_104)
I(0,0,put_symbol_next_104)

put_symbol_ok_104:
T(current_symbol,104)
I(0,0,while)

put_symbol_next_104:
S(n)
I(n,put_symbol_to,put_symbol_ok_105)
I(0,0,put_symbol_next_105)

put_symbol_ok_105:
T(current_symbol,105)
I(0,0,while)

put_symbol_next_105:
S(n)
I(n,put_symbol_to,put_symbol_ok_106)
I(0,0,put_symbol_next_106)

put_symbol_ok_106:
T(current_symbol,106)
I(0,0,while)

put_symbol_next_106:
S(n)
I(n,put_symbol_to,put_symbol_ok_107)
I(0,0,put_symbol_next_107)

put_symbol_ok_107:
T(current_symbol,107)
I(0,0,while)

put_symbol_next_107:
S(n)
I(n,put_symbol_to,put_symbol_ok_108)
I(0,0,put_symbol_next_108)

put_symbol_ok_108:
T(current_symbol,108)
I(0,0,while)

put_symbol_next_108:
S(n)
I(n,put_symbol_to,put_symbol_ok_109)
I(0,0,put_symbol_next_109)

put_symbol_ok_109:
T(current_symbol,109)
I(0,0,while)

put_symbol_next_109:
S(n)
I(n,put_symbol_to,put_symbol_ok_110)
I(0,0,put_symbol_next_110)

put_symbol_ok_110:
T(current_symbol,110)
I(0,0,while)

put_symbol_next_110:
S(n)
I(0,0,undefined_state)

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