.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(3) ldi r25, hi8(3) # allocating object of size 3 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 Dotrun /* epilogue start */ endLabel: jmp endLabel ret .size main, .-main .text .global Dotrun .type Dotrun, @function Dotrun: 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 /* done with function Dotrun prologue */ # Push Meggy.Tone.C3 onto the stack. ldi r25, hi8(61157) ldi r24, lo8(61157) # push two byte expression onto stack push r25 push r24 ### AssignStatement # load rhs exp # load a two byte expression off stack pop r24 pop r25 # store rhs into var localvar std Y + 4, r25 std Y + 3, r24 # Color expression Meggy.Color.ORANGE ldi r22,2 # push one byte expression onto stack push r22 ### AssignStatement # load rhs exp # load a one byte expression off stack pop r24 # loading the implicit "this" # load a two byte variable from base+offset ldd r31, Y + 2 ldd r30, Y + 1 # store rhs into var dotcolor std Z + 2, r24 # Load constant int 3 ldi r24,lo8(3) ldi r25,hi8(3) # 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 ### AssignStatement # load rhs exp # load a one byte expression off stack pop r24 # loading the implicit "this" # load a two byte variable from base+offset ldd r31, Y + 2 ldd r30, Y + 1 # store rhs into var curr_x std Z + 0, 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 ### AssignStatement # load rhs exp # load a one byte expression off stack pop r24 # loading the implicit "this" # load a two byte variable from base+offset ldd r31, Y + 2 ldd r30, Y + 1 # store rhs into var curr_y std Z + 1, r24 #### while statement MJ_L0: # True/1 expression ldi r22, 1 # push one byte expression onto stack push r22 # if not(condition) # load a one byte expression off stack pop r24 ldi r25,0 cp r24, r25 # WANT breq MJ_L2 brne MJ_L1 jmp MJ_L2 # while loop body MJ_L1: #### if statement ### MeggyCheckButton call _Z16CheckButtonsDownv lds r24, Button_Up # if button value is zero, push 0 else push 1 tst r24 breq MJ_L6 MJ_L7: ldi r24, 1 jmp MJ_L8 MJ_L6: MJ_L8: # 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_L3 brne MJ_L4 jmp MJ_L3 # then label for if MJ_L4: # 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 curr_x # loading the implicit "this" # load a two byte variable from base+offset ldd r31, Y + 2 ldd r30, Y + 1 # variable is a member variable # load a one byte variable from base+offset ldd r24, Z + 0 # push one byte expression onto stack push r24 # IdExp # load value for variable curr_y # loading the implicit "this" # load a two byte variable from base+offset ldd r31, Y + 2 ldd r30, Y + 1 # variable is a member variable # load a one byte variable from base+offset ldd r24, Z + 1 # 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_L9 ldi r25, 0 jmp MJ_L10 MJ_L9: ldi r25, hi8(-1) MJ_L10: # promoting a byte to an int tst r18 brlt MJ_L11 ldi r19, 0 jmp MJ_L12 MJ_L11: ldi r19, hi8(-1) MJ_L12: # 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 Dotmovedot # IdExp # load value for variable localvar # variable is a local or param variable # load a two byte variable from base+offset ldd r25, Y + 4 ldd r24, Y + 3 # push two byte expression onto stack push r25 push r24 # Load constant int 50 ldi r24,lo8(50) ldi r25,hi8(50) # push two byte expression onto stack push r25 push r24 ### Meggy.toneStart(tone, time_ms) call # load a two byte expression off stack pop r22 pop r23 # load a two byte expression off stack pop r24 pop r25 call _Z10Tone_Startjj jmp MJ_L5 # else label for if MJ_L3: # done label for if MJ_L5: #### if statement ### MeggyCheckButton call _Z16CheckButtonsDownv lds r24, Button_Down # if button value is zero, push 0 else push 1 tst r24 breq MJ_L16 MJ_L17: ldi r24, 1 jmp MJ_L18 MJ_L16: MJ_L18: # 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_L13 brne MJ_L14 jmp MJ_L13 # then label for if MJ_L14: # 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 curr_x # loading the implicit "this" # load a two byte variable from base+offset ldd r31, Y + 2 ldd r30, Y + 1 # variable is a member variable # load a one byte variable from base+offset ldd r24, Z + 0 # push one byte expression onto stack push r24 # IdExp # load value for variable curr_y # loading the implicit "this" # load a two byte variable from base+offset ldd r31, Y + 2 ldd r30, Y + 1 # variable is a member variable # load a one byte variable from base+offset ldd r24, Z + 1 # 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_L19 ldi r25, 0 jmp MJ_L20 MJ_L19: ldi r25, hi8(-1) MJ_L20: # promoting a byte to an int tst r18 brlt MJ_L21 ldi r19, 0 jmp MJ_L22 MJ_L21: ldi r19, hi8(-1) MJ_L22: # 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 Dotmovedot # IdExp # load value for variable localvar # variable is a local or param variable # load a two byte variable from base+offset ldd r25, Y + 4 ldd r24, Y + 3 # push two byte expression onto stack push r25 push r24 # Load constant int 50 ldi r24,lo8(50) ldi r25,hi8(50) # push two byte expression onto stack push r25 push r24 ### Meggy.toneStart(tone, time_ms) call # load a two byte expression off stack pop r22 pop r23 # load a two byte expression off stack pop r24 pop r25 call _Z10Tone_Startjj jmp MJ_L15 # else label for if MJ_L13: # done label for if MJ_L15: #### if statement ### MeggyCheckButton call _Z16CheckButtonsDownv lds r24, Button_Left # if button value is zero, push 0 else push 1 tst r24 breq MJ_L26 MJ_L27: ldi r24, 1 jmp MJ_L28 MJ_L26: MJ_L28: # 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_L23 brne MJ_L24 jmp MJ_L23 # then label for if MJ_L24: # 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 curr_x # loading the implicit "this" # load a two byte variable from base+offset ldd r31, Y + 2 ldd r30, Y + 1 # variable is a member variable # load a one byte variable from base+offset ldd r24, Z + 0 # 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_L29 ldi r25, 0 jmp MJ_L30 MJ_L29: ldi r25, hi8(-1) MJ_L30: # promoting a byte to an int tst r18 brlt MJ_L31 ldi r19, 0 jmp MJ_L32 MJ_L31: ldi r19, hi8(-1) MJ_L32: # 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 curr_y # loading the implicit "this" # load a two byte variable from base+offset ldd r31, Y + 2 ldd r30, Y + 1 # variable is a member variable # load a one byte variable from base+offset ldd r24, Z + 1 # 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 Dotmovedot # IdExp # load value for variable localvar # variable is a local or param variable # load a two byte variable from base+offset ldd r25, Y + 4 ldd r24, Y + 3 # push two byte expression onto stack push r25 push r24 # Load constant int 50 ldi r24,lo8(50) ldi r25,hi8(50) # push two byte expression onto stack push r25 push r24 ### Meggy.toneStart(tone, time_ms) call # load a two byte expression off stack pop r22 pop r23 # load a two byte expression off stack pop r24 pop r25 call _Z10Tone_Startjj jmp MJ_L25 # else label for if MJ_L23: # done label for if MJ_L25: #### if statement ### MeggyCheckButton call _Z16CheckButtonsDownv lds r24, Button_Right # if button value is zero, push 0 else push 1 tst r24 breq MJ_L36 MJ_L37: ldi r24, 1 jmp MJ_L38 MJ_L36: MJ_L38: # 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_L33 brne MJ_L34 jmp MJ_L33 # then 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 curr_x # loading the implicit "this" # load a two byte variable from base+offset ldd r31, Y + 2 ldd r30, Y + 1 # variable is a member variable # load a one byte variable from base+offset ldd r24, Z + 0 # 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_L39 ldi r25, 0 jmp MJ_L40 MJ_L39: ldi r25, hi8(-1) MJ_L40: # promoting a byte to an int tst r18 brlt MJ_L41 ldi r19, 0 jmp MJ_L42 MJ_L41: ldi r19, hi8(-1) MJ_L42: # 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 curr_y # loading the implicit "this" # load a two byte variable from base+offset ldd r31, Y + 2 ldd r30, Y + 1 # variable is a member variable # load a one byte variable from base+offset ldd r24, Z + 1 # 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 Dotmovedot # IdExp # load value for variable localvar # variable is a local or param variable # load a two byte variable from base+offset ldd r25, Y + 4 ldd r24, Y + 3 # push two byte expression onto stack push r25 push r24 # Load constant int 50 ldi r24,lo8(50) ldi r25,hi8(50) # push two byte expression onto stack push r25 push r24 ### Meggy.toneStart(tone, time_ms) call # load a two byte expression off stack pop r22 pop r23 # load a two byte expression off stack pop r24 pop r25 call _Z10Tone_Startjj jmp MJ_L35 # else label for if MJ_L33: # done label for if MJ_L35: # Load constant int 100 ldi r24,lo8(100) ldi r25,hi8(100) # 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 # jump to while test jmp MJ_L0 # end of while MJ_L2: /* epilogue start for Dotrun */ # no return value # 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 Dotrun, .-Dotrun .text .global Dotmovedot .type Dotmovedot, @function Dotmovedot: 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 Dotmovedot prologue */ #### 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 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 DotinBounds # 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_L43 brne MJ_L44 jmp MJ_L43 # then label for if MJ_L44: # IdExp # load value for variable curr_x # loading the implicit "this" # load a two byte variable from base+offset ldd r31, Y + 2 ldd r30, Y + 1 # variable is a member variable # load a one byte variable from base+offset ldd r24, Z + 0 # push one byte expression onto stack push r24 # IdExp # load value for variable curr_y # loading the implicit "this" # load a two byte variable from base+offset ldd r31, Y + 2 ldd r30, Y + 1 # variable is a member variable # load a one byte variable from base+offset ldd r24, Z + 1 # push one byte expression onto stack push r24 # Color expression Meggy.Color.DARK ldi r22,0 # 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 # 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 # IdExp # load value for variable dotcolor # loading the implicit "this" # load a two byte variable from base+offset ldd r31, Y + 2 ldd r30, Y + 1 # variable is a member variable # load a one byte variable from base+offset ldd r24, Z + 2 # push one byte expression onto stack push r24 ### 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 # 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 ### AssignStatement # load rhs exp # load a one byte expression off stack pop r24 # loading the implicit "this" # load a two byte variable from base+offset ldd r31, Y + 2 ldd r30, Y + 1 # store rhs into var curr_x std Z + 0, 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 ### AssignStatement # load rhs exp # load a one byte expression off stack pop r24 # loading the implicit "this" # load a two byte variable from base+offset ldd r31, Y + 2 ldd r30, Y + 1 # store rhs into var curr_y std Z + 1, r24 jmp MJ_L45 # else label for if MJ_L43: # done label for if MJ_L45: /* epilogue start for Dotmovedot */ # no return value # 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 Dotmovedot, .-Dotmovedot .text .global DotinBounds .type DotinBounds, @function DotinBounds: 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 DotinBounds 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_L47 # load false MJ_L46: ldi r24, 0 jmp MJ_L48 # load true MJ_L47: ldi r24, 1 # push result of less than MJ_L48: # 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_L49 brne MJ_L50 jmp MJ_L49 MJ_L50: # 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_L52 # load false MJ_L51: ldi r24, 0 jmp MJ_L53 # load true MJ_L52: ldi r24, 1 # push result of less than MJ_L53: # 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_L49: # &&: 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_L54 brne MJ_L55 jmp MJ_L54 MJ_L55: # 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_L57 # load false MJ_L56: ldi r24, 0 jmp MJ_L58 # load true MJ_L57: ldi r24, 1 # push result of less than MJ_L58: # 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_L54: # &&: 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_L59 brne MJ_L60 jmp MJ_L59 MJ_L60: # 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_L62 # load false MJ_L61: ldi r24, 0 jmp MJ_L63 # load true MJ_L62: ldi r24, 1 # push result of less than MJ_L63: # 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_L59: /* epilogue start for DotinBounds */ # handle return value # load a one byte expression off stack pop r24 # 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 DotinBounds, .-DotinBounds