Edinburgh IMP77 Compiler - Version 8.4 1 %BEGIN .Ltext0: .align 2 RELEASECHAIN.7846: .LFB186: .LVL668: sub sp, sp, #3504 sub sp, sp, #65536 stp x29, x30, [sp] add x29, sp, 0 stp x19, x20, [sp, 16] stp x21, x22, [sp, 32] stp x23, x24, [sp, 48] stp x25, x26, [sp, 64] stp x27, x28, [sp, 80] adrp x2, :got:__stack_chk_guard ldr x2, [x2, #:got_lo12:__stack_chk_guard] add x3, x29, 65536 add x3, x3, 16 ldr x4, [x2] str x4, [x3, 3480] mov x4,0 add x2, x29, 65536 add x2, x2, 3504 str x2, [x29, 5008] 2 %CONSTINTEGER BIT = X'80000000' bl _imp_initialise .LVL669: 3 %CONSTINTEGER MAX SCORE = +50000 4 !! 5 %EXTERNALROUTINESPEC PROMPT(%STRING (255) S) 6 7 8 %CONSTINTEGER PLYWIDTH = 5 9 %RECORDFORMAT SQF(%INTEGER P, ATT, DEF, ATTP) 10 { %RECORDFORMAT ROWF(%RECORD %ARRAY R(1:8)(SQF)) 11 %RECORDFORMAT ROWF(%RECORD (SQF) %ARRAY R(1:8)) 12 13 %OWN %RECORD(ROWF)%ARRAY BRD(1:8) 14 %OWN %RECORD(ROWF)%ARRAY BRDOLD(1:8) 15 %INTEGERARRAY VAL(-6:6) 16 17 !! PIECE = BRD(Y)_R(X)_P 18 19 %RECORDFORMAT LISTF(%RECORD(LISTF)%NAME L, %INTEGER SCORE %or %integer HOLD, %C 20 %BYTEINTEGER FR, TO, %INTEGER SPEC, CHK) 21 !! SCORE - CONTAINS SCORE FOR THE MOVE 22 !! SPEC - CONTAINS FLAGS FOR QUEENING, CASTLING 23 !! CHK - OPPOSING KING IS IN CHECK 24 25 !!%RECORDFORMAT QHF(%RECORD(LISTF)%NAME L,%INTEGER HOLD) 26 {%RECORDSPEC QHF_L(LISTF) 27 !! 28 %RECORDFORMAT PTF(%INTEGERNAME P) 29 %RECORD(PTF)%ARRAY PT(1:64) 30 !! 31 %CONSTINTEGER KING = 6; ! NB: AND -6 32 %CONSTINTEGER QUEEN = 5; ! AND -5 33 %CONSTINTEGER ROOK = 4; ! AND -4 34 %CONSTINTEGER PAWN = 1; ! AND -1 35 !! 36 37 %RECORD(LISTF)%NAME FREELIST 38 %RECORD(LISTF{QHF}) MOVE 39 %RECORD(LISTF)%ARRAY LISTA(0:4000) 40 %RECORD (SQF) %NAME SQ 41 !! 42 %OWNINTEGERARRAY PINX(1:32) = 0(32) 43 %OWNINTEGERARRAY PINY(1:32) = 0(32) 44 %INTEGERARRAY PINDX, PINPY(1:32) 45 %OWNINTEGER PIN PT, PX, PY 46 !! 47 %RECORDFORMAT SQIF(%RECORD(SQF)%NAME SQ) 48 {%RECORDSPEC SQIF_SQ(SQF) 49 %RECORD(SQIF)%ARRAY SQI(1:64) 50 %CONSTINTEGERARRAY BIT VAL(1:6)=256,64,32,8,2,1 adrp x0, .LANCHOR1 add x0, x0, :lo12:.LANCHOR1 ldp x2, x3, [x0, 384] add x1, x29, 4096 add x1, x1, 528 stp x2, x3, [x1, 24] ldr x0, [x0, 400] str x0, [x29, 4664] 51 !! 52 %CONSTINTEGERARRAY PAWN 2D(9:72) = %C adrp x19, .LANCHOR4 add x19, x19, :lo12:.LANCHOR4 mov x2, 256 add x1, x19, 48 add x0, x29, 4096 add x0, x0, 296 bl memcpy .LVL670: 53 0, 0, 0, 0, 0, 0, 0, 0, 54 0, 0, 0, 0, 0, 5, 0, 0, 55 3, 3, 3, 20, 20, 3, 3, 3, 56 4, 6, 6, 50, 50, 6, 6, 4, 57 8, 9, 30, 55, 55, 30, 9, 8, 58 10, 10, 35, 60, 60, 35, 10, 10, 59 100(8), 60 500(8) 61 !! 62 %CONSTBYTEINTEGERARRAY POSX(1:12) = %C mov w0, 2 add x1, x29, 4096 add x1, x1, 16 strb w0, [x1, 880] mov w0, 3 strb w0, [x1, 881] mov w0, 6 strb w0, [x1, 882] mov w0, 7 strb w0, [x1, 883] mov w0, 58 strb w0, [x1, 884] mov w0, 59 strb w0, [x1, 885] mov w0, 62 strb w0, [x1, 886] mov w0, 63 strb w0, [x1, 887] mov w0, 1 strb w0, [x1, 888] mov w0, 8 strb w0, [x1, 889] mov w0, 57 strb w0, [x1, 890] mov w0, 64 strb w0, [x1, 891] 63 2, 3, 6, 7, 58, 59, 62, 63, 1, 8, 57, 64 64 %CONSTINTEGERARRAY POSP(1:12) = %C ldp x2, x3, [x19, 304] stp x2, x3, [x1, 232] ldp x2, x3, [x19, 320] stp x2, x3, [x1, 248] ldp x0, x1, [x19, 336] add x2, x29, 4096 add x2, x2, 528 stp x0, x1, [x2, -248] 65 -2, -3, -3, -2, 2, 3, 3, 2, -4, -4, 4, 4 66 %CONSTINTEGERARRAY POSPP(1:12) = %C ldp x2, x3, [x19, 352] add x1, x29, 4096 add x1, x1, 16 stp x2, x3, [x1, 184] ldp x2, x3, [x19, 368] stp x2, x3, [x1, 200] ldp x0, x1, [x19, 384] add x2, x29, 4096 add x2, x2, 16 stp x0, x1, [x2, 216] 67 -7(4), 7(4), -10(2), 10(2) 68 !! 69 %CONSTINTEGERARRAY NOLEG MOVE(-1:1) = -24000, 0, 24000 mov w0, -24000 str w0, [x29, 4980] str wzr, [x29, 4984] mov w0, 24000 str w0, [x29, 4988] .LVL671: add x1, x29, 4096 add x1, x1, 920 add x0, x1, 16 add x1, x1, 61440 add x1, x1, 2576 .LVL672: .L386: .LBB635: 70 !! 71 %OWNBYTEINTEGERARRAY KMOVE(-1:1) = 0(3) 72 %OWNINTEGERARRAY KCAS(-1:1) = 0(3) 73 !! 74 %RECORD (LISTF)LM 75 %RECORD (LISTF{QHF})MMOVE 76 !! 77 78 79 %INTEGER I, X, Y, PLAY 80 %OWNLONGREAL TIME, TIME2, TIMTT = 15 81 %OWNINTEGER NO = 1, SCOREA, XDEPTH, PDEPTH, MON, JUST ONE PLY 82 %OWNINTEGER CHK, LAST CHK, PIN REMOVE 83 !! 84 %EXTERNALLONGREALFNSPEC CPU TIME 85 !! 86 %INTEGERFNSPEC N PLY(%INTEGER WHICH, DEPTH, %RECORD(LISTF)%NAME CHAIN) 87 %INTEGERFNSPEC SORT AND PRUNE(%RECORD(LISTF)%NAME LIST, %C 88 %INTEGER WIDTH, WHICH) 89 %INTEGERFNSPEC SCORE(%INTEGER WHICH, %RECORD (LISTF)%NAME L) 90 %INTEGERFNSPEC MOVES(%INTEGER WHICH, SCRQ) 91 %INTEGERFNSPEC ONEPLY(%INTEGER WHICH, WIDTH) 92 %INTEGERFNSPEC CHANGE BOARD(%RECORD(LISTF{QHF})%NAME B) 93 %ROUTINESPEC RESTORE BOARD(%RECORD(LISTF{QHF})%NAME B) 94 %ROUTINESPEC BURP(%RECORD (LISTF{QHF}) %NAME X, %INTEGER W) 95 %ROUTINESPEC TELL(%RECORD (LISTF)%NAME MOVE, %INTEGER WHICH) 96 %ROUTINESPEC PRINT BOARD 97 %ROUTINESPEC PRINTMOVE(%RECORD (LISTF)%NAME LIST) 98 %INTEGERFNSPEC CHECK YOUR MOVE(%RECORD (LISTF)%NAME LIST) 99 %ROUTINESPEC YOUR MOVE 100 101 !**** INITIALISATION ETC 102 103 %CYCLE I = 0, 1, 4000-1 104 LISTA(I)_L == LISTA(I+1) str x0, [x0, -16] .LDL21: add x0, x0, 16 105 %REPEAT 106 FREELIST == LISTA(0) add x0, x29, 4096 add x0, x0, 920 str x0, [x29, 4288] .LVL673: .LBB636: .LBB637: adrp x0, :got:_imp_InStream ldr x0, [x0, #:got_lo12:_imp_InStream] mov w1, 1 str w1, [x0] adrp x0, :got:_imp_infile ldr x0, [x0, #:got_lo12:_imp_infile] ldr x1, [x0, 296] adrp x0, :got:_imp_InFile ldr x0, [x0, #:got_lo12:_imp_InFile] str x1, [x0] adrp x0, .LANCHOR4 add x0, x0, :lo12:.LANCHOR4 add x0, x0, 400 bl check_instream .LVL674: add x0, x29, 3232 add x20, x0, 1696 add x19, x0, 1748 .LVL675: .L388: .LBE637: .LBE636: 107 !! 108 SELECTINPUT(1) cmp x0, x1 bne .L386 .L387: .LBE635: 109 %CYCLE I = -6, 1, 6 110 READ(VAL(I)) mov x0, x20 bl _imp_readint .LVL676: .LDL22: add x20, x20, 4 111 %REPEAT 112 READ(PDEPTH) cmp x20, x19 bne .L388 .L389: adrp x19, .LANCHOR0 add x19, x19, :lo12:.LANCHOR0 add x0, x19, 1092 bl _imp_readint .LVL677: 113 READ(MON); READ(PLAY) add x0, x19, 1088 bl _imp_readint .LVL678: 114 I = 1 add x0, x29, 372 bl _imp_readint .LVL679: mov w20, 0 mov x21, x19 .LVL681: .L390: 115 %CYCLE Y = 1,1,8 116 %CYCLE X = 1,1,8 117 SQ == BRD(Y)_R(X) 118 READ(SQ_P) mov x0, x21 bl _imp_readint .LVL682: cmp w20, 64 bne .L392 .L391: .LVL687: .LBB638: .LBB639: adrp x0, :got:_imp_InStream ldr x0, [x0, #:got_lo12:_imp_InStream] str wzr, [x0] adrp x0, :got:_imp_infile ldr x0, [x0, #:got_lo12:_imp_infile] ldr x1, [x0, 8] .LVL688: adrp x0, :got:_imp_InFile ldr x0, [x0, #:got_lo12:_imp_InFile] str x1, [x0] adrp x22, .LANCHOR4 .LVL689: add x22, x22, :lo12:.LANCHOR4 add x0, x22, 400 bl check_instream .LVL690: .LBE639: .LBE638: 119 SQI(I)_SQ == SQ add x22, x29, 3232 .LVL680: .L392: add w23, w20, 8 sxtw x0, w20 add x1, x0, 68 str x21, [x22, x1, lsl 3] cmp w20, w23 bne .L390 .LDL24: .LDL25: .LVL686: add x19, x19, 128 120 PT(I)_P == SQ_P; I = I+1 add x0, x0, 4 str x21, [x22, x0, lsl 3] .LDL23: .LVL683: add x21, x21, 16 .LVL684: add w20, w20, 1 .LVL685: 121 %REPEAT 122 %REPEAT 123 SELECT INPUT(0) 124 MMOVE_HOLD = 0; MOVE_HOLD = 0 125 LM_SCORE = 0; LM_CHK = 0 str wzr, [x29, 400] str wzr, [x29, 3240] 126 MMOVE_L == LM str wzr, [x29, 3244] add x0, x29, 3232 str x0, [x29, 3248] .LBB640: 127 PRINTSTRING("Version 2.5 add x21, x29, 2976 .LVL691: mov x19, 256 mov x2, x19 add x1, x22, 424 mov x0, x21 bl memcpy .LVL692: add x20, x29, 416 .LVL693: mov x2, x19 mov x1, x21 mov x0, x20 bl memcpy .LVL694: add x23, x29, 1184 mov x2, x19 mov x1, x20 mov x0, x23 bl memcpy .LVL695: .LBE640: .LBB641: .LBB642: add x20, x29, 112 mov x2, x19 mov x1, x23 mov x0, x20 bl memcpy .LVL696: mov x0, x20 bl _imp_printstring .LVL697: .LBE642: .LBE641: .LBB643: 128 HOW DIFFICULT A GAME DO YOU WANT? 129 2 = NORMAL STRENGTH, 3 = MORE DIFFICULT 130 ") 131 PROMPT("2-4?") mov x2, x19 add x1, x22, 680 mov x0, x21 bl memcpy .LVL698: add x23, x29, 672 mov x2, x19 mov x1, x21 mov x0, x23 bl memcpy .LVL699: .LBE643: mov x2, x19 mov x1, x23 mov x0, x20 bl memcpy .LVL700: mov x0, x20 bl PROMPT .LVL701: 132 READ(PDEPTH); SKIPSYMBOL adrp x23, .LANCHOR0 add x23, x23, :lo12:.LANCHOR0 add x0, x23, 1092 bl _imp_readint .LVL702: .LBB644: .LBB645: bl _imp_skipsymbol .LVL703: .LBE645: .LBE644: .LBB646: 133 PROMPT("Move?") mov x2, x19 add x1, x22, 936 mov x0, x21 bl memcpy .LVL704: add x0, x29, 928 mov x2, x19 mov x1, x21 mov x21, x0 bl memcpy .LVL705: .LBE646: mov x2, x19 mov x1, x21 mov x0, x20 bl memcpy .LVL706: mov x0, x20 bl PROMPT .LVL707: 134 PRINTBOARD bl PRINTBOARD.7804 .LVL708: 135 !! 136 !! 137 !! N B WHITE PIECES ARE -VE, BLACK ARE +VE 138 !! 139 !**** MAIN LOOP 140 TIME2 = CPUTIME bl CPUTIME .LVL709: str d0, [x23, 1048] .LBB647: .LBB648: 141 %CYCLE 142 %IF PLAY = 1 %START ldr w0, [x29, 372] cmp w0, 1 beq .L434 .L395: .LBB727: .LBB720: 143 MOVE_L == RECORD(N PLY(-1, 0, MOVE)) add x20, x29, 400 mov x18, x25 mov x2, x20 mov w1, 0 mov w0, -1 bl NPLY.7779 .LVL710: sxtw x0, w0 .LVL711: str x0, [x29, 400] 144 TELL(MOVE_L, -1) mov w1, -1 bl TELL.7802 .LVL712: 145 I =CHANGE BOARD(MOVE) mov x0, x20 bl CHANGEBOARD.7794 .LVL713: 146 %FINISHELSESTART b .L396 .L435: .LBB722: .LBB719: 147 YOURMOVE 148 BURP(MMOVE, -1) add x0, x25, 16 str x0, [x29, 104] .LBB721: .LBB718: .LBB649: mov w1, -1 ldr x0, [x29, 104] bl BURP.7799 .LVL780: .L396: 149 %FINISH 150 TIME = CPUTIME bl CPUTIME .LVL781: adrp x0, .LANCHOR0+1040 str d0, [x0, #:lo12:.LANCHOR0+1040] 151 MOVE_L == RECORD(N PLY(+1, 0, MMOVE_L)) mov x18, x25 ldr x2, [x29, 3248] mov w1, 0 mov w0, 1 bl NPLY.7779 .LVL782: sxtw x0, w0 str x0, [x29, 400] 152 BURP(MOVE, +1) mov w1, 1 add x0, x29, 400 bl BURP.7799 .LVL783: 153 PRINTBOARD bl PRINTBOARD.7804 .LVL784: .LBB723: .LBB724: adrp x24, :got:_imp_OutStream ldr x24, [x24, #:got_lo12:_imp_OutStream] mov w0, 2 str w0, [x24] adrp x21, :got:_imp_OutFile ldr x21, [x21, #:got_lo12:_imp_OutFile] adrp x23, :got:_imp_outfile ldr x23, [x23, #:got_lo12:_imp_outfile] ldr x0, [x23, 584] str x0, [x21] adrp x20, .LANCHOR1 add x20, x20, :lo12:.LANCHOR1 add x20, x20, 3032 mov x0, x20 bl check_outstream .LVL785: .LBE724: .LBE723: 154 SELECT OUTPUT(2); PRINTBOARD; SELECT OUTPUT(0) 155 NO = NO+1 bl PRINTBOARD.7804 .LVL786: .LBB725: .LBB726: str wzr, [x24] ldr x0, [x23, 8] str x0, [x21] mov x0, x20 bl check_outstream .LVL787: .LBE726: .LBE725: adrp x1, .LANCHOR2 ldr w0, [x1, #:lo12:.LANCHOR2] add w0, w0, 1 str w0, [x1, #:lo12:.LANCHOR2] .L394: 156 %REPEAT 157 158 !! 159 %ROUTINE RELEASE CHAIN(%RECORD(LISTF)%NAME L) .LVL0: mov x2, x0 b .L2 .LVL1: .L4: 160 {%RECORDSPEC L(LISTF) 161 %RECORD(LISTF)%NAME L2 162 L2 == L 163 %WHILE ADDR(L_L) # 0 %CYCLE 164 L == L_L; ! GO TO BOTTOM OF CHAIN mov x2, x1 .LVL2: .L2: ldr x1, [x2] cbnz x1, .L4 .L3: 165 %REPEAT 166 L_L == FREELIST ldr x1, [x18, 1056] str x1, [x2] 167 FREELIST == RECORD(ADDR(L2)) str x0, [x18, 1056] 168 %END 169 !! ret .LFE186: .align 2 CHANGEBOARD.7794: .LFB196: 170 %INTEGERFN N PLY(%INTEGER WHICH, DEPTH, %RECORD(LISTF)%NAME CHAIN) .LVL580: sub sp, sp, #3168 stp x29, x30, [sp] add x29, sp, 0 stp x22, x23, [sp, 40] str x24, [sp, 56] str x26, [sp, 72] str x28, [sp, 88] mov w22, w0 str w0, [x29, 132] mov x28, x2 mov x24, x18 str x18, [x29, 136] adrp x0, :got:__stack_chk_guard .LVL581: ldr x0, [x0, #:got_lo12:__stack_chk_guard] ldr x2, [x0] str x2, [x29, 3160] mov x2,0 .LVL582: 171 %INTEGER I, XWHICH, J, SWIDTH, CI, FLAG 172 %RECORD(LISTF{QHF})%NAME BPT 173 %RECORD(LISTF{QHF})%ARRAY B(1:40) 174 %RECORD(LISTF)%NAME LIST, LISTX 175 176 %CONSTINTEGERARRAY XWIDTH(0:10) = 8, 8, 3(9) adrp x0, .LANCHOR1 add x0, x0, :lo12:.LANCHOR1 add x0, x0, 3840 ldp x2, x3, [x0] add x5, x29, 576 stp x2, x3, [x5, 104] ldp x2, x3, [x0, 16] stp x2, x3, [x5, 120] ldr x2, [x0, 32] str x2, [x29, 712] ldr w0, [x0, 40] str w0, [x29, 720] 177 !! 178 XDEPTH = DEPTH; ! HOLD FOR GLOBAL USE adrp x0, .LANCHOR0 add x0, x0, :lo12:.LANCHOR0 str w1, [x0, 1064] 179 DEPTH = DEPTH+1 add w23, w1, 1 .LVL583: 180 SWIDTH = XWIDTH(DEPTH) add x1, x29, 680 ldr w26, [x1, w23, sxtw 2] .LVL584: 181 %IF DEPTH=PDEPTH %THEN SWIDTH=1 ldr w0, [x0, 1092] 182 LAST CHK = CHAIN_CHK cmp w0, w23 csinc w26, w26, wzr, ne .LVL585: .L346: ldr w1, [x28, 12] adrp x0, .LANCHOR0+1076 str w1, [x0, #:lo12:.LANCHOR0+1076] .LVL586: .LBB510: .LBB511: 183 LIST == RECORD(ONE PLY(WHICH, SWIDTH)) 184 I = 1 185 B(1)_L == RECORD(0) str xzr, [x29, 2520] .LVL589: 186 FLAG = 0 str wzr, [x29, 156] add x27, x29, 2520 187 %WHILE ADDR(LIST)#0 %CYCLE 188 BPT == B(I) cbz w0, .L345 stp x19, x20, [x29, 16] str x21, [x29, 32] str x25, [x29, 64] str x27, [x29, 80] sxtw x20, w0 .LVL590: cbz x20, .L349 mov x19, x0 .LVL592: .L348: lsl x25, x19, 4 add x24, x27, x25 189 BPT_L == LIST str x20, [x24, -32] 190 LIST == LIST_L ldr x20, [x20] .LVL593: 191 %IF MON#0 %START adrp x21, .LANCHOR0 add x21, x21, :lo12:.LANCHOR0 .LBB512: ldr w0, [x21, 1088] cbnz w0, .L374 .L350: 192 SELECT OUTPUT(2) 193 SPACES(DEPTH*3) add w0, w23, w23, lsl 1 str w0, [x29, 152] mov x19, 2 194 WRITE(DEPTH, 1); SPACES(2); PRINTMOVE(BPT_L) mov w1, 1 mov w0, w23 bl _imp_writeint .LVL607: .LBB524: .LBB525: mov w0, w22 bl _imp_spaces .LVL608: .LBE525: .LBE524: 195 %IF LAST CHK#0 %THEN PRINTSTRING(" FORCED") ldr w0, [x21, 1076] cbnz w0, .L376 .L351: .LBB526: .LBB527: bl _imp_newline .LVL610: .LBE527: .LBE526: .LBB528: .LBB529: adrp x0, :got:_imp_OutStream ldr x0, [x0, #:got_lo12:_imp_OutStream] str wzr, [x0] adrp x0, :got:_imp_outfile ldr x0, [x0, #:got_lo12:_imp_outfile] ldr x1, [x0, 8] adrp x0, :got:_imp_OutFile ldr x0, [x0, #:got_lo12:_imp_OutFile] str x1, [x0] adrp x0, .LANCHOR1 add x0, x0, :lo12:.LANCHOR1 add x0, x0, 3032 bl check_outstream .LVL611: b .L350 .LVL612: .L376: .LBE529: .LBE528: .LBB530: 196 NEWLINE add x0, x29, 1752 str x0, [x29, 144] .LBE512: ldr x0, [x24, -32] bl PRINTMOVE.7806 .LVL609: mov x22, 256 mov x2, x22 adrp x1, .LANCHOR1 add x1, x1, :lo12:.LANCHOR1 add x1, x1, 3888 ldr x0, [x29, 144] bl memcpy .LVL613: add x0, x29, 728 mov x2, x22 ldr x1, [x29, 144] str x0, [x29, 120] bl memcpy .LVL614: add x0, x29, 2008 mov x2, x22 ldr x1, [x29, 120] str x0, [x29, 120] bl memcpy .LVL615: .LBE530: .LBB531: .LBB532: add x0, x29, 416 mov x2, x22 ldr x1, [x29, 120] mov x22, x0 bl memcpy .LVL616: mov x0, x22 bl _imp_printstring .LVL617: b .L351 .LVL618: .L375: add x0, x29, 2488 add x0, x0, x25 .LBE532: .LBE531: 197 SELECT OUTPUT(0) 198 %FINISH 199 I = I+1 mov w22, w19 .LVL594: 200 ! %EXIT %IF LIST == NULL; ! ONLY ONE MOVE ALLOWED 201 ! %EXIT %IF ADDR(LIST) = 0 %AND I = 2; ! SEE ABOVE 202 XWHICH = WHICH!!X'FFFFFFFE' 203 %IF DEPTH < PDEPTH %START ldr w0, [x21, 1092] cmp w0, w23 bgt .L375 .L352: .LVL595: .L354: 204 205 CI = CHANGE BOARD(BPT) str x0, [x29, 120] bl CHANGEBOARD.7794 .LVL619: 206 LISTX == RECORD(N PLY(XWHICH, DEPTH, BPT_L)) ldr x18, [x29, 136] ldr x2, [x24, -32] mov w1, w23 ldr w3, [x29, 132] eor w0, w3, -2 bl NPLY.7779 .LVL620: sxtw x25, w0 207 LAST CHK = CHAIN_CHK; ! REALLY FOR MONITORING ldr w0, [x28, 12] str w0, [x21, 1076] 208 RESTORE BOARD(BPT) ldr x0, [x29, 120] bl RESTOREBOARD.7796 .LVL621: 209 %UNLESS ADDR(LISTX)=0 %START cbnz x25, .L377 .L353: 210 BPT_L_SCORE = LISTX_SCORE; ! GET BEST OPP PIECE SCORE ldr x0, [x24, -32] ldr w1, [x25, 8] str w1, [x0, 8] 211 RELEASE CHAIN(LISTX); FLAG = FLAG+1 ldr x18, [x29, 136] mov x0, x25 bl RELEASECHAIN.7846 .LVL622: 212 %FINISHELSESTART ldr w0, [x29, 156] add w0, w0, 1 str w0, [x29, 156] .LVL623: b .L354 .L356: .LVL624: .L358: 213 BPT_L_SCORE = NO LEG MOVE(WHICH) add w0, w22, 1 add x0, x24, x0, sxtw 2 add x0, x0, 1744 str x0, [x29, 96] b .L348 .LVL591: .L355: add x0, x19, 1 ldr x0, [x24, -32] ldr x1, [x29, 96] ldr w1, [x1, 4] str w1, [x0, 8] b .L354 .L377: 214 ! %IF BPT_L_CHK = 0 %THEN BPT_L_SCORE = 0; ! ???? 215 %FINISH 216 %FINISH 217 %IF I > SWIDTH %START cmp w26, w22 bge .L355 218 %IF FLAG # 0 %OR I = 2 %THEN %EXIT; ! MOVE FOUND 219 %IF MON # 0 %START ldr w0, [x29, 156] cmp w0, 0 ccmp w22, 2, 4, eq beq .L358 .L357: ldr w0, [x21, 1088] cbz w0, .L355 .LVL596: .LBB513: .LBB514: adrp x0, :got:_imp_OutStream ldr x0, [x0, #:got_lo12:_imp_OutStream] mov x1, x0 mov w0, 2 str x1, [x29, 120] str w0, [x1] adrp x0, :got:_imp_OutFile ldr x25, [x0, #:got_lo12:_imp_OutFile] adrp x24, :got:_imp_outfile ldr x24, [x24, #:got_lo12:_imp_outfile] ldr x0, [x24, 584] str x0, [x25] adrp x0, .LANCHOR1 add x0, x0, :lo12:.LANCHOR1 add x2, x0, 3032 str x2, [x29, 112] mov x0, x2 bl check_outstream .LVL597: .LBE514: .LBE513: .LBB515: 220 SELECT OUTPUT(2) 221 PRINTSTRING("FORCED TO INCREASE PLYWIDTH mov x2, 256 adrp x1, .LANCHOR4 add x1, x1, :lo12:.LANCHOR4 sub x1, x1, #208 ldr x0, [x29, 144] bl memcpy .LVL598: add x0, x29, 984 mov x2, 256 ldr x1, [x29, 144] str x0, [x29, 104] bl memcpy .LVL599: add x0, x29, 2264 mov x2, 256 ldr x1, [x29, 104] str x0, [x29, 104] bl memcpy .LVL600: .LBE515: .LBB516: .LBB517: add x0, x29, 416 mov x2, 256 ldr x1, [x29, 104] str x0, [x29, 104] bl memcpy .LVL601: ldr x0, [x29, 104] bl _imp_printstring .LVL602: .LBE517: .LBE516: .LBB518: .LBB519: ldr x1, [x29, 120] str wzr, [x1] ldr x0, [x24, 8] str x0, [x25] ldr x0, [x29, 112] bl check_outstream .LVL603: b .L355 .LVL604: .L374: .LBE519: .LBE518: .LBB520: .LBB521: mov w22, 2 adrp x0, :got:_imp_OutStream ldr x0, [x0, #:got_lo12:_imp_OutStream] str w22, [x0] adrp x0, :got:_imp_outfile ldr x0, [x0, #:got_lo12:_imp_outfile] ldr x1, [x0, 584] adrp x0, :got:_imp_OutFile ldr x0, [x0, #:got_lo12:_imp_OutFile] str x1, [x0] adrp x0, .LANCHOR1 add x0, x0, :lo12:.LANCHOR1 add x0, x0, 3032 bl check_outstream .LVL605: .LBE521: .LBE520: .LBB522: .LBB523: ldr w0, [x29, 152] bl _imp_spaces .LVL606: .LBE523: .LBE522: 222 ") 223 SELECT OUTPUT(0) 224 %FINISH 225 !! IF NO LEGAL MOVE, SEARCH ALL MOVES ON THIS LEVEL 226 %FINISH 227 %REPEAT 228 RELEASE CHAIN(LIST) %IF ADDR(LIST)#0 cbz x20, .L349 229 LIST == RECORD(0) ldr x18, [x29, 136] mov x0, x20 bl RELEASECHAIN.7846 .LVL625: .L349: 230 %IF I = 1 %THEN %RESULT = 0; ! NO LEGAL MOVE cmp w22, 1 beq .L373 .L359: 231 %IF I = 2 %THEN %RESULT = ADDR(B(1)_L); ! SINGLE RESULT mov w0, 0 cmp w22, 2 beq .L378 .L360: .LVL626: .LBB533: 232 %CYCLE J = 1, 1, I-1 ldr w0, [x29, 2520] ldp x19, x20, [x29, 16] .LVL638: ldr x21, [x29, 32] ldr x25, [x29, 64] ldr x27, [x29, 80] b .L345 .LVL639: .L379: .LBB535: 233 B(J)_L_L == LIST ldr x2, [x1] str x0, [x2] 234 LIST == B(J)_L; ! STACK THE RESULTS cmp w22, #2 bmi .L379 .LVL627: .L361: ldr x0, [x1], 16 .LVL630: adrp x0, :got:_imp_current_file ldr x0, [x0, #:got_lo12:_imp_current_file] ldr x0, [x0] cbz x0, .L362 add x8, x29, 1496 bl _imp_c2istr .LVL640: .L363: adrp x0, :got:_imp_current_line ldr x0, [x0, #:got_lo12:_imp_current_line] ldr w21, [x0] cmp w21, 0 mov w0, 234 csel w21, w21, w0, ne add x24, x29, 1752 mov x8, x24 adrp x0, .LC37 add x0, x0, :lo12:.LC37 bl _imp_c2istr .LVL641: add x20, x29, 416 mov x25, 256 mov x2, x25 add x1, x29, 1496 mov x0, x20 bl memcpy .LVL642: add x23, x29, 160 mov x2, x25 mov x1, x24 mov x0, x23 bl memcpy .LVL643: mov w5, 0 mov w4, 1 mov w3, 5 mov x2, x23 mov w1, w21 mov x0, x20 bl _signal_event .LVL644: b .L361 .LVL645: .L362: .LBB534: add x21, x29, 1752 mov x23, 256 .LVL646: mov x2, x23 adrp x1, .LANCHOR1 add x1, x1, :lo12:.LANCHOR1 mov x0, x21 bl memcpy .LVL647: add x20, x29, 1240 mov x2, x23 mov x1, x21 mov x0, x20 bl memcpy .LVL648: .LBE534: mov x2, x23 mov x1, x20 add x0, x29, 1496 bl memcpy .LVL649: b .L363 .LVL650: .L370: 235 %REPEAT 236 %RESULT = SORT AND PRUNE(LIST, 1, WHICH) ldr x18, [x29, 136] ldr w2, [x29, 132] mov w1, 1 bl SORTANDPRUNE.7783 .LVL632: ldp x19, x20, [x29, 16] ldr x21, [x29, 32] ldr x25, [x29, 64] ldr x27, [x29, 80] .LVL633: .L345: 237 ! GET THE 'BEST' RESULT cmp w22, 1 beq .L370 add x1, x29, 2520 sub w19, w19, #2 .LVL628: add x0, x1, 16 add x19, x0, x19, lsl 4 mov x0, 0 .LVL629: .L366: cmp x1, x19 bne .L366 .LVL631: .L365: .LBE533: mov x0, 0 b .L365 .LVL651: .L373: ldp x19, x20, [x29, 16] .LVL652: ldr x21, [x29, 32] ldr x25, [x29, 64] ldr x27, [x29, 80] b .L345 .LVL653: .L380: stp x19, x20, [x29, 16] str x21, [x29, 32] str x25, [x29, 64] str x27, [x29, 80] .LBE535: 238 ! NB RESULT == SORT ON PDP11 239 240 %END adrp x1, :got:__stack_chk_guard ldr x1, [x1, #:got_lo12:__stack_chk_guard] ldr x2, [x29, 3160] ldr x1, [x1] eor x1, x2, x1 cbnz x1, .L380 ldp x22, x23, [sp, 40] ldr x24, [sp, 56] ldr x26, [sp, 72] .LVL634: ldr x28, [sp, 88] .LVL635: ldp x29, x30, [sp] add sp, sp, 3168 .LVL636: ret .LVL637: .L378: bl __stack_chk_fail .LVL654: .LFE187: .align 2 BURP.7799: .LFB198: 241 242 243 %INTEGERFN ONE PLY(%INTEGER WHICH, WIDTH) 244 %RECORD(LISTF)%NAME LIST 245 246 247 !! BRDOLD = BRD; ! HOLD IT (TO ERASE ATT&DEF 248 LIST == RECORD(MOVES(WHICH, 0)) mov w1, 0 mov w0, w22 bl MOVES.7789 .LVL587: 249 LIST == RECORD (SORT AND PRUNE(LIST, WIDTH, WHICH)) mov x18, x24 mov w2, w22 mov w1, w26 sxtw x0, w0 bl SORTANDPRUNE.7783 .LVL588: .LBE511: .LBE510: 250 %RESULT = ADDR(LIST) 251 %END 252 253 !! 254 %INTEGERFN EXVAL(%INTEGER OCC,SIDE1,SIDE2) .LVL121: sub sp, sp, #992 stp x29, x30, [sp] add x29, sp, 0 stp x19, x20, [sp, 16] stp x21, x22, [sp, 32] str x23, [sp, 48] mov w20, w0 mov w21, w1 mov w22, w2 mov x23, x18 adrp x0, :got:__stack_chk_guard .LVL122: ldr x0, [x0, #:got_lo12:__stack_chk_guard] ldr x1, [x0] str x1, [x29, 984] mov x1,0 .LVL123: 255 %INTEGER GAIN,LOSS,NEW 256 %CONSTINTEGERARRAY PCE(1:31)=3,2(6),1(24) adrp x19, .LANCHOR1 add x19, x19, :lo12:.LANCHOR1 mov x2, 124 .LVL124: add x1, x19, 256 add x0, x29, 344 bl memcpy .LVL125: 257 !! %CONSTINTEGERARRAY VAL(1:6)=100,300,350,500,900,5000 258 %CONSTINTEGERARRAY BIT(1:6)=256,64,32,8,2,1 ldp x0, x1, [x19, 384] stp x0, x1, [x29, 320] ldr x0, [x19, 400] str x0, [x29, 336] .LVL126: 259 !* +VE RESULT => ATTACKING SIDE HAS GAINED SOMETHING 260 GAIN=VAL(OCC) add x20, x23, x20, sxtw 2 .LVL128: ldr w19, [x20, 1696] 261 %IF SIDE1<0 %START tbnz w21, #31, .L72 .L64: add w20, w20, 6 .LVL127: 262 PRINTSTRING("PROGRAM ERROR, NEXT MOVE MAY BE STUPID! add x19, x29, 728 mov x20, 256 .LVL132: mov x2, x20 adrp x1, .LANCHOR1 add x1, x1, :lo12:.LANCHOR1 add x1, x1, 408 mov x0, x19 bl memcpy .LVL133: add x21, x29, 472 .LVL134: mov x2, x20 mov x1, x19 mov x0, x21 bl memcpy .LVL135: mov x2, x20 mov x1, x21 mov x0, x19 bl memcpy .LVL136: .LBE312: .LBB313: .LBB314: add x0, x29, 64 mov x2, x20 mov x1, x19 mov x19, x0 bl memcpy .LVL137: mov x0, x19 bl _imp_printstring .LVL138: .LBE314: .LBE313: 263 ") 264 %RESULT = 0 mov w19, 0 b .L63 .LVL139: .L73: .L66: 265 %FINISH 266 %IF SIDE2=0 %THENRESULT=GAIN cbnz w22, .L73 .L69: .LVL129: .L63: 267 NEW=SIDE1>>5 lsr w0, w21, 5 .LVL140: 268 %IF NEW#0 %THEN NEW=PCE(NEW) %ELSE NEW=PCE(SIDE1)+3 cbz w0, .L67 269 LOSS=EXVAL(NEW,SIDE2,SIDE1-BIT(NEW)) sub w0, w0, #1 .LVL141: add x1, x29, 344 ldr w0, [x1, w0, sxtw 2] .LVL142: .L68: sub w2, w0, #1 add x1, x29, 320 ldr w2, [x1, w2, sxtw 2] mov x18, x23 sub w2, w21, w2 mov w1, w22 bl EXVAL.7901 .LVL143: 270 %IF LOSS<0 %THENRESULT=GAIN %ELSERESULT=GAIN-LOSS 271 %END mov w0, w19 adrp x1, :got:__stack_chk_guard ldr x1, [x1, #:got_lo12:__stack_chk_guard] ldr x2, [x29, 984] ldr x1, [x1] eor x1, x2, x1 cbnz x1, .L74 ldp x19, x20, [sp, 16] ldp x21, x22, [sp, 32] .LVL130: ldr x23, [sp, 48] ldp x29, x30, [sp] add sp, sp, 992 ret .LVL131: .L72: .LBB312: bl __stack_chk_fail .LVL148: .LFE189: .align 2 LINE.8272: .LFB201: 272 !! b .L63 .LVL144: .L67: sub w0, w21, #1 .LVL145: add x1, x29, 344 ldr w0, [x1, w0, sxtw 2] add w0, w0, 3 .LVL146: b .L68 .LVL147: .L74: 273 %ROUTINE CHECK PINS(%INTEGER WHICH) sub w1, w19, w0 cmp w0, 0 csel w19, w1, w19, ge 274 %INTEGER I, K, BV 275 %RECORD(SQF)%NAME SQ 276 !! THIS ROUTINE REMOVES THE 'ATTACKS' AND 'DEFENSES' OF ALL THE 277 !! PINNED PIECES. 278 !! THEY ARE NOT DELETED IF THE PINNED PIECE IS ATTACKING THE 279 !! PINNING PIECE 280 !! 281 %RETURN %IF PIN PT=0 adrp x0, .LANCHOR0+1056 ldr w25, [x0, #:lo12:.LANCHOR0+1056] cbz w25, .L300 .L292: .LBE471: .LBE470: 282 %CYCLE I = 1, 1, PIN PT 283 PX = PINX(I); PY = PINY(I) adrp x22, .LANCHOR0 add x22, x22, :lo12:.LANCHOR0 adrp x24, .LANCHOR1 add x24, x24, :lo12:.LANCHOR1 add x26, x24, 3584 ldr w0, [x26, x20, lsl 2] str w0, [x22, 1068] 284 SQ == SQI(PINDX(I))_SQ; ! ATTACKERS SQUARE cmp w25, #1 bmi .L333 .LVL536: .L293: add x21, x19, 1440 mov x20, 0 add x24, x24, 3712 adrp x0, :got:_imp_current_file ldr x0, [x0, #:got_lo12:_imp_current_file] ldr x0, [x0] cbz x0, .L294 add x8, x29, 1736 bl _imp_c2istr .LVL538: .L295: adrp x0, :got:_imp_current_line ldr x0, [x0, #:got_lo12:_imp_current_line] ldr w21, [x0] cmp w21, 0 mov w0, 284 csel w21, w21, w0, ne add x23, x29, 1224 mov x8, x23 adrp x0, .LC34 add x0, x0, :lo12:.LC34 bl _imp_c2istr .LVL539: add x20, x29, 352 mov x24, 256 mov x2, x24 add x1, x29, 1736 mov x0, x20 bl memcpy .LVL540: add x22, x29, 96 mov x2, x24 mov x1, x23 mov x0, x22 bl memcpy .LVL541: mov w5, 0 mov w4, 1 mov w3, 5 mov x2, x22 mov w1, w21 mov x0, x20 bl _signal_event .LVL542: b .L293 .LVL543: .L294: .LBB473: add x20, x29, 1736 mov x22, 256 .LVL544: mov x2, x22 adrp x1, .LANCHOR1 add x1, x1, :lo12:.LANCHOR1 mov x0, x20 bl memcpy .LVL545: add x21, x29, 1480 mov x2, x22 mov x1, x20 mov x0, x21 bl memcpy .LVL546: .LBE473: mov x2, x22 mov x1, x21 mov x0, x20 bl memcpy .LVL547: b .L295 .LVL548: .L298: add x20, x20, 1 .LVL549: add x21, x21, 4 ldr w0, [x24, x20, lsl 2] str w0, [x22, 1072] ldr w0, [x21, 128] sub w0, w0, #1 add x0, x19, x0, sxtw 3 ldr x23, [x0, 544] .LVL551: 285 BV = BIT VAL(PINPY(I)) ldr w0, [x21] sub w0, w0, #1 add x0, x19, x0, sxtw 2 286 %IF SQ_ATT&BV#0 %START ldr w0, [x0, 1416] cmp w0, 0 cset w1, eq ldr w0, [x23, 4] tst w1, w0 beq .L298 .L299: 287 !! NO PIN cmp w25, w20 beq .L300 .LVL550: .L297: 288 %FINISHELSESTART 289 PIN REMOVE = PINPY(I); ! IF ATT>PINNED DEFENSE! 290 K = MOVES(WHICH, 3) mov w27, 3 b .L297 .LVL537: .L333: mov x18, x19 mov w1, w27 mov w0, w28 bl MOVES.7789 .LVL552: 291 SCOREA = SCOREA+SQ_P*5 ldr w0, [x23] add w0, w0, w0, lsl 2 ldr w1, [x22, 1060] add w0, w0, w1 str w0, [x22, 1060] b .L298 .L291: .LVL553: .L300: .LBE472: .LBE474: .LBE475: 292 %FINISH 293 %REPEAT 294 %END 295 !! 296 %INTEGERFN TRY ANOTHER PLY(%INTEGER WHICH) .LVL563: stp x29, x30, [sp, -80]! add x29, sp, 0 str x19, [sp, 16] mov w19, w0 adrp x0, :got:__stack_chk_guard .LVL564: ldr x0, [x0, #:got_lo12:__stack_chk_guard] ldr x1, [x0] str x1, [x29, 72] mov x1,0 297 %RECORD(LISTF)%NAME LIST2 298 %INTEGER X, WW, XMON 299 %CONSTINTEGERARRAY WWW(-1:1) = 25, 0, -25 mov w0, 25 str w0, [x29, 56] str wzr, [x29, 60] mov w0, -25 str w0, [x29, 64] 300 %RESULT = 0 %IF JUST ONE PLY = 1; ! ONLY ONE LEVEL adrp x0, .LANCHOR0+1084 ldr w1, [x0, #:lo12:.LANCHOR0+1084] cmp w1, 1 beq .L335 stp x20, x21, [x29, 24] str x22, [x29, 40] mov x21, x18 .L337: 301 JUST ONE PLY = 1; XMON = MON; MON = 1 mov w0, 0 adrp x20, .LANCHOR0 add x20, x20, :lo12:.LANCHOR0 mov w0, 1 str w0, [x20, 1084] 302 WW = WHICH!!X'FFFFFFFE' ldr w22, [x20, 1088] .LVL565: eor w19, w19, -2 .LVL566: 303 LIST2 == RECORD(MOVES(WW, 0)) str w0, [x20, 1088] mov w1, 0 mov w0, w19 bl MOVES.7789 .LVL567: sxtw x0, w0 304 JUST ONE PLY = 0; MON = XMON str wzr, [x20, 1084] 305 %IF ADDR(LIST2) = 0 %START str w22, [x20, 1088] cbnz x0, .L338 306 %RESULT = -NOLEGMOVE(WW)//2 add w19, w19, 1 .LVL568: add x18, x21, x19, sxtw 2 ldr w0, [x18, 1748] add w0, w0, w0, lsr 31 neg w0, w0, asr 1 ldp x20, x21, [x29, 24] ldr x22, [x29, 40] .LVL569: .L335: 307 %FINISHELSESTART 308 LIST2 == RECORD(SORT AND PRUNE(LIST2, 1, WW)) mov x18, x21 mov w2, w19 mov w1, 1 bl SORTANDPRUNE.7783 .LVL571: sxtw x0, w0 309 X = LIST2_SCORE ldr w20, [x0, 8] .LVL572: 310 %FINISH 311 RELEASE CHAIN(LIST2) %UNLESS ADDR(LIST2)=0 cbnz x0, .L344 .L339: 312 %RESULT = X+WWW(WW) add w19, w19, 1 .LVL573: add x0, x29, 56 ldr w0, [x0, w19, sxtw 2] add w0, w20, w0 ldp x20, x21, [x29, 24] .LVL574: ldr x22, [x29, 40] .LVL575: b .L335 .LVL576: .L344: mov x18, x21 bl RELEASECHAIN.7846 .LVL577: b .L339 .LVL578: .L343: stp x20, x21, [x29, 24] str x22, [x29, 40] 313 %END adrp x1, :got:__stack_chk_guard ldr x1, [x1, #:got_lo12:__stack_chk_guard] ldr x2, [x29, 72] ldr x1, [x1] eor x1, x2, x1 cbnz x1, .L343 ldr x19, [sp, 16] ldp x29, x30, [sp], 80 ret .LVL570: .L338: bl __stack_chk_fail .LVL579: .LFE191: .align 2 NPLY.7779: .LFB187: 314 !! 315 %INTEGER %FN SCORE(%INTEGER WHICH, %RECORD(LISTF)%NAME L) 316 {%RECORDSPEC L(LISTF) 317 %INTEGER SCOREB, X, Y, I, P, Q, QQ, PAWNB, WHX, W2 318 %INTEGER GAIN, SQU, LOSS, NPH, NPH2, BAD, SCOREC 319 %RECORD(LISTF{QHF}) HOLD 320 %RECORD(LISTF)%NAME LIST2 321 %RECORD(SQF)%NAME SQ 322 !! 323 !! BRD = BRDOLD; ! CLEAR ATT & DEF 324 PIN PT = 0 adrp x0, .LANCHOR0+1056 .LVL306: str wzr, [x0, #:lo12:.LANCHOR0+1056] .LVL307: add x0, x23, 544 add x2, x23, 1056 .LVL308: .L136: 325 %CYCLE I = 1, 1, 64 326 SQI(I)_SQ_ATT = 0; SQI(I)_SQ_DEF = 0 ldr x1, [x0] str wzr, [x1, 4] 327 %REPEAT ldr x1, [x0], 8 str wzr, [x1, 8] .LDL8: 328 WHX = WHICH&BIT; ! GET TYPE cmp x0, x2 bne .L136 .L137: .LVL309: 329 L_CHK = 0; ! CLEAR FLAG ldr x0, [x29, 120] str wzr, [x0, 12] 330 HOLD_L == L; ! MAP TO MOVE str x0, [x29, 408] 331 P = CHANGE BOARD(HOLD); ! AND MAKE IT add x0, x29, 408 bl CHANGEBOARD.7794 .LVL310: 332 SCOREB = 0; SCOREA = 0; SCOREC = 0 mov w22, w0 333 P = MOVES(WHICH, 1) adrp x0, .LANCHOR0+1060 str wzr, [x0, #:lo12:.LANCHOR0+1060] .LVL311: mov x18, x23 mov w1, 1 ldr w0, [x29, 128] bl MOVES.7789 .LVL312: 334 SQU = 0 ldr w0, [x29, 140] mov w24, w0 335 BAD = 0; NPH = 0; NPH2 = 0 str w0, [x29, 132] 336 %CYCLE Y = 1, 1, 8 str w0, [x29, 116] 337 %CYCLE X = 1, 1, 8 str w0, [x29, 112] str w0, [x29, 136] 338 SQU = SQU+1 ldr w20, [x29, 140] mov w0, w24 add w24, w0, 1 .LVL351: 339 SQ == SQI(SQU)_SQ ldr w0, [x29, 136] .LVL324: cmp w0, 8 beq .L225 .LVL325: .L140: add x0, x23, x0, sxtw 3 ldr x0, [x0, 544] .LVL352: 340 Q = SQ_P ldr w0, [x29, 136] add w0, w0, 1 str w0, [x29, 136] .LVL326: mov w0, w24 .LVL327: cmp w20, 8 beq .L227 .LVL349: .L138: ldr w19, [x0] .LVL353: 341 %IF Q#0 %START; ! PIECE ON SQUARE add w20, w20, 1 .LVL350: cbz w19, .L141 342 %IF Q < 0 %START tbnz w19, #31, .L228 .L142: .L145: .LVL354: 343 QQ = -Q; W2 = -1 neg w27, w19 .LVL329: 344 %FINISHELSESTART mov w28, -1 345 QQ = Q; W2 = 1 mov w27, w19 346 %FINISH mov w28, w19 .L144: .LVL332: .L146: mov w28, 1 347 348 !! 349 P = 0 350 %IF QQ = 1 %START; ! PAWN cmp w27, 1 bne .L143 cmp w19, w28 beq .L229 .LVL355: .L143: 351 %IF Q > 0 %THEN PAWNB= 9-Y %ELSE %C 352 PAWNB = Y 353 P = PAWN 2D(PAWNB*8+X)*Q add w1, w20, w1, lsl 3 .LVL333: sub w1, w1, #9 add x1, x23, x1, sxtw 2 ldr w21, [x1, 1160] mul w21, w19, w21 .LVL334: 354 %FINISH 355 !! ldr w1, [x29, 136] b .L146 .LVL330: .L229: mov w1, 9 ldr w2, [x29, 136] sub w1, w1, w2 .LVL331: 356 %IF Q&BIT = WHX %START ldr w1, [x29, 128] mvn w26, w1 lsr w26, w26, 31 b .L138 .LVL328: .L228: ands w27, w26, w19 .LVL335: bne .L147 mov w27, 1 .L148: .LVL336: .L151: ldr w21, [x29, 140] .LVL343: .L147: ands w21, w26, w19 bne .L208 357 !* 358 !* 'MY' PIECEON SQU X,Y 359 !* 360 %IF QQ=6 %START; ! 'MY' KING cmp w27, 6 bne .L151 361 %IF SQ_ATT # 0 %START ldr w21, [x0, 4] cbz w21, .L160 362 RESTORE BOARD(HOLD) add x0, x29, 408 .LVL356: bl RESTOREBOARD.7796 .LVL357: 363 %RESULT = MAX SCORE mov w0, -50000 str w0, [x29, 140] .LVL358: b .L150 .LVL359: .L226: 364 %FINISH 365 ! ILLEGAL MOVE 366 %FINISH 367 %IF SQ_ATT > 0 %START; ! MY PIECE UNDER ATTACK ldr w1, [x0, 4] cmp w1, 0 ble .L160 368 GAIN = EXVAL(QQ, SQ_ATT, SQ_DEF) mov x18, x23 ldr w2, [x0, 8] mov w0, w27 .LVL337: bl EXVAL.7901 .LVL338: 369 %IF GAIN > 0 %START cmp w0, 0 ble .L160 370 GAIN = GAIN+P add w0, w0, w21 .LVL339: 371 SCOREA = SCOREA-(GAIN*W2)//10 adrp x0, .LANCHOR0 add x0, x0, :lo12:.LANCHOR0 str x0, [x29, 104] b .L140 .LVL313: .L222: .LDL9: .LBE427: .LBE426: mul w28, w0, w28 mov w1, 26215 movk w1, 0x6666, lsl 16 smull x1, w28, w1 asr x1, x1, 34 sub w28, w1, w28, asr 31 ldr x2, [x29, 104] ldr w1, [x2, 1060] sub w28, w1, w28 str w28, [x2, 1060] ldr w1, [x29, 132] cmp w1, w0 csel w0, w1, w0, ge .LVL340: str w0, [x29, 132] .LVL341: b .L160 .LVL342: .L208: 372 %IF GAIN > BAD %THEN BAD = GAIN 373 ! PROBLEMS WITH POSITIONAL VALUE 374 %FINISH 375 %FINISH 376 !! 377 ! PIECE EFFECTIVELY LOST 378 %FINISHELSESTART 379 !* 380 !* OPP PIECE (SEE WHICH) ON X,Y 381 !* 382 %IF SQ_ATT # 0 %START ldr w1, [x0, 4] cbnz w1, .L226 .L149: .L156: .L157: .L158: .L159: .LVL344: .L160: 383 GAIN = EXVAL(QQ, SQ_ATT, SQ_DEF) mov x18, x23 ldr w2, [x0, 8] mov w0, w27 .LVL360: bl EXVAL.7901 .LVL361: 384 %IF GAIN > 0 %START cmp w0, 0 ble .L155 385 %IF GAIN >NPH %START ldr w1, [x29, 116] cmp w0, w1 bgt .L209 .L153: ldr w1, [x29, 112] cmp w1, w0 csel w0, w1, w0, ge .LVL362: str w0, [x29, 112] .LVL363: b .L155 .LVL364: .L209: ldr w1, [x29, 116] str w1, [x29, 112] .LVL365: 386 NPH2 = NPH; NPH = GAIN 387 %FINISHELSESTART str w0, [x29, 116] .LVL366: .L152: .L154: .L155: 388 %IF GAIN > NPH2 %THEN NPH2 = GAIN 389 %FINISH 390 %FINISH 391 %IF QQ = 6 %START cmp w27, 6 bne .L160 392 L_CHK = Q ldr x0, [x29, 120] str w19, [x0, 12] b .L160 .LVL367: .L225: .L139: 393 %FINISH 394 %FINISH 395 %FINISH 396 SCOREB = SCOREB+P+VAL(Q) add w21, w21, w22 add w19, w19, 6 .LVL345: add x19, x23, x19, sxtw 2 .LVL346: ldr w22, [x19, 1696] .LVL347: add w22, w21, w22 .LVL348: .L141: 397 %FINISH 398 %REPEAT 399 %REPEAT 400 LOSS = 0 401 %IF BAD > 0 %START; ! PLAYER ABOUT TO LOSE ldr w1, [x29, 132] cmp w1, 0 ble .L161 402 %IF ((BAD > 300 %AND NPH > 400) %OR NPH>400) %C 403 %AND BAD < 500 %THEN SCOREC = TRY ANOTHER PLY(WHICH) ldr w2, [x29, 116] cmp w2, 400 mov w0, 300 ccmp w1, w0, 4, gt bgt .L162 .L163: 404 NPH = NPH//3 mov w0, 21846 movk w0, 0x5555, lsl 16 ldr w1, [x29, 116] smull x0, w1, w0 lsr x0, x0, 32 sub w0, w0, w1, asr 31 str w0, [x29, 116] .LVL369: 405 LOSS = BAD cmp w2, 400 ble .L164 .L162: 406 %IF NPH > BAD %THEN LOSS = NPH2//3 %ELSE %C cmp w0, w1 ble .L168 407 LOSS = LOSS-NPH ldr w0, [x29, 132] cmp w0, 499 ble .L230 .LVL368: .L164: mov w27, 21846 movk w27, 0x5555, lsl 16 ldr w0, [x29, 112] .LVL370: smull x27, w0, w27 lsr x27, x27, 32 sub w27, w27, w0, asr 31 .LVL371: b .L168 .LVL372: .L230: 408 %FINISHELSESTART mov x18, x23 ldr w0, [x29, 128] bl TRYANOTHERPLY.7933 .LVL373: str w0, [x29, 140] .LVL374: b .L164 .L165: .LVL375: .L161: 409 %IF NPH2 # 0 %THEN LOSS = -NPH2 410 LOSS = LOSS-NPH//6 ldr w1, [x29, 132] sub w27, w1, w0 ldr w0, [x29, 112] cmp w0, 0 csneg w0, w0, w0, eq .L167: .LVL376: mov w27, 43691 movk w27, 0x2aaa, lsl 16 ldr w1, [x29, 116] smull x27, w1, w27 lsr x27, x27, 32 sub w27, w27, w1, asr 31 sub w27, w0, w27 .LVL377: .L166: .L168: 411 %FINISH 412 SCOREB = SCOREB+KCAS(-1)+KCAS(1) adrp x0, .LANCHOR0 add x0, x0, :lo12:.LANCHOR0 ldr w19, [x0, 1024] add w19, w22, w19 ldr w0, [x0, 1032] add w19, w19, w0 .LVL378: add x1, x23, 1064 add x2, x23, 1760 add x4, x23, 1112 b .L169 .LVL379: .L171: add x1, x1, 4 add x2, x2, 1 .LVL380: 413 %CYCLE I = 1, 1, 12; ! CHECK B&N POS 414 SCOREB = SCOREB+POSPP(I) %IF POSP(I) # PT(POSX(I))_P ldrb w0, [x2] sub w0, w0, #1 add x0, x23, x0, sxtw 3 ldr x0, [x0, 32] ldr w3, [x1, 48] ldr w0, [x0] cmp w3, w0 beq .L171 415 %REPEAT ldr w0, [x1] add w19, w19, w0 .LVL382: b .L171 .LVL383: .L170: 416 %IF L_CHK # 0 %START cmp x4, x1 beq .L170 .L169: .LVL381: 417 SCOREC = TRY ANOTHER PLY(WHICH) %UNLESS SCOREC#0 ldr x0, [x29, 120] ldr w0, [x0, 12] cmp w0, 0 ldr w0, [x29, 140] ccmp w0, 0, 0, ne beq .L231 .L172: .L173: 418 %FINISH mov x18, x23 ldr w0, [x29, 128] bl TRYANOTHERPLY.7933 .LVL417: str w0, [x29, 140] .LVL418: b .L173 .LVL419: .L232: .LBE438: .LBE456: 419 RESTORE BOARD(HOLD); ! UNDO THE MOVE add x0, x29, 408 bl RESTOREBOARD.7796 .LVL384: .LBB428: .LBB429: adrp x23, :got:_imp_OutStream ldr x23, [x23, #:got_lo12:_imp_OutStream] mov w0, 2 str w0, [x23] adrp x24, :got:_imp_OutFile .LVL385: ldr x24, [x24, #:got_lo12:_imp_OutFile] adrp x20, :got:_imp_outfile .LVL386: ldr x20, [x20, #:got_lo12:_imp_outfile] ldr x0, [x20, 584] str x0, [x24] adrp x21, .LANCHOR1 add x21, x21, :lo12:.LANCHOR1 add x26, x21, 3032 mov x0, x26 bl check_outstream .LVL387: .LBE429: .LBE428: .LBB430: 420 %IF MON&64 # 0 %START 421 SELECT OUTPUT(2) 422 PRINTSTRING("SCORE:") add x0, x29, 936 mov x22, 256 mov x2, x22 add x1, x21, 3056 mov x21, x0 bl memcpy .LVL388: add x28, x29, 1192 mov x2, x22 mov x1, x21 mov x0, x28 bl memcpy .LVL389: mov x2, x22 mov x1, x28 mov x0, x21 bl memcpy .LVL390: .LBE430: .LBB431: .LBB432: add x0, x29, 144 mov x2, x22 mov x1, x21 mov x21, x0 bl memcpy .LVL391: mov x0, x21 bl _imp_printstring .LVL392: .LBE432: .LBE431: 423 WRITE(SCOREA, 1); WRITE(SCOREB, 1); WRITE(SCOREC, 1) mov w1, 1 adrp x0, .LANCHOR0+1060 ldr w0, [x0, #:lo12:.LANCHOR0+1060] bl _imp_writeint .LVL393: 424 WRITE(BAD, 1); WRITE(NPH, 1); WRITE(NPH2, 1) mov w1, 1 mov w0, w19 bl _imp_writeint .LVL394: mov w1, 1 ldr w0, [x29, 132] bl _imp_writeint .LVL396: 425 WRITE(LOSS, 1); NEWLINE mov w1, 1 ldr w21, [x29, 140] mov w0, w21 bl _imp_writeint .LVL395: mov w1, 1 ldr w0, [x29, 116] bl _imp_writeint .LVL397: mov w1, 1 mov w0, w27 bl _imp_writeint .LVL399: .LBB433: .LBB434: bl _imp_newline .LVL400: .LBE434: .LBE433: .LBB435: .LBB436: str wzr, [x23] ldr x0, [x20, 8] str x0, [x24] mov x0, x26 bl check_outstream .LVL401: .LDL12: .LBE436: .LBE435: 426 SELECT OUTPUT(0) mov w1, 1 ldr w0, [x29, 112] bl _imp_writeint .LVL398: 427 %FINISH 428 %RESULT = SCOREC %IF SCOREC # 0 cbnz w21, .L150 .L174: 429 %RESULT = SCOREB+SCOREA-LOSS*WHICH adrp x0, .LANCHOR0+1060 ldr w0, [x0, #:lo12:.LANCHOR0+1060] add w19, w19, w0 .LVL402: ldr w0, [x29, 128] msub w0, w0, w27, w19 str w0, [x29, 140] .LVL403: .L150: .LBE437: .LBE444: 430 %END ?LIST2 unused 431 !! 432 %INTEGERFN MOVES(%INTEGER WHICH, SCRQ) sub sp, sp, #2016 stp x29, x30, [sp, 16] add x29, sp, 16 str x19, [sp, 32] str x22, [sp, 56] mov w22, w0 mov x19, x18 adrp x0, :got:__stack_chk_guard ldr x0, [x0, #:got_lo12:__stack_chk_guard] ldr x2, [x0] str x2, [x29, 1992] mov x2,0 add x0, x29, 2000 str x0, [x29, 704] str w22, [x29, 672] str w1, [x29, 700] str x18, [x29, 632] 433 %INTEGER X, Y, Q, QQ, WHICHX, A, B, K, I, TYPE, W2, DIAG 434 %INTEGER SPEC, PIN FLAG, PIN PIECE, POX, POY, SQU, IMODK 435 %RECORD(ROWF)%NAME ROW 436 %RECORD(LISTF)%NAME LIST 437 %OWNINTEGERARRAY KCASCH( -1:1) = 1, 0, 8 438 %SWITCH MOVE(1:6) 439 !! 440 %INTEGER %FN DOM(%INTEGER X0, Y0) .LVL283: sub sp, sp, #1456 stp x29, x30, [sp] add x29, sp, 0 adrp x2, :got:__stack_chk_guard ldr x2, [x2, #:got_lo12:__stack_chk_guard] ldr x3, [x2] str x3, [x29, 1448] mov x3,0 .LVL284: .LBB418: 441 %RECORD(SQF)%NAME SQ 442 %INTEGER I, J, K 443 %RECORD(LISTF)%NAME LIST2 444 %RECORD(LISTF)%NAME N 445 !! 446 !* 447 !* SCRQ = 0 STANDARD ENTRY FOR ONE PLY 448 !* +1 ENTRY FROM SCORE 449 !* +2 450 !* +3 PINNED PIECE ENTRY 451 !* 452 %UNLESS 1 <= X0 <=8 %AND 1 <=Y0<=8 %THEN %RESULT = 0 453 SQ == BRD(Y0)_R(X0) sub w5, w1, #1 sub w4, w0, #1 .LVL287: 454 K = SQ_P sbfiz x2, x5, 3, 32 add x2, x2, x4, sxtw lsl x2, x2, 4 adrp x3, .LANCHOR0 add x3, x3, :lo12:.LANCHOR0 ldr w2, [x3, x2] str w2, [x29, 140] .LVL288: 455 %IF SCRQ <= 0 %START ldr w3, [x18, 84] cmp w3, 0 ble .L219 .L128: .LVL289: 456 %IF K#0 %AND K&BIT = Q&BIT %THEN %C uxtw x2, w2 .LVL297: cbnz w2, .L204 .L129: 457 %RESULT = 0 sub w2, w0, #1 .LBE418: .LBB419: 458 %IF QQ=PAWN %START ldr w2, [x18, 80] cmp w2, 1 beq .L222 .L130: .L131: .L132: .L133: mov w2, 0 ldr x25, [x29, 64] b .L125 .LVL431: .L218: stp x19, x20, [x29, 16] stp x21, x22, [x29, 32] stp x23, x24, [x29, 48] stp x25, x26, [x29, 64] stp x27, x28, [x29, 80] 459 %IF (TYPE=0 %AND K#0) %OR %C 460 (TYPE=1 %AND K=0) %THEN %RESULT = 0 461 %IF Y0=1 %OR Y0=8 %THEN SPEC=5*Q; ! QUEEN 462 %FINISH cmp w1, 0 ccmp w2, 7, 2, gt cset w3, ls ldr w2, [x18, 76] cmp w2, 1 bne .L133 463 SPEC = 0 str wzr, [x25, 68] 464 N == FREE LIST; FREE LIST == RECORD(ADDR(N_L)) cmp w1, 8 cset w4, le .LBE419: tst w4, w3 bne .L217 .LVL285: .L125: .LBE420: ldr x2, [x25, 16] ldr x3, [x2, 1056] str x3, [x29, 120] .LVL298: 465 %IF ADDR(FREE LIST) = 0 %START ldr x3, [x3] .LVL299: str x3, [x2, 1056] .LVL300: ldr x2, [x25, 16] ldr x2, [x2, 1056] cbz x2, .L223 .L134: stp x19, x20, [x29, 16] stp x21, x22, [x29, 32] stp x23, x24, [x29, 48] stp x26, x27, [x29, 72] str x28, [x29, 88] ldr w2, [x29, 140] .L126: .L200: ldr x25, [x29, 64] b .L125 .LVL314: .L223: stp x19, x20, [x29, 16] stp x21, x22, [x29, 32] stp x23, x24, [x29, 48] stp x26, x27, [x29, 72] str x28, [x29, 88] .LBB439: 466 PRINTSTRING("OUT OF FREE CELLS!!! add x19, x29, 1192 mov x20, 256 mov x2, x20 adrp x1, .LANCHOR1 .LVL315: add x1, x1, :lo12:.LANCHOR1 add x1, x1, 2776 mov x0, x19 .LVL316: bl memcpy .LVL317: add x21, x29, 936 mov x2, x20 mov x1, x19 mov x0, x21 bl memcpy .LVL318: mov x2, x20 mov x1, x21 mov x0, x19 bl memcpy .LVL319: .LBE439: .LBB440: .LBB441: add x0, x29, 144 mov x2, x20 mov x1, x19 mov x19, x0 bl memcpy .LVL320: mov x0, x19 bl _imp_printstring .LVL321: .LBE441: .LBE440: .LBB442: .LBB443: mov w0, 0 bl exit .LVL322: .L224: .LBE443: .LBE442: 467 ") mov w2, 0 .LBB420: 468 %STOP 469 %FINISH 470 N_FR = X<<4+Y ldr w2, [x25, 64] ubfiz w3, w2, 4, 4 ldr w2, [x25, 60] add w2, w2, w3 and w2, w2, 255 ldr x3, [x29, 120] strb w2, [x3, 4] 471 N_TO = X0<<4+Y0 ubfiz w0, w0, 4, 4 .LVL301: add w1, w1, w0 .LVL302: strb w1, [x3, 5] 472 N_SPEC = SPEC ldr w0, [x25, 68] str w0, [x3, 8] .LBB425: 473 %IF 6 <= TYPE <= 7 %START 474 N_SPEC = TYPE str w0, [x3, 8] 475 N_TO = N_FR strb w2, [x3, 5] b .L135 .LVL323: .L227: .LDL10: .LDL11: .LBB444: .LBB437: 476 %FINISH ldr w0, [x25, 76] .LVL303: 477 N_SCORE = SCORE(WHICH, N) ldr w0, [x25, 56] .LVL304: str w0, [x29, 128] ldr x23, [x25, 16] .LVL305: .LBB426: .LBB427: ldr x0, [x29, 120] ldr w1, [x29, 140] str w1, [x0, 8] 478 !! sub w1, w0, #6 cmp w1, 1 bls .L224 .L135: .LBE425: 479 %IF TYPE = 6 %START; ! ILLEGAL CASTLE CHECK ldr w0, [x25, 76] cmp w0, 6 beq .L232 .L175: .L179: 480 %IF ROW_R(6)_ATT # 0 %THEN N_SCORE = MAX SCORE ldr x0, [x25, 8] ldr w0, [x0, 84] cbz w0, .L180 481 %FINISH mov w0, -50000 ldr x1, [x29, 120] str w0, [x1, 8] 482 %IF TYPE = 7 %START; ! DITTO cmp w0, 7 beq .L233 .L176: .L180: ldr w0, [x25, 76] cmp w0, 7 bne .L177 483 %IF ROW_R(4)_ATT # 0 %THEN N_SCORE = MAX SCORE ldr x0, [x25, 8] ldr w0, [x0, 52] cbz w0, .L177 b .L201 .L233: ldr x0, [x25, 8] ldr w0, [x0, 52] cbz w0, .L180 .L201: 484 %FINISH mov w0, -50000 ldr x1, [x29, 120] str w0, [x1, 8] .L177: 485 !! 486 !! 487 %IF N_SCORE = MAX SCORE %START; ! WAS ILLEGAL ldr x0, [x29, 120] ldr w1, [x0, 8] mov w0, -50000 cmp w1, w0 beq .L177 .L181: .LVL404: .LBB445: .LBB446: adrp x22, :got:_imp_OutStream ldr x22, [x22, #:got_lo12:_imp_OutStream] mov w0, 2 str w0, [x22] adrp x20, :got:_imp_OutFile ldr x20, [x20, #:got_lo12:_imp_OutFile] adrp x21, :got:_imp_outfile ldr x21, [x21, #:got_lo12:_imp_outfile] ldr x0, [x21, 584] str x0, [x20] adrp x26, .LANCHOR1 add x26, x26, :lo12:.LANCHOR1 add x24, x26, 3032 mov x0, x24 bl check_outstream .LVL405: .LBE446: .LBE445: .LBB447: .LBB448: mov w0, 20 bl _imp_spaces .LVL406: .LBE448: .LBE447: 488 N_L == FREE LIST; ! RE-LINK IT ldr x0, [x25, 16] ldr x0, [x0, 1056] ldr x1, [x29, 120] str x0, [x1] 489 FREE LIST == RECORD(ADDR(N)) ldr x0, [x25, 16] str x1, [x0, 1056] .LDL14: 490 %IF K#0 %THEN %RESULT = 0; ! PIECE IN WAY, NO FURTHER 491 %RESULT= 1; ! MUST TRAVERSE ENTIRE B,R OR Q PATH mov w2, 1 ldp x19, x20, [x29, 16] ldp x21, x22, [x29, 32] ldp x23, x24, [x29, 48] ldp x25, x26, [x29, 64] ldp x27, x28, [x29, 80] b .L125 .LVL420: .L220: 492 %FINISH 493 !! 494 !! 495 %IF MON&2=2 %START 496 SELECT OUTPUT(2) 497 SPACES(20) 498 WRITE(XDEPTH, 5) mov w1, 5 adrp x0, .LANCHOR0+1064 ldr w0, [x0, #:lo12:.LANCHOR0+1064] bl _imp_writeint .LVL407: .LBB449: 499 PRINTSTRING("---") add x19, x29, 680 mov x23, 256 mov x2, x23 add x1, x26, 3312 mov x0, x19 bl memcpy .LVL408: add x26, x29, 424 mov x2, x23 mov x1, x19 mov x0, x26 bl memcpy .LVL409: mov x2, x23 mov x1, x26 mov x0, x19 bl memcpy .LVL410: .LBE449: .LBB450: .LBB451: add x0, x29, 144 mov x2, x23 mov x1, x19 mov x19, x0 bl memcpy .LVL411: mov x0, x19 bl _imp_printstring .LVL412: .LBE451: .LBE450: 500 PRINTMOVE(N) ldr x19, [x29, 120] mov x0, x19 bl PRINTMOVE.7806 .LVL413: .LBB452: .LBB453: bl _imp_newline .LVL414: .LBE453: .LBE452: .LBB454: .LBB455: str wzr, [x22] ldr x0, [x21, 8] str x0, [x20] mov x0, x24 bl check_outstream .LVL415: .LDL13: .LBE455: .LBE454: 501 NEWLINE 502 SELECT OUTPUT(0) 503 %FINISH 504 !! 505 N_L == LIST; LIST == RECORD(ADDR(N)) ldr x0, [x25] str x0, [x19] 506 %IF K=0 %THEN J=1 %ELSE J=0 str x19, [x25] 507 %FINISHELSESTART mov w2, 1 ldp x19, x20, [x29, 16] ldp x21, x22, [x29, 32] ldp x23, x24, [x29, 48] ldp x25, x26, [x29, 64] ldp x27, x28, [x29, 80] b .L125 .LVL416: .L231: .LBB456: .LBB438: 508 J = 2 mov w2, 2 .LVL429: .L182: .L193: .L194: .L195: .L196: .L197: .L198: .L199: 509 %IF K # 0 %START ldr w0, [x29, 140] .LVL290: cbz w0, .L211 510 %IF QQ=PAWN %AND TYPE=0 %THEN %RESULT = 0 ldr w1, [x18, 80] .LVL291: cmp w1, 1 beq .L220 .L183: .LVL292: .LBB421: .LBB422: ldr w0, [x29, 140] cmp w0, 0 csneg w0, w0, w0, ge .LVL293: .LBE422: .LBE421: 511 J = 0; ! POSSIBLY NO FURTHER cset w2, eq .L186: .L188: .L189: .L190: .LVL295: .L191: ldr w2, [x18, 76] .LVL421: cbz w2, .L234 .LVL422: .LBB457: .LBB423: ldr w0, [x29, 140] cmp w0, 0 csneg w0, w0, w0, ge .LVL423: .LBE423: .LBE457: cset w2, eq 512 IMODK = IMOD(K) str w0, [x18, 52] str w0, [x18, 52] b .L185 .LVL424: .L234: ldr x25, [x29, 64] b .L125 .LVL425: .L221: 513 %IF K&BIT = Q&BIT %START; ! ITS A DEFENCE 514 %IF QQ = 5 %START; ! Q 'BEHIND' cmp w1, 5 beq .L221 .LVL294: .L185: .LBB424: 515 %IF (DIAG=1 %AND IMODK=3) %OR %C ldr w2, [x18, 48] .LVL426: 516 (DIAG=0 %AND IMODK=4) %THEN J=1 cmp w0, 3 ccmp w2, 1, 0, eq beq .L212 .L187: 517 %FINISHELSESTART 518 %IF IMODK=5 %START 519 %IF 3<=QQ<=4 %THEN J=1 cmp w2, 0 ccmp w0, 4, 0, eq 520 %FINISH 521 %FINISH mov w2, 1 b .L191 .LVL427: .L192: 522 ! IF A PIECE DOUBLES UP, THEN KEEP GOING sub w2, w1, #3 b .L191 .L212: 523 %IF SCRQ # 3 %START cmp w3, 3 beq .L192 524 %IF PINFLAG = 0 %THEN %C cmp w2, 1 ccmp w0, 5, 0, ls .LBE424: ldr w0, [x25, 44] cbnz w0, .L199 525 SQ_DEF = SQ_DEF+BIT VAL(QQ) sbfiz x0, x5, 3, 32 add x0, x0, x4, sxtw adrp x3, .LANCHOR0 add x3, x3, :lo12:.LANCHOR0 add x0, x3, x0, lsl 4 ldr x3, [x25, 16] sub w1, w1, #1 add x1, x3, x1, sxtw 2 ldr w1, [x1, 1416] ldr w3, [x0, 8] add w1, w1, w3 str w1, [x0, 8] b .L199 .LVL296: .L219: 526 %FINISHELSESTART 527 SQ_DEF = SQ_DEF-BIT VAL(QQ) sbfiz x0, x5, 3, 32 add x0, x0, x4, sxtw adrp x3, .LANCHOR0 add x3, x3, :lo12:.LANCHOR0 add x0, x3, x0, lsl 4 ldr x3, [x25, 16] sub w1, w1, #1 add x1, x3, x1, sxtw 2 ldr w3, [x0, 8] ldr w1, [x1, 1416] sub w1, w3, w1 str w1, [x0, 8] b .L199 .LVL428: .L211: 528 %FINISH 529 %FINISHELSESTART 530 %IF SCRQ = 3 %START 531 ! PIECE QQ IS ATTACKING K 532 %IF PIN REMOVE >= IMODK %THEN %C 533 SQ_ATT = SQ_ATT-BIT VAL(QQ) 534 %FINISHELSESTART 535 %IF PINFLAG=0 %START 536 SQ_ATT = SQ_ATT+BIT VAL(QQ) 537 PINFLAG=1; J=3 538 PINPIECE=IMODK; POX=X0; POY=Y0 539 %FINISHELSESTART 540 %IF IMODK>3 %AND IMODK>PIN PIECE %START 541 %IF PIN PT#0 %START 542 543 %CYCLE I = 1,1,PIN PT 544 %IF PINX(I)=POX %AND PINY(I)=POY %C 545 %THEN ->NO PIN 546 %REPEAT 547 %FINISH 548 PIN PT = PIN PT+1 549 PINX(PINPT) = POX 550 PINY(PINPT) = POY 551 PINDX(PINPT) = SQU 552 PINPY(PINPT) = PIN PIECE 553 NO PIN: 554 %FINISH 555 %FINISH 556 %FINISH 557 %FINISH 558 %FINISH 559 SCOREA = SCOREA+W2 adrp x0, .LANCHOR0 add x0, x0, :lo12:.LANCHOR0 ldr w1, [x0, 1060] ldr w3, [x25, 24] add w1, w1, w3 str w1, [x0, 1060] ldr x25, [x29, 64] b .L125 .LVL430: .L204: 560 %FINISH 561 %RESULT = J 562 %END mov w0, w2 adrp x1, :got:__stack_chk_guard ldr x1, [x1, #:got_lo12:__stack_chk_guard] ldr x2, [x29, 1448] ldr x1, [x1] eor x1, x2, x1 cbnz x1, .L218 ldp x29, x30, [sp] add sp, sp, 1456 ret .LVL286: .L217: str x25, [x29, 64] mov x25, x18 .L127: bl __stack_chk_fail .LVL432: .LFE194: .align 2 MOVES.7789: .LFB193: ?LIST2 unused 563 !! 564 DIAG = 0 str wzr, [x29, 664] 565 LIST == RECORD(0) str xzr, [x29, 616] .LVL433: 566 WHICHX = WHICH&BIT 567 !! 568 %IF SCRQ = 3 %START; ! PIN ENTRY cmp w1, 3 beq .L323 .L236: 569 X = PX; Y = PY adrp x1, .LANCHOR0 add x1, x1, :lo12:.LANCHOR0 ldr w2, [x1, 1068] str w2, [x29, 680] 570 SQU = (Y-1)*8+X ldr w0, [x1, 1072] str w0, [x29, 676] sub w0, w0, #1 add w0, w2, w0, lsl 3 str w0, [x29, 644] .L237: 571 -> PIN ENTRY 572 %FINISH 573 574 !! 575 SQU = 0 str wzr, [x29, 644] 576 %CYCLE Y = 1,1, 8 577 578 %CYCLE X = 1, 1, 8 579 TYPE = -1 mov w0, 0 .L238: mov w0, -1 str w0, [x29, 692] ldr w0, [x29, 676] cmp w0, 8 beq .L241 ldp x20, x21, [x29, 24] ldp x23, x24, [x29, 48] ldp x25, x26, [x29, 64] ldp x27, x28, [x29, 80] b .L238 .LVL505: .L277: 580 SQU = SQU+1 add w0, w0, 1 str w0, [x29, 676] ldr w0, [x29, 644] add w0, w0, 1 str w0, [x29, 644] b .L237 .L323: 581 PIN ENTRY: mov w0, 0 .L242: ldr w0, [x29, 680] cmp w0, 8 bne .L242 .L239: stp x20, x21, [x29, 24] stp x23, x24, [x29, 48] stp x25, x26, [x29, 64] stp x27, x28, [x29, 80] .L240: 582 Q = PT(SQU)_P; ! PICK UP PIECE(X,Y) add w0, w0, 1 str w0, [x29, 680] ldr w0, [x29, 644] sub w0, w0, #1 add x0, x19, x0, sxtw 3 ldr x0, [x0, 32] ldr w0, [x0] str w0, [x29, 688] 583 %IF Q # 0 %AND (Q&BIT = WHICHX %OR %C cbz w0, .L289 584 SCRQ > 0) %START tst w0, w22, lsr 31 bne .L246 585 %IF Q<0 %THEN QQ=-Q %AND W2=-1 %ELSE %C ldr w1, [x29, 700] cmp w1, 0 ble .L289 .L246: stp x20, x21, [x29, 24] str x23, [x29, 48] tbnz w0, #31, .L324 .L247: 586 QQ = Q %AND W2 = +1 neg w0, w0 str w0, [x29, 696] 587 -> MOVE(QQ) ldr w20, [x29, 696] .LVL435: .LDL15: mov w0, -1 str w0, [x29, 640] 588 b .L248 .LVL438: .L251: 589 MOVE(1): ! PAWN 590 TYPE = 0 str w0, [x29, 696] str wzr, [x29, 692] 591 PIN FLAG = 0 mov w0, 1 str w0, [x29, 640] .L248: .LVL434: str wzr, [x29, 660] 592 K = DOM(X, Y-W2) add x18, x29, 616 ldr w1, [x29, 676] ldr w0, [x29, 640] sub w1, w1, w0 ldr w0, [x29, 680] bl DOM.8047 .LVL439: 593 PIN FLAG = 0 str wzr, [x29, 660] 594 K=DOM(X, Y-W2-W2) %IF (Y=2 %OR Y=7) %AND K#0 ldr w1, [x29, 676] 595 TYPE = 1 cmp w1, 7 ccmp w1, 2, 4, ne bne .L252 .L253: mov w0, 1 str w0, [x29, 692] 596 PIN FLAG = 0 str wzr, [x29, 660] 597 K = DOM(X-1, Y-W2); PIN FLAG = 0; K=DOM(X+1, Y-W2) cbnz w0, .L325 .LVL440: .L252: add x20, x29, 616 .LVL441: mov x18, x20 ldr w1, [x29, 676] ldr w0, [x29, 640] sub w1, w1, w0 ldr w0, [x29, 680] sub w0, w0, #1 bl DOM.8047 .LVL442: 598 ->OUT str wzr, [x29, 660] ldp x20, x21, [x29, 24] ldr x23, [x29, 48] b .L289 .LVL444: .L325: add x18, x29, 616 ldr w0, [x29, 640] .LVL445: sub w1, w1, w0, lsl 1 ldr w0, [x29, 680] bl DOM.8047 .LVL446: b .L252 .L254: .LVL447: 599 !! mov x18, x20 ldr w1, [x29, 676] ldr w0, [x29, 640] sub w1, w1, w0 ldr w0, [x29, 680] add w0, w0, 1 bl DOM.8047 .LVL443: 600 MOVE(2): ! KNIGHT 601 %CYCLE A = -2, 4, 2 602 %CYCLE B = -1, 2, 1 mov w21, -6 603 PIN FLAG = 0 mov w20, -3 .LVL451: .L255: str wzr, [x29, 660] 604 K = DOM(X+A, Y+B) add x23, x29, 616 b .L256 .LVL448: .L327: .LDL16: .LDL17: cmp w21, 2 beq .L326 .LVL449: .L256: mov x18, x23 ldr w1, [x29, 676] add w1, w20, w1 ldr w0, [x29, 680] add w0, w21, w0 bl DOM.8047 .LVL453: 605 PIN FLAG = 0 add w21, w21, 4 .LVL450: str wzr, [x29, 660] cmp w20, 1 bne .L255 b .L327 .L326: 606 K = DOM(X+B, Y+A) add w20, w20, 2 .LVL452: mov x18, x23 ldr w1, [x29, 676] add w1, w21, w1 ldr w0, [x29, 680] add w0, w20, w0 bl DOM.8047 .LVL454: .LDL18: 607 %REPEAT 608 %REPEAT 609 -> OUT 610 !!! 611 MOVE(3): ! BISHOP ldp x20, x21, [x29, 24] .LVL455: ldr x23, [x29, 48] b .L289 .LVL456: .L258: .L259: 612 MOVE(5): ! QUEEN 613 DIAG = 1 mov w0, 1 str w0, [x29, 664] .LVL457: 614 I = 0; PIN FLAG = 0 mov w21, 0 615 %CYCLE str wzr, [x29, 660] 616 I = I-1 sub w21, w21, #1 .LVL459: 617 K = DOM(X+I, Y+I) add x23, x29, 616 .LVL458: .L260: mov x18, x23 ldr w1, [x29, 676] add w1, w21, w1 ldr w0, [x29, 680] add w0, w21, w0 bl DOM.8047 .LVL460: mov w20, w0 .LVL461: 618 %REPEAT %UNTIL K = 0 cbnz w0, .L260 .L261: .LVL462: 619 I = 0; PIN FLAG = 0 620 %CYCLE str wzr, [x29, 660] 621 I = I-1 sub w20, w20, #1 .LVL464: 622 K = DOM(X-I, Y+I) add x23, x29, 616 .LVL463: .L262: mov x18, x23 ldr w1, [x29, 676] add w1, w20, w1 ldr w0, [x29, 680] .LVL465: sub w0, w0, w20 bl DOM.8047 .LVL466: mov w21, w0 .LVL467: 623 %REPEAT %UNTIL K = 0 cbnz w0, .L262 .L263: .LVL468: 624 I = 0; PIN FLAG = 0 625 %CYCLE str wzr, [x29, 660] 626 I = I-1 sub w21, w21, #1 .LVL470: 627 K = DOM(X+I, Y-I) add x23, x29, 616 .LVL469: .L264: mov x18, x23 ldr w1, [x29, 676] sub w1, w1, w21 ldr w0, [x29, 680] .LVL471: add w0, w21, w0 bl DOM.8047 .LVL472: mov w20, w0 .LVL473: 628 %REPEAT %UNTIL K = 0 cbnz w0, .L264 .L265: .LVL474: 629 I = 0; PIN FLAG = 0 630 %CYCLE str wzr, [x29, 660] 631 I = I-1 sub w20, w20, #1 .LVL476: 632 K = DOM(X-I, Y-I) add x21, x29, 616 .LVL475: .L266: mov x18, x21 ldr w1, [x29, 676] sub w1, w1, w20 ldr w0, [x29, 680] .LVL477: sub w0, w0, w20 bl DOM.8047 .LVL478: 633 %REPEAT %UNTIL K = 0 cbnz w0, .L266 .L267: 634 -> OUT %IF QQ # QUEEN; ! THE BISHOP ldr w0, [x29, 696] .LVL479: cmp w0, 5 beq .L269 .L245: .L285: .L286: .L287: .L288: ldp x20, x21, [x29, 24] .LVL480: ldr x23, [x29, 48] b .L289 .L268: .L269: 635 636 MOVE(4): ! ROOK 637 DIAG = 0 str wzr, [x29, 664] .LVL481: 638 K = 1; I = 0; PIN FLAG = 0 639 %CYCLE mov w21, 0 640 I = I-1 str wzr, [x29, 660] sub w21, w21, #1 .LVL483: 641 K = DOM(X, Y+I) add x23, x29, 616 .LVL482: .L270: mov x18, x23 ldr w1, [x29, 676] add w1, w21, w1 ldr w0, [x29, 680] bl DOM.8047 .LVL484: mov w20, w0 .LVL485: 642 %REPEAT %UNTIL K = 0 cbnz w0, .L270 .L271: .LVL486: 643 I = 0; PIN FLAG = 0 644 %CYCLE str wzr, [x29, 660] 645 I = I+1 add w20, w20, 1 .LVL488: 646 K = DOM(X+I, Y) add x23, x29, 616 .LVL487: .L272: mov x18, x23 ldr w1, [x29, 676] ldr w0, [x29, 680] .LVL489: add w0, w20, w0 bl DOM.8047 .LVL490: mov w21, w0 .LVL491: 647 %REPEAT %UNTIL K = 0 cbnz w0, .L272 .L273: .LVL492: 648 I = 0; PIN FLAG = 0 649 %CYCLE str wzr, [x29, 660] 650 I = I+1 add w21, w21, 1 .LVL494: 651 K = DOM(X, Y+I) add x23, x29, 616 .LVL493: .L274: mov x18, x23 ldr w1, [x29, 676] add w1, w21, w1 ldr w0, [x29, 680] .LVL495: bl DOM.8047 .LVL496: mov w20, w0 .LVL497: 652 %REPEAT %UNTIL K = 0 cbnz w0, .L274 .L275: .LVL498: 653 I = 0; PIN FLAG = 0 654 %CYCLE str wzr, [x29, 660] 655 I = I-1 sub w20, w20, #1 .LVL500: 656 K = DOM(X+I, Y) add x21, x29, 616 .LVL499: .L276: mov x18, x21 ldr w1, [x29, 676] ldr w0, [x29, 680] .LVL501: add w0, w20, w0 bl DOM.8047 .LVL502: 657 %REPEAT %UNTIL K = 0 cbnz w0, .L276 658 -> OUT 659 ldp x20, x21, [x29, 24] .LVL503: ldr x23, [x29, 48] .LVL504: .L289: 660 661 !! 662 MOVE(6): ! KING 663 ROW == BRD(Y) ldr w0, [x29, 676] sub w0, w0, #1 sbfiz x1, x0, 7, 32 adrp x0, .LANCHOR0 add x0, x0, :lo12:.LANCHOR0 add x0, x0, x1 str x0, [x29, 624] .LVL506: 664 %CYCLE A = -1, 1, 1 665 %CYCLE B = -1, 1, 1 mov w21, -2 666 %IF A#0 %OR B#0 %START mov w20, -2 .LVL510: .L278: 667 PIN FLAG = 0 cmp w21, 1 beq .L328 .LVL508: .L280: orr w0, w21, w20 cbz w0, .L278 .L282: str wzr, [x29, 660] 668 K = DOM(X+A, Y+B) add x23, x29, 616 b .L280 .LVL507: .L329: .LDL19: .LDL20: add w21, w21, 1 .LVL509: mov x18, x23 ldr w1, [x29, 676] add w1, w20, w1 ldr w0, [x29, 680] add w0, w21, w0 bl DOM.8047 .LVL512: cmp w20, 1 bne .L278 b .L329 .L328: .L279: 669 ! %IF K#0 %AND W2#WHICH %THEN K MOB=K MOB+1 add w20, w20, 1 .LVL511: 670 %FINISH 671 %REPEAT 672 %REPEAT 673 %IF LAST CHK # Q %AND %C adrp x0, .LANCHOR0+1076 ldr w1, [x0, #:lo12:.LANCHOR0+1076] ldr w0, [x29, 688] cmp w1, w0 beq .L316 674 KCASCH(W2) = Y %AND KMOVE(W2)=0 %START ldr w3, [x29, 640] add w2, w3, 1 adrp x0, .LANCHOR1 add x0, x0, :lo12:.LANCHOR1 add x0, x0, 3568 ldr w1, [x0, w2, sxtw 2] ldr w0, [x29, 676] cmp w1, w0 beq .L330 ldp x20, x21, [x29, 24] .LVL513: ldr x23, [x29, 48] b .L289 .LVL514: .L330: 675 ! CORRECT ROW AND ABLE TO CASTLE adrp x0, .LANCHOR0 add x0, x0, :lo12:.LANCHOR0 add x0, x0, 1080 ldrb w0, [x0, w2, sxtw] cbnz w0, .L318 .LBB468: 676 %IF ROW_R(6)_P = 0 = ROW_R(7)_P %AND %C 677 ROW_R(8)_P = ROOK*W2 %START 678 TYPE = 6; K = DOM(7, Y); ! DO CASTLE mov w0, 6 str w0, [x29, 692] 679 %FINISH ldr x0, [x29, 624] .LVL515: ldr w2, [x0, 80] cbnz w2, .L284 add x18, x29, 616 mov w0, 7 bl DOM.8047 .LVL519: b .L284 .LVL520: .L332: 680 %IF ROW_R(4)_P = 0 =ROW_R(3)_P %AND %C 681 ROW_R(2)_P = 0 %AND ROW_R(1)_P = ROOK*W2 %C ldr w2, [x0, 96] cbnz w2, .L284 .LBE468: 682 %START 683 TYPE = 7; K = DOM(3, Y) ldr w0, [x0, 112] cmp w0, w3, lsl 2 beq .L331 .L284: .LBB469: ldr x0, [x29, 624] .LVL516: ldr w1, [x0, 48] cbnz w1, .L319 mov w0, 7 str w0, [x29, 692] 684 %FINISH add x18, x29, 616 ldr w1, [x29, 676] mov w0, 3 bl DOM.8047 .LVL521: ldp x20, x21, [x29, 24] .LVL522: ldr x23, [x29, 48] b .L289 .LVL523: .L316: ldp x20, x21, [x29, 24] .LVL524: ldr x23, [x29, 48] b .L289 .LVL525: .L318: ldp x20, x21, [x29, 24] .LVL526: ldr x23, [x29, 48] b .L289 .LVL527: .L319: ldp x20, x21, [x29, 24] .LVL528: ldr x23, [x29, 48] b .L289 .LVL529: .L320: ldp x20, x21, [x29, 24] .LVL530: ldr x23, [x29, 48] b .L289 .LVL531: .L321: ldp x20, x21, [x29, 24] .LVL532: ldr x23, [x29, 48] b .L289 .LVL533: .L241: 685 %FINISH ldr w1, [x0, 32] cbnz w1, .L320 .LBE469: 686 !! 687 OUT: ldr w1, [x0, 16] cbnz w1, .L321 688 %FINISH ldr w0, [x0] ldr w1, [x29, 640] cmp w0, w1, lsl 2 beq .L332 ldp x20, x21, [x29, 24] .LVL517: ldr x23, [x29, 48] b .L289 .LVL518: .L331: 689 %RESULT = 0 %IF SCRQ = 3 ldr w1, [x29, 700] cmp w1, 3 beq .L235 .L243: .L244: 690 %REPEAT mov w0, 0 691 %REPEAT 692 CHECK PINS(WHICH) %IF SCRQ > 0 cmp w1, 0 ble .L300 .LVL534: .LBB470: .LBB471: 693 ! ONLY ON SCORE ENTRY ldr w28, [x29, 672] .LVL535: .LBB475: .LBB474: .LBB472: 694 695 %RESULT = ADDR(LIST) ldr w0, [x29, 616] ldp x20, x21, [x29, 24] ldp x23, x24, [x29, 48] ldp x25, x26, [x29, 64] ldp x27, x28, [x29, 80] .L235: 696 %END 697 !! 698 %INTEGERFN SORT AND PRUNE(%RECORD(LISTF)%NAME LIST, %C .LVL69: sub sp, sp, #1408 stp x29, x30, [sp] add x29, sp, 0 stp x21, x22, [sp, 32] mov x21, x0 mov w22, w1 adrp x0, :got:__stack_chk_guard .LVL70: ldr x0, [x0, #:got_lo12:__stack_chk_guard] ldr x1, [x0] str x1, [x29, 1400] mov x1,0 .LVL71: sub w0, w20, #1 cmp w0, 5 bhi .L249 .L250: adrp x0, :got:_imp_current_file ldr x0, [x0, #:got_lo12:_imp_current_file] ldr x0, [x0] cbz x0, .L301 add x8, x29, 968 bl _imp_c2istr .LVL555: .L302: adrp x0, :got:_imp_current_line ldr x0, [x0, #:got_lo12:_imp_current_line] ldr w23, [x0] cmp w23, 0 mov w0, 698 csel w23, w23, w0, ne add x21, x29, 96 mov x2, 256 add x1, x29, 968 mov x0, x21 bl memcpy .LVL556: mov w0, 587 str w0, [sp] adrp x7, .LC35 add x7, x7, :lo12:.LC35 mov w6, w20 adrp x5, .LC36 add x5, x5, :lo12:.LC36 mov w4, w20 mov w3, 3 mov w2, 6 mov w1, w23 mov x0, x21 bl _signal_eventf .LVL557: b .L250 .L301: str x24, [x29, 56] .LBB476: add x23, x29, 1736 mov x24, 256 mov x2, x24 adrp x1, .LANCHOR1 add x1, x1, :lo12:.LANCHOR1 mov x0, x23 bl memcpy .LVL558: add x21, x29, 712 mov x2, x24 mov x1, x23 mov x0, x21 bl memcpy .LVL559: .LBE476: mov x2, x24 mov x1, x21 add x0, x29, 968 bl memcpy .LVL560: ldr x24, [x29, 56] b .L302 .LVL561: .L334: stp x20, x21, [x29, 24] stp x23, x24, [x29, 48] stp x25, x26, [x29, 64] stp x27, x28, [x29, 80] 699 %INTEGER WIDTH, WHICH) sub w20, w20, #1 .LVL436: adrp x0, .LANCHOR3 add x0, x0, :lo12:.LANCHOR3 ldr x0, [x0, w20, sxtw 3] br x0 .LVL437: .L324: 700 adrp x1, :got:__stack_chk_guard ldr x1, [x1, #:got_lo12:__stack_chk_guard] ldr x2, [x29, 1992] ldr x1, [x1] eor x1, x2, x1 cbnz x1, .L334 ldr x19, [sp, 32] ldr x22, [sp, 56] ldp x29, x30, [sp, 16] add sp, sp, 2016 ret .LVL554: .L249: bl __stack_chk_fail .LVL562: .LFE193: .align 2 TRYANOTHERPLY.7933: .LFB191: 701 702 %INTEGER I, MAX 703 %RECORD(LISTF)%NAME M1, M2, L, LN, RES 704 %CONSTINTEGERARRAY MAXA(-1:1) = 25000, 0, -25000 mov w0, 25000 str w0, [x29, 616] str wzr, [x29, 620] mov w0, -25000 str w0, [x29, 624] 705 !! 706 707 %RESULT = 0 %IF ADDR(LIST) = 0 cbz x21, .L29 stp x19, x20, [x29, 16] str x23, [x29, 48] mov w20, w2 mov x23, x18 .L31: .LVL72: .LBB308: 708 mov w0, 0 709 RES == RECORD(0) 710 %CYCLE I = 1, 1, WIDTH 711 M1 == RECORD(0) mov x4, x5 b .L44 .LVL102: .L38: .LBE308: 712 M2 == M1; LN == M1 cmp w22, #1 bmi .L59 .LVL73: .L32: adrp x0, :got:_imp_current_file ldr x0, [x0, #:got_lo12:_imp_current_file] ldr x0, [x0] cbz x0, .L33 add x8, x29, 888 bl _imp_c2istr .LVL77: .L34: adrp x0, :got:_imp_current_line ldr x0, [x0, #:got_lo12:_imp_current_line] ldr w24, [x0] cmp w24, 0 mov w0, 712 csel w24, w24, w0, ne add x26, x29, 1144 mov x8, x26 adrp x0, .LC33 add x0, x0, :lo12:.LC33 bl _imp_c2istr .LVL78: add x19, x29, 352 mov x27, 256 mov x2, x27 add x1, x29, 888 mov x0, x19 bl memcpy .LVL79: add x25, x29, 96 mov x2, x27 mov x1, x26 mov x0, x25 bl memcpy .LVL80: mov w5, 0 mov w4, 1 mov w3, 5 mov x2, x25 mov w1, w24 mov x0, x19 bl _signal_event .LVL81: ldp x24, x25, [x29, 56] ldp x26, x27, [x29, 72] b .L32 .LVL82: .L33: .LBB309: add x24, x29, 1144 mov x25, 256 mov x2, x25 .LVL83: adrp x1, .LANCHOR1 add x1, x1, :lo12:.LANCHOR1 mov x0, x24 bl memcpy .LVL84: add x19, x29, 632 mov x2, x25 mov x1, x24 mov x0, x19 bl memcpy .LVL85: .LBE309: mov x2, x25 mov x1, x19 add x0, x29, 888 bl memcpy .LVL86: b .L34 .LVL87: .L55: mov x19, x5 mov x19, x5 b .L46 .LVL119: .L62: stp x19, x20, [x29, 16] stp x23, x24, [x29, 48] stp x25, x26, [x29, 64] str x27, [x29, 80] .LBE311: 713 MAX = MAXA(WHICH) add w0, w20, 1 .LVL75: mov x7, 0 mov x0, x5 714 715 L == LIST cbz w22, .L53 .LVL74: cmp w22, w6 beq .L38 mov x19, 0 b .L36 .LVL106: .L57: .LBE310: 716 %%EXIT %IF ADDR(L) = 0 mov w6, 1 add w6, w6, 1 .LVL100: mov x7, x19 cbz x21, .L39 .LVL101: .L37: 717 718 %WHILE ADDR(L) # 0 %CYCLE 719 %IF (WHICH<0 %AND L_SCORE0 %AND L_SCORE>MAX) %START ldr w2, [x1, 8] cmp w2, w3 bge .L43 .L42: .LVL90: 721 !! 722 M2 == L; M1 == LN; MAX = L_SCORE cmp w20, 0 ble .L43 723 %FINISH ldr w2, [x1, 8] cmp w2, w3 ble .L43 724 !! ldr w3, [x1, 8] .LVL91: mov x19, x1 mov x4, x0 .LVL92: .L43: b .L42 .LVL96: .L60: .L45: 725 LN == L; L == L_L 726 %REPEAT ldr x2, [x1] .LDL1: .LDL2: .LVL93: mov x0, x1 mov x1, x2 .LVL95: .L44: 727 728 !! 729 L == M2_L; ! PICKUP ITS POINTER mov x5, 0 mov x21, x0 .LVL88: b .L46 .LVL89: .L61: ldr x0, [x19] .LVL97: ldr x21, [x5] .LVL117: 730 M2_L == RES str x7, [x19] .LVL98: str x7, [x5] .LVL118: 731 RES == M2; ! NOTE LINKS BACKWARDS 732 %IF ADDR(M1) = 0 %THEN LIST == L %ELSE %C cbz x4, .L55 .L47: 733 M1_L == L 734 %REPEAT 735 736 %IF ADDR(LIST) # 0 %THEN RELEASE CHAIN(LIST) str x0, [x4] .LVL99: .L46: cbz x21, .L39 .LVL103: .L36: 737 L == RECORD (0) mov x18, x23 mov x0, x21 bl RELEASECHAIN.7846 .LVL104: .L39: 738 %WHILE ADDR(RES) # 0 %CYCLE 739 M1 == RES_L; ! NEXT LINK cbz x19, .L56 mov x1, 0 b .L49 .LVL105: .L53: .LBB310: ldr x0, [x19] .LVL108: cbnz x0, .L57 .LVL110: .L48: mov x19, 0 .LVL115: b .L48 .LVL116: .L40: .LBB311: 740 RES_L == L; ! LINK TO NEXT str x1, [x19] .LVL109: mov x1, x19 741 L == RES 742 RES == M1 mov x19, x0 .LVL107: .L49: 743 %REPEAT 744 %RESULT = ADDR(L) mov w0, w19 ldp x19, x20, [x29, 16] .LVL111: ldr x23, [x29, 48] .LVL112: .L29: 745 %END adrp x1, :got:__stack_chk_guard ldr x1, [x1, #:got_lo12:__stack_chk_guard] ldr x2, [x29, 1400] ldr x1, [x1] eor x1, x2, x1 cbnz x1, .L62 ldp x21, x22, [sp, 32] .LVL113: ldp x29, x30, [sp] add sp, sp, 1408 ret .LVL114: .L56: bl __stack_chk_fail .LVL120: .LFE195: .align 2 EXVAL.7901: .LFB189: 746 !! 747 %INTEGERFN CHANGE BOARD(%RECORD(LISTF{QHF})%NAME B) .LVL3: 748 749 %RECORD(SQF)%NAME SQ 750 %RECORD(ROWF)%NAME ROW 751 %RECORD(LISTF)%NAME LIST 752 %INTEGER FROM, TO, X, Y, X0, Y0, KING, CAS, ROOK 753 LIST == B_L ldr x5, [x0] .LVL4: 754 FROM = LIST_FR; TO = LIST_TO ldrb w2, [x5, 4] .LVL5: 755 X = FROM>>4; X0 = TO>>4 ldrb w3, [x5, 5] .LVL6: lsr w7, w2, 4 .LVL7: 756 Y = FROM&15; Y0 = TO&15 and w6, w2, 15 .LVL8: lsr w3, w3, 4 .LVL9: sub w1, w3, #1 .LVL10: 757 SQ == BRD(Y0)_R(X0) and w4, w3, 15 sub w4, w4, #1 758 B_HOLD = SQ_P sbfiz x2, x4, 3, 32 .LVL11: add x2, x2, x1, sxtw lsl x2, x2, 4 adrp x3, .LANCHOR0 add x3, x3, :lo12:.LANCHOR0 ldr w2, [x3, x2] str w2, [x0] .LVL12: 759 %IF LIST_SPEC # 0 %START ldr w3, [x5, 8] cbz w3, .L6 760 %IF LIST_SPEC >= 6 %START; ! CASTLE cmp w3, 5 ble .L7 761 %IF SQ_P<0 %START sbfiz x0, x4, 3, 32 .LVL13: add x0, x0, x1, sxtw lsl x0, x0, 4 adrp x2, .LANCHOR0 add x2, x2, :lo12:.LANCHOR0 ldr w0, [x2, x0] tbnz w0, #31, .L14 .L8: .LVL14: 762 CAS = 1; KING = -6; ROOK = -4; KCAS(-1) = -30 mov w2, 1 763 %FINISHELSESTART mov w0, -6 b .L9 .LVL23: .L15: 764 CAS = 8; KING = 6; ROOK = 4; KCAS(1) = 30 mov w2, 8 mov w5, -4 .LVL22: 765 %FINISH mov w0, 6 .LVL16: .L9: adrp x0, .LANCHOR0+1024 mov w2, -30 str w2, [x0, #:lo12:.LANCHOR0+1024] 766 ROW == BRD(CAS) mov w5, 4 .LVL15: sub w2, w2, #1 .LVL17: cmp w3, 6 beq .L15 .L10: 767 %IF LIST_SPEC = 6 %START; ! KING SIDE adrp x0, .LANCHOR0+1032 mov w2, 30 str w2, [x0, #:lo12:.LANCHOR0+1032] 768 ROW_R(7)_P = KING; ROW_R(6)_P = ROOK sbfiz x2, x2, 7, 32 .LVL24: adrp x3, .LANCHOR0 add x3, x3, :lo12:.LANCHOR0 add x2, x3, x2 str w0, [x2, 96] 769 ROW_R(8)_P = 0 str w5, [x2, 80] str wzr, [x2, 112] 770 %FINISHELSESTART b .L11 .LVL25: .L7: 771 ROW_R(3)_P = KING; ROW_R(4)_P = ROOK adrp x3, .LANCHOR0 add x3, x3, :lo12:.LANCHOR0 sbfiz x2, x2, 7, 32 .LVL18: add x6, x3, x2 .LVL19: str w0, [x6, 32] 772 ROW_R(1)_P = 0 str w5, [x6, 48] str wzr, [x3, x2] .L11: 773 %FINISH 774 SQ_P = 0 sbfiz x4, x4, 3, 32 .LVL20: add x1, x4, x1, sxtw lsl x1, x1, 4 adrp x2, .LANCHOR0 add x2, x2, :lo12:.LANCHOR0 str wzr, [x2, x1] 775 %RESULT = KING b .L5 .LVL21: .L14: 776 %FINISH 777 SQ_P = LIST_SPEC sbfiz x0, x4, 3, 32 .LVL26: add x0, x0, x1, sxtw lsl x0, x0, 4 adrp x2, .LANCHOR0 add x2, x2, :lo12:.LANCHOR0 str w3, [x2, x0] 778 %FINISHELSESTART b .L13 .LVL27: .L6: 779 SQ_P = BRD(Y)_R(X)_P adrp x0, .LANCHOR0 .LVL28: add x0, x0, :lo12:.LANCHOR0 sub w3, w7, #1 sub w2, w6, #1 sbfiz x2, x2, 3, 32 add x3, x2, x3, sxtw lsl x3, x3, 4 ldr w2, [x0, x3] sbfiz x3, x4, 3, 32 add x3, x3, x1, sxtw lsl x3, x3, 4 str w2, [x0, x3] .L13: 780 %FINISH 781 BRD(Y)_R(X)_P = 0 adrp x3, .LANCHOR0 add x3, x3, :lo12:.LANCHOR0 sub w0, w7, #1 sub w2, w6, #1 sbfiz x2, x2, 3, 32 add x0, x2, x0, sxtw lsl x0, x0, 4 str wzr, [x3, x0] 782 %RESULT = SQ_P sbfiz x0, x4, 3, 32 add x1, x0, x1, sxtw .LVL29: lsl x1, x1, 4 ldr w0, [x3, x1] .LVL30: .L5: 783 %END ret .LFE196: .align 2 RESTOREBOARD.7796: .LFB197: 784 !! 785 %ROUTINE RESTORE BOARD(%RECORD(LISTF{QHF})%NAME B) .LVL31: 786 %RECORD(SQF)%NAME SQ 787 %RECORD(ROWF)%NAME ROW 788 %RECORD(LISTF)%NAME LIST 789 %INTEGER FROM, TO, X, Y, X0, Y0, KING, CAS, ROOK 790 LIST == B_L ldr x7, [x0] .LVL32: 791 FROM = LIST_FR; TO = LIST_TO ldrb w1, [x7, 4] .LVL33: 792 X = FROM>>4; X0 = TO>>4 ldrb w4, [x7, 5] .LVL34: lsr w2, w1, 4 .LVL35: 793 Y = FROM&15; Y0 = TO&15 and w1, w1, 15 .LVL36: lsr w3, w4, 4 sub w3, w3, #1 .LVL38: 794 SQ == BRD(Y0)_R(X0) and w6, w4, 15 .LVL37: sub w5, w6, #1 795 %IF LIST_SPEC # 0 %START ldr w4, [x7, 8] .LVL39: cbz w4, .L25 796 %IF LIST_SPEC >= 6 %START; ! CASTLE cmp w4, 5 ble .L18 797 %IF Y0 = 1 %START cmp w6, 1 beq .L26 .L19: .LVL40: 798 CAS = 1; KING = -6; ROOK = -4; KCAS(-1) = 0 799 %FINISHELSESTART mov w1, -6 .LVL52: b .L20 .LVL53: .L27: 800 CAS = 8; KING = 6; ROOK = 4; KCAS(1) = 0 mov w6, 8 .LVL43: mov w2, -4 .LVL51: 801 %FINISH mov w1, 6 .LVL44: .L20: adrp x0, .LANCHOR0+1024 .LVL50: str wzr, [x0, #:lo12:.LANCHOR0+1024] 802 ROW == BRD(CAS) mov w2, 4 .LVL42: sub w6, w6, #1 .LVL45: cmp w4, 6 beq .L27 .L21: 803 %IF LIST_SPEC = 6 %START; ! KING SIDE adrp x0, .LANCHOR0+1032 .LVL41: str wzr, [x0, #:lo12:.LANCHOR0+1032] 804 ROW_R(8)_P = ROOK sbfiz x6, x6, 7, 32 .LVL54: adrp x0, .LANCHOR0 add x0, x0, :lo12:.LANCHOR0 add x6, x0, x6 str w2, [x6, 112] .LVL55: 805 ROW_R(7)_P = 0; ROW_R(6)_P = 0 str wzr, [x6, 96] 806 %FINISHELSESTART str wzr, [x6, 80] b .L22 .LVL56: .L18: 807 ROW_R(1)_P = ROOK adrp x0, .LANCHOR0 add x0, x0, :lo12:.LANCHOR0 sbfiz x6, x6, 7, 32 .LVL46: add x4, x0, x6 str w2, [x0, x6] .LVL47: 808 ROW_R(3)_P = 0; ROW_R(4)_P = 0 str wzr, [x4, 32] 809 %FINISH str wzr, [x4, 48] .L22: 810 SQ_P = KING sbfiz x5, x5, 3, 32 .LVL48: add x3, x5, x3, sxtw lsl x3, x3, 4 adrp x0, .LANCHOR0 add x0, x0, :lo12:.LANCHOR0 str w1, [x0, x3] 811 %RETURN b .L16 .LVL49: .L26: 812 %FINISH 813 %IF Y0=8 %THEN SQ_P=-1 %ELSE SQ_P=1 cmp w6, 8 beq .L28 .L24: 814 %FINISH adrp x4, .LANCHOR0 add x4, x4, :lo12:.LANCHOR0 add x4, x4, x3, sxtw 4 mov w6, -1 .LVL67: str w6, [x4, 896] .LVL68: 815 BRD(Y)_R(X)_P = SQ_P adrp x4, .LANCHOR0 add x4, x4, :lo12:.LANCHOR0 sbfiz x5, x5, 3, 32 .LVL60: add x3, x5, x3, sxtw lsl x3, x3, 4 ldr w5, [x4, x3] sub w2, w2, #1 .LVL61: sub w1, w1, #1 .LVL62: sbfiz x1, x1, 3, 32 .LVL63: add x1, x1, x2, sxtw lsl x1, x1, 4 str w5, [x4, x1] b .L25 .LFE197: .align 2 SORTANDPRUNE.7783: .LFB195: 816 SQ_P = B_HOLD ldr w0, [x0] .LVL64: str w0, [x4, x3] .LVL65: .L16: 817 %END sbfiz x4, x5, 3, 32 add x4, x4, x3, sxtw lsl x4, x4, 4 adrp x6, .LANCHOR0 .LVL57: add x6, x6, :lo12:.LANCHOR0 mov w7, 1 .LVL58: str w7, [x6, x4] .LVL59: .L17: .L25: 818 !! ret .LVL66: .L28: 819 !! 820 %ROUTINE BURP(%RECORD(LISTF{QHF})%NAME X, %INTEGER W) .LVL655: stp x29, x30, [sp, -64]! add x29, sp, 0 stp x19, x20, [sp, 16] stp x21, x22, [sp, 32] stp x23, x24, [sp, 48] mov x24, x0 mov w20, w1 821 %INTEGER I 822 !! 823 TELL(X_L, W) ldr x0, [x0] .LVL656: bl TELL.7802 .LVL657: .LBB536: .LBB537: adrp x23, :got:_imp_OutStream ldr x23, [x23, #:got_lo12:_imp_OutStream] mov w0, 2 str w0, [x23] adrp x21, :got:_imp_OutFile ldr x21, [x21, #:got_lo12:_imp_OutFile] adrp x22, :got:_imp_outfile ldr x22, [x22, #:got_lo12:_imp_outfile] ldr x0, [x22, 584] str x0, [x21] adrp x19, .LANCHOR1 add x19, x19, :lo12:.LANCHOR1 add x19, x19, 3032 mov x0, x19 bl check_outstream .LVL658: .LBE537: .LBE536: .LBB538: .LBB539: mov w0, 42 bl _imp_printsymbol .LVL659: .LBE539: .LBE538: 824 SELECT OUTPUT(2) 825 PRINTSYMBOL('*'); TELL(X_L, W) 826 SELECT OUTPUT(0) mov w1, w20 ldr x0, [x24] bl TELL.7802 .LVL660: .LBB540: .LBB541: str wzr, [x23] ldr x0, [x22, 8] str x0, [x21] mov x0, x19 bl check_outstream .LVL661: .LBE541: .LBE540: 827 ! %IF W > 0 %AND TIMTT < 3 %AND PDEPTH#1 %THEN PDEPTH=PDEPTH+1 828 I = CHANGE BOARD(X) mov x0, x24 bl CHANGEBOARD.7794 .LVL662: 829 %IF I = KING*W %THEN KMOVE(W) = 1 add w1, w20, w20, lsl 1 cmp w0, w1, lsl 1 beq .L384 .L382: .LVL663: .L381: 830 %END adrp x0, .LANCHOR0 .LVL666: add x0, x0, :lo12:.LANCHOR0 add x0, x0, 1080 add w20, w20, 1 .LVL667: mov w1, 1 strb w1, [x0, w20, sxtw] b .L381 .LFE198: .align 2 .global main main: .LFB185: 831 !! ldp x19, x20, [sp, 16] ldp x21, x22, [sp, 32] ldp x23, x24, [sp, 48] .LVL664: ldp x29, x30, [sp], 64 ret .LVL665: .L384: 832 %ROUTINE TELL(%RECORD(LISTF)%NAME MOVE, %INTEGER WHICH) .LVL213: sub sp, sp, #1344 stp x29, x30, [sp] add x29, sp, 0 stp x19, x20, [sp, 16] mov x19, x0 mov w20, w1 adrp x0, :got:__stack_chk_guard .LVL214: ldr x0, [x0, #:got_lo12:__stack_chk_guard] ldr x1, [x0] str x1, [x29, 1336] mov x1,0 .LVL215: 833 834 %IF ADDR(MOVE) = 0 %START cbz x19, .L114 .L107: str x21, [x29, 32] 835 %IF WHICH < 0 %THEN PRINTSTRING("I Win tbnz w20, #31, .L116 .L108: .LBB359: 836 ") %ELSE %C add x20, x29, 1080 .LVL244: mov x21, 256 mov x2, x21 adrp x1, .LANCHOR1 add x1, x1, :lo12:.LANCHOR1 add x1, x1, 1752 mov x0, x20 bl memcpy .LVL245: add x19, x29, 312 .LVL246: mov x2, x21 mov x1, x20 mov x0, x19 bl memcpy .LVL247: add x20, x29, 824 mov x2, x21 mov x1, x19 mov x0, x20 bl memcpy .LVL248: .LBE364: .LBB365: .LBB366: add x19, x29, 48 mov x2, x21 mov x1, x20 mov x0, x19 bl memcpy .LVL249: mov x0, x19 bl _imp_printstring .LVL250: b .L109 .LVL251: .L110: .LBE366: .LBE365: .LBB367: .LBB368: mov w0, 4 bl _imp_spaces .LVL252: .LBE368: .LBE367: 837 PRINTSTRING("YOU WIN 838 ") 839 %STOP add x19, x29, 1080 .LVL236: mov x20, 256 .LVL237: mov x2, x20 adrp x1, .LANCHOR1 add x1, x1, :lo12:.LANCHOR1 add x1, x1, 2008 mov x0, x19 bl memcpy .LVL238: add x21, x29, 568 mov x2, x20 mov x1, x19 mov x0, x21 bl memcpy .LVL239: mov x2, x20 mov x1, x21 mov x0, x19 bl memcpy .LVL240: .LBE359: .LBB360: .LBB361: add x0, x29, 48 mov x2, x20 mov x1, x19 mov x19, x0 bl memcpy .LVL241: mov x0, x19 bl _imp_printstring .LVL242: .L109: .LBE361: .LBE360: .LBB362: .LBB363: mov w0, 0 bl exit .LVL243: .L116: .LBE363: .LBE362: .LBB364: 840 %FINISH 841 !! 842 WRITE(NO, 1) mov w1, 1 adrp x0, .LANCHOR2 ldr w0, [x0, #:lo12:.LANCHOR2] bl _imp_writeint .LVL216: 843 %IF WHICH > 0 %THEN SPACES(25) %ELSE SPACES(4) cmp w20, 0 ble .L110 .LVL217: .LBB348: .LBB349: mov w0, 25 bl _imp_spaces .LVL218: .LBE349: .LBE348: 844 PRINTMOVE(MOVE) mov x0, x19 bl PRINTMOVE.7806 .LVL219: .LBB350: mov x0, x19 bl PRINTMOVE.7806 .LVL253: .LBB369: 845 PRINTSTRING("(") add x20, x29, 1080 .LVL220: mov x21, 256 mov x2, x21 adrp x1, .LANCHOR1 add x1, x1, :lo12:.LANCHOR1 add x1, x1, 2264 mov x0, x20 bl memcpy .LVL221: add x19, x29, 312 .LVL222: mov x2, x21 mov x1, x20 mov x0, x19 bl memcpy .LVL223: add x20, x29, 824 mov x2, x21 mov x1, x19 mov x0, x20 bl memcpy .LVL224: .LBE350: .LBB351: .LBB352: add x19, x29, 48 mov x2, x21 mov x1, x20 mov x0, x19 bl memcpy .LVL225: mov x0, x19 bl _imp_printstring .LVL226: .LBE352: .LBE351: add x20, x29, 1080 .LVL254: mov x21, 256 mov x2, x21 adrp x1, .LANCHOR1 add x1, x1, :lo12:.LANCHOR1 add x1, x1, 2264 mov x0, x20 bl memcpy .LVL255: add x19, x29, 312 .LVL256: mov x2, x21 mov x1, x20 mov x0, x19 bl memcpy .LVL257: add x20, x29, 824 mov x2, x21 mov x1, x19 mov x0, x20 bl memcpy .LVL258: .LBE369: .LBB370: .LBB353: add x19, x29, 48 mov x2, x21 mov x1, x20 mov x0, x19 bl memcpy .LVL259: mov x0, x19 bl _imp_printstring .LVL260: .LDL7: .LBE353: .LBE370: 846 %IF WHICH > 0 %START 847 TIMTT = CPUTIME-TIME bl CPUTIME .LVL227: adrp x0, .LANCHOR0+1040 ldr d1, [x0, #:lo12:.LANCHOR0+1040] .LBB354: .LBB355: mov w1, 2 mov w0, 1 fsub d0, d0, d1 .LVL228: bl _imp_print .LVL229: .L111: .LBE355: .LBE354: .LBB356: 848 PRINT(TIMTT, 1, 2) 849 %FINISHELSESTART 850 PRINT(CPUTIME-TIME2, 1, 2) bl CPUTIME .LVL261: adrp x0, .LANCHOR0+1048 ldr d1, [x0, #:lo12:.LANCHOR0+1048] .LBB371: .LBB372: mov w1, 2 mov w0, 1 fsub d0, d0, d1 .LVL262: bl _imp_print .LVL263: b .L111 .LVL264: .L115: .LBE372: .LBE371: 851 %FINISH 852 PRINTSTRING(" Secs) add x19, x29, 1080 mov x20, 256 mov x2, x20 adrp x1, .LANCHOR1 add x1, x1, :lo12:.LANCHOR1 add x1, x1, 2520 mov x0, x19 bl memcpy .LVL230: add x21, x29, 568 mov x2, x20 mov x1, x19 mov x0, x21 bl memcpy .LVL231: mov x2, x20 mov x1, x21 mov x0, x19 bl memcpy .LVL232: .LBE356: .LBB357: .LBB358: add x0, x29, 48 mov x2, x20 mov x1, x19 mov x19, x0 bl memcpy .LVL233: mov x0, x19 bl _imp_printstring .LVL234: .LBE358: .LBE357: 853 ") 854 %END 855 !! adrp x0, :got:__stack_chk_guard ldr x0, [x0, #:got_lo12:__stack_chk_guard] ldr x1, [x29, 1336] ldr x0, [x0] eor x0, x1, x0 cbnz x0, .L115 ldr x21, [x29, 32] ldp x19, x20, [sp, 16] ldp x29, x30, [sp] add sp, sp, 1344 ret .LVL235: .L114: str x21, [x29, 32] bl __stack_chk_fail .LVL265: .LFE199: .align 2 READM.8330: .LFB207: 856 %ROUTINE PRINTBOARD sub sp, sp, #2000 stp x29, x30, [sp] add x29, sp, 0 stp x19, x20, [sp, 16] stp x21, x22, [sp, 32] stp x23, x24, [sp, 48] stp x25, x26, [sp, 64] stp x27, x28, [sp, 80] adrp x0, :got:__stack_chk_guard ldr x0, [x0, #:got_lo12:__stack_chk_guard] ldr x1, [x0] str x1, [x29, 1992] mov x1,0 857 %CONSTBYTEINTEGERARRAY BLACK(1:64) = %C adrp x0, .LANCHOR1 add x0, x0, :lo12:.LANCHOR1 add x0, x0, 920 ldp x2, x3, [x0] add x1, x29, 2064 stp x2, x3, [x1, -136] ldp x2, x3, [x0, 16] stp x2, x3, [x1, -120] ldp x2, x3, [x0, 32] stp x2, x3, [x1, -104] ldp x0, x1, [x0, 48] add x2, x29, 2064 stp x0, x1, [x2, -88] 858 0, 1, 0, 1, 0, 1, 0, 1, 859 1, 0, 1, 0, 1, 0, 1, 0, 860 0, 1, 0, 1, 0, 1, 0, 1, 861 1, 0, 1, 0, 1, 0, 1, 0, 862 0, 1, 0, 1, 0, 1, 0, 1, 863 1, 0, 1, 0, 1, 0, 1, 0, 864 0, 1, 0, 1, 0, 1, 0, 1, 865 1, 0, 1, 0, 1, 0, 1, 0 866 !! 867 %ROUTINE LINE sub sp, sp, #832 stp x29, x30, [sp] add x29, sp, 0 stp x19, x20, [sp, 16] stp x21, x22, [sp, 32] adrp x20, :got:__stack_chk_guard ldr x20, [x20, #:got_lo12:__stack_chk_guard] ldr x0, [x20] str x0, [x29, 824] mov x0,0 .LBB315: 868 PRINTSTRING(" !---!---!---!---!---!---!---!---! add x19, x29, 568 mov x21, 256 mov x2, x21 adrp x1, .LANCHOR1 add x1, x1, :lo12:.LANCHOR1 add x1, x1, 664 mov x0, x19 bl memcpy .LVL149: add x22, x29, 312 mov x2, x21 mov x1, x19 mov x0, x22 bl memcpy .LVL150: mov x2, x21 mov x1, x22 mov x0, x19 bl memcpy .LVL151: .LBE315: .LBB316: .LBB317: add x0, x29, 48 mov x2, x21 mov x1, x19 mov x19, x0 bl memcpy .LVL152: mov x0, x19 bl _imp_printstring .LVL153: .LBE317: .LBE316: 869 ") 870 %END 871 !! ldr x1, [x29, 824] ldr x0, [x20] eor x0, x1, x0 cbnz x0, .L78 ldp x19, x20, [sp, 16] ldp x21, x22, [sp, 32] ldp x29, x30, [sp] add sp, sp, 832 ret .L78: bl __stack_chk_fail .LVL154: .LFE201: .align 2 BURP.8306: .LFB203: 872 %CONSTBYTEINTEGERARRAY PX(-6:6) = %C mov w0, 107 strb w0, [x29, 1912] mov w0, 113 strb w0, [x29, 1913] mov w0, 114 strb w0, [x29, 1914] mov w0, 98 strb w0, [x29, 1915] mov w0, 110 strb w0, [x29, 1916] mov w0, 112 strb w0, [x29, 1917] mov w0, 32 strb w0, [x29, 1918] mov w0, 80 strb w0, [x29, 1919] mov w0, 78 strb w0, [x29, 1920] mov w0, 66 strb w0, [x29, 1921] mov w0, 82 strb w0, [x29, 1922] mov w0, 81 strb w0, [x29, 1923] mov w0, 75 strb w0, [x29, 1924] .LVL170: adrp x28, .LANCHOR0 add x28, x28, :lo12:.LANCHOR0 add x28, x28, 896 mov w26, 8 873 'k', 'q', 'r', 'b', 'n', 'p', 874 ' ', 'P', 'N', 'B', 'R', 'Q', 'K' 875 %INTEGER X,Y, I, P, Q 876 %RECORD(ROWF)%NAME ROW 877 !! 878 Q = 1 879 %CYCLE Y = 8, -1, 1 880 ROW == BRD(Y) mov w27, 9 .LBB326: 881 LINE bl LINE.8272 .LVL200: 882 WRITE(Y, 1) cmp w27, 1 beq .L104 .LVL198: .L94: mov w1, 1 mov w0, w27 bl _imp_writeint .LVL201: sub w20, w26, #8 mov x21, x28 b .L92 .LVL202: .L104: .L95: 883 %CYCLE X = 1, 1, 8 sub w27, w27, #1 .LVL199: 884 PRINTSTRING("! ") adrp x0, .LANCHOR1 add x0, x0, :lo12:.LANCHOR1 str x0, [x29, 96] add x0, x0, 984 str x0, [x29, 104] add x23, x29, 1656 add x25, x29, 376 add x24, x29, 1144 .LBE326: .LBB327: .LBB328: add x22, x29, 112 b .L94 .LVL171: .L102: .LBE328: .LBE327: mov x19, 256 mov x2, x19 ldr x1, [x29, 104] mov x0, x23 bl memcpy .LVL178: mov x2, x19 mov x1, x23 mov x0, x25 bl memcpy .LVL179: mov x2, x19 mov x1, x25 mov x0, x24 bl memcpy .LVL180: .LBE334: .LBB335: .LBB329: mov x2, x19 mov x1, x24 mov x0, x22 bl memcpy .LVL181: mov x0, x22 bl _imp_printstring .LVL182: .LBE329: .LBE335: 885 P = ROW_R(X)_P ldr w19, [x21] .LVL183: 886 %IF P # 0 %THEN PRINTSYMBOL(PX(P)) %ELSE %START cmp w20, w26 beq .L101 .LVL177: .L92: .LBB334: cbnz w19, .L102 .L86: 887 %IF BLACK(Q) = 1 %THEN PRINTSYMBOL('*') %C add w1, w19, 6 .LVL172: .LBB330: .LBB331: add x0, x29, 1912 ldrb w0, [x0, w1, sxtw] bl _imp_printsymbol .LVL173: .LDL3: .LDL4: .LBE331: .LBE330: add x0, x29, 1928 ldrb w0, [x0, w20, sxtw] cmp w0, 1 beq .L103 .L89: .LVL184: .LBB336: .LBB337: mov w0, 32 bl _imp_printsymbol .LVL185: .L87: .LBE337: .LBE336: .LBB338: .LBB339: mov w0, 32 bl _imp_printsymbol .LVL186: b .L91 .LVL187: .L103: .LBE339: .LBE338: .LBB340: .LBB341: mov w0, 42 bl _imp_printsymbol .LVL188: b .L87 .LVL189: .L101: .L93: .LBE341: .LBE340: .LBB342: 888 %ELSE PRINTSYMBOL(' ') 889 %FINISH 890 %IF P > 0 %THEN PRINTSYMBOL('+') %ELSE %C cmp w19, 0 ble .L87 .LVL174: .LBB332: .LBB333: mov w0, 43 bl _imp_printsymbol .LVL175: .L91: .LDL5: add x21, x21, 16 add w20, w20, 1 .LVL176: .LBE333: .LBE332: 891 PRINTSYMBOL(' ') 892 Q = Q+1 893 %REPEAT 894 PRINTSTRING("! mov x20, 256 .LVL190: mov x2, x20 ldr x0, [x29, 96] add x1, x0, 1240 mov x0, x23 bl memcpy .LVL191: add x21, x29, 632 mov x2, x20 mov x1, x23 mov x0, x21 bl memcpy .LVL192: add x19, x29, 1400 .LVL193: mov x2, x20 mov x1, x21 mov x0, x19 bl memcpy .LVL194: .LBE342: .LBB343: .LBB344: mov x2, x20 mov x1, x19 mov x0, x22 bl memcpy .LVL195: mov x0, x22 bl _imp_printstring .LVL196: .LDL6: add w26, w26, 8 .LVL197: sub x28, x28, #128 .LBE344: .LBE343: 895 ") 896 %REPEAT 897 LINE bl LINE.8272 .LVL203: .LBB345: 898 PRINTSTRING(" A B C D E F G H add x19, x29, 1656 mov x2, x20 adrp x1, .LANCHOR1 add x1, x1, :lo12:.LANCHOR1 add x1, x1, 1496 mov x0, x19 bl memcpy .LVL204: add x21, x29, 888 mov x2, x20 mov x1, x19 mov x0, x21 bl memcpy .LVL205: mov x2, x20 mov x1, x21 mov x0, x19 bl memcpy .LVL206: .LBE345: .LBB346: .LBB347: add x0, x29, 112 mov x2, x20 mov x1, x19 mov x19, x0 bl memcpy .LVL207: mov x0, x19 bl _imp_printstring .LVL208: .LBE347: .LBE346: 899 ") 900 %END ?I unused 901 !! adrp x0, :got:__stack_chk_guard ldr x0, [x0, #:got_lo12:__stack_chk_guard] ldr x1, [x29, 1992] ldr x0, [x0] eor x0, x1, x0 cbnz x0, .L105 ldp x19, x20, [sp, 16] ldp x21, x22, [sp, 32] ldp x23, x24, [sp, 48] ldp x25, x26, [sp, 64] .LVL209: ldp x27, x28, [sp, 80] .LVL210: ldp x29, x30, [sp] add sp, sp, 2000 ret .LVL211: .L105: bl __stack_chk_fail .LVL212: .LFE200: .align 2 TELL.7802: .LFB199: 902 !! 903 %ROUTINE PRINTMOVE(%RECORD(LISTF)%NAME LIST) .LVL162: stp x29, x30, [sp, -32]! add x29, sp, 0 str x19, [sp, 16] mov x19, x0 904 %INTEGER I,J,K 905 %ROUTINE BURP(%INTEGER X) .LVL155: stp x29, x30, [sp, -32]! add x29, sp, 0 str x19, [sp, 16] mov w19, w0 .LVL156: 906 PRINTSYMBOL((X>>4)+'A'-1) lsr w0, w0, 4 .LVL157: add w0, w0, 64 .LBB318: .LBB319: bl _imp_printsymbol .LVL158: .LBE319: .LBE318: 907 PRINTSYMBOL(X&15+'0') and w0, w19, 15 add w0, w0, 48 .LBB320: .LBB321: bl _imp_printsymbol .LVL159: .LBE321: .LBE320: .LBB322: .LBB323: bl _imp_space .LVL160: .LBE323: .LBE322: 908 SPACE 909 %END 910 !! ldr x19, [sp, 16] .LVL161: ldp x29, x30, [sp], 32 ret .LFE203: .align 2 PRINTMOVE.7806: .LFB202: 911 BURP(LIST_FR); BURP(LIST_TO) ldrb w0, [x0, 4] .LVL163: bl BURP.8306 .LVL164: 912 %IF LIST_CHK # 0 %THEN PRINTSYMBOL('+') ldrb w0, [x19, 5] bl BURP.8306 .LVL165: ldr w0, [x19, 12] cbnz w0, .L84 .L82: 913 WRITE(LIST_SCORE, 5) mov w1, 5 ldr w0, [x19, 8] bl _imp_writeint .LVL166: 914 %END ?K unused ?J unused ?I unused 915 !! ldr x19, [sp, 16] .LVL167: ldp x29, x30, [sp], 32 ret .LVL168: .L84: .LBB324: .LBB325: mov w0, 43 bl _imp_printsymbol .LVL169: b .L82 .LBE325: .LBE324: .LFE202: .align 2 PRINTBOARD.7804: .LFB200: 916 %INTEGER %FN CHECK YOUR MOVE(%RECORD(LISTF)%NAME LIST) 917 %RECORD(LISTF)%NAME L2, MM 918 %INTEGER I 919 MM == MMOVE_L 920 L2 == LIST 921 %WHILE ADDR(LIST) # 0 %CYCLE 922 %IF LIST_FR = MM_FR %AND LIST_TO = MM_TO %C cbz w27, .L414 ldrb w2, [x29, 3236] cbz x0, .L414 .L418: ldrb w1, [x0, 4] cmp w1, w2 bne .L417 923 %START ldrb w3, [x29, 3237] mov x0, x26 b .L418 .LVL764: .L427: .L408: .LBE690: .LBE689: .LBB692: .LBB693: add x0, x29, 376 .LVL765: bl _imp_readsymbol .LVL766: .LBE693: .LBE692: ldrb w1, [x0, 5] cmp w1, w3 bne .L417 924 MM_SCORE = LIST_SCORE; MM_CHK = LIST_CHK ldr w1, [x0, 8] str w1, [x29, 3240] 925 %RESULT = 1 ldr w0, [x0, 12] .LVL776: str w0, [x29, 3244] .LDL27: .LVL777: .LBE691: .LBE706: .LBB707: .LBB708: bl _imp_skipsymbol .LVL778: .LBE708: .LBE707: 926 %FINISH 927 LIST == LIST_L ldr x0, [x0] .LVL775: .LDL26: 928 %REPEAT 929 %RESULT = 0 930 %END ?I unused 931 !! 932 %INTEGERFN PRINT MOVES(%RECORD(LISTF)%NAME LIST) 933 %RECORD(LISTF)%NAME L 934 SELECT OUTPUT(2) 935 LIST == RECORD(SORT AND PRUNE(LIST, 100, -1)) mov x18, x25 mov w2, -1 mov w1, 100 mov x0, x21 bl SORTANDPRUNE.7783 .LVL791: mov w27, w0 .LVL792: sxtw x26, w0 .LVL793: 936 L == LIST mov x20, x26 .L398: .LVL794: .L424: .L399: 937 %CYCLE 938 PRINTMOVE(L); NEWLINE mov x0, x20 bl PRINTMOVE.7806 .LVL795: .LBB713: .LBB714: bl _imp_newline .LVL796: .LBE714: .LBE713: 939 L == L_L ldr x20, [x20] .LVL797: 940 %EXIT %IF ADDR(L) = 0 cbnz x20, .L424 .L400: .LVL798: .LBB715: .LBB716: adrp x0, :got:_imp_OutStream ldr x0, [x0, #:got_lo12:_imp_OutStream] str wzr, [x0] adrp x0, :got:_imp_outfile ldr x0, [x0, #:got_lo12:_imp_outfile] ldr x1, [x0, 8] adrp x0, :got:_imp_OutFile ldr x0, [x0, #:got_lo12:_imp_OutFile] str x1, [x0] adrp x0, .LANCHOR1 add x0, x0, :lo12:.LANCHOR1 add x0, x0, 3032 bl check_outstream .LVL799: .LBE716: .LBE715: .LBE710: .LBE709: .LBB717: 941 %REPEAT 942 SELECT OUTPUT(0) 943 %RESULT = ADDR(LIST) 944 %END 945 946 %ROUTINE YOUR MOVE 947 %INTEGER %FN READM(%INTEGERNAME X, Y) .LVL266: stp x29, x30, [sp, -48]! add x29, sp, 0 stp x19, x20, [sp, 16] mov x20, x0 mov x19, x1 adrp x0, :got:__stack_chk_guard .LVL267: ldr x0, [x0, #:got_lo12:__stack_chk_guard] ldr x1, [x0] str x1, [x29, 40] mov x1,0 .LVL268: .L118: .LBB373: .LBB374: bl _imp_nextsymbol .LVL269: .LBE374: .LBE373: 948 %INTEGER I,J 949 SKIPSYMBOL %WHILE NEXTSYMBOL=NL 950 READSYMBOL(I) cmp w0, 10 bne .L119 .LBB375: .LBB376: bl _imp_skipsymbol .LVL270: b .L118 .L119: .LVL271: .LBE376: .LBE375: .LBB377: .LBB378: add x0, x29, 32 .LVL272: bl _imp_readsymbol .LVL273: .L120: .LBE378: .LBE377: .LBB379: .LBB380: bl _imp_nextsymbol .LVL274: .LBE380: .LBE379: 951 SKIPSYMBOL %WHILE NEXTSYMBOL=NL 952 READSYMBOL(J) cmp w0, 10 bne .L121 .LBB381: .LBB382: bl _imp_skipsymbol .LVL275: b .L120 .L121: .LVL276: .LBE382: .LBE381: .LBB383: .LBB384: add x0, x29, 36 .LVL277: bl _imp_readsymbol .LVL278: .LBE384: .LBE383: 953 X = I-'A'+1; Y = J-'0' ldr w0, [x29, 32] sub w0, w0, #64 str w0, [x20] 954 %RESULT = 0 ldr w0, [x29, 36] sub w0, w0, #48 str w0, [x19] 955 %END mov w0, 0 adrp x1, :got:__stack_chk_guard ldr x1, [x1, #:got_lo12:__stack_chk_guard] ldr x2, [x29, 40] ldr x1, [x1] eor x1, x2, x1 cbnz x1, .L124 ldp x19, x20, [sp, 16] .LVL279: ldp x29, x30, [sp], 48 .LVL280: ret .LVL281: .L124: bl __stack_chk_fail .LVL282: .LFE207: .align 2 DOM.8047: .LFB194: 956 957 %INTEGER I, X, Y, X0, Y0, K 958 %RECORD(LISTF)%NAME LIST 959 !! 960 JUST ONE PLY = 1; ! DONT ALLOW LOOK AHEAD (NO POINT) adrp x20, .LANCHOR0 add x20, x20, :lo12:.LANCHOR0 mov w0, 1 str w0, [x20, 1084] 961 LIST == RECORD(MOVES(-1, 0)); ! GET OPPS LEGAL MOVES add x25, x29, 3232 .LBE648: .LBE647: mov x18, x25 mov w1, 0 mov w0, -1 bl MOVES.7789 .LVL788: sxtw x21, w0 962 JUST ONE PLY = 0 str wzr, [x20, 1084] 963 %IF ADDR(LIST) = 0 %THEN TELL(LIST, -1); ! CHECKMATE cbz x21, .L435 .L397: .LVL789: .LBB709: .LBB710: .LBB711: .LBB712: adrp x0, :got:_imp_OutStream ldr x0, [x0, #:got_lo12:_imp_OutStream] mov w1, 2 str w1, [x0] adrp x0, :got:_imp_outfile ldr x0, [x0, #:got_lo12:_imp_outfile] ldr x1, [x0, 584] adrp x0, :got:_imp_OutFile ldr x0, [x0, #:got_lo12:_imp_OutFile] str x1, [x0] adrp x0, .LANCHOR1 add x0, x0, :lo12:.LANCHOR1 add x0, x0, 3032 bl check_outstream .LVL790: .LBE712: .LBE711: 964 %IF MON&1#0 %THEN LIST == RECORD(PRINT MOVES(LIST)) mov w1, -1 mov x0, 0 bl TELL.7802 .LVL714: b .L397 .L428: .LBB650: .LBB651: bl _imp_skipsymbol .LVL715: .LBE651: .LBE650: .LBB652: 965 AGAIN: 966 LM_SPEC = 0 str wzr, [x29, 3240] .LBB675: .LBB676: bl _imp_nextsymbol .LVL749: .LBE676: .LBE675: 967 %IF NEXTSYMBOL='M' %START; ! MONITOR cmp w0, 77 beq .L428 .L402: .LBB677: .LBB678: bl _imp_nextsymbol .LVL750: .LBE678: .LBE677: 968 SKIPSYMBOL 969 PROMPT("MON?"); READ(MON); SKIPSYMBOL mov x21, 256 mov x2, x21 add x1, x23, 1192 mov x0, x19 bl memcpy .LVL716: add x28, x29, 2976 mov x2, x21 mov x1, x19 mov x0, x28 bl memcpy .LVL717: .LBE652: add x20, x29, 112 mov x2, x21 mov x1, x28 mov x0, x20 bl memcpy .LVL718: mov x0, x20 bl PROMPT .LVL719: 970 PROMPT("Move?") adrp x0, .LANCHOR0 add x0, x0, :lo12:.LANCHOR0 add x0, x0, 1088 bl _imp_readint .LVL720: .LBB653: .LBB654: bl _imp_skipsymbol .LVL721: .LBE654: .LBE653: .LBB655: mov x2, x21 add x1, x23, 936 mov x0, x19 bl memcpy .LVL722: add x28, x29, 2720 mov x2, x21 mov x1, x19 mov x0, x28 bl memcpy .LVL723: .LBE655: mov x2, x21 mov x1, x28 mov x0, x20 bl memcpy .LVL724: mov x0, x20 bl PROMPT .LVL725: b .L401 .L429: .LBB656: .LBB657: bl _imp_skipsymbol .LVL726: .LBE657: .LBE656: .LBB658: .LBB659: bl _imp_skipsymbol .LVL727: b .L404 .L430: .LBE659: .LBE658: .LBB660: 971 ->AGAIN 972 %FINISH 973 %IF NEXTSYMBOL='X' %START cmp w0, 88 beq .L429 .L404: .LBB679: .LBB680: bl _imp_nextsymbol .LVL751: .LBE680: .LBE679: 974 SKIPSYMBOL; SKIPSYMBOL; !PPROFILE 975 %FINISH 976 %IF NEXTSYMBOL = 'P' %START cmp w0, 80 beq .L430 .L405: .LBB681: .LBB682: bl _imp_nextsymbol .LVL752: .LBE682: .LBE681: 977 PROMPT("NEW PLY?"); SKIPSYMBOL mov x21, 256 mov x2, x21 add x1, x23, 1448 mov x0, x19 bl memcpy .LVL728: add x28, x29, 2464 mov x2, x21 mov x1, x19 mov x0, x28 bl memcpy .LVL729: .LBE660: add x20, x29, 112 mov x2, x21 mov x1, x28 mov x0, x20 bl memcpy .LVL730: mov x0, x20 bl PROMPT .LVL731: .LBB661: .LBB662: bl _imp_skipsymbol .LVL732: .LBE662: .LBE661: 978 READ(PDEPTH); SKIPSYMBOL adrp x0, .LANCHOR0 add x0, x0, :lo12:.LANCHOR0 add x0, x0, 1092 bl _imp_readint .LVL733: .LBB663: .LBB664: bl _imp_skipsymbol .LVL734: .LBE664: .LBE663: .LBB665: 979 PROMPT("Move?") mov x2, x21 add x1, x23, 936 mov x0, x19 bl memcpy .LVL735: add x28, x29, 2208 mov x2, x21 mov x1, x19 mov x0, x28 bl memcpy .LVL736: .LBE665: mov x2, x21 mov x1, x28 mov x0, x20 bl memcpy .LVL737: mov x0, x20 bl PROMPT .LVL738: b .L401 .L431: 980 -> AGAIN 981 %FINISH 982 %IF NEXTSYMBOL='O' %START; ! CASTLE cmp w0, 79 beq .L431 .L406: 983 X = 0 str wzr, [x29, 380] .LBB666: .LBB667: bl _imp_skipsymbol .LVL739: .LBE667: .LBE666: .LBB668: .LBB669: add x0, x29, 376 .LVL740: bl _imp_readsymbol .LVL741: .LBE669: .LBE668: 984 SKIPSYMBOL; READSYMBOL(I) 985 %IF I # '-' %THEN -> NO ldr w0, [x29, 376] cmp w0, 45 beq .L427 .L407: .L414: .LBB670: mov x28, 256 mov x2, x28 mov x1, x24 mov x0, x19 bl memcpy .LVL742: mov x2, x28 mov x1, x19 mov x0, x22 bl memcpy .LVL743: add x21, x29, 1440 mov x2, x28 mov x1, x22 mov x0, x21 bl memcpy .LVL744: .LBE670: .LBB671: .LBB672: add x20, x29, 112 mov x2, x28 mov x1, x21 mov x0, x20 bl memcpy .LVL745: mov x0, x20 bl _imp_printstring .LVL746: .LBE672: .LBE671: .LBB673: .LBB674: add x20, x29, 376 .L415: .L425: .L416: .LVL747: mov x0, x20 bl _imp_readsymbol .LVL748: .LBE674: .LBE673: 986 READSYMBOL(I); -> NO %IF I#'O' 987 %IF NEXTSYMBOL = '-' %START; ! QUEEN SIDE ldr w0, [x29, 376] cmp w0, 79 bne .L414 .L409: .LBB694: .LBB695: bl _imp_nextsymbol .LVL767: .LBE695: .LBE694: cmp w0, 45 beq .L433 .L410: 988 X = 1; SKIPSYMBOL; SKIPSYMBOL mov w0, 1 str w0, [x29, 380] .LBB696: .LBB697: bl _imp_skipsymbol .LVL768: .LBE697: .LBE696: .LBB698: .LBB699: bl _imp_skipsymbol .LVL769: b .L410 .L432: .LBE699: .LBE698: .LBB700: .LBB701: bl _imp_skipsymbol .LVL770: .LBE701: .LBE700: .LBB702: .LBB703: add x0, x29, 396 .LVL771: bl _imp_readsymbol .LVL772: .LBE703: .LBE702: .LBB704: .LBB705: bl _imp_skipsymbol .LVL773: .LBE705: .LBE704: 989 %FINISH 990 LM_SPEC = 6+X ldr w0, [x29, 380] add w0, w0, 6 str w0, [x29, 3240] 991 LM_FR = 5<<4+1 mov w0, 81 strb w0, [x29, 3236] 992 LM_TO = 5<<4+1 strb w0, [x29, 3237] b .L411 .L433: 993 %FINISHELSESTART 994 I = READM(X, Y); I=READM(X0, Y0) add x1, x29, 384 add x0, x29, 380 bl READM.8330 .LVL753: str w0, [x29, 376] 995 %IF NEXTSYMBOL='(' %START add x1, x29, 392 add x0, x29, 388 bl READM.8330 .LVL754: str w0, [x29, 376] .LBB683: .LBB684: bl _imp_nextsymbol .LVL755: .LBE684: .LBE683: cmp w0, 40 beq .L432 .L412: .LBB685: 996 SKIPSYMBOL; READSYMBOL(K); SKIPSYMBOL 997 LM_SPEC = (K-'0')*(-1) mov w0, 48 ldr w1, [x29, 396] sub w0, w0, w1 str w0, [x29, 3240] b .L412 .LVL774: .L417: .LBB706: .LBB691: 998 %FINISH 999 1000 %UNLESS 0MOVE(%d) out of bounds at %s line %d" .zero 1 .LC37: .string "Illegal cycle J = 1, 1, I - 1" .Letext0: 1004 %CYCLE 1005 READSYMBOL(I) sub w1, w0, #1 cmp w1, 7 bhi .L414 .LBE685: .LBB686: 1006 %EXIT %IF I=NL ldr w0, [x29, 376] cmp w0, 10 bne .L425 .L401: 1007 %REPEAT 1008 ->AGAIN 1009 %FINISH 1010 ldr w1, [x29, 388] .LVL757: 1011 !! 1012 LM_FR = X<<4+Y sub w2, w1, #1 cmp w2, 7 bhi .L414 .LBE686: .LBB687: ubfiz w0, w0, 4, 4 .LVL760: add w0, w2, w0 strb w0, [x29, 3236] 1013 LM_TO = X0<<4+Y0 ubfiz w1, w1, 4, 4 .LVL761: add w1, w3, w1 strb w1, [x29, 3237] .LVL762: .L411: 1014 %FINISH 1015 MMOVE_L == LM str x25, [x29, 3248] .LVL763: .LBB689: .LBB690: 1016 %IF CHECK YOUR MOVE(LIST) = 0 %THEN ->NO 1017 SKIPSYMBOL ldr w2, [x29, 384] .LVL758: 1018 RELEASE CHAIN(LIST) mov x18, x25 mov x0, x26 bl RELEASECHAIN.7846 .LVL779: .LBE719: .LBE722: 1019 %END sub w3, w2, #1 cmp w3, 7 bhi .L414 .LBE687: .LBB688: 1020 %ENDOFPROGRAM ?CHK unused ?BRDOLD unused ?PLYWIDTH unused 879 Statements compiled ldr w3, [x29, 392] .LVL759: sub w4, w3, #1 cmp w4, 7 bhi .L414 .L413: .LBE688: