.file "main.java" __SREG__ = 0x3f __SP_H__ = 0x3e __SP_L__ = 0x3d __tmp_reg__ = 0 __zero_reg__ = 1 .global __do_copy_data .global __do_clear_bss .text .global main .type main, @function main: push r29 push r28 in r28,__SP_L__ in r29,__SP_H__ /* prologue: function */ call _Z18MeggyJrSimpleSetupv /* Need to call this so that the meggy library gets set up */ # NewExp ldi r24, lo8(0) ldi r25, hi8(0) # allocating object of size 0 on heap call malloc # push object address # push two byte expression onto stack push r25 push r24 #### function call # put parameter values into appropriate registers # receiver will be passed as first param # load a two byte expression off stack pop r24 pop r25 call Solver_run /* epilogue start */ endLabel: jmp endLabel ret .size main, .-main .text .global Solver_initMaze1 .type Solver_initMaze1, @function Solver_initMaze1: push r29 push r28 # make space for locals and params ldi r30, 0 push r30 push r30 # Copy stack pointer to frame pointer in r28,__SP_L__ in r29,__SP_H__ # save off parameters std Y + 2, r25 std Y + 1, r24 /* done with function Solver_initMaze1 prologue */ /* epilogue start for Solver_initMaze1 */ # no return value # pop space off stack for parameters and locals pop r30 pop r30 # restoring the frame pointer pop r28 pop r29 ret .size Solver_initMaze1, .-Solver_initMaze1 .text .global Solver_initMaze2 .type Solver_initMaze2, @function Solver_initMaze2: push r29 push r28 # make space for locals and params ldi r30, 0 push r30 push r30 # Copy stack pointer to frame pointer in r28,__SP_L__ in r29,__SP_H__ # save off parameters std Y + 2, r25 std Y + 1, r24 /* done with function Solver_initMaze2 prologue */ # loading the implicit "this" # load a two byte variable from base+offset ldd r31, Y + 2 ldd r30, Y + 1 # push two byte expression onto stack push r31 push r30 # Load constant int 0 ldi r24,lo8(0) ldi r25,hi8(0) # push two byte expression onto stack push r25 push r24 # Casting int to byte by popping # 2 bytes off stack and only pushing low order bits # back on. Low order bits are on top of stack. pop r24 pop r25 push r24 # Load constant int 7 ldi r24,lo8(7) ldi r25,hi8(7) # push two byte expression onto stack push r25 push r24 # Casting int to byte by popping # 2 bytes off stack and only pushing low order bits # back on. Low order bits are on top of stack. pop r24 pop r25 push r24 # Load constant int 7 ldi r24,lo8(7) ldi r25,hi8(7) # push two byte expression onto stack push r25 push r24 # Casting int to byte by popping # 2 bytes off stack and only pushing low order bits # back on. Low order bits are on top of stack. pop r24 pop r25 push r24 #### function call # put parameter values into appropriate registers # load a one byte expression off stack pop r18 # load a one byte expression off stack pop r20 # load a one byte expression off stack pop r22 # receiver will be passed as first param # load a two byte expression off stack pop r24 pop r25 call Solver_mazeRow # loading the implicit "this" # load a two byte variable from base+offset ldd r31, Y + 2 ldd r30, Y + 1 # push two byte expression onto stack push r31 push r30 # Load constant int 0 ldi r24,lo8(0) ldi r25,hi8(0) # push two byte expression onto stack push r25 push r24 # Casting int to byte by popping # 2 bytes off stack and only pushing low order bits # back on. Low order bits are on top of stack. pop r24 pop r25 push r24 # Load constant int 5 ldi r24,lo8(5) ldi r25,hi8(5) # push two byte expression onto stack push r25 push r24 # Casting int to byte by popping # 2 bytes off stack and only pushing low order bits # back on. Low order bits are on top of stack. pop r24 pop r25 push r24 # Load constant int 5 ldi r24,lo8(5) ldi r25,hi8(5) # push two byte expression onto stack push r25 push r24 # Casting int to byte by popping # 2 bytes off stack and only pushing low order bits # back on. Low order bits are on top of stack. pop r24 pop r25 push r24 #### function call # put parameter values into appropriate registers # load a one byte expression off stack pop r18 # load a one byte expression off stack pop r20 # load a one byte expression off stack pop r22 # receiver will be passed as first param # load a two byte expression off stack pop r24 pop r25 call Solver_mazeRow # loading the implicit "this" # load a two byte variable from base+offset ldd r31, Y + 2 ldd r30, Y + 1 # push two byte expression onto stack push r31 push r30 # Load constant int 7 ldi r24,lo8(7) ldi r25,hi8(7) # push two byte expression onto stack push r25 push r24 # Casting int to byte by popping # 2 bytes off stack and only pushing low order bits # back on. Low order bits are on top of stack. pop r24 pop r25 push r24 # Load constant int 0 ldi r24,lo8(0) ldi r25,hi8(0) # push two byte expression onto stack push r25 push r24 # Casting int to byte by popping # 2 bytes off stack and only pushing low order bits # back on. Low order bits are on top of stack. pop r24 pop r25 push r24 # Load constant int 7 ldi r24,lo8(7) ldi r25,hi8(7) # push two byte expression onto stack push r25 push r24 # Casting int to byte by popping # 2 bytes off stack and only pushing low order bits # back on. Low order bits are on top of stack. pop r24 pop r25 push r24 #### function call # put parameter values into appropriate registers # load a one byte expression off stack pop r18 # load a one byte expression off stack pop r20 # load a one byte expression off stack pop r22 # receiver will be passed as first param # load a two byte expression off stack pop r24 pop r25 call Solver_mazeCol # loading the implicit "this" # load a two byte variable from base+offset ldd r31, Y + 2 ldd r30, Y + 1 # push two byte expression onto stack push r31 push r30 # Load constant int 5 ldi r24,lo8(5) ldi r25,hi8(5) # push two byte expression onto stack push r25 push r24 # Casting int to byte by popping # 2 bytes off stack and only pushing low order bits # back on. Low order bits are on top of stack. pop r24 pop r25 push r24 # Load constant int 0 ldi r24,lo8(0) ldi r25,hi8(0) # push two byte expression onto stack push r25 push r24 # Casting int to byte by popping # 2 bytes off stack and only pushing low order bits # back on. Low order bits are on top of stack. pop r24 pop r25 push r24 # Load constant int 5 ldi r24,lo8(5) ldi r25,hi8(5) # push two byte expression onto stack push r25 push r24 # Casting int to byte by popping # 2 bytes off stack and only pushing low order bits # back on. Low order bits are on top of stack. pop r24 pop r25 push r24 #### function call # put parameter values into appropriate registers # load a one byte expression off stack pop r18 # load a one byte expression off stack pop r20 # load a one byte expression off stack pop r22 # receiver will be passed as first param # load a two byte expression off stack pop r24 pop r25 call Solver_mazeCol /* epilogue start for Solver_initMaze2 */ # no return value # pop space off stack for parameters and locals pop r30 pop r30 # restoring the frame pointer pop r28 pop r29 ret .size Solver_initMaze2, .-Solver_initMaze2 .text .global Solver_initMazeCool .type Solver_initMazeCool, @function Solver_initMazeCool: push r29 push r28 # make space for locals and params ldi r30, 0 push r30 push r30 # Copy stack pointer to frame pointer in r28,__SP_L__ in r29,__SP_H__ # save off parameters std Y + 2, r25 std Y + 1, r24 /* done with function Solver_initMazeCool prologue */ # loading the implicit "this" # load a two byte variable from base+offset ldd r31, Y + 2 ldd r30, Y + 1 # push two byte expression onto stack push r31 push r30 # Load constant int 0 ldi r24,lo8(0) ldi r25,hi8(0) # push two byte expression onto stack push r25 push r24 # Casting int to byte by popping # 2 bytes off stack and only pushing low order bits # back on. Low order bits are on top of stack. pop r24 pop r25 push r24 # Load constant int 7 ldi r24,lo8(7) ldi r25,hi8(7) # push two byte expression onto stack push r25 push r24 # Casting int to byte by popping # 2 bytes off stack and only pushing low order bits # back on. Low order bits are on top of stack. pop r24 pop r25 push r24 # Load constant int 7 ldi r24,lo8(7) ldi r25,hi8(7) # push two byte expression onto stack push r25 push r24 # Casting int to byte by popping # 2 bytes off stack and only pushing low order bits # back on. Low order bits are on top of stack. pop r24 pop r25 push r24 #### function call # put parameter values into appropriate registers # load a one byte expression off stack pop r18 # load a one byte expression off stack pop r20 # load a one byte expression off stack pop r22 # receiver will be passed as first param # load a two byte expression off stack pop r24 pop r25 call Solver_mazeRow # loading the implicit "this" # load a two byte variable from base+offset ldd r31, Y + 2 ldd r30, Y + 1 # push two byte expression onto stack push r31 push r30 # Load constant int 0 ldi r24,lo8(0) ldi r25,hi8(0) # push two byte expression onto stack push r25 push r24 # Casting int to byte by popping # 2 bytes off stack and only pushing low order bits # back on. Low order bits are on top of stack. pop r24 pop r25 push r24 # Load constant int 7 ldi r24,lo8(7) ldi r25,hi8(7) # push two byte expression onto stack push r25 push r24 # Casting int to byte by popping # 2 bytes off stack and only pushing low order bits # back on. Low order bits are on top of stack. pop r24 pop r25 push r24 # Load constant int 0 ldi r24,lo8(0) ldi r25,hi8(0) # push two byte expression onto stack push r25 push r24 # Casting int to byte by popping # 2 bytes off stack and only pushing low order bits # back on. Low order bits are on top of stack. pop r24 pop r25 push r24 #### function call # put parameter values into appropriate registers # load a one byte expression off stack pop r18 # load a one byte expression off stack pop r20 # load a one byte expression off stack pop r22 # receiver will be passed as first param # load a two byte expression off stack pop r24 pop r25 call Solver_mazeRow # loading the implicit "this" # load a two byte variable from base+offset ldd r31, Y + 2 ldd r30, Y + 1 # push two byte expression onto stack push r31 push r30 # Load constant int 7 ldi r24,lo8(7) ldi r25,hi8(7) # push two byte expression onto stack push r25 push r24 # Casting int to byte by popping # 2 bytes off stack and only pushing low order bits # back on. Low order bits are on top of stack. pop r24 pop r25 push r24 # Load constant int 0 ldi r24,lo8(0) ldi r25,hi8(0) # push two byte expression onto stack push r25 push r24 # Casting int to byte by popping # 2 bytes off stack and only pushing low order bits # back on. Low order bits are on top of stack. pop r24 pop r25 push r24 # Load constant int 7 ldi r24,lo8(7) ldi r25,hi8(7) # push two byte expression onto stack push r25 push r24 # Casting int to byte by popping # 2 bytes off stack and only pushing low order bits # back on. Low order bits are on top of stack. pop r24 pop r25 push r24 #### function call # put parameter values into appropriate registers # load a one byte expression off stack pop r18 # load a one byte expression off stack pop r20 # load a one byte expression off stack pop r22 # receiver will be passed as first param # load a two byte expression off stack pop r24 pop r25 call Solver_mazeCol # loading the implicit "this" # load a two byte variable from base+offset ldd r31, Y + 2 ldd r30, Y + 1 # push two byte expression onto stack push r31 push r30 # Load constant int 0 ldi r24,lo8(0) ldi r25,hi8(0) # push two byte expression onto stack push r25 push r24 # Casting int to byte by popping # 2 bytes off stack and only pushing low order bits # back on. Low order bits are on top of stack. pop r24 pop r25 push r24 # Load constant int 0 ldi r24,lo8(0) ldi r25,hi8(0) # push two byte expression onto stack push r25 push r24 # Casting int to byte by popping # 2 bytes off stack and only pushing low order bits # back on. Low order bits are on top of stack. pop r24 pop r25 push r24 # Load constant int 7 ldi r24,lo8(7) ldi r25,hi8(7) # push two byte expression onto stack push r25 push r24 # Casting int to byte by popping # 2 bytes off stack and only pushing low order bits # back on. Low order bits are on top of stack. pop r24 pop r25 push r24 #### function call # put parameter values into appropriate registers # load a one byte expression off stack pop r18 # load a one byte expression off stack pop r20 # load a one byte expression off stack pop r22 # receiver will be passed as first param # load a two byte expression off stack pop r24 pop r25 call Solver_mazeCol # loading the implicit "this" # load a two byte variable from base+offset ldd r31, Y + 2 ldd r30, Y + 1 # push two byte expression onto stack push r31 push r30 # Load constant int 2 ldi r24,lo8(2) ldi r25,hi8(2) # push two byte expression onto stack push r25 push r24 # Casting int to byte by popping # 2 bytes off stack and only pushing low order bits # back on. Low order bits are on top of stack. pop r24 pop r25 push r24 # Load constant int 5 ldi r24,lo8(5) ldi r25,hi8(5) # push two byte expression onto stack push r25 push r24 # Casting int to byte by popping # 2 bytes off stack and only pushing low order bits # back on. Low order bits are on top of stack. pop r24 pop r25 push r24 # Load constant int 5 ldi r24,lo8(5) ldi r25,hi8(5) # push two byte expression onto stack push r25 push r24 # Casting int to byte by popping # 2 bytes off stack and only pushing low order bits # back on. Low order bits are on top of stack. pop r24 pop r25 push r24 #### function call # put parameter values into appropriate registers # load a one byte expression off stack pop r18 # load a one byte expression off stack pop r20 # load a one byte expression off stack pop r22 # receiver will be passed as first param # load a two byte expression off stack pop r24 pop r25 call Solver_mazeRow # loading the implicit "this" # load a two byte variable from base+offset ldd r31, Y + 2 ldd r30, Y + 1 # push two byte expression onto stack push r31 push r30 # Load constant int 2 ldi r24,lo8(2) ldi r25,hi8(2) # push two byte expression onto stack push r25 push r24 # Casting int to byte by popping # 2 bytes off stack and only pushing low order bits # back on. Low order bits are on top of stack. pop r24 pop r25 push r24 # Load constant int 2 ldi r24,lo8(2) ldi r25,hi8(2) # push two byte expression onto stack push r25 push r24 # Casting int to byte by popping # 2 bytes off stack and only pushing low order bits # back on. Low order bits are on top of stack. pop r24 pop r25 push r24 # Load constant int 5 ldi r24,lo8(5) ldi r25,hi8(5) # push two byte expression onto stack push r25 push r24 # Casting int to byte by popping # 2 bytes off stack and only pushing low order bits # back on. Low order bits are on top of stack. pop r24 pop r25 push r24 #### function call # put parameter values into appropriate registers # load a one byte expression off stack pop r18 # load a one byte expression off stack pop r20 # load a one byte expression off stack pop r22 # receiver will be passed as first param # load a two byte expression off stack pop r24 pop r25 call Solver_mazeCol # loading the implicit "this" # load a two byte variable from base+offset ldd r31, Y + 2 ldd r30, Y + 1 # push two byte expression onto stack push r31 push r30 # Load constant int 2 ldi r24,lo8(2) ldi r25,hi8(2) # push two byte expression onto stack push r25 push r24 # Casting int to byte by popping # 2 bytes off stack and only pushing low order bits # back on. Low order bits are on top of stack. pop r24 pop r25 push r24 # Load constant int 5 ldi r24,lo8(5) ldi r25,hi8(5) # push two byte expression onto stack push r25 push r24 # Casting int to byte by popping # 2 bytes off stack and only pushing low order bits # back on. Low order bits are on top of stack. pop r24 pop r25 push r24 # Load constant int 2 ldi r24,lo8(2) ldi r25,hi8(2) # push two byte expression onto stack push r25 push r24 # Casting int to byte by popping # 2 bytes off stack and only pushing low order bits # back on. Low order bits are on top of stack. pop r24 pop r25 push r24 #### function call # put parameter values into appropriate registers # load a one byte expression off stack pop r18 # load a one byte expression off stack pop r20 # load a one byte expression off stack pop r22 # receiver will be passed as first param # load a two byte expression off stack pop r24 pop r25 call Solver_mazeRow # Load constant int 5 ldi r24,lo8(5) ldi r25,hi8(5) # push two byte expression onto stack push r25 push r24 # Casting int to byte by popping # 2 bytes off stack and only pushing low order bits # back on. Low order bits are on top of stack. pop r24 pop r25 push r24 # Load constant int 1 ldi r24,lo8(1) ldi r25,hi8(1) # push two byte expression onto stack push r25 push r24 # Casting int to byte by popping # 2 bytes off stack and only pushing low order bits # back on. Low order bits are on top of stack. pop r24 pop r25 push r24 # Color expression Meggy.Color.VIOLET ldi r22,6 # push one byte expression onto stack push r22 ### Meggy.setPixel(x,y,color) call # load a one byte expression off stack pop r20 # load a one byte expression off stack pop r22 # load a one byte expression off stack pop r24 call _Z6DrawPxhhh call _Z12DisplaySlatev /* epilogue start for Solver_initMazeCool */ # no return value # pop space off stack for parameters and locals pop r30 pop r30 # restoring the frame pointer pop r28 pop r29 ret .size Solver_initMazeCool, .-Solver_initMazeCool .text .global Solver_run .type Solver_run, @function Solver_run: push r29 push r28 # make space for locals and params ldi r30, 0 push r30 push r30 # Copy stack pointer to frame pointer in r28,__SP_L__ in r29,__SP_H__ # save off parameters std Y + 2, r25 std Y + 1, r24 /* done with function Solver_run prologue */ # loading the implicit "this" # load a two byte variable from base+offset ldd r31, Y + 2 ldd r30, Y + 1 # push two byte expression onto stack push r31 push r30 #### function call # put parameter values into appropriate registers # receiver will be passed as first param # load a two byte expression off stack pop r24 pop r25 call Solver_initMazeCool # loading the implicit "this" # load a two byte variable from base+offset ldd r31, Y + 2 ldd r30, Y + 1 # push two byte expression onto stack push r31 push r30 # Load constant int 1 ldi r24,lo8(1) ldi r25,hi8(1) # push two byte expression onto stack push r25 push r24 # Casting int to byte by popping # 2 bytes off stack and only pushing low order bits # back on. Low order bits are on top of stack. pop r24 pop r25 push r24 # Load constant int 6 ldi r24,lo8(6) ldi r25,hi8(6) # push two byte expression onto stack push r25 push r24 # Casting int to byte by popping # 2 bytes off stack and only pushing low order bits # back on. Low order bits are on top of stack. pop r24 pop r25 push r24 # Load constant int 6 ldi r24,lo8(6) ldi r25,hi8(6) # push two byte expression onto stack push r25 push r24 # Casting int to byte by popping # 2 bytes off stack and only pushing low order bits # back on. Low order bits are on top of stack. pop r24 pop r25 push r24 # Load constant int 1 ldi r24,lo8(1) ldi r25,hi8(1) # push two byte expression onto stack push r25 push r24 # Casting int to byte by popping # 2 bytes off stack and only pushing low order bits # back on. Low order bits are on top of stack. pop r24 pop r25 push r24 #### function call # put parameter values into appropriate registers # load a one byte expression off stack pop r16 # load a one byte expression off stack pop r18 # load a one byte expression off stack pop r20 # load a one byte expression off stack pop r22 # receiver will be passed as first param # load a two byte expression off stack pop r24 pop r25 call Solver_move /* epilogue start for Solver_run */ # no return value # pop space off stack for parameters and locals pop r30 pop r30 # restoring the frame pointer pop r28 pop r29 ret .size Solver_run, .-Solver_run .text .global Solver_inBounds .type Solver_inBounds, @function Solver_inBounds: push r29 push r28 # make space for locals and params ldi r30, 0 push r30 push r30 push r30 push r30 # Copy stack pointer to frame pointer in r28,__SP_L__ in r29,__SP_H__ # save off parameters std Y + 2, r25 std Y + 1, r24 std Y + 3, r22 std Y + 4, r20 /* done with function Solver_inBounds prologue */ #### short-circuited && operation # &&: left operand #### short-circuited && operation # &&: left operand #### short-circuited && operation # &&: left operand # Load constant int 0 ldi r24,lo8(0) ldi r25,hi8(0) # push two byte expression onto stack push r25 push r24 # Load constant int 1 ldi r24,lo8(1) ldi r25,hi8(1) # push two byte expression onto stack push r25 push r24 # load a two byte expression off stack pop r18 pop r19 # load a two byte expression off stack pop r24 pop r25 # Do INT sub operation sub r24, r18 sbc r25, r19 # push hi order byte first # push two byte expression onto stack push r25 push r24 # Casting int to byte by popping # 2 bytes off stack and only pushing low order bits # back on. Low order bits are on top of stack. pop r24 pop r25 push r24 # IdExp # load value for variable x # variable is a local or param variable # load a one byte variable from base+offset ldd r24, Y + 3 # push one byte expression onto stack push r24 # less than expression # load a one byte expression off stack pop r18 # load a one byte expression off stack pop r24 cp r24, r18 brlt MJ_L1 # load false MJ_L0: ldi r24, 0 jmp MJ_L2 # load true MJ_L1: ldi r24, 1 # push result of less than MJ_L2: # push one byte expression onto stack push r24 # &&: if left operand is false do not eval right # load a one byte expression off stack pop r24 # push one byte expression onto stack push r24 # compare left exp with zero ldi r25, 0 cp r24, r25 # Want this, breq MJ_L3 brne MJ_L4 jmp MJ_L3 MJ_L4: # right operand # load a one byte expression off stack pop r24 # IdExp # load value for variable x # variable is a local or param variable # load a one byte variable from base+offset ldd r24, Y + 3 # push one byte expression onto stack push r24 # Load constant int 8 ldi r24,lo8(8) ldi r25,hi8(8) # push two byte expression onto stack push r25 push r24 # Casting int to byte by popping # 2 bytes off stack and only pushing low order bits # back on. Low order bits are on top of stack. pop r24 pop r25 push r24 # less than expression # load a one byte expression off stack pop r18 # load a one byte expression off stack pop r24 cp r24, r18 brlt MJ_L6 # load false MJ_L5: ldi r24, 0 jmp MJ_L7 # load true MJ_L6: ldi r24, 1 # push result of less than MJ_L7: # push one byte expression onto stack push r24 # load a one byte expression off stack pop r24 # push one byte expression onto stack push r24 MJ_L3: # &&: if left operand is false do not eval right # load a one byte expression off stack pop r24 # push one byte expression onto stack push r24 # compare left exp with zero ldi r25, 0 cp r24, r25 # Want this, breq MJ_L8 brne MJ_L9 jmp MJ_L8 MJ_L9: # right operand # load a one byte expression off stack pop r24 # Load constant int 0 ldi r24,lo8(0) ldi r25,hi8(0) # push two byte expression onto stack push r25 push r24 # Load constant int 1 ldi r24,lo8(1) ldi r25,hi8(1) # push two byte expression onto stack push r25 push r24 # load a two byte expression off stack pop r18 pop r19 # load a two byte expression off stack pop r24 pop r25 # Do INT sub operation sub r24, r18 sbc r25, r19 # push hi order byte first # push two byte expression onto stack push r25 push r24 # Casting int to byte by popping # 2 bytes off stack and only pushing low order bits # back on. Low order bits are on top of stack. pop r24 pop r25 push r24 # IdExp # load value for variable y # variable is a local or param variable # load a one byte variable from base+offset ldd r24, Y + 4 # push one byte expression onto stack push r24 # less than expression # load a one byte expression off stack pop r18 # load a one byte expression off stack pop r24 cp r24, r18 brlt MJ_L11 # load false MJ_L10: ldi r24, 0 jmp MJ_L12 # load true MJ_L11: ldi r24, 1 # push result of less than MJ_L12: # push one byte expression onto stack push r24 # load a one byte expression off stack pop r24 # push one byte expression onto stack push r24 MJ_L8: # &&: if left operand is false do not eval right # load a one byte expression off stack pop r24 # push one byte expression onto stack push r24 # compare left exp with zero ldi r25, 0 cp r24, r25 # Want this, breq MJ_L13 brne MJ_L14 jmp MJ_L13 MJ_L14: # right operand # load a one byte expression off stack pop r24 # IdExp # load value for variable y # variable is a local or param variable # load a one byte variable from base+offset ldd r24, Y + 4 # push one byte expression onto stack push r24 # Load constant int 8 ldi r24,lo8(8) ldi r25,hi8(8) # push two byte expression onto stack push r25 push r24 # Casting int to byte by popping # 2 bytes off stack and only pushing low order bits # back on. Low order bits are on top of stack. pop r24 pop r25 push r24 # less than expression # load a one byte expression off stack pop r18 # load a one byte expression off stack pop r24 cp r24, r18 brlt MJ_L16 # load false MJ_L15: ldi r24, 0 jmp MJ_L17 # load true MJ_L16: ldi r24, 1 # push result of less than MJ_L17: # push one byte expression onto stack push r24 # load a one byte expression off stack pop r24 # push one byte expression onto stack push r24 MJ_L13: /* epilogue start for Solver_inBounds */ # handle return value # load a one byte expression off stack pop r24 # promoting a byte to an int tst r24 brlt MJ_L18 ldi r25, 0 jmp MJ_L19 MJ_L18: ldi r25, hi8(-1) MJ_L19: # pop space off stack for parameters and locals pop r30 pop r30 pop r30 pop r30 # restoring the frame pointer pop r28 pop r29 ret .size Solver_inBounds, .-Solver_inBounds .text .global Solver_isDark .type Solver_isDark, @function Solver_isDark: push r29 push r28 # make space for locals and params ldi r30, 0 push r30 push r30 push r30 push r30 # Copy stack pointer to frame pointer in r28,__SP_L__ in r29,__SP_H__ # save off parameters std Y + 2, r25 std Y + 1, r24 std Y + 3, r22 std Y + 4, r20 /* done with function Solver_isDark prologue */ #### short-circuited && operation # &&: left operand # loading the implicit "this" # load a two byte variable from base+offset ldd r31, Y + 2 ldd r30, Y + 1 # push two byte expression onto stack push r31 push r30 # IdExp # load value for variable x # variable is a local or param variable # load a one byte variable from base+offset ldd r24, Y + 3 # push one byte expression onto stack push r24 # IdExp # load value for variable y # variable is a local or param variable # load a one byte variable from base+offset ldd r24, Y + 4 # push one byte expression onto stack push r24 #### function call # put parameter values into appropriate registers # load a one byte expression off stack pop r20 # load a one byte expression off stack pop r22 # receiver will be passed as first param # load a two byte expression off stack pop r24 pop r25 call Solver_inBounds # handle return value # push one byte expression onto stack push r24 # &&: if left operand is false do not eval right # load a one byte expression off stack pop r24 # push one byte expression onto stack push r24 # compare left exp with zero ldi r25, 0 cp r24, r25 # Want this, breq MJ_L20 brne MJ_L21 jmp MJ_L20 MJ_L21: # right operand # load a one byte expression off stack pop r24 # IdExp # load value for variable x # variable is a local or param variable # load a one byte variable from base+offset ldd r24, Y + 3 # push one byte expression onto stack push r24 # IdExp # load value for variable y # variable is a local or param variable # load a one byte variable from base+offset ldd r24, Y + 4 # push one byte expression onto stack push r24 ### Meggy.getPixel(x,y) call # load a one byte expression off stack pop r22 # load a one byte expression off stack pop r24 call _Z6ReadPxhh # push one byte expression onto stack push r24 # Color expression Meggy.Color.DARK ldi r22,0 # push one byte expression onto stack push r22 # equality check expression # load a one byte expression off stack pop r18 # load a one byte expression off stack pop r24 cp r24, r18 breq MJ_L23 # result is false MJ_L22: ldi r24, 0 jmp MJ_L24 # result is true MJ_L23: ldi r24, 1 # store result of equal expression MJ_L24: # push one byte expression onto stack push r24 # load a one byte expression off stack pop r24 # push one byte expression onto stack push r24 MJ_L20: /* epilogue start for Solver_isDark */ # handle return value # load a one byte expression off stack pop r24 # promoting a byte to an int tst r24 brlt MJ_L25 ldi r25, 0 jmp MJ_L26 MJ_L25: ldi r25, hi8(-1) MJ_L26: # pop space off stack for parameters and locals pop r30 pop r30 pop r30 pop r30 # restoring the frame pointer pop r28 pop r29 ret .size Solver_isDark, .-Solver_isDark .text .global Solver_isBLUE .type Solver_isBLUE, @function Solver_isBLUE: push r29 push r28 # make space for locals and params ldi r30, 0 push r30 push r30 push r30 push r30 # Copy stack pointer to frame pointer in r28,__SP_L__ in r29,__SP_H__ # save off parameters std Y + 2, r25 std Y + 1, r24 std Y + 3, r22 std Y + 4, r20 /* done with function Solver_isBLUE prologue */ #### short-circuited && operation # &&: left operand # loading the implicit "this" # load a two byte variable from base+offset ldd r31, Y + 2 ldd r30, Y + 1 # push two byte expression onto stack push r31 push r30 # IdExp # load value for variable x # variable is a local or param variable # load a one byte variable from base+offset ldd r24, Y + 3 # push one byte expression onto stack push r24 # IdExp # load value for variable y # variable is a local or param variable # load a one byte variable from base+offset ldd r24, Y + 4 # push one byte expression onto stack push r24 #### function call # put parameter values into appropriate registers # load a one byte expression off stack pop r20 # load a one byte expression off stack pop r22 # receiver will be passed as first param # load a two byte expression off stack pop r24 pop r25 call Solver_inBounds # handle return value # push one byte expression onto stack push r24 # &&: if left operand is false do not eval right # load a one byte expression off stack pop r24 # push one byte expression onto stack push r24 # compare left exp with zero ldi r25, 0 cp r24, r25 # Want this, breq MJ_L27 brne MJ_L28 jmp MJ_L27 MJ_L28: # right operand # load a one byte expression off stack pop r24 # IdExp # load value for variable x # variable is a local or param variable # load a one byte variable from base+offset ldd r24, Y + 3 # push one byte expression onto stack push r24 # IdExp # load value for variable y # variable is a local or param variable # load a one byte variable from base+offset ldd r24, Y + 4 # push one byte expression onto stack push r24 ### Meggy.getPixel(x,y) call # load a one byte expression off stack pop r22 # load a one byte expression off stack pop r24 call _Z6ReadPxhh # push one byte expression onto stack push r24 # Color expression Meggy.Color.BLUE ldi r22,5 # push one byte expression onto stack push r22 # equality check expression # load a one byte expression off stack pop r18 # load a one byte expression off stack pop r24 cp r24, r18 breq MJ_L30 # result is false MJ_L29: ldi r24, 0 jmp MJ_L31 # result is true MJ_L30: ldi r24, 1 # store result of equal expression MJ_L31: # push one byte expression onto stack push r24 # load a one byte expression off stack pop r24 # push one byte expression onto stack push r24 MJ_L27: /* epilogue start for Solver_isBLUE */ # handle return value # load a one byte expression off stack pop r24 # promoting a byte to an int tst r24 brlt MJ_L32 ldi r25, 0 jmp MJ_L33 MJ_L32: ldi r25, hi8(-1) MJ_L33: # pop space off stack for parameters and locals pop r30 pop r30 pop r30 pop r30 # restoring the frame pointer pop r28 pop r29 ret .size Solver_isBLUE, .-Solver_isBLUE .text .global Solver_findTargetOrMove .type Solver_findTargetOrMove, @function Solver_findTargetOrMove: push r29 push r28 # make space for locals and params ldi r30, 0 push r30 push r30 push r30 push r30 push r30 push r30 # Copy stack pointer to frame pointer in r28,__SP_L__ in r29,__SP_H__ # save off parameters std Y + 2, r25 std Y + 1, r24 std Y + 3, r22 std Y + 4, r20 std Y + 5, r18 std Y + 6, r16 /* done with function Solver_findTargetOrMove prologue */ #### if statement #### short-circuited && operation # &&: left operand # IdExp # load value for variable nextX # variable is a local or param variable # load a one byte variable from base+offset ldd r24, Y + 3 # push one byte expression onto stack push r24 # IdExp # load value for variable targetX # variable is a local or param variable # load a one byte variable from base+offset ldd r24, Y + 5 # push one byte expression onto stack push r24 # equality check expression # load a one byte expression off stack pop r18 # load a one byte expression off stack pop r24 cp r24, r18 breq MJ_L38 # result is false MJ_L37: ldi r24, 0 jmp MJ_L39 # result is true MJ_L38: ldi r24, 1 # store result of equal expression MJ_L39: # push one byte expression onto stack push r24 # &&: if left operand is false do not eval right # load a one byte expression off stack pop r24 # push one byte expression onto stack push r24 # compare left exp with zero ldi r25, 0 cp r24, r25 # Want this, breq MJ_L40 brne MJ_L41 jmp MJ_L40 MJ_L41: # right operand # load a one byte expression off stack pop r24 # IdExp # load value for variable nextY # variable is a local or param variable # load a one byte variable from base+offset ldd r24, Y + 4 # push one byte expression onto stack push r24 # IdExp # load value for variable targetY # variable is a local or param variable # load a one byte variable from base+offset ldd r24, Y + 6 # push one byte expression onto stack push r24 # equality check expression # load a one byte expression off stack pop r18 # load a one byte expression off stack pop r24 cp r24, r18 breq MJ_L43 # result is false MJ_L42: ldi r24, 0 jmp MJ_L44 # result is true MJ_L43: ldi r24, 1 # store result of equal expression MJ_L44: # push one byte expression onto stack push r24 # load a one byte expression off stack pop r24 # push one byte expression onto stack push r24 MJ_L40: # load condition and branch if false # load a one byte expression off stack pop r24 #load zero into reg ldi r25, 0 #use cp to set SREG cp r24, r25 #WANT breq MJ_L34 brne MJ_L35 jmp MJ_L34 # then label for if MJ_L35: # IdExp # load value for variable nextX # variable is a local or param variable # load a one byte variable from base+offset ldd r24, Y + 3 # push one byte expression onto stack push r24 # IdExp # load value for variable nextY # variable is a local or param variable # load a one byte variable from base+offset ldd r24, Y + 4 # push one byte expression onto stack push r24 # Color expression Meggy.Color.BLUE ldi r22,5 # push one byte expression onto stack push r22 ### Meggy.setPixel(x,y,color) call # load a one byte expression off stack pop r20 # load a one byte expression off stack pop r22 # load a one byte expression off stack pop r24 call _Z6DrawPxhhh call _Z12DisplaySlatev jmp MJ_L36 # else label for if MJ_L34: # loading the implicit "this" # load a two byte variable from base+offset ldd r31, Y + 2 ldd r30, Y + 1 # push two byte expression onto stack push r31 push r30 # IdExp # load value for variable nextX # variable is a local or param variable # load a one byte variable from base+offset ldd r24, Y + 3 # push one byte expression onto stack push r24 # IdExp # load value for variable nextY # variable is a local or param variable # load a one byte variable from base+offset ldd r24, Y + 4 # push one byte expression onto stack push r24 # IdExp # load value for variable targetX # variable is a local or param variable # load a one byte variable from base+offset ldd r24, Y + 5 # push one byte expression onto stack push r24 # IdExp # load value for variable targetY # variable is a local or param variable # load a one byte variable from base+offset ldd r24, Y + 6 # push one byte expression onto stack push r24 #### function call # put parameter values into appropriate registers # load a one byte expression off stack pop r16 # load a one byte expression off stack pop r18 # load a one byte expression off stack pop r20 # load a one byte expression off stack pop r22 # receiver will be passed as first param # load a two byte expression off stack pop r24 pop r25 call Solver_move # done label for if MJ_L36: /* epilogue start for Solver_findTargetOrMove */ # no return value # pop space off stack for parameters and locals pop r30 pop r30 pop r30 pop r30 pop r30 pop r30 # restoring the frame pointer pop r28 pop r29 ret .size Solver_findTargetOrMove, .-Solver_findTargetOrMove .text .global Solver_move .type Solver_move, @function Solver_move: push r29 push r28 # make space for locals and params ldi r30, 0 push r30 push r30 push r30 push r30 push r30 push r30 # Copy stack pointer to frame pointer in r28,__SP_L__ in r29,__SP_H__ # save off parameters std Y + 2, r25 std Y + 1, r24 std Y + 3, r22 std Y + 4, r20 std Y + 5, r18 std Y + 6, r16 /* done with function Solver_move prologue */ # Load constant int 256 ldi r24,lo8(256) ldi r25,hi8(256) # push two byte expression onto stack push r25 push r24 ### Meggy.delay() call # load delay parameter # load a two byte expression off stack pop r24 pop r25 call _Z8delay_msj # IdExp # load value for variable currentX # variable is a local or param variable # load a one byte variable from base+offset ldd r24, Y + 3 # push one byte expression onto stack push r24 # IdExp # load value for variable currentY # variable is a local or param variable # load a one byte variable from base+offset ldd r24, Y + 4 # push one byte expression onto stack push r24 # Color expression Meggy.Color.BLUE ldi r22,5 # push one byte expression onto stack push r22 ### Meggy.setPixel(x,y,color) call # load a one byte expression off stack pop r20 # load a one byte expression off stack pop r22 # load a one byte expression off stack pop r24 call _Z6DrawPxhhh call _Z12DisplaySlatev #### if statement # loading the implicit "this" # load a two byte variable from base+offset ldd r31, Y + 2 ldd r30, Y + 1 # push two byte expression onto stack push r31 push r30 # IdExp # load value for variable currentX # variable is a local or param variable # load a one byte variable from base+offset ldd r24, Y + 3 # push one byte expression onto stack push r24 # IdExp # load value for variable currentY # variable is a local or param variable # load a one byte variable from base+offset ldd r24, Y + 4 # push one byte expression onto stack push r24 # Load constant int 1 ldi r24,lo8(1) ldi r25,hi8(1) # push two byte expression onto stack push r25 push r24 # Casting int to byte by popping # 2 bytes off stack and only pushing low order bits # back on. Low order bits are on top of stack. pop r24 pop r25 push r24 # load a one byte expression off stack pop r18 # load a one byte expression off stack pop r24 # promoting a byte to an int tst r24 brlt MJ_L48 ldi r25, 0 jmp MJ_L49 MJ_L48: ldi r25, hi8(-1) MJ_L49: # promoting a byte to an int tst r18 brlt MJ_L50 ldi r19, 0 jmp MJ_L51 MJ_L50: ldi r19, hi8(-1) MJ_L51: # Do INT sub operation sub r24, r18 sbc r25, r19 # push hi order byte first # push two byte expression onto stack push r25 push r24 # Casting int to byte by popping # 2 bytes off stack and only pushing low order bits # back on. Low order bits are on top of stack. pop r24 pop r25 push r24 #### function call # put parameter values into appropriate registers # load a one byte expression off stack pop r20 # load a one byte expression off stack pop r22 # receiver will be passed as first param # load a two byte expression off stack pop r24 pop r25 call Solver_isDark # handle return value # push one byte expression onto stack push r24 # load condition and branch if false # load a one byte expression off stack pop r24 #load zero into reg ldi r25, 0 #use cp to set SREG cp r24, r25 #WANT breq MJ_L45 brne MJ_L46 jmp MJ_L45 # then label for if MJ_L46: # loading the implicit "this" # load a two byte variable from base+offset ldd r31, Y + 2 ldd r30, Y + 1 # push two byte expression onto stack push r31 push r30 # IdExp # load value for variable currentX # variable is a local or param variable # load a one byte variable from base+offset ldd r24, Y + 3 # push one byte expression onto stack push r24 # IdExp # load value for variable currentY # variable is a local or param variable # load a one byte variable from base+offset ldd r24, Y + 4 # push one byte expression onto stack push r24 # Load constant int 1 ldi r24,lo8(1) ldi r25,hi8(1) # push two byte expression onto stack push r25 push r24 # Casting int to byte by popping # 2 bytes off stack and only pushing low order bits # back on. Low order bits are on top of stack. pop r24 pop r25 push r24 # load a one byte expression off stack pop r18 # load a one byte expression off stack pop r24 # promoting a byte to an int tst r24 brlt MJ_L52 ldi r25, 0 jmp MJ_L53 MJ_L52: ldi r25, hi8(-1) MJ_L53: # promoting a byte to an int tst r18 brlt MJ_L54 ldi r19, 0 jmp MJ_L55 MJ_L54: ldi r19, hi8(-1) MJ_L55: # Do INT sub operation sub r24, r18 sbc r25, r19 # push hi order byte first # push two byte expression onto stack push r25 push r24 # Casting int to byte by popping # 2 bytes off stack and only pushing low order bits # back on. Low order bits are on top of stack. pop r24 pop r25 push r24 # IdExp # load value for variable targetX # variable is a local or param variable # load a one byte variable from base+offset ldd r24, Y + 5 # push one byte expression onto stack push r24 # IdExp # load value for variable targetY # variable is a local or param variable # load a one byte variable from base+offset ldd r24, Y + 6 # push one byte expression onto stack push r24 #### function call # put parameter values into appropriate registers # load a one byte expression off stack pop r16 # load a one byte expression off stack pop r18 # load a one byte expression off stack pop r20 # load a one byte expression off stack pop r22 # receiver will be passed as first param # load a two byte expression off stack pop r24 pop r25 call Solver_findTargetOrMove jmp MJ_L47 # else label for if MJ_L45: #### if statement # loading the implicit "this" # load a two byte variable from base+offset ldd r31, Y + 2 ldd r30, Y + 1 # push two byte expression onto stack push r31 push r30 # IdExp # load value for variable currentX # variable is a local or param variable # load a one byte variable from base+offset ldd r24, Y + 3 # push one byte expression onto stack push r24 # Load constant int 1 ldi r24,lo8(1) ldi r25,hi8(1) # push two byte expression onto stack push r25 push r24 # Casting int to byte by popping # 2 bytes off stack and only pushing low order bits # back on. Low order bits are on top of stack. pop r24 pop r25 push r24 # load a one byte expression off stack pop r18 # load a one byte expression off stack pop r24 # promoting a byte to an int tst r24 brlt MJ_L59 ldi r25, 0 jmp MJ_L60 MJ_L59: ldi r25, hi8(-1) MJ_L60: # promoting a byte to an int tst r18 brlt MJ_L61 ldi r19, 0 jmp MJ_L62 MJ_L61: ldi r19, hi8(-1) MJ_L62: # Do add operation add r24, r18 adc r25, r19 # push two byte expression onto stack push r25 push r24 # Casting int to byte by popping # 2 bytes off stack and only pushing low order bits # back on. Low order bits are on top of stack. pop r24 pop r25 push r24 # IdExp # load value for variable currentY # variable is a local or param variable # load a one byte variable from base+offset ldd r24, Y + 4 # push one byte expression onto stack push r24 #### function call # put parameter values into appropriate registers # load a one byte expression off stack pop r20 # load a one byte expression off stack pop r22 # receiver will be passed as first param # load a two byte expression off stack pop r24 pop r25 call Solver_isDark # handle return value # push one byte expression onto stack push r24 # load condition and branch if false # load a one byte expression off stack pop r24 #load zero into reg ldi r25, 0 #use cp to set SREG cp r24, r25 #WANT breq MJ_L56 brne MJ_L57 jmp MJ_L56 # then label for if MJ_L57: # loading the implicit "this" # load a two byte variable from base+offset ldd r31, Y + 2 ldd r30, Y + 1 # push two byte expression onto stack push r31 push r30 # IdExp # load value for variable currentX # variable is a local or param variable # load a one byte variable from base+offset ldd r24, Y + 3 # push one byte expression onto stack push r24 # Load constant int 1 ldi r24,lo8(1) ldi r25,hi8(1) # push two byte expression onto stack push r25 push r24 # Casting int to byte by popping # 2 bytes off stack and only pushing low order bits # back on. Low order bits are on top of stack. pop r24 pop r25 push r24 # load a one byte expression off stack pop r18 # load a one byte expression off stack pop r24 # promoting a byte to an int tst r24 brlt MJ_L63 ldi r25, 0 jmp MJ_L64 MJ_L63: ldi r25, hi8(-1) MJ_L64: # promoting a byte to an int tst r18 brlt MJ_L65 ldi r19, 0 jmp MJ_L66 MJ_L65: ldi r19, hi8(-1) MJ_L66: # Do add operation add r24, r18 adc r25, r19 # push two byte expression onto stack push r25 push r24 # Casting int to byte by popping # 2 bytes off stack and only pushing low order bits # back on. Low order bits are on top of stack. pop r24 pop r25 push r24 # IdExp # load value for variable currentY # variable is a local or param variable # load a one byte variable from base+offset ldd r24, Y + 4 # push one byte expression onto stack push r24 # IdExp # load value for variable targetX # variable is a local or param variable # load a one byte variable from base+offset ldd r24, Y + 5 # push one byte expression onto stack push r24 # IdExp # load value for variable targetY # variable is a local or param variable # load a one byte variable from base+offset ldd r24, Y + 6 # push one byte expression onto stack push r24 #### function call # put parameter values into appropriate registers # load a one byte expression off stack pop r16 # load a one byte expression off stack pop r18 # load a one byte expression off stack pop r20 # load a one byte expression off stack pop r22 # receiver will be passed as first param # load a two byte expression off stack pop r24 pop r25 call Solver_findTargetOrMove jmp MJ_L58 # else label for if MJ_L56: #### if statement # loading the implicit "this" # load a two byte variable from base+offset ldd r31, Y + 2 ldd r30, Y + 1 # push two byte expression onto stack push r31 push r30 # IdExp # load value for variable currentX # variable is a local or param variable # load a one byte variable from base+offset ldd r24, Y + 3 # push one byte expression onto stack push r24 # IdExp # load value for variable currentY # variable is a local or param variable # load a one byte variable from base+offset ldd r24, Y + 4 # push one byte expression onto stack push r24 # Load constant int 1 ldi r24,lo8(1) ldi r25,hi8(1) # push two byte expression onto stack push r25 push r24 # Casting int to byte by popping # 2 bytes off stack and only pushing low order bits # back on. Low order bits are on top of stack. pop r24 pop r25 push r24 # load a one byte expression off stack pop r18 # load a one byte expression off stack pop r24 # promoting a byte to an int tst r24 brlt MJ_L70 ldi r25, 0 jmp MJ_L71 MJ_L70: ldi r25, hi8(-1) MJ_L71: # promoting a byte to an int tst r18 brlt MJ_L72 ldi r19, 0 jmp MJ_L73 MJ_L72: ldi r19, hi8(-1) MJ_L73: # Do add operation add r24, r18 adc r25, r19 # push two byte expression onto stack push r25 push r24 # Casting int to byte by popping # 2 bytes off stack and only pushing low order bits # back on. Low order bits are on top of stack. pop r24 pop r25 push r24 #### function call # put parameter values into appropriate registers # load a one byte expression off stack pop r20 # load a one byte expression off stack pop r22 # receiver will be passed as first param # load a two byte expression off stack pop r24 pop r25 call Solver_isDark # handle return value # push one byte expression onto stack push r24 # load condition and branch if false # load a one byte expression off stack pop r24 #load zero into reg ldi r25, 0 #use cp to set SREG cp r24, r25 #WANT breq MJ_L67 brne MJ_L68 jmp MJ_L67 # then label for if MJ_L68: # loading the implicit "this" # load a two byte variable from base+offset ldd r31, Y + 2 ldd r30, Y + 1 # push two byte expression onto stack push r31 push r30 # IdExp # load value for variable currentX # variable is a local or param variable # load a one byte variable from base+offset ldd r24, Y + 3 # push one byte expression onto stack push r24 # IdExp # load value for variable currentY # variable is a local or param variable # load a one byte variable from base+offset ldd r24, Y + 4 # push one byte expression onto stack push r24 # Load constant int 1 ldi r24,lo8(1) ldi r25,hi8(1) # push two byte expression onto stack push r25 push r24 # Casting int to byte by popping # 2 bytes off stack and only pushing low order bits # back on. Low order bits are on top of stack. pop r24 pop r25 push r24 # load a one byte expression off stack pop r18 # load a one byte expression off stack pop r24 # promoting a byte to an int tst r24 brlt MJ_L74 ldi r25, 0 jmp MJ_L75 MJ_L74: ldi r25, hi8(-1) MJ_L75: # promoting a byte to an int tst r18 brlt MJ_L76 ldi r19, 0 jmp MJ_L77 MJ_L76: ldi r19, hi8(-1) MJ_L77: # Do add operation add r24, r18 adc r25, r19 # push two byte expression onto stack push r25 push r24 # Casting int to byte by popping # 2 bytes off stack and only pushing low order bits # back on. Low order bits are on top of stack. pop r24 pop r25 push r24 # IdExp # load value for variable targetX # variable is a local or param variable # load a one byte variable from base+offset ldd r24, Y + 5 # push one byte expression onto stack push r24 # IdExp # load value for variable targetY # variable is a local or param variable # load a one byte variable from base+offset ldd r24, Y + 6 # push one byte expression onto stack push r24 #### function call # put parameter values into appropriate registers # load a one byte expression off stack pop r16 # load a one byte expression off stack pop r18 # load a one byte expression off stack pop r20 # load a one byte expression off stack pop r22 # receiver will be passed as first param # load a two byte expression off stack pop r24 pop r25 call Solver_findTargetOrMove jmp MJ_L69 # else label for if MJ_L67: #### if statement # loading the implicit "this" # load a two byte variable from base+offset ldd r31, Y + 2 ldd r30, Y + 1 # push two byte expression onto stack push r31 push r30 # IdExp # load value for variable currentX # variable is a local or param variable # load a one byte variable from base+offset ldd r24, Y + 3 # push one byte expression onto stack push r24 # Load constant int 1 ldi r24,lo8(1) ldi r25,hi8(1) # push two byte expression onto stack push r25 push r24 # Casting int to byte by popping # 2 bytes off stack and only pushing low order bits # back on. Low order bits are on top of stack. pop r24 pop r25 push r24 # load a one byte expression off stack pop r18 # load a one byte expression off stack pop r24 # promoting a byte to an int tst r24 brlt MJ_L81 ldi r25, 0 jmp MJ_L82 MJ_L81: ldi r25, hi8(-1) MJ_L82: # promoting a byte to an int tst r18 brlt MJ_L83 ldi r19, 0 jmp MJ_L84 MJ_L83: ldi r19, hi8(-1) MJ_L84: # Do INT sub operation sub r24, r18 sbc r25, r19 # push hi order byte first # push two byte expression onto stack push r25 push r24 # Casting int to byte by popping # 2 bytes off stack and only pushing low order bits # back on. Low order bits are on top of stack. pop r24 pop r25 push r24 # IdExp # load value for variable currentY # variable is a local or param variable # load a one byte variable from base+offset ldd r24, Y + 4 # push one byte expression onto stack push r24 #### function call # put parameter values into appropriate registers # load a one byte expression off stack pop r20 # load a one byte expression off stack pop r22 # receiver will be passed as first param # load a two byte expression off stack pop r24 pop r25 call Solver_isDark # handle return value # push one byte expression onto stack push r24 # load condition and branch if false # load a one byte expression off stack pop r24 #load zero into reg ldi r25, 0 #use cp to set SREG cp r24, r25 #WANT breq MJ_L78 brne MJ_L79 jmp MJ_L78 # then label for if MJ_L79: # loading the implicit "this" # load a two byte variable from base+offset ldd r31, Y + 2 ldd r30, Y + 1 # push two byte expression onto stack push r31 push r30 # IdExp # load value for variable currentX # variable is a local or param variable # load a one byte variable from base+offset ldd r24, Y + 3 # push one byte expression onto stack push r24 # Load constant int 1 ldi r24,lo8(1) ldi r25,hi8(1) # push two byte expression onto stack push r25 push r24 # Casting int to byte by popping # 2 bytes off stack and only pushing low order bits # back on. Low order bits are on top of stack. pop r24 pop r25 push r24 # load a one byte expression off stack pop r18 # load a one byte expression off stack pop r24 # promoting a byte to an int tst r24 brlt MJ_L85 ldi r25, 0 jmp MJ_L86 MJ_L85: ldi r25, hi8(-1) MJ_L86: # promoting a byte to an int tst r18 brlt MJ_L87 ldi r19, 0 jmp MJ_L88 MJ_L87: ldi r19, hi8(-1) MJ_L88: # Do INT sub operation sub r24, r18 sbc r25, r19 # push hi order byte first # push two byte expression onto stack push r25 push r24 # Casting int to byte by popping # 2 bytes off stack and only pushing low order bits # back on. Low order bits are on top of stack. pop r24 pop r25 push r24 # IdExp # load value for variable currentY # variable is a local or param variable # load a one byte variable from base+offset ldd r24, Y + 4 # push one byte expression onto stack push r24 # IdExp # load value for variable targetX # variable is a local or param variable # load a one byte variable from base+offset ldd r24, Y + 5 # push one byte expression onto stack push r24 # IdExp # load value for variable targetY # variable is a local or param variable # load a one byte variable from base+offset ldd r24, Y + 6 # push one byte expression onto stack push r24 #### function call # put parameter values into appropriate registers # load a one byte expression off stack pop r16 # load a one byte expression off stack pop r18 # load a one byte expression off stack pop r20 # load a one byte expression off stack pop r22 # receiver will be passed as first param # load a two byte expression off stack pop r24 pop r25 call Solver_findTargetOrMove jmp MJ_L80 # else label for if MJ_L78: #### if statement # loading the implicit "this" # load a two byte variable from base+offset ldd r31, Y + 2 ldd r30, Y + 1 # push two byte expression onto stack push r31 push r30 # IdExp # load value for variable currentX # variable is a local or param variable # load a one byte variable from base+offset ldd r24, Y + 3 # push one byte expression onto stack push r24 # IdExp # load value for variable currentY # variable is a local or param variable # load a one byte variable from base+offset ldd r24, Y + 4 # push one byte expression onto stack push r24 # Load constant int 1 ldi r24,lo8(1) ldi r25,hi8(1) # push two byte expression onto stack push r25 push r24 # Casting int to byte by popping # 2 bytes off stack and only pushing low order bits # back on. Low order bits are on top of stack. pop r24 pop r25 push r24 # load a one byte expression off stack pop r18 # load a one byte expression off stack pop r24 # promoting a byte to an int tst r24 brlt MJ_L92 ldi r25, 0 jmp MJ_L93 MJ_L92: ldi r25, hi8(-1) MJ_L93: # promoting a byte to an int tst r18 brlt MJ_L94 ldi r19, 0 jmp MJ_L95 MJ_L94: ldi r19, hi8(-1) MJ_L95: # Do INT sub operation sub r24, r18 sbc r25, r19 # push hi order byte first # push two byte expression onto stack push r25 push r24 # Casting int to byte by popping # 2 bytes off stack and only pushing low order bits # back on. Low order bits are on top of stack. pop r24 pop r25 push r24 #### function call # put parameter values into appropriate registers # load a one byte expression off stack pop r20 # load a one byte expression off stack pop r22 # receiver will be passed as first param # load a two byte expression off stack pop r24 pop r25 call Solver_isBLUE # handle return value # push one byte expression onto stack push r24 # load condition and branch if false # load a one byte expression off stack pop r24 #load zero into reg ldi r25, 0 #use cp to set SREG cp r24, r25 #WANT breq MJ_L89 brne MJ_L90 jmp MJ_L89 # then label for if MJ_L90: # IdExp # load value for variable currentX # variable is a local or param variable # load a one byte variable from base+offset ldd r24, Y + 3 # push one byte expression onto stack push r24 # IdExp # load value for variable currentY # variable is a local or param variable # load a one byte variable from base+offset ldd r24, Y + 4 # push one byte expression onto stack push r24 # Color expression Meggy.Color.YELLOW ldi r22,3 # push one byte expression onto stack push r22 ### Meggy.setPixel(x,y,color) call # load a one byte expression off stack pop r20 # load a one byte expression off stack pop r22 # load a one byte expression off stack pop r24 call _Z6DrawPxhhh call _Z12DisplaySlatev # loading the implicit "this" # load a two byte variable from base+offset ldd r31, Y + 2 ldd r30, Y + 1 # push two byte expression onto stack push r31 push r30 # IdExp # load value for variable currentX # variable is a local or param variable # load a one byte variable from base+offset ldd r24, Y + 3 # push one byte expression onto stack push r24 # IdExp # load value for variable currentY # variable is a local or param variable # load a one byte variable from base+offset ldd r24, Y + 4 # push one byte expression onto stack push r24 # Load constant int 1 ldi r24,lo8(1) ldi r25,hi8(1) # push two byte expression onto stack push r25 push r24 # Casting int to byte by popping # 2 bytes off stack and only pushing low order bits # back on. Low order bits are on top of stack. pop r24 pop r25 push r24 # load a one byte expression off stack pop r18 # load a one byte expression off stack pop r24 # promoting a byte to an int tst r24 brlt MJ_L96 ldi r25, 0 jmp MJ_L97 MJ_L96: ldi r25, hi8(-1) MJ_L97: # promoting a byte to an int tst r18 brlt MJ_L98 ldi r19, 0 jmp MJ_L99 MJ_L98: ldi r19, hi8(-1) MJ_L99: # Do INT sub operation sub r24, r18 sbc r25, r19 # push hi order byte first # push two byte expression onto stack push r25 push r24 # Casting int to byte by popping # 2 bytes off stack and only pushing low order bits # back on. Low order bits are on top of stack. pop r24 pop r25 push r24 # IdExp # load value for variable targetX # variable is a local or param variable # load a one byte variable from base+offset ldd r24, Y + 5 # push one byte expression onto stack push r24 # IdExp # load value for variable targetY # variable is a local or param variable # load a one byte variable from base+offset ldd r24, Y + 6 # push one byte expression onto stack push r24 #### function call # put parameter values into appropriate registers # load a one byte expression off stack pop r16 # load a one byte expression off stack pop r18 # load a one byte expression off stack pop r20 # load a one byte expression off stack pop r22 # receiver will be passed as first param # load a two byte expression off stack pop r24 pop r25 call Solver_move jmp MJ_L91 # else label for if MJ_L89: #### if statement # loading the implicit "this" # load a two byte variable from base+offset ldd r31, Y + 2 ldd r30, Y + 1 # push two byte expression onto stack push r31 push r30 # IdExp # load value for variable currentX # variable is a local or param variable # load a one byte variable from base+offset ldd r24, Y + 3 # push one byte expression onto stack push r24 # Load constant int 1 ldi r24,lo8(1) ldi r25,hi8(1) # push two byte expression onto stack push r25 push r24 # Casting int to byte by popping # 2 bytes off stack and only pushing low order bits # back on. Low order bits are on top of stack. pop r24 pop r25 push r24 # load a one byte expression off stack pop r18 # load a one byte expression off stack pop r24 # promoting a byte to an int tst r24 brlt MJ_L103 ldi r25, 0 jmp MJ_L104 MJ_L103: ldi r25, hi8(-1) MJ_L104: # promoting a byte to an int tst r18 brlt MJ_L105 ldi r19, 0 jmp MJ_L106 MJ_L105: ldi r19, hi8(-1) MJ_L106: # Do add operation add r24, r18 adc r25, r19 # push two byte expression onto stack push r25 push r24 # Casting int to byte by popping # 2 bytes off stack and only pushing low order bits # back on. Low order bits are on top of stack. pop r24 pop r25 push r24 # IdExp # load value for variable currentY # variable is a local or param variable # load a one byte variable from base+offset ldd r24, Y + 4 # push one byte expression onto stack push r24 #### function call # put parameter values into appropriate registers # load a one byte expression off stack pop r20 # load a one byte expression off stack pop r22 # receiver will be passed as first param # load a two byte expression off stack pop r24 pop r25 call Solver_isBLUE # handle return value # push one byte expression onto stack push r24 # load condition and branch if false # load a one byte expression off stack pop r24 #load zero into reg ldi r25, 0 #use cp to set SREG cp r24, r25 #WANT breq MJ_L100 brne MJ_L101 jmp MJ_L100 # then label for if MJ_L101: # IdExp # load value for variable currentX # variable is a local or param variable # load a one byte variable from base+offset ldd r24, Y + 3 # push one byte expression onto stack push r24 # IdExp # load value for variable currentY # variable is a local or param variable # load a one byte variable from base+offset ldd r24, Y + 4 # push one byte expression onto stack push r24 # Color expression Meggy.Color.YELLOW ldi r22,3 # push one byte expression onto stack push r22 ### Meggy.setPixel(x,y,color) call # load a one byte expression off stack pop r20 # load a one byte expression off stack pop r22 # load a one byte expression off stack pop r24 call _Z6DrawPxhhh call _Z12DisplaySlatev # loading the implicit "this" # load a two byte variable from base+offset ldd r31, Y + 2 ldd r30, Y + 1 # push two byte expression onto stack push r31 push r30 # IdExp # load value for variable currentX # variable is a local or param variable # load a one byte variable from base+offset ldd r24, Y + 3 # push one byte expression onto stack push r24 # Load constant int 1 ldi r24,lo8(1) ldi r25,hi8(1) # push two byte expression onto stack push r25 push r24 # Casting int to byte by popping # 2 bytes off stack and only pushing low order bits # back on. Low order bits are on top of stack. pop r24 pop r25 push r24 # load a one byte expression off stack pop r18 # load a one byte expression off stack pop r24 # promoting a byte to an int tst r24 brlt MJ_L107 ldi r25, 0 jmp MJ_L108 MJ_L107: ldi r25, hi8(-1) MJ_L108: # promoting a byte to an int tst r18 brlt MJ_L109 ldi r19, 0 jmp MJ_L110 MJ_L109: ldi r19, hi8(-1) MJ_L110: # Do add operation add r24, r18 adc r25, r19 # push two byte expression onto stack push r25 push r24 # Casting int to byte by popping # 2 bytes off stack and only pushing low order bits # back on. Low order bits are on top of stack. pop r24 pop r25 push r24 # IdExp # load value for variable currentY # variable is a local or param variable # load a one byte variable from base+offset ldd r24, Y + 4 # push one byte expression onto stack push r24 # IdExp # load value for variable targetX # variable is a local or param variable # load a one byte variable from base+offset ldd r24, Y + 5 # push one byte expression onto stack push r24 # IdExp # load value for variable targetY # variable is a local or param variable # load a one byte variable from base+offset ldd r24, Y + 6 # push one byte expression onto stack push r24 #### function call # put parameter values into appropriate registers # load a one byte expression off stack pop r16 # load a one byte expression off stack pop r18 # load a one byte expression off stack pop r20 # load a one byte expression off stack pop r22 # receiver will be passed as first param # load a two byte expression off stack pop r24 pop r25 call Solver_move jmp MJ_L102 # else label for if MJ_L100: #### if statement # loading the implicit "this" # load a two byte variable from base+offset ldd r31, Y + 2 ldd r30, Y + 1 # push two byte expression onto stack push r31 push r30 # IdExp # load value for variable currentX # variable is a local or param variable # load a one byte variable from base+offset ldd r24, Y + 3 # push one byte expression onto stack push r24 # IdExp # load value for variable currentY # variable is a local or param variable # load a one byte variable from base+offset ldd r24, Y + 4 # push one byte expression onto stack push r24 # Load constant int 1 ldi r24,lo8(1) ldi r25,hi8(1) # push two byte expression onto stack push r25 push r24 # Casting int to byte by popping # 2 bytes off stack and only pushing low order bits # back on. Low order bits are on top of stack. pop r24 pop r25 push r24 # load a one byte expression off stack pop r18 # load a one byte expression off stack pop r24 # promoting a byte to an int tst r24 brlt MJ_L114 ldi r25, 0 jmp MJ_L115 MJ_L114: ldi r25, hi8(-1) MJ_L115: # promoting a byte to an int tst r18 brlt MJ_L116 ldi r19, 0 jmp MJ_L117 MJ_L116: ldi r19, hi8(-1) MJ_L117: # Do add operation add r24, r18 adc r25, r19 # push two byte expression onto stack push r25 push r24 # Casting int to byte by popping # 2 bytes off stack and only pushing low order bits # back on. Low order bits are on top of stack. pop r24 pop r25 push r24 #### function call # put parameter values into appropriate registers # load a one byte expression off stack pop r20 # load a one byte expression off stack pop r22 # receiver will be passed as first param # load a two byte expression off stack pop r24 pop r25 call Solver_isBLUE # handle return value # push one byte expression onto stack push r24 # load condition and branch if false # load a one byte expression off stack pop r24 #load zero into reg ldi r25, 0 #use cp to set SREG cp r24, r25 #WANT breq MJ_L111 brne MJ_L112 jmp MJ_L111 # then label for if MJ_L112: # IdExp # load value for variable currentX # variable is a local or param variable # load a one byte variable from base+offset ldd r24, Y + 3 # push one byte expression onto stack push r24 # IdExp # load value for variable currentY # variable is a local or param variable # load a one byte variable from base+offset ldd r24, Y + 4 # push one byte expression onto stack push r24 # Color expression Meggy.Color.YELLOW ldi r22,3 # push one byte expression onto stack push r22 ### Meggy.setPixel(x,y,color) call # load a one byte expression off stack pop r20 # load a one byte expression off stack pop r22 # load a one byte expression off stack pop r24 call _Z6DrawPxhhh call _Z12DisplaySlatev # loading the implicit "this" # load a two byte variable from base+offset ldd r31, Y + 2 ldd r30, Y + 1 # push two byte expression onto stack push r31 push r30 # IdExp # load value for variable currentX # variable is a local or param variable # load a one byte variable from base+offset ldd r24, Y + 3 # push one byte expression onto stack push r24 # IdExp # load value for variable currentY # variable is a local or param variable # load a one byte variable from base+offset ldd r24, Y + 4 # push one byte expression onto stack push r24 # Load constant int 1 ldi r24,lo8(1) ldi r25,hi8(1) # push two byte expression onto stack push r25 push r24 # Casting int to byte by popping # 2 bytes off stack and only pushing low order bits # back on. Low order bits are on top of stack. pop r24 pop r25 push r24 # load a one byte expression off stack pop r18 # load a one byte expression off stack pop r24 # promoting a byte to an int tst r24 brlt MJ_L118 ldi r25, 0 jmp MJ_L119 MJ_L118: ldi r25, hi8(-1) MJ_L119: # promoting a byte to an int tst r18 brlt MJ_L120 ldi r19, 0 jmp MJ_L121 MJ_L120: ldi r19, hi8(-1) MJ_L121: # Do add operation add r24, r18 adc r25, r19 # push two byte expression onto stack push r25 push r24 # Casting int to byte by popping # 2 bytes off stack and only pushing low order bits # back on. Low order bits are on top of stack. pop r24 pop r25 push r24 # IdExp # load value for variable targetX # variable is a local or param variable # load a one byte variable from base+offset ldd r24, Y + 5 # push one byte expression onto stack push r24 # IdExp # load value for variable targetY # variable is a local or param variable # load a one byte variable from base+offset ldd r24, Y + 6 # push one byte expression onto stack push r24 #### function call # put parameter values into appropriate registers # load a one byte expression off stack pop r16 # load a one byte expression off stack pop r18 # load a one byte expression off stack pop r20 # load a one byte expression off stack pop r22 # receiver will be passed as first param # load a two byte expression off stack pop r24 pop r25 call Solver_move jmp MJ_L113 # else label for if MJ_L111: #### if statement # loading the implicit "this" # load a two byte variable from base+offset ldd r31, Y + 2 ldd r30, Y + 1 # push two byte expression onto stack push r31 push r30 # IdExp # load value for variable currentX # variable is a local or param variable # load a one byte variable from base+offset ldd r24, Y + 3 # push one byte expression onto stack push r24 # Load constant int 1 ldi r24,lo8(1) ldi r25,hi8(1) # push two byte expression onto stack push r25 push r24 # Casting int to byte by popping # 2 bytes off stack and only pushing low order bits # back on. Low order bits are on top of stack. pop r24 pop r25 push r24 # load a one byte expression off stack pop r18 # load a one byte expression off stack pop r24 # promoting a byte to an int tst r24 brlt MJ_L125 ldi r25, 0 jmp MJ_L126 MJ_L125: ldi r25, hi8(-1) MJ_L126: # promoting a byte to an int tst r18 brlt MJ_L127 ldi r19, 0 jmp MJ_L128 MJ_L127: ldi r19, hi8(-1) MJ_L128: # Do INT sub operation sub r24, r18 sbc r25, r19 # push hi order byte first # push two byte expression onto stack push r25 push r24 # Casting int to byte by popping # 2 bytes off stack and only pushing low order bits # back on. Low order bits are on top of stack. pop r24 pop r25 push r24 # IdExp # load value for variable currentY # variable is a local or param variable # load a one byte variable from base+offset ldd r24, Y + 4 # push one byte expression onto stack push r24 #### function call # put parameter values into appropriate registers # load a one byte expression off stack pop r20 # load a one byte expression off stack pop r22 # receiver will be passed as first param # load a two byte expression off stack pop r24 pop r25 call Solver_isBLUE # handle return value # push one byte expression onto stack push r24 # load condition and branch if false # load a one byte expression off stack pop r24 #load zero into reg ldi r25, 0 #use cp to set SREG cp r24, r25 #WANT breq MJ_L122 brne MJ_L123 jmp MJ_L122 # then label for if MJ_L123: # IdExp # load value for variable currentX # variable is a local or param variable # load a one byte variable from base+offset ldd r24, Y + 3 # push one byte expression onto stack push r24 # IdExp # load value for variable currentY # variable is a local or param variable # load a one byte variable from base+offset ldd r24, Y + 4 # push one byte expression onto stack push r24 # Color expression Meggy.Color.YELLOW ldi r22,3 # push one byte expression onto stack push r22 ### Meggy.setPixel(x,y,color) call # load a one byte expression off stack pop r20 # load a one byte expression off stack pop r22 # load a one byte expression off stack pop r24 call _Z6DrawPxhhh call _Z12DisplaySlatev # loading the implicit "this" # load a two byte variable from base+offset ldd r31, Y + 2 ldd r30, Y + 1 # push two byte expression onto stack push r31 push r30 # IdExp # load value for variable currentX # variable is a local or param variable # load a one byte variable from base+offset ldd r24, Y + 3 # push one byte expression onto stack push r24 # Load constant int 1 ldi r24,lo8(1) ldi r25,hi8(1) # push two byte expression onto stack push r25 push r24 # Casting int to byte by popping # 2 bytes off stack and only pushing low order bits # back on. Low order bits are on top of stack. pop r24 pop r25 push r24 # load a one byte expression off stack pop r18 # load a one byte expression off stack pop r24 # promoting a byte to an int tst r24 brlt MJ_L129 ldi r25, 0 jmp MJ_L130 MJ_L129: ldi r25, hi8(-1) MJ_L130: # promoting a byte to an int tst r18 brlt MJ_L131 ldi r19, 0 jmp MJ_L132 MJ_L131: ldi r19, hi8(-1) MJ_L132: # Do INT sub operation sub r24, r18 sbc r25, r19 # push hi order byte first # push two byte expression onto stack push r25 push r24 # Casting int to byte by popping # 2 bytes off stack and only pushing low order bits # back on. Low order bits are on top of stack. pop r24 pop r25 push r24 # IdExp # load value for variable currentY # variable is a local or param variable # load a one byte variable from base+offset ldd r24, Y + 4 # push one byte expression onto stack push r24 # IdExp # load value for variable targetX # variable is a local or param variable # load a one byte variable from base+offset ldd r24, Y + 5 # push one byte expression onto stack push r24 # IdExp # load value for variable targetY # variable is a local or param variable # load a one byte variable from base+offset ldd r24, Y + 6 # push one byte expression onto stack push r24 #### function call # put parameter values into appropriate registers # load a one byte expression off stack pop r16 # load a one byte expression off stack pop r18 # load a one byte expression off stack pop r20 # load a one byte expression off stack pop r22 # receiver will be passed as first param # load a two byte expression off stack pop r24 pop r25 call Solver_move jmp MJ_L124 # else label for if MJ_L122: # done label for if MJ_L124: # done label for if MJ_L113: # done label for if MJ_L102: # done label for if MJ_L91: # done label for if MJ_L80: # done label for if MJ_L69: # done label for if MJ_L58: # done label for if MJ_L47: /* epilogue start for Solver_move */ # no return value # pop space off stack for parameters and locals pop r30 pop r30 pop r30 pop r30 pop r30 pop r30 # restoring the frame pointer pop r28 pop r29 ret .size Solver_move, .-Solver_move .text .global Solver_mazeRow .type Solver_mazeRow, @function Solver_mazeRow: push r29 push r28 # make space for locals and params ldi r30, 0 push r30 push r30 push r30 push r30 push r30 # Copy stack pointer to frame pointer in r28,__SP_L__ in r29,__SP_H__ # save off parameters std Y + 2, r25 std Y + 1, r24 std Y + 3, r22 std Y + 4, r20 std Y + 5, r18 /* done with function Solver_mazeRow prologue */ # IdExp # load value for variable startcol # variable is a local or param variable # load a one byte variable from base+offset ldd r24, Y + 3 # push one byte expression onto stack push r24 # IdExp # load value for variable row # variable is a local or param variable # load a one byte variable from base+offset ldd r24, Y + 5 # push one byte expression onto stack push r24 # Color expression Meggy.Color.VIOLET ldi r22,6 # push one byte expression onto stack push r22 ### Meggy.setPixel(x,y,color) call # load a one byte expression off stack pop r20 # load a one byte expression off stack pop r22 # load a one byte expression off stack pop r24 call _Z6DrawPxhhh call _Z12DisplaySlatev #### if statement # IdExp # load value for variable startcol # variable is a local or param variable # load a one byte variable from base+offset ldd r24, Y + 3 # push one byte expression onto stack push r24 # IdExp # load value for variable endcol # variable is a local or param variable # load a one byte variable from base+offset ldd r24, Y + 4 # push one byte expression onto stack push r24 # less than expression # load a one byte expression off stack pop r18 # load a one byte expression off stack pop r24 cp r24, r18 brlt MJ_L137 # load false MJ_L136: ldi r24, 0 jmp MJ_L138 # load true MJ_L137: ldi r24, 1 # push result of less than MJ_L138: # push one byte expression onto stack push r24 # load condition and branch if false # load a one byte expression off stack pop r24 #load zero into reg ldi r25, 0 #use cp to set SREG cp r24, r25 #WANT breq MJ_L133 brne MJ_L134 jmp MJ_L133 # then label for if MJ_L134: # loading the implicit "this" # load a two byte variable from base+offset ldd r31, Y + 2 ldd r30, Y + 1 # push two byte expression onto stack push r31 push r30 # IdExp # load value for variable startcol # variable is a local or param variable # load a one byte variable from base+offset ldd r24, Y + 3 # push one byte expression onto stack push r24 # Load constant int 1 ldi r24,lo8(1) ldi r25,hi8(1) # push two byte expression onto stack push r25 push r24 # Casting int to byte by popping # 2 bytes off stack and only pushing low order bits # back on. Low order bits are on top of stack. pop r24 pop r25 push r24 # load a one byte expression off stack pop r18 # load a one byte expression off stack pop r24 # promoting a byte to an int tst r24 brlt MJ_L139 ldi r25, 0 jmp MJ_L140 MJ_L139: ldi r25, hi8(-1) MJ_L140: # promoting a byte to an int tst r18 brlt MJ_L141 ldi r19, 0 jmp MJ_L142 MJ_L141: ldi r19, hi8(-1) MJ_L142: # Do add operation add r24, r18 adc r25, r19 # push two byte expression onto stack push r25 push r24 # Casting int to byte by popping # 2 bytes off stack and only pushing low order bits # back on. Low order bits are on top of stack. pop r24 pop r25 push r24 # IdExp # load value for variable endcol # variable is a local or param variable # load a one byte variable from base+offset ldd r24, Y + 4 # push one byte expression onto stack push r24 # IdExp # load value for variable row # variable is a local or param variable # load a one byte variable from base+offset ldd r24, Y + 5 # push one byte expression onto stack push r24 #### function call # put parameter values into appropriate registers # load a one byte expression off stack pop r18 # load a one byte expression off stack pop r20 # load a one byte expression off stack pop r22 # receiver will be passed as first param # load a two byte expression off stack pop r24 pop r25 call Solver_mazeRow jmp MJ_L135 # else label for if MJ_L133: # done label for if MJ_L135: /* epilogue start for Solver_mazeRow */ # no return value # pop space off stack for parameters and locals pop r30 pop r30 pop r30 pop r30 pop r30 # restoring the frame pointer pop r28 pop r29 ret .size Solver_mazeRow, .-Solver_mazeRow .text .global Solver_mazeCol .type Solver_mazeCol, @function Solver_mazeCol: push r29 push r28 # make space for locals and params ldi r30, 0 push r30 push r30 push r30 push r30 push r30 # Copy stack pointer to frame pointer in r28,__SP_L__ in r29,__SP_H__ # save off parameters std Y + 2, r25 std Y + 1, r24 std Y + 3, r22 std Y + 4, r20 std Y + 5, r18 /* done with function Solver_mazeCol prologue */ # IdExp # load value for variable col # variable is a local or param variable # load a one byte variable from base+offset ldd r24, Y + 3 # push one byte expression onto stack push r24 # IdExp # load value for variable startrow # variable is a local or param variable # load a one byte variable from base+offset ldd r24, Y + 4 # push one byte expression onto stack push r24 # Color expression Meggy.Color.VIOLET ldi r22,6 # push one byte expression onto stack push r22 ### Meggy.setPixel(x,y,color) call # load a one byte expression off stack pop r20 # load a one byte expression off stack pop r22 # load a one byte expression off stack pop r24 call _Z6DrawPxhhh call _Z12DisplaySlatev #### if statement # IdExp # load value for variable startrow # variable is a local or param variable # load a one byte variable from base+offset ldd r24, Y + 4 # push one byte expression onto stack push r24 # IdExp # load value for variable endrow # variable is a local or param variable # load a one byte variable from base+offset ldd r24, Y + 5 # push one byte expression onto stack push r24 # less than expression # load a one byte expression off stack pop r18 # load a one byte expression off stack pop r24 cp r24, r18 brlt MJ_L147 # load false MJ_L146: ldi r24, 0 jmp MJ_L148 # load true MJ_L147: ldi r24, 1 # push result of less than MJ_L148: # push one byte expression onto stack push r24 # load condition and branch if false # load a one byte expression off stack pop r24 #load zero into reg ldi r25, 0 #use cp to set SREG cp r24, r25 #WANT breq MJ_L143 brne MJ_L144 jmp MJ_L143 # then label for if MJ_L144: # loading the implicit "this" # load a two byte variable from base+offset ldd r31, Y + 2 ldd r30, Y + 1 # push two byte expression onto stack push r31 push r30 # IdExp # load value for variable col # variable is a local or param variable # load a one byte variable from base+offset ldd r24, Y + 3 # push one byte expression onto stack push r24 # IdExp # load value for variable startrow # variable is a local or param variable # load a one byte variable from base+offset ldd r24, Y + 4 # push one byte expression onto stack push r24 # Load constant int 1 ldi r24,lo8(1) ldi r25,hi8(1) # push two byte expression onto stack push r25 push r24 # Casting int to byte by popping # 2 bytes off stack and only pushing low order bits # back on. Low order bits are on top of stack. pop r24 pop r25 push r24 # load a one byte expression off stack pop r18 # load a one byte expression off stack pop r24 # promoting a byte to an int tst r24 brlt MJ_L149 ldi r25, 0 jmp MJ_L150 MJ_L149: ldi r25, hi8(-1) MJ_L150: # promoting a byte to an int tst r18 brlt MJ_L151 ldi r19, 0 jmp MJ_L152 MJ_L151: ldi r19, hi8(-1) MJ_L152: # Do add operation add r24, r18 adc r25, r19 # push two byte expression onto stack push r25 push r24 # Casting int to byte by popping # 2 bytes off stack and only pushing low order bits # back on. Low order bits are on top of stack. pop r24 pop r25 push r24 # IdExp # load value for variable endrow # variable is a local or param variable # load a one byte variable from base+offset ldd r24, Y + 5 # push one byte expression onto stack push r24 #### function call # put parameter values into appropriate registers # load a one byte expression off stack pop r18 # load a one byte expression off stack pop r20 # load a one byte expression off stack pop r22 # receiver will be passed as first param # load a two byte expression off stack pop r24 pop r25 call Solver_mazeCol jmp MJ_L145 # else label for if MJ_L143: # done label for if MJ_L145: /* epilogue start for Solver_mazeCol */ # no return value # pop space off stack for parameters and locals pop r30 pop r30 pop r30 pop r30 pop r30 # restoring the frame pointer pop r28 pop r29 ret .size Solver_mazeCol, .-Solver_mazeCol