1 2 # Core program 3 # Defining function strcpy 4 :FUNCTION_strcpy 5 # Defining local i 6 mov_rax, %0 7 push_rax #i 8 :WHILE_strcpy_0 9 mov_rax, %0 10 push_rax #_common_recursion 11 lea_rax,[rbp+DWORD] %-16 12 mov_rax,[rax] 13 push_rax #_common_recursion 14 lea_rax,[rbp+DWORD] %-32 15 mov_rax,[rax] 16 pop_rbx # _common_recursion 17 add_rax,rbx 18 movsx_rax,BYTE_PTR_[rax] 19 pop_rbx # _common_recursion 20 cmp_rbx,rax 21 setne_al 22 movzx_rax,al 23 test_rax,rax 24 je %END_WHILE_strcpy_0 25 # THEN_while_strcpy_0 26 lea_rax,[rbp+DWORD] %-8 27 mov_rax,[rax] 28 push_rax #_common_recursion 29 lea_rax,[rbp+DWORD] %-32 30 mov_rax,[rax] 31 pop_rbx # _common_recursion 32 add_rax,rbx 33 push_rax #_common_recursion 34 lea_rax,[rbp+DWORD] %-16 35 mov_rax,[rax] 36 push_rax #_common_recursion 37 lea_rax,[rbp+DWORD] %-32 38 mov_rax,[rax] 39 pop_rbx # _common_recursion 40 add_rax,rbx 41 movsx_rax,BYTE_PTR_[rax] 42 pop_rbx # _common_recursion 43 mov_[rbx],al 44 lea_rax,[rbp+DWORD] %-32 45 push_rax #_common_recursion 46 lea_rax,[rbp+DWORD] %-32 47 mov_rax,[rax] 48 push_rax #_common_recursion 49 mov_rax, %1 50 pop_rbx # _common_recursion 51 add_rax,rbx 52 pop_rbx # _common_recursion 53 mov_[rbx],rax 54 jmp %WHILE_strcpy_0 55 :END_WHILE_strcpy_0 56 lea_rax,[rbp+DWORD] %-8 57 mov_rax,[rax] 58 push_rax #_common_recursion 59 lea_rax,[rbp+DWORD] %-32 60 mov_rax,[rax] 61 pop_rbx # _common_recursion 62 add_rax,rbx 63 push_rax #_common_recursion 64 mov_rax, %0 65 pop_rbx # _common_recursion 66 mov_[rbx],al 67 lea_rax,[rbp+DWORD] %-8 68 mov_rax,[rax] 69 pop_rbx # _return_result_locals 70 ret 71 # Defining function strncpy 72 :FUNCTION_strncpy 73 # IF_strncpy_0 74 mov_rax, %0 75 push_rax #_common_recursion 76 lea_rax,[rbp+DWORD] %-24 77 mov_rax,[rax] 78 pop_rbx # _common_recursion 79 cmp_rbx,rax 80 sete_al 81 movzx_rax,al 82 test_rax,rax 83 je %ELSE_strncpy_0 84 lea_rax,[rbp+DWORD] %-8 85 mov_rax,[rax] 86 ret 87 jmp %_END_IF_strncpy_0 88 :ELSE_strncpy_0 89 :_END_IF_strncpy_0 90 # Defining local i 91 mov_rax, %0 92 push_rax #i 93 :WHILE_strncpy_1 94 mov_rax, %0 95 push_rax #_common_recursion 96 lea_rax,[rbp+DWORD] %-16 97 mov_rax,[rax] 98 push_rax #_common_recursion 99 lea_rax,[rbp+DWORD] %-40 100 mov_rax,[rax] 101 pop_rbx # _common_recursion 102 add_rax,rbx 103 movsx_rax,BYTE_PTR_[rax] 104 pop_rbx # _common_recursion 105 cmp_rbx,rax 106 setne_al 107 movzx_rax,al 108 test_rax,rax 109 je %END_WHILE_strncpy_1 110 # THEN_while_strncpy_1 111 lea_rax,[rbp+DWORD] %-8 112 mov_rax,[rax] 113 push_rax #_common_recursion 114 lea_rax,[rbp+DWORD] %-40 115 mov_rax,[rax] 116 pop_rbx # _common_recursion 117 add_rax,rbx 118 push_rax #_common_recursion 119 lea_rax,[rbp+DWORD] %-16 120 mov_rax,[rax] 121 push_rax #_common_recursion 122 lea_rax,[rbp+DWORD] %-40 123 mov_rax,[rax] 124 pop_rbx # _common_recursion 125 add_rax,rbx 126 movsx_rax,BYTE_PTR_[rax] 127 pop_rbx # _common_recursion 128 mov_[rbx],al 129 lea_rax,[rbp+DWORD] %-40 130 push_rax #_common_recursion 131 lea_rax,[rbp+DWORD] %-40 132 mov_rax,[rax] 133 push_rax #_common_recursion 134 mov_rax, %1 135 pop_rbx # _common_recursion 136 add_rax,rbx 137 pop_rbx # _common_recursion 138 mov_[rbx],rax 139 # IF_strncpy_2 140 lea_rax,[rbp+DWORD] %-24 141 mov_rax,[rax] 142 push_rax #_common_recursion 143 lea_rax,[rbp+DWORD] %-40 144 mov_rax,[rax] 145 pop_rbx # _common_recursion 146 cmp_rbx,rax 147 sete_al 148 movzx_rax,al 149 test_rax,rax 150 je %ELSE_strncpy_2 151 lea_rax,[rbp+DWORD] %-8 152 mov_rax,[rax] 153 pop_rbx # _return_result_locals 154 ret 155 jmp %_END_IF_strncpy_2 156 :ELSE_strncpy_2 157 :_END_IF_strncpy_2 158 jmp %WHILE_strncpy_1 159 :END_WHILE_strncpy_1 160 :WHILE_strncpy_3 161 lea_rax,[rbp+DWORD] %-40 162 mov_rax,[rax] 163 push_rax #_common_recursion 164 lea_rax,[rbp+DWORD] %-24 165 mov_rax,[rax] 166 pop_rbx # _common_recursion 167 cmp_rbx,rax 168 setbe_al 169 movzx_rax,al 170 test_rax,rax 171 je %END_WHILE_strncpy_3 172 # THEN_while_strncpy_3 173 lea_rax,[rbp+DWORD] %-8 174 mov_rax,[rax] 175 push_rax #_common_recursion 176 lea_rax,[rbp+DWORD] %-40 177 mov_rax,[rax] 178 pop_rbx # _common_recursion 179 add_rax,rbx 180 push_rax #_common_recursion 181 mov_rax, %0 182 pop_rbx # _common_recursion 183 mov_[rbx],al 184 lea_rax,[rbp+DWORD] %-40 185 push_rax #_common_recursion 186 lea_rax,[rbp+DWORD] %-40 187 mov_rax,[rax] 188 push_rax #_common_recursion 189 mov_rax, %1 190 pop_rbx # _common_recursion 191 add_rax,rbx 192 pop_rbx # _common_recursion 193 mov_[rbx],rax 194 jmp %WHILE_strncpy_3 195 :END_WHILE_strncpy_3 196 lea_rax,[rbp+DWORD] %-8 197 mov_rax,[rax] 198 pop_rbx # _return_result_locals 199 ret 200 # Defining function strcat 201 :FUNCTION_strcat 202 # Defining local i 203 mov_rax, %0 204 push_rax #i 205 # Defining local j 206 mov_rax, %0 207 push_rax #j 208 :WHILE_strcat_0 209 mov_rax, %0 210 push_rax #_common_recursion 211 lea_rax,[rbp+DWORD] %-8 212 mov_rax,[rax] 213 push_rax #_common_recursion 214 lea_rax,[rbp+DWORD] %-32 215 mov_rax,[rax] 216 pop_rbx # _common_recursion 217 add_rax,rbx 218 movsx_rax,BYTE_PTR_[rax] 219 pop_rbx # _common_recursion 220 cmp_rbx,rax 221 setne_al 222 movzx_rax,al 223 test_rax,rax 224 je %END_WHILE_strcat_0 225 # THEN_while_strcat_0 226 lea_rax,[rbp+DWORD] %-32 227 push_rax #_common_recursion 228 lea_rax,[rbp+DWORD] %-32 229 mov_rax,[rax] 230 push_rax #_common_recursion 231 mov_rax, %1 232 pop_rbx # _common_recursion 233 add_rax,rbx 234 pop_rbx # _common_recursion 235 mov_[rbx],rax 236 jmp %WHILE_strcat_0 237 :END_WHILE_strcat_0 238 :WHILE_strcat_1 239 mov_rax, %0 240 push_rax #_common_recursion 241 lea_rax,[rbp+DWORD] %-16 242 mov_rax,[rax] 243 push_rax #_common_recursion 244 lea_rax,[rbp+DWORD] %-40 245 mov_rax,[rax] 246 pop_rbx # _common_recursion 247 add_rax,rbx 248 movsx_rax,BYTE_PTR_[rax] 249 pop_rbx # _common_recursion 250 cmp_rbx,rax 251 setne_al 252 movzx_rax,al 253 test_rax,rax 254 je %END_WHILE_strcat_1 255 # THEN_while_strcat_1 256 lea_rax,[rbp+DWORD] %-8 257 mov_rax,[rax] 258 push_rax #_common_recursion 259 lea_rax,[rbp+DWORD] %-32 260 mov_rax,[rax] 261 pop_rbx # _common_recursion 262 add_rax,rbx 263 push_rax #_common_recursion 264 lea_rax,[rbp+DWORD] %-16 265 mov_rax,[rax] 266 push_rax #_common_recursion 267 lea_rax,[rbp+DWORD] %-40 268 mov_rax,[rax] 269 pop_rbx # _common_recursion 270 add_rax,rbx 271 movsx_rax,BYTE_PTR_[rax] 272 pop_rbx # _common_recursion 273 mov_[rbx],al 274 lea_rax,[rbp+DWORD] %-32 275 push_rax #_common_recursion 276 lea_rax,[rbp+DWORD] %-32 277 mov_rax,[rax] 278 push_rax #_common_recursion 279 mov_rax, %1 280 pop_rbx # _common_recursion 281 add_rax,rbx 282 pop_rbx # _common_recursion 283 mov_[rbx],rax 284 lea_rax,[rbp+DWORD] %-40 285 push_rax #_common_recursion 286 lea_rax,[rbp+DWORD] %-40 287 mov_rax,[rax] 288 push_rax #_common_recursion 289 mov_rax, %1 290 pop_rbx # _common_recursion 291 add_rax,rbx 292 pop_rbx # _common_recursion 293 mov_[rbx],rax 294 jmp %WHILE_strcat_1 295 :END_WHILE_strcat_1 296 lea_rax,[rbp+DWORD] %-8 297 mov_rax,[rax] 298 push_rax #_common_recursion 299 lea_rax,[rbp+DWORD] %-32 300 mov_rax,[rax] 301 pop_rbx # _common_recursion 302 add_rax,rbx 303 push_rax #_common_recursion 304 mov_rax, %0 305 pop_rbx # _common_recursion 306 mov_[rbx],al 307 lea_rax,[rbp+DWORD] %-8 308 mov_rax,[rax] 309 pop_rbx # _return_result_locals 310 pop_rbx # _return_result_locals 311 ret 312 # Defining function strncat 313 :FUNCTION_strncat 314 # Defining local i 315 mov_rax, %0 316 push_rax #i 317 # Defining local j 318 mov_rax, %0 319 push_rax #j 320 :WHILE_strncat_0 321 mov_rax, %0 322 push_rax #_common_recursion 323 lea_rax,[rbp+DWORD] %-8 324 mov_rax,[rax] 325 push_rax #_common_recursion 326 lea_rax,[rbp+DWORD] %-40 327 mov_rax,[rax] 328 pop_rbx # _common_recursion 329 add_rax,rbx 330 movsx_rax,BYTE_PTR_[rax] 331 pop_rbx # _common_recursion 332 cmp_rbx,rax 333 setne_al 334 movzx_rax,al 335 test_rax,rax 336 je %END_WHILE_strncat_0 337 # THEN_while_strncat_0 338 lea_rax,[rbp+DWORD] %-40 339 push_rax #_common_recursion 340 lea_rax,[rbp+DWORD] %-40 341 mov_rax,[rax] 342 push_rax #_common_recursion 343 mov_rax, %1 344 pop_rbx # _common_recursion 345 add_rax,rbx 346 pop_rbx # _common_recursion 347 mov_[rbx],rax 348 jmp %WHILE_strncat_0 349 :END_WHILE_strncat_0 350 :WHILE_strncat_1 351 mov_rax, %0 352 push_rax #_common_recursion 353 lea_rax,[rbp+DWORD] %-16 354 mov_rax,[rax] 355 push_rax #_common_recursion 356 lea_rax,[rbp+DWORD] %-48 357 mov_rax,[rax] 358 pop_rbx # _common_recursion 359 add_rax,rbx 360 movsx_rax,BYTE_PTR_[rax] 361 pop_rbx # _common_recursion 362 cmp_rbx,rax 363 setne_al 364 movzx_rax,al 365 test_rax,rax 366 je %END_WHILE_strncat_1 367 # THEN_while_strncat_1 368 # IF_strncat_2 369 lea_rax,[rbp+DWORD] %-24 370 mov_rax,[rax] 371 push_rax #_common_recursion 372 lea_rax,[rbp+DWORD] %-48 373 mov_rax,[rax] 374 pop_rbx # _common_recursion 375 cmp_rbx,rax 376 sete_al 377 movzx_rax,al 378 test_rax,rax 379 je %ELSE_strncat_2 380 lea_rax,[rbp+DWORD] %-8 381 mov_rax,[rax] 382 push_rax #_common_recursion 383 lea_rax,[rbp+DWORD] %-40 384 mov_rax,[rax] 385 pop_rbx # _common_recursion 386 add_rax,rbx 387 push_rax #_common_recursion 388 mov_rax, %0 389 pop_rbx # _common_recursion 390 mov_[rbx],al 391 lea_rax,[rbp+DWORD] %-8 392 mov_rax,[rax] 393 pop_rbx # _return_result_locals 394 pop_rbx # _return_result_locals 395 ret 396 jmp %_END_IF_strncat_2 397 :ELSE_strncat_2 398 :_END_IF_strncat_2 399 lea_rax,[rbp+DWORD] %-8 400 mov_rax,[rax] 401 push_rax #_common_recursion 402 lea_rax,[rbp+DWORD] %-40 403 mov_rax,[rax] 404 pop_rbx # _common_recursion 405 add_rax,rbx 406 push_rax #_common_recursion 407 lea_rax,[rbp+DWORD] %-16 408 mov_rax,[rax] 409 push_rax #_common_recursion 410 lea_rax,[rbp+DWORD] %-48 411 mov_rax,[rax] 412 pop_rbx # _common_recursion 413 add_rax,rbx 414 movsx_rax,BYTE_PTR_[rax] 415 pop_rbx # _common_recursion 416 mov_[rbx],al 417 lea_rax,[rbp+DWORD] %-40 418 push_rax #_common_recursion 419 lea_rax,[rbp+DWORD] %-40 420 mov_rax,[rax] 421 push_rax #_common_recursion 422 mov_rax, %1 423 pop_rbx # _common_recursion 424 add_rax,rbx 425 pop_rbx # _common_recursion 426 mov_[rbx],rax 427 lea_rax,[rbp+DWORD] %-48 428 push_rax #_common_recursion 429 lea_rax,[rbp+DWORD] %-48 430 mov_rax,[rax] 431 push_rax #_common_recursion 432 mov_rax, %1 433 pop_rbx # _common_recursion 434 add_rax,rbx 435 pop_rbx # _common_recursion 436 mov_[rbx],rax 437 jmp %WHILE_strncat_1 438 :END_WHILE_strncat_1 439 lea_rax,[rbp+DWORD] %-8 440 mov_rax,[rax] 441 push_rax #_common_recursion 442 lea_rax,[rbp+DWORD] %-40 443 mov_rax,[rax] 444 pop_rbx # _common_recursion 445 add_rax,rbx 446 push_rax #_common_recursion 447 mov_rax, %0 448 pop_rbx # _common_recursion 449 mov_[rbx],al 450 lea_rax,[rbp+DWORD] %-8 451 mov_rax,[rax] 452 pop_rbx # _return_result_locals 453 pop_rbx # _return_result_locals 454 ret 455 # Defining function strlen 456 :FUNCTION_strlen 457 # Defining local i 458 mov_rax, %0 459 push_rax #i 460 :WHILE_strlen_0 461 mov_rax, %0 462 push_rax #_common_recursion 463 lea_rax,[rbp+DWORD] %-8 464 mov_rax,[rax] 465 push_rax #_common_recursion 466 lea_rax,[rbp+DWORD] %-24 467 mov_rax,[rax] 468 pop_rbx # _common_recursion 469 add_rax,rbx 470 movsx_rax,BYTE_PTR_[rax] 471 pop_rbx # _common_recursion 472 cmp_rbx,rax 473 setne_al 474 movzx_rax,al 475 test_rax,rax 476 je %END_WHILE_strlen_0 477 # THEN_while_strlen_0 478 lea_rax,[rbp+DWORD] %-24 479 push_rax #_common_recursion 480 lea_rax,[rbp+DWORD] %-24 481 mov_rax,[rax] 482 push_rax #_common_recursion 483 mov_rax, %1 484 pop_rbx # _common_recursion 485 add_rax,rbx 486 pop_rbx # _common_recursion 487 mov_[rbx],rax 488 jmp %WHILE_strlen_0 489 :END_WHILE_strlen_0 490 lea_rax,[rbp+DWORD] %-24 491 mov_rax,[rax] 492 pop_rbx # _return_result_locals 493 ret 494 # Defining function strnlen_s 495 :FUNCTION_strnlen_s 496 # Defining local i 497 mov_rax, %0 498 push_rax #i 499 :WHILE_strnlen_s_0 500 mov_rax, %0 501 push_rax #_common_recursion 502 lea_rax,[rbp+DWORD] %-8 503 mov_rax,[rax] 504 push_rax #_common_recursion 505 lea_rax,[rbp+DWORD] %-32 506 mov_rax,[rax] 507 pop_rbx # _common_recursion 508 add_rax,rbx 509 movsx_rax,BYTE_PTR_[rax] 510 pop_rbx # _common_recursion 511 cmp_rbx,rax 512 setne_al 513 movzx_rax,al 514 test_rax,rax 515 je %END_WHILE_strnlen_s_0 516 # THEN_while_strnlen_s_0 517 # IF_strnlen_s_1 518 lea_rax,[rbp+DWORD] %-16 519 mov_rax,[rax] 520 push_rax #_common_recursion 521 lea_rax,[rbp+DWORD] %-32 522 mov_rax,[rax] 523 pop_rbx # _common_recursion 524 cmp_rbx,rax 525 sete_al 526 movzx_rax,al 527 test_rax,rax 528 je %ELSE_strnlen_s_1 529 lea_rax,[rbp+DWORD] %-32 530 mov_rax,[rax] 531 pop_rbx # _return_result_locals 532 ret 533 jmp %_END_IF_strnlen_s_1 534 :ELSE_strnlen_s_1 535 :_END_IF_strnlen_s_1 536 lea_rax,[rbp+DWORD] %-32 537 push_rax #_common_recursion 538 lea_rax,[rbp+DWORD] %-32 539 mov_rax,[rax] 540 push_rax #_common_recursion 541 mov_rax, %1 542 pop_rbx # _common_recursion 543 add_rax,rbx 544 pop_rbx # _common_recursion 545 mov_[rbx],rax 546 jmp %WHILE_strnlen_s_0 547 :END_WHILE_strnlen_s_0 548 lea_rax,[rbp+DWORD] %-32 549 mov_rax,[rax] 550 pop_rbx # _return_result_locals 551 ret 552 # Defining function strcmp 553 :FUNCTION_strcmp 554 # Defining local i 555 mov_rax, %0 556 push_rax #i 557 :WHILE_strcmp_0 558 mov_rax, %0 559 push_rax #_common_recursion 560 lea_rax,[rbp+DWORD] %-8 561 mov_rax,[rax] 562 push_rax #_common_recursion 563 lea_rax,[rbp+DWORD] %-32 564 mov_rax,[rax] 565 pop_rbx # _common_recursion 566 add_rax,rbx 567 movsx_rax,BYTE_PTR_[rax] 568 pop_rbx # _common_recursion 569 cmp_rbx,rax 570 setne_al 571 movzx_rax,al 572 test_rax,rax 573 je %END_WHILE_strcmp_0 574 # THEN_while_strcmp_0 575 # IF_strcmp_1 576 lea_rax,[rbp+DWORD] %-8 577 mov_rax,[rax] 578 push_rax #_common_recursion 579 lea_rax,[rbp+DWORD] %-32 580 mov_rax,[rax] 581 pop_rbx # _common_recursion 582 add_rax,rbx 583 movsx_rax,BYTE_PTR_[rax] 584 push_rax #_common_recursion 585 lea_rax,[rbp+DWORD] %-16 586 mov_rax,[rax] 587 push_rax #_common_recursion 588 lea_rax,[rbp+DWORD] %-32 589 mov_rax,[rax] 590 pop_rbx # _common_recursion 591 add_rax,rbx 592 movsx_rax,BYTE_PTR_[rax] 593 pop_rbx # _common_recursion 594 cmp_rbx,rax 595 setne_al 596 movzx_rax,al 597 test_rax,rax 598 je %ELSE_strcmp_1 599 lea_rax,[rbp+DWORD] %-8 600 mov_rax,[rax] 601 push_rax #_common_recursion 602 lea_rax,[rbp+DWORD] %-32 603 mov_rax,[rax] 604 pop_rbx # _common_recursion 605 add_rax,rbx 606 movsx_rax,BYTE_PTR_[rax] 607 push_rax #_common_recursion 608 lea_rax,[rbp+DWORD] %-16 609 mov_rax,[rax] 610 push_rax #_common_recursion 611 lea_rax,[rbp+DWORD] %-32 612 mov_rax,[rax] 613 pop_rbx # _common_recursion 614 add_rax,rbx 615 movsx_rax,BYTE_PTR_[rax] 616 pop_rbx # _common_recursion 617 sub_rbx,rax 618 mov_rax,rbx 619 pop_rbx # _return_result_locals 620 ret 621 jmp %_END_IF_strcmp_1 622 :ELSE_strcmp_1 623 :_END_IF_strcmp_1 624 lea_rax,[rbp+DWORD] %-32 625 push_rax #_common_recursion 626 lea_rax,[rbp+DWORD] %-32 627 mov_rax,[rax] 628 push_rax #_common_recursion 629 mov_rax, %1 630 pop_rbx # _common_recursion 631 add_rax,rbx 632 pop_rbx # _common_recursion 633 mov_[rbx],rax 634 jmp %WHILE_strcmp_0 635 :END_WHILE_strcmp_0 636 lea_rax,[rbp+DWORD] %-8 637 mov_rax,[rax] 638 push_rax #_common_recursion 639 lea_rax,[rbp+DWORD] %-32 640 mov_rax,[rax] 641 pop_rbx # _common_recursion 642 add_rax,rbx 643 movsx_rax,BYTE_PTR_[rax] 644 push_rax #_common_recursion 645 lea_rax,[rbp+DWORD] %-16 646 mov_rax,[rax] 647 push_rax #_common_recursion 648 lea_rax,[rbp+DWORD] %-32 649 mov_rax,[rax] 650 pop_rbx # _common_recursion 651 add_rax,rbx 652 movsx_rax,BYTE_PTR_[rax] 653 pop_rbx # _common_recursion 654 sub_rbx,rax 655 mov_rax,rbx 656 pop_rbx # _return_result_locals 657 ret 658 # Defining function strncmp 659 :FUNCTION_strncmp 660 # Defining local i 661 mov_rax, %0 662 push_rax #i 663 :WHILE_strncmp_0 664 lea_rax,[rbp+DWORD] %-24 665 mov_rax,[rax] 666 push_rax #_common_recursion 667 lea_rax,[rbp+DWORD] %-40 668 mov_rax,[rax] 669 pop_rbx # _common_recursion 670 cmp_rbx,rax 671 seta_al 672 movzx_rax,al 673 test_rax,rax 674 je %END_WHILE_strncmp_0 675 # THEN_while_strncmp_0 676 # IF_strncmp_1 677 mov_rax, %0 678 push_rax #_common_recursion 679 lea_rax,[rbp+DWORD] %-8 680 mov_rax,[rax] 681 push_rax #_common_recursion 682 lea_rax,[rbp+DWORD] %-40 683 mov_rax,[rax] 684 pop_rbx # _common_recursion 685 add_rax,rbx 686 movsx_rax,BYTE_PTR_[rax] 687 pop_rbx # _common_recursion 688 cmp_rbx,rax 689 sete_al 690 movzx_rax,al 691 test_rax,rax 692 je %ELSE_strncmp_1 693 jmp %END_WHILE_strncmp_0 694 jmp %_END_IF_strncmp_1 695 :ELSE_strncmp_1 696 :_END_IF_strncmp_1 697 # IF_strncmp_2 698 lea_rax,[rbp+DWORD] %-8 699 mov_rax,[rax] 700 push_rax #_common_recursion 701 lea_rax,[rbp+DWORD] %-40 702 mov_rax,[rax] 703 pop_rbx # _common_recursion 704 add_rax,rbx 705 movsx_rax,BYTE_PTR_[rax] 706 push_rax #_common_recursion 707 lea_rax,[rbp+DWORD] %-16 708 mov_rax,[rax] 709 push_rax #_common_recursion 710 lea_rax,[rbp+DWORD] %-40 711 mov_rax,[rax] 712 pop_rbx # _common_recursion 713 add_rax,rbx 714 movsx_rax,BYTE_PTR_[rax] 715 pop_rbx # _common_recursion 716 cmp_rbx,rax 717 setne_al 718 movzx_rax,al 719 test_rax,rax 720 je %ELSE_strncmp_2 721 lea_rax,[rbp+DWORD] %-8 722 mov_rax,[rax] 723 push_rax #_common_recursion 724 lea_rax,[rbp+DWORD] %-40 725 mov_rax,[rax] 726 pop_rbx # _common_recursion 727 add_rax,rbx 728 movsx_rax,BYTE_PTR_[rax] 729 push_rax #_common_recursion 730 lea_rax,[rbp+DWORD] %-16 731 mov_rax,[rax] 732 push_rax #_common_recursion 733 lea_rax,[rbp+DWORD] %-40 734 mov_rax,[rax] 735 pop_rbx # _common_recursion 736 add_rax,rbx 737 movsx_rax,BYTE_PTR_[rax] 738 pop_rbx # _common_recursion 739 sub_rbx,rax 740 mov_rax,rbx 741 pop_rbx # _return_result_locals 742 ret 743 jmp %_END_IF_strncmp_2 744 :ELSE_strncmp_2 745 :_END_IF_strncmp_2 746 lea_rax,[rbp+DWORD] %-40 747 push_rax #_common_recursion 748 lea_rax,[rbp+DWORD] %-40 749 mov_rax,[rax] 750 push_rax #_common_recursion 751 mov_rax, %1 752 pop_rbx # _common_recursion 753 add_rax,rbx 754 pop_rbx # _common_recursion 755 mov_[rbx],rax 756 jmp %WHILE_strncmp_0 757 :END_WHILE_strncmp_0 758 mov_rax, %0 759 pop_rbx # _return_result_locals 760 ret 761 # Defining function strchr 762 :FUNCTION_strchr 763 # Defining local p 764 lea_rax,[rbp+DWORD] %-8 765 mov_rax,[rax] 766 push_rax #p 767 :WHILE_strchr_0 768 lea_rax,[rbp+DWORD] %-16 769 mov_rax,[rax] 770 push_rax #_common_recursion 771 lea_rax,[rbp+DWORD] %-32 772 mov_rax,[rax] 773 push_rax #_common_recursion 774 mov_rax, %0 775 pop_rbx # _common_recursion 776 add_rax,rbx 777 movsx_rax,BYTE_PTR_[rax] 778 pop_rbx # _common_recursion 779 cmp_rbx,rax 780 setne_al 781 movzx_rax,al 782 test_rax,rax 783 je %END_WHILE_strchr_0 784 # THEN_while_strchr_0 785 # IF_strchr_1 786 mov_rax, %0 787 push_rax #_common_recursion 788 lea_rax,[rbp+DWORD] %-32 789 mov_rax,[rax] 790 push_rax #_common_recursion 791 mov_rax, %0 792 pop_rbx # _common_recursion 793 add_rax,rbx 794 movsx_rax,BYTE_PTR_[rax] 795 pop_rbx # _common_recursion 796 cmp_rbx,rax 797 sete_al 798 movzx_rax,al 799 test_rax,rax 800 je %ELSE_strchr_1 801 mov_rax, %0 802 pop_rbx # _return_result_locals 803 ret 804 jmp %_END_IF_strchr_1 805 :ELSE_strchr_1 806 :_END_IF_strchr_1 807 lea_rax,[rbp+DWORD] %-32 808 push_rax #_common_recursion 809 lea_rax,[rbp+DWORD] %-32 810 mov_rax,[rax] 811 push_rax #_common_recursion 812 mov_rax, %1 813 pop_rbx # _common_recursion 814 add_rax,rbx 815 pop_rbx # _common_recursion 816 mov_[rbx],rax 817 jmp %WHILE_strchr_0 818 :END_WHILE_strchr_0 819 # IF_strchr_2 820 mov_rax, %0 821 push_rax #_common_recursion 822 lea_rax,[rbp+DWORD] %-32 823 mov_rax,[rax] 824 push_rax #_common_recursion 825 mov_rax, %0 826 pop_rbx # _common_recursion 827 add_rax,rbx 828 movsx_rax,BYTE_PTR_[rax] 829 pop_rbx # _common_recursion 830 cmp_rbx,rax 831 sete_al 832 movzx_rax,al 833 test_rax,rax 834 je %ELSE_strchr_2 835 mov_rax, %0 836 pop_rbx # _return_result_locals 837 ret 838 jmp %_END_IF_strchr_2 839 :ELSE_strchr_2 840 :_END_IF_strchr_2 841 lea_rax,[rbp+DWORD] %-32 842 mov_rax,[rax] 843 pop_rbx # _return_result_locals 844 ret 845 # Defining function strrchr 846 :FUNCTION_strrchr 847 # Defining local p 848 lea_rax,[rbp+DWORD] %-8 849 mov_rax,[rax] 850 push_rax #p 851 # Defining local i 852 mov_rax, %0 853 push_rax #i 854 :WHILE_strrchr_0 855 mov_rax, %0 856 push_rax #_common_recursion 857 lea_rax,[rbp+DWORD] %-32 858 mov_rax,[rax] 859 push_rax #_common_recursion 860 lea_rax,[rbp+DWORD] %-40 861 mov_rax,[rax] 862 pop_rbx # _common_recursion 863 add_rax,rbx 864 movsx_rax,BYTE_PTR_[rax] 865 pop_rbx # _common_recursion 866 cmp_rbx,rax 867 setne_al 868 movzx_rax,al 869 test_rax,rax 870 je %END_WHILE_strrchr_0 871 # THEN_while_strrchr_0 872 lea_rax,[rbp+DWORD] %-40 873 push_rax #_common_recursion 874 lea_rax,[rbp+DWORD] %-40 875 mov_rax,[rax] 876 push_rax #_common_recursion 877 mov_rax, %1 878 pop_rbx # _common_recursion 879 add_rax,rbx 880 pop_rbx # _common_recursion 881 mov_[rbx],rax 882 jmp %WHILE_strrchr_0 883 :END_WHILE_strrchr_0 884 :WHILE_strrchr_1 885 lea_rax,[rbp+DWORD] %-16 886 mov_rax,[rax] 887 push_rax #_common_recursion 888 lea_rax,[rbp+DWORD] %-32 889 mov_rax,[rax] 890 push_rax #_common_recursion 891 lea_rax,[rbp+DWORD] %-40 892 mov_rax,[rax] 893 pop_rbx # _common_recursion 894 add_rax,rbx 895 movsx_rax,BYTE_PTR_[rax] 896 pop_rbx # _common_recursion 897 cmp_rbx,rax 898 setne_al 899 movzx_rax,al 900 test_rax,rax 901 je %END_WHILE_strrchr_1 902 # THEN_while_strrchr_1 903 # IF_strrchr_2 904 mov_rax, %0 905 push_rax #_common_recursion 906 lea_rax,[rbp+DWORD] %-40 907 mov_rax,[rax] 908 pop_rbx # _common_recursion 909 cmp_rbx,rax 910 sete_al 911 movzx_rax,al 912 test_rax,rax 913 je %ELSE_strrchr_2 914 mov_rax, %0 915 pop_rbx # _return_result_locals 916 pop_rbx # _return_result_locals 917 ret 918 jmp %_END_IF_strrchr_2 919 :ELSE_strrchr_2 920 :_END_IF_strrchr_2 921 lea_rax,[rbp+DWORD] %-40 922 push_rax #_common_recursion 923 lea_rax,[rbp+DWORD] %-40 924 mov_rax,[rax] 925 push_rax #_common_recursion 926 mov_rax, %1 927 pop_rbx # _common_recursion 928 sub_rbx,rax 929 mov_rax,rbx 930 pop_rbx # _common_recursion 931 mov_[rbx],rax 932 jmp %WHILE_strrchr_1 933 :END_WHILE_strrchr_1 934 lea_rax,[rbp+DWORD] %-32 935 mov_rax,[rax] 936 push_rax #_common_recursion 937 lea_rax,[rbp+DWORD] %-40 938 mov_rax,[rax] 939 pop_rbx # _common_recursion 940 add_rax,rbx 941 pop_rbx # _return_result_locals 942 pop_rbx # _return_result_locals 943 ret 944 # Defining function strspn 945 :FUNCTION_strspn 946 # IF_strspn_0 947 mov_rax, %0 948 push_rax #_common_recursion 949 lea_rax,[rbp+DWORD] %-8 950 mov_rax,[rax] 951 push_rax #_common_recursion 952 mov_rax, %0 953 pop_rbx # _common_recursion 954 add_rax,rbx 955 movsx_rax,BYTE_PTR_[rax] 956 pop_rbx # _common_recursion 957 cmp_rbx,rax 958 sete_al 959 movzx_rax,al 960 test_rax,rax 961 je %ELSE_strspn_0 962 mov_rax, %0 963 ret 964 jmp %_END_IF_strspn_0 965 :ELSE_strspn_0 966 :_END_IF_strspn_0 967 # Defining local i 968 mov_rax, %0 969 push_rax #i 970 :WHILE_strspn_1 971 mov_rax, %0 972 push_rax #_common_recursion 973 push_rdi # Prevent overwriting in recursion 974 push_rbp # Protect the old base pointer 975 mov_rdi,rsp # Copy new base pointer 976 lea_rax,[rbp+DWORD] %-16 977 mov_rax,[rax] 978 push_rax #_process_expression1 979 lea_rax,[rbp+DWORD] %-8 980 mov_rax,[rax] 981 push_rax #_common_recursion 982 lea_rax,[rbp+DWORD] %-32 983 mov_rax,[rax] 984 pop_rbx # _common_recursion 985 add_rax,rbx 986 movsx_rax,BYTE_PTR_[rax] 987 push_rax #_process_expression2 988 mov_rbp,rdi 989 call %FUNCTION_strchr 990 pop_rbx # _process_expression_locals 991 pop_rbx # _process_expression_locals 992 pop_rbp # Restore old base pointer 993 pop_rdi # Prevent overwrite 994 pop_rbx # _common_recursion 995 cmp_rbx,rax 996 setne_al 997 movzx_rax,al 998 test_rax,rax 999 je %END_WHILE_strspn_1 1000 # THEN_while_strspn_1 1001 lea_rax,[rbp+DWORD] %-32 1002 push_rax #_common_recursion 1003 lea_rax,[rbp+DWORD] %-32 1004 mov_rax,[rax] 1005 push_rax #_common_recursion 1006 mov_rax, %1 1007 pop_rbx # _common_recursion 1008 add_rax,rbx 1009 pop_rbx # _common_recursion 1010 mov_[rbx],rax 1011 jmp %WHILE_strspn_1 1012 :END_WHILE_strspn_1 1013 lea_rax,[rbp+DWORD] %-32 1014 mov_rax,[rax] 1015 pop_rbx # _return_result_locals 1016 ret 1017 # Defining function strcspn 1018 :FUNCTION_strcspn 1019 # Defining local i 1020 mov_rax, %0 1021 push_rax #i 1022 :WHILE_strcspn_0 1023 mov_rax, %0 1024 push_rax #_common_recursion 1025 push_rdi # Prevent overwriting in recursion 1026 push_rbp # Protect the old base pointer 1027 mov_rdi,rsp # Copy new base pointer 1028 lea_rax,[rbp+DWORD] %-16 1029 mov_rax,[rax] 1030 push_rax #_process_expression1 1031 lea_rax,[rbp+DWORD] %-8 1032 mov_rax,[rax] 1033 push_rax #_common_recursion 1034 lea_rax,[rbp+DWORD] %-32 1035 mov_rax,[rax] 1036 pop_rbx # _common_recursion 1037 add_rax,rbx 1038 movsx_rax,BYTE_PTR_[rax] 1039 push_rax #_process_expression2 1040 mov_rbp,rdi 1041 call %FUNCTION_strchr 1042 pop_rbx # _process_expression_locals 1043 pop_rbx # _process_expression_locals 1044 pop_rbp # Restore old base pointer 1045 pop_rdi # Prevent overwrite 1046 pop_rbx # _common_recursion 1047 cmp_rbx,rax 1048 sete_al 1049 movzx_rax,al 1050 test_rax,rax 1051 je %END_WHILE_strcspn_0 1052 # THEN_while_strcspn_0 1053 lea_rax,[rbp+DWORD] %-32 1054 push_rax #_common_recursion 1055 lea_rax,[rbp+DWORD] %-32 1056 mov_rax,[rax] 1057 push_rax #_common_recursion 1058 mov_rax, %1 1059 pop_rbx # _common_recursion 1060 add_rax,rbx 1061 pop_rbx # _common_recursion 1062 mov_[rbx],rax 1063 jmp %WHILE_strcspn_0 1064 :END_WHILE_strcspn_0 1065 lea_rax,[rbp+DWORD] %-32 1066 mov_rax,[rax] 1067 pop_rbx # _return_result_locals 1068 ret 1069 # Defining function strpbrk 1070 :FUNCTION_strpbrk 1071 # Defining local p 1072 lea_rax,[rbp+DWORD] %-8 1073 mov_rax,[rax] 1074 push_rax #p 1075 # Defining local s 1076 push_rax #s 1077 :WHILE_strpbrk_0 1078 mov_rax, %0 1079 push_rax #_common_recursion 1080 lea_rax,[rbp+DWORD] %-32 1081 mov_rax,[rax] 1082 push_rax #_common_recursion 1083 mov_rax, %0 1084 pop_rbx # _common_recursion 1085 add_rax,rbx 1086 movsx_rax,BYTE_PTR_[rax] 1087 pop_rbx # _common_recursion 1088 cmp_rbx,rax 1089 setne_al 1090 movzx_rax,al 1091 test_rax,rax 1092 je %END_WHILE_strpbrk_0 1093 # THEN_while_strpbrk_0 1094 lea_rax,[rbp+DWORD] %-40 1095 push_rax #_common_recursion 1096 push_rdi # Prevent overwriting in recursion 1097 push_rbp # Protect the old base pointer 1098 mov_rdi,rsp # Copy new base pointer 1099 lea_rax,[rbp+DWORD] %-16 1100 mov_rax,[rax] 1101 push_rax #_process_expression1 1102 lea_rax,[rbp+DWORD] %-32 1103 mov_rax,[rax] 1104 push_rax #_common_recursion 1105 mov_rax, %0 1106 pop_rbx # _common_recursion 1107 add_rax,rbx 1108 movsx_rax,BYTE_PTR_[rax] 1109 push_rax #_process_expression2 1110 mov_rbp,rdi 1111 call %FUNCTION_strchr 1112 pop_rbx # _process_expression_locals 1113 pop_rbx # _process_expression_locals 1114 pop_rbp # Restore old base pointer 1115 pop_rdi # Prevent overwrite 1116 pop_rbx # _common_recursion 1117 mov_[rbx],rax 1118 # IF_strpbrk_1 1119 mov_rax, %0 1120 push_rax #_common_recursion 1121 lea_rax,[rbp+DWORD] %-40 1122 mov_rax,[rax] 1123 pop_rbx # _common_recursion 1124 cmp_rbx,rax 1125 setne_al 1126 movzx_rax,al 1127 test_rax,rax 1128 je %ELSE_strpbrk_1 1129 push_rdi # Prevent overwriting in recursion 1130 push_rbp # Protect the old base pointer 1131 mov_rdi,rsp # Copy new base pointer 1132 lea_rax,[rbp+DWORD] %-32 1133 mov_rax,[rax] 1134 push_rax #_process_expression1 1135 lea_rax,[rbp+DWORD] %-40 1136 mov_rax,[rax] 1137 push_rax #_common_recursion 1138 mov_rax, %0 1139 pop_rbx # _common_recursion 1140 add_rax,rbx 1141 movsx_rax,BYTE_PTR_[rax] 1142 push_rax #_process_expression2 1143 mov_rbp,rdi 1144 call %FUNCTION_strchr 1145 pop_rbx # _process_expression_locals 1146 pop_rbx # _process_expression_locals 1147 pop_rbp # Restore old base pointer 1148 pop_rdi # Prevent overwrite 1149 pop_rbx # _return_result_locals 1150 pop_rbx # _return_result_locals 1151 ret 1152 jmp %_END_IF_strpbrk_1 1153 :ELSE_strpbrk_1 1154 :_END_IF_strpbrk_1 1155 lea_rax,[rbp+DWORD] %-32 1156 push_rax #_common_recursion 1157 lea_rax,[rbp+DWORD] %-32 1158 mov_rax,[rax] 1159 push_rax #_common_recursion 1160 mov_rax, %1 1161 pop_rbx # _common_recursion 1162 add_rax,rbx 1163 pop_rbx # _common_recursion 1164 mov_[rbx],rax 1165 jmp %WHILE_strpbrk_0 1166 :END_WHILE_strpbrk_0 1167 lea_rax,[rbp+DWORD] %-32 1168 mov_rax,[rax] 1169 pop_rbx # _return_result_locals 1170 pop_rbx # _return_result_locals 1171 ret 1172 # Defining function memset 1173 :FUNCTION_memset 1174 # IF_memset_0 1175 mov_rax, %0 1176 push_rax #_common_recursion 1177 lea_rax,[rbp+DWORD] %-8 1178 mov_rax,[rax] 1179 pop_rbx # _common_recursion 1180 cmp_rbx,rax 1181 sete_al 1182 movzx_rax,al 1183 test_rax,rax 1184 je %ELSE_memset_0 1185 lea_rax,[rbp+DWORD] %-8 1186 mov_rax,[rax] 1187 ret 1188 jmp %_END_IF_memset_0 1189 :ELSE_memset_0 1190 :_END_IF_memset_0 1191 # Defining local i 1192 mov_rax, %0 1193 push_rax #i 1194 # Defining local s 1195 lea_rax,[rbp+DWORD] %-8 1196 mov_rax,[rax] 1197 push_rax #s 1198 :WHILE_memset_1 1199 lea_rax,[rbp+DWORD] %-40 1200 mov_rax,[rax] 1201 push_rax #_common_recursion 1202 lea_rax,[rbp+DWORD] %-24 1203 mov_rax,[rax] 1204 pop_rbx # _common_recursion 1205 cmp_rbx,rax 1206 setb_al 1207 movzx_rax,al 1208 test_rax,rax 1209 je %END_WHILE_memset_1 1210 # THEN_while_memset_1 1211 lea_rax,[rbp+DWORD] %-48 1212 mov_rax,[rax] 1213 push_rax #_common_recursion 1214 lea_rax,[rbp+DWORD] %-40 1215 mov_rax,[rax] 1216 pop_rbx # _common_recursion 1217 add_rax,rbx 1218 push_rax #_common_recursion 1219 lea_rax,[rbp+DWORD] %-16 1220 mov_rax,[rax] 1221 pop_rbx # _common_recursion 1222 mov_[rbx],al 1223 lea_rax,[rbp+DWORD] %-40 1224 push_rax #_common_recursion 1225 lea_rax,[rbp+DWORD] %-40 1226 mov_rax,[rax] 1227 push_rax #_common_recursion 1228 mov_rax, %1 1229 pop_rbx # _common_recursion 1230 add_rax,rbx 1231 pop_rbx # _common_recursion 1232 mov_[rbx],rax 1233 jmp %WHILE_memset_1 1234 :END_WHILE_memset_1 1235 lea_rax,[rbp+DWORD] %-8 1236 mov_rax,[rax] 1237 pop_rbx # _return_result_locals 1238 pop_rbx # _return_result_locals 1239 ret 1240 # Defining function memcpy 1241 :FUNCTION_memcpy 1242 # IF_memcpy_0 1243 mov_rax, %0 1244 push_rax #_common_recursion 1245 lea_rax,[rbp+DWORD] %-8 1246 mov_rax,[rax] 1247 pop_rbx # _common_recursion 1248 cmp_rbx,rax 1249 sete_al 1250 movzx_rax,al 1251 test_rax,rax 1252 je %ELSE_memcpy_0 1253 lea_rax,[rbp+DWORD] %-8 1254 mov_rax,[rax] 1255 ret 1256 jmp %_END_IF_memcpy_0 1257 :ELSE_memcpy_0 1258 :_END_IF_memcpy_0 1259 # IF_memcpy_1 1260 mov_rax, %0 1261 push_rax #_common_recursion 1262 lea_rax,[rbp+DWORD] %-16 1263 mov_rax,[rax] 1264 pop_rbx # _common_recursion 1265 cmp_rbx,rax 1266 sete_al 1267 movzx_rax,al 1268 test_rax,rax 1269 je %ELSE_memcpy_1 1270 mov_rax, %0 1271 ret 1272 jmp %_END_IF_memcpy_1 1273 :ELSE_memcpy_1 1274 :_END_IF_memcpy_1 1275 # Defining local s1 1276 lea_rax,[rbp+DWORD] %-8 1277 mov_rax,[rax] 1278 push_rax #s1 1279 # Defining local s2 1280 lea_rax,[rbp+DWORD] %-16 1281 mov_rax,[rax] 1282 push_rax #s2 1283 # Defining local i 1284 mov_rax, %0 1285 push_rax #i 1286 :WHILE_memcpy_2 1287 lea_rax,[rbp+DWORD] %-56 1288 mov_rax,[rax] 1289 push_rax #_common_recursion 1290 lea_rax,[rbp+DWORD] %-24 1291 mov_rax,[rax] 1292 pop_rbx # _common_recursion 1293 cmp_rbx,rax 1294 setb_al 1295 movzx_rax,al 1296 test_rax,rax 1297 je %END_WHILE_memcpy_2 1298 # THEN_while_memcpy_2 1299 lea_rax,[rbp+DWORD] %-40 1300 mov_rax,[rax] 1301 push_rax #_common_recursion 1302 lea_rax,[rbp+DWORD] %-56 1303 mov_rax,[rax] 1304 pop_rbx # _common_recursion 1305 add_rax,rbx 1306 push_rax #_common_recursion 1307 lea_rax,[rbp+DWORD] %-48 1308 mov_rax,[rax] 1309 push_rax #_common_recursion 1310 lea_rax,[rbp+DWORD] %-56 1311 mov_rax,[rax] 1312 pop_rbx # _common_recursion 1313 add_rax,rbx 1314 movsx_rax,BYTE_PTR_[rax] 1315 pop_rbx # _common_recursion 1316 mov_[rbx],al 1317 lea_rax,[rbp+DWORD] %-56 1318 push_rax #_common_recursion 1319 lea_rax,[rbp+DWORD] %-56 1320 mov_rax,[rax] 1321 push_rax #_common_recursion 1322 mov_rax, %1 1323 pop_rbx # _common_recursion 1324 add_rax,rbx 1325 pop_rbx # _common_recursion 1326 mov_[rbx],rax 1327 jmp %WHILE_memcpy_2 1328 :END_WHILE_memcpy_2 1329 lea_rax,[rbp+DWORD] %-8 1330 mov_rax,[rax] 1331 pop_rbx # _return_result_locals 1332 pop_rbx # _return_result_locals 1333 pop_rbx # _return_result_locals 1334 ret 1335 # Defining function memmove 1336 :FUNCTION_memmove 1337 # IF_memmove_0 1338 lea_rax,[rbp+DWORD] %-8 1339 mov_rax,[rax] 1340 push_rax #_common_recursion 1341 lea_rax,[rbp+DWORD] %-16 1342 mov_rax,[rax] 1343 pop_rbx # _common_recursion 1344 cmp_rbx,rax 1345 setb_al 1346 movzx_rax,al 1347 test_rax,rax 1348 je %ELSE_memmove_0 1349 push_rdi # Prevent overwriting in recursion 1350 push_rbp # Protect the old base pointer 1351 mov_rdi,rsp # Copy new base pointer 1352 lea_rax,[rbp+DWORD] %-8 1353 mov_rax,[rax] 1354 push_rax #_process_expression1 1355 lea_rax,[rbp+DWORD] %-16 1356 mov_rax,[rax] 1357 push_rax #_process_expression2 1358 lea_rax,[rbp+DWORD] %-24 1359 mov_rax,[rax] 1360 push_rax #_process_expression2 1361 mov_rbp,rdi 1362 call %FUNCTION_memcpy 1363 pop_rbx # _process_expression_locals 1364 pop_rbx # _process_expression_locals 1365 pop_rbx # _process_expression_locals 1366 pop_rbp # Restore old base pointer 1367 pop_rdi # Prevent overwrite 1368 ret 1369 jmp %_END_IF_memmove_0 1370 :ELSE_memmove_0 1371 :_END_IF_memmove_0 1372 # Defining local p 1373 lea_rax,[rbp+DWORD] %-8 1374 mov_rax,[rax] 1375 push_rax #p 1376 # Defining local q 1377 lea_rax,[rbp+DWORD] %-16 1378 mov_rax,[rax] 1379 push_rax #q 1380 lea_rax,[rbp+DWORD] %-24 1381 push_rax #_common_recursion 1382 lea_rax,[rbp+DWORD] %-24 1383 mov_rax,[rax] 1384 push_rax #_common_recursion 1385 mov_rax, %1 1386 pop_rbx # _common_recursion 1387 sub_rbx,rax 1388 mov_rax,rbx 1389 pop_rbx # _common_recursion 1390 mov_[rbx],rax 1391 :WHILE_memmove_1 1392 lea_rax,[rbp+DWORD] %-24 1393 mov_rax,[rax] 1394 push_rax #_common_recursion 1395 mov_rax, %0 1396 pop_rbx # _common_recursion 1397 cmp_rbx,rax 1398 setae_al 1399 movzx_rax,al 1400 test_rax,rax 1401 je %END_WHILE_memmove_1 1402 # THEN_while_memmove_1 1403 lea_rax,[rbp+DWORD] %-40 1404 mov_rax,[rax] 1405 push_rax #_common_recursion 1406 lea_rax,[rbp+DWORD] %-24 1407 mov_rax,[rax] 1408 pop_rbx # _common_recursion 1409 add_rax,rbx 1410 push_rax #_common_recursion 1411 lea_rax,[rbp+DWORD] %-48 1412 mov_rax,[rax] 1413 push_rax #_common_recursion 1414 lea_rax,[rbp+DWORD] %-24 1415 mov_rax,[rax] 1416 pop_rbx # _common_recursion 1417 add_rax,rbx 1418 movsx_rax,BYTE_PTR_[rax] 1419 pop_rbx # _common_recursion 1420 mov_[rbx],al 1421 lea_rax,[rbp+DWORD] %-24 1422 push_rax #_common_recursion 1423 lea_rax,[rbp+DWORD] %-24 1424 mov_rax,[rax] 1425 push_rax #_common_recursion 1426 mov_rax, %1 1427 pop_rbx # _common_recursion 1428 sub_rbx,rax 1429 mov_rax,rbx 1430 pop_rbx # _common_recursion 1431 mov_[rbx],rax 1432 jmp %WHILE_memmove_1 1433 :END_WHILE_memmove_1 1434 lea_rax,[rbp+DWORD] %-8 1435 mov_rax,[rax] 1436 pop_rbx # _return_result_locals 1437 pop_rbx # _return_result_locals 1438 ret 1439 # Defining function memcmp 1440 :FUNCTION_memcmp 1441 # IF_memcmp_0 1442 mov_rax, %0 1443 push_rax #_common_recursion 1444 lea_rax,[rbp+DWORD] %-24 1445 mov_rax,[rax] 1446 pop_rbx # _common_recursion 1447 cmp_rbx,rax 1448 sete_al 1449 movzx_rax,al 1450 test_rax,rax 1451 je %ELSE_memcmp_0 1452 mov_rax, %0 1453 ret 1454 jmp %_END_IF_memcmp_0 1455 :ELSE_memcmp_0 1456 :_END_IF_memcmp_0 1457 # Defining local i 1458 mov_rax, %0 1459 push_rax #i 1460 # Defining local s1 1461 lea_rax,[rbp+DWORD] %-8 1462 mov_rax,[rax] 1463 push_rax #s1 1464 # Defining local s2 1465 lea_rax,[rbp+DWORD] %-16 1466 mov_rax,[rax] 1467 push_rax #s2 1468 :WHILE_memcmp_1 1469 lea_rax,[rbp+DWORD] %-48 1470 mov_rax,[rax] 1471 push_rax #_common_recursion 1472 lea_rax,[rbp+DWORD] %-40 1473 mov_rax,[rax] 1474 pop_rbx # _common_recursion 1475 add_rax,rbx 1476 movsx_rax,BYTE_PTR_[rax] 1477 push_rax #_common_recursion 1478 lea_rax,[rbp+DWORD] %-56 1479 mov_rax,[rax] 1480 push_rax #_common_recursion 1481 lea_rax,[rbp+DWORD] %-40 1482 mov_rax,[rax] 1483 pop_rbx # _common_recursion 1484 add_rax,rbx 1485 movsx_rax,BYTE_PTR_[rax] 1486 pop_rbx # _common_recursion 1487 cmp_rbx,rax 1488 sete_al 1489 movzx_rax,al 1490 test_rax,rax 1491 je %END_WHILE_memcmp_1 1492 # THEN_while_memcmp_1 1493 lea_rax,[rbp+DWORD] %-40 1494 push_rax #_common_recursion 1495 lea_rax,[rbp+DWORD] %-40 1496 mov_rax,[rax] 1497 push_rax #_common_recursion 1498 mov_rax, %1 1499 pop_rbx # _common_recursion 1500 add_rax,rbx 1501 pop_rbx # _common_recursion 1502 mov_[rbx],rax 1503 # IF_memcmp_2 1504 lea_rax,[rbp+DWORD] %-24 1505 mov_rax,[rax] 1506 push_rax #_common_recursion 1507 lea_rax,[rbp+DWORD] %-40 1508 mov_rax,[rax] 1509 pop_rbx # _common_recursion 1510 cmp_rbx,rax 1511 sete_al 1512 movzx_rax,al 1513 test_rax,rax 1514 je %ELSE_memcmp_2 1515 lea_rax,[rbp+DWORD] %-24 1516 mov_rax,[rax] 1517 pop_rbx # _return_result_locals 1518 pop_rbx # _return_result_locals 1519 pop_rbx # _return_result_locals 1520 ret 1521 jmp %_END_IF_memcmp_2 1522 :ELSE_memcmp_2 1523 :_END_IF_memcmp_2 1524 jmp %WHILE_memcmp_1 1525 :END_WHILE_memcmp_1 1526 lea_rax,[rbp+DWORD] %-48 1527 mov_rax,[rax] 1528 push_rax #_common_recursion 1529 lea_rax,[rbp+DWORD] %-40 1530 mov_rax,[rax] 1531 pop_rbx # _common_recursion 1532 add_rax,rbx 1533 movsx_rax,BYTE_PTR_[rax] 1534 push_rax #_common_recursion 1535 lea_rax,[rbp+DWORD] %-56 1536 mov_rax,[rax] 1537 push_rax #_common_recursion 1538 lea_rax,[rbp+DWORD] %-40 1539 mov_rax,[rax] 1540 pop_rbx # _common_recursion 1541 add_rax,rbx 1542 movsx_rax,BYTE_PTR_[rax] 1543 pop_rbx # _common_recursion 1544 sub_rbx,rax 1545 mov_rax,rbx 1546 pop_rbx # _return_result_locals 1547 pop_rbx # _return_result_locals 1548 pop_rbx # _return_result_locals 1549 ret 1550 # Defining function chmod 1551 :FUNCTION_chmod 1552 LOAD_EFFECTIVE_ADDRESS_rdi %16 1553 LOAD_INTEGER_rdi 1554 LOAD_EFFECTIVE_ADDRESS_rsi %8 1555 LOAD_INTEGER_rsi 1556 LOAD_IMMEDIATE_rax %90 1557 SYSCALL 1558 ret 1559 # Defining function fchmod 1560 :FUNCTION_fchmod 1561 LOAD_EFFECTIVE_ADDRESS_rdi %16 1562 LOAD_INTEGER_rdi 1563 LOAD_EFFECTIVE_ADDRESS_rsi %8 1564 LOAD_INTEGER_rsi 1565 LOAD_IMMEDIATE_rax %91 1566 SYSCALL 1567 ret 1568 # Defining function mkdir 1569 :FUNCTION_mkdir 1570 LOAD_EFFECTIVE_ADDRESS_rdi %16 1571 LOAD_INTEGER_rdi 1572 LOAD_EFFECTIVE_ADDRESS_rsi %8 1573 LOAD_INTEGER_rsi 1574 LOAD_IMMEDIATE_rax %83 1575 SYSCALL 1576 ret 1577 # Defining function mknod 1578 :FUNCTION_mknod 1579 LOAD_EFFECTIVE_ADDRESS_rdi %24 1580 LOAD_INTEGER_rdi 1581 LOAD_EFFECTIVE_ADDRESS_rsi %16 1582 LOAD_INTEGER_rsi 1583 LOAD_EFFECTIVE_ADDRESS_rdx %8 1584 LOAD_INTEGER_rdx 1585 LOAD_IMMEDIATE_rax %133 1586 SYSCALL 1587 ret 1588 # Defining function umask 1589 :FUNCTION_umask 1590 LOAD_EFFECTIVE_ADDRESS_rdi %8 1591 LOAD_INTEGER_rdi 1592 LOAD_IMMEDIATE_rax %95 1593 SYSCALL 1594 ret 1595 # Defining function open 1596 :FUNCTION_open 1597 LOAD_EFFECTIVE_ADDRESS_rdi %24 1598 LOAD_INTEGER_rdi 1599 LOAD_EFFECTIVE_ADDRESS_rsi %16 1600 LOAD_INTEGER_rsi 1601 LOAD_EFFECTIVE_ADDRESS_rdx %8 1602 LOAD_INTEGER_rdx 1603 LOAD_IMMEDIATE_rax %2 1604 SYSCALL 1605 ret 1606 # Defining function access 1607 :FUNCTION_access 1608 LOAD_EFFECTIVE_ADDRESS_rdi %16 1609 LOAD_INTEGER_rdi 1610 LOAD_EFFECTIVE_ADDRESS_rsi %8 1611 LOAD_INTEGER_rsi 1612 LOAD_IMMEDIATE_rax %21 1613 SYSCALL 1614 ret 1615 # Defining function chdir 1616 :FUNCTION_chdir 1617 LOAD_EFFECTIVE_ADDRESS_rdi %8 1618 LOAD_INTEGER_rdi 1619 LOAD_IMMEDIATE_rax %80 1620 SYSCALL 1621 ret 1622 # Defining function fchdir 1623 :FUNCTION_fchdir 1624 LOAD_EFFECTIVE_ADDRESS_rdi %8 1625 LOAD_INTEGER_rdi 1626 LOAD_IMMEDIATE_rax %81 1627 SYSCALL 1628 ret 1629 # Defining function fork 1630 :FUNCTION_fork 1631 LOAD_IMMEDIATE_rax %57 1632 LOAD_IMMEDIATE_rdi %0 1633 SYSCALL 1634 ret 1635 # Defining function waitpid 1636 :FUNCTION_waitpid 1637 LOAD_EFFECTIVE_ADDRESS_rdi %24 1638 LOAD_INTEGER_rdi 1639 LOAD_EFFECTIVE_ADDRESS_rsi %16 1640 LOAD_INTEGER_rsi 1641 LOAD_EFFECTIVE_ADDRESS_rdx %8 1642 LOAD_INTEGER_rdx 1643 LOAD_IMMEDIATE_r10 %0 1644 LOAD_IMMEDIATE_rax %61 1645 SYSCALL 1646 ret 1647 # Defining function execve 1648 :FUNCTION_execve 1649 LOAD_EFFECTIVE_ADDRESS_rdi %24 1650 LOAD_INTEGER_rdi 1651 LOAD_EFFECTIVE_ADDRESS_rsi %16 1652 LOAD_INTEGER_rsi 1653 LOAD_EFFECTIVE_ADDRESS_rdx %8 1654 LOAD_INTEGER_rdx 1655 LOAD_IMMEDIATE_rax %59 1656 SYSCALL 1657 ret 1658 # Defining function read 1659 :FUNCTION_read 1660 LOAD_EFFECTIVE_ADDRESS_rdi %24 1661 LOAD_INTEGER_rdi 1662 LOAD_EFFECTIVE_ADDRESS_rsi %16 1663 LOAD_INTEGER_rsi 1664 LOAD_EFFECTIVE_ADDRESS_rdx %8 1665 LOAD_INTEGER_rdx 1666 LOAD_IMMEDIATE_rax %0 1667 SYSCALL 1668 ret 1669 # Defining function write 1670 :FUNCTION_write 1671 LOAD_EFFECTIVE_ADDRESS_rdi %24 1672 LOAD_INTEGER_rdi 1673 LOAD_EFFECTIVE_ADDRESS_rsi %16 1674 LOAD_INTEGER_rsi 1675 LOAD_EFFECTIVE_ADDRESS_rdx %8 1676 LOAD_INTEGER_rdx 1677 LOAD_IMMEDIATE_rax %1 1678 SYSCALL 1679 ret 1680 # Defining function lseek 1681 :FUNCTION_lseek 1682 LOAD_EFFECTIVE_ADDRESS_rdi %24 1683 LOAD_INTEGER_rdi 1684 LOAD_EFFECTIVE_ADDRESS_rsi %16 1685 LOAD_INTEGER_rsi 1686 LOAD_EFFECTIVE_ADDRESS_rdx %8 1687 LOAD_INTEGER_rdx 1688 LOAD_IMMEDIATE_rax %8 1689 SYSCALL 1690 ret 1691 # Defining function close 1692 :FUNCTION_close 1693 LOAD_EFFECTIVE_ADDRESS_rdi %8 1694 LOAD_INTEGER_rdi 1695 LOAD_IMMEDIATE_rax %3 1696 SYSCALL 1697 ret 1698 # Defining function unlink 1699 :FUNCTION_unlink 1700 LOAD_EFFECTIVE_ADDRESS_rdi %8 1701 LOAD_INTEGER_rdi 1702 LOAD_IMMEDIATE_rax %87 1703 SYSCALL 1704 ret 1705 # Defining function _getcwd 1706 :FUNCTION__getcwd 1707 LOAD_EFFECTIVE_ADDRESS_rdi %16 1708 LOAD_INTEGER_rdi 1709 LOAD_EFFECTIVE_ADDRESS_rsi %8 1710 LOAD_INTEGER_rsi 1711 LOAD_IMMEDIATE_rax %79 1712 SYSCALL 1713 ret 1714 # Defining function getcwd 1715 :FUNCTION_getcwd 1716 # Defining local c 1717 push_rdi # Prevent overwriting in recursion 1718 push_rbp # Protect the old base pointer 1719 mov_rdi,rsp # Copy new base pointer 1720 lea_rax,[rbp+DWORD] %-8 1721 mov_rax,[rax] 1722 push_rax #_process_expression1 1723 lea_rax,[rbp+DWORD] %-16 1724 mov_rax,[rax] 1725 push_rax #_process_expression2 1726 mov_rbp,rdi 1727 call %FUNCTION__getcwd 1728 pop_rbx # _process_expression_locals 1729 pop_rbx # _process_expression_locals 1730 pop_rbp # Restore old base pointer 1731 pop_rdi # Prevent overwrite 1732 push_rax #c 1733 # IF_getcwd_0 1734 mov_rax, %0 1735 push_rax #_common_recursion 1736 lea_rax,[rbp+DWORD] %-32 1737 mov_rax,[rax] 1738 pop_rbx # _common_recursion 1739 cmp_rbx,rax 1740 sete_al 1741 movzx_rax,al 1742 test_rax,rax 1743 je %ELSE_getcwd_0 1744 mov_rax, %0 1745 pop_rbx # _return_result_locals 1746 ret 1747 jmp %_END_IF_getcwd_0 1748 :ELSE_getcwd_0 1749 :_END_IF_getcwd_0 1750 lea_rax,[rbp+DWORD] %-8 1751 mov_rax,[rax] 1752 pop_rbx # _return_result_locals 1753 ret 1754 # Defining function getwd 1755 :FUNCTION_getwd 1756 push_rdi # Prevent overwriting in recursion 1757 push_rbp # Protect the old base pointer 1758 mov_rdi,rsp # Copy new base pointer 1759 lea_rax,[rbp+DWORD] %-8 1760 mov_rax,[rax] 1761 push_rax #_process_expression1 1762 mov_rax, %4096 1763 push_rax #_process_expression2 1764 mov_rbp,rdi 1765 call %FUNCTION_getcwd 1766 pop_rbx # _process_expression_locals 1767 pop_rbx # _process_expression_locals 1768 pop_rbp # Restore old base pointer 1769 pop_rdi # Prevent overwrite 1770 ret 1771 # Defining function get_current_dir_name 1772 :FUNCTION_get_current_dir_name 1773 push_rdi # Prevent overwriting in recursion 1774 push_rbp # Protect the old base pointer 1775 mov_rdi,rsp # Copy new base pointer 1776 push_rdi # Prevent overwriting in recursion 1777 push_rbp # Protect the old base pointer 1778 mov_rdi,rsp # Copy new base pointer 1779 mov_rax, %4096 1780 push_rax #_process_expression1 1781 mov_rbp,rdi 1782 call %FUNCTION_malloc 1783 pop_rbx # _process_expression_locals 1784 pop_rbp # Restore old base pointer 1785 pop_rdi # Prevent overwrite 1786 push_rax #_process_expression1 1787 mov_rax, %4096 1788 push_rax #_process_expression2 1789 mov_rbp,rdi 1790 call %FUNCTION_getcwd 1791 pop_rbx # _process_expression_locals 1792 pop_rbx # _process_expression_locals 1793 pop_rbp # Restore old base pointer 1794 pop_rdi # Prevent overwrite 1795 ret 1796 # Defining function brk 1797 :FUNCTION_brk 1798 LOAD_RSP_IMMEDIATE_into_rax %8 1799 PUSH_RAX 1800 LOAD_IMMEDIATE_rax %12 1801 POP_RBX 1802 COPY_rbx_to_rdi 1803 SYSCALL 1804 ret 1805 # Defining function uname 1806 :FUNCTION_uname 1807 LOAD_EFFECTIVE_ADDRESS_rdi %8 1808 LOAD_INTEGER_rdi 1809 LOAD_IMMEDIATE_rax %63 1810 SYSCALL 1811 ret 1812 # Defining function free 1813 :FUNCTION_free 1814 ret 1815 # Defining function malloc 1816 :FUNCTION_malloc 1817 # IF_malloc_0 1818 mov_rax, %0 1819 push_rax #_common_recursion 1820 lea_rax,[rip+DWORD] %GLOBAL__brk_ptr 1821 mov_rax,[rax] 1822 pop_rbx # _common_recursion 1823 cmp_rbx,rax 1824 sete_al 1825 movzx_rax,al 1826 test_rax,rax 1827 je %ELSE_malloc_0 1828 lea_rax,[rip+DWORD] %GLOBAL__brk_ptr 1829 push_rax #_common_recursion 1830 push_rdi # Prevent overwriting in recursion 1831 push_rbp # Protect the old base pointer 1832 mov_rdi,rsp # Copy new base pointer 1833 mov_rax, %0 1834 push_rax #_process_expression1 1835 mov_rbp,rdi 1836 call %FUNCTION_brk 1837 pop_rbx # _process_expression_locals 1838 pop_rbp # Restore old base pointer 1839 pop_rdi # Prevent overwrite 1840 pop_rbx # _common_recursion 1841 mov_[rbx],rax 1842 lea_rax,[rip+DWORD] %GLOBAL__malloc_ptr 1843 push_rax #_common_recursion 1844 lea_rax,[rip+DWORD] %GLOBAL__brk_ptr 1845 mov_rax,[rax] 1846 pop_rbx # _common_recursion 1847 mov_[rbx],rax 1848 jmp %_END_IF_malloc_0 1849 :ELSE_malloc_0 1850 :_END_IF_malloc_0 1851 # IF_malloc_1 1852 lea_rax,[rip+DWORD] %GLOBAL__brk_ptr 1853 mov_rax,[rax] 1854 push_rax #_common_recursion 1855 lea_rax,[rip+DWORD] %GLOBAL__malloc_ptr 1856 mov_rax,[rax] 1857 push_rax #_common_recursion 1858 lea_rax,[rbp+DWORD] %-8 1859 mov_rax,[rax] 1860 pop_rbx # _common_recursion 1861 add_rax,rbx 1862 pop_rbx # _common_recursion 1863 cmp_rbx,rax 1864 setl_al 1865 movzx_rax,al 1866 test_rax,rax 1867 je %ELSE_malloc_1 1868 lea_rax,[rip+DWORD] %GLOBAL__brk_ptr 1869 push_rax #_common_recursion 1870 push_rdi # Prevent overwriting in recursion 1871 push_rbp # Protect the old base pointer 1872 mov_rdi,rsp # Copy new base pointer 1873 lea_rax,[rip+DWORD] %GLOBAL__malloc_ptr 1874 mov_rax,[rax] 1875 push_rax #_common_recursion 1876 lea_rax,[rbp+DWORD] %-8 1877 mov_rax,[rax] 1878 pop_rbx # _common_recursion 1879 add_rax,rbx 1880 push_rax #_process_expression1 1881 mov_rbp,rdi 1882 call %FUNCTION_brk 1883 pop_rbx # _process_expression_locals 1884 pop_rbp # Restore old base pointer 1885 pop_rdi # Prevent overwrite 1886 pop_rbx # _common_recursion 1887 mov_[rbx],rax 1888 # IF_malloc_2 1889 mov_rax, %0 1890 push_rax #_common_recursion 1891 mov_rax, %1 1892 pop_rbx # _common_recursion 1893 sub_rbx,rax 1894 mov_rax,rbx 1895 push_rax #_common_recursion 1896 lea_rax,[rip+DWORD] %GLOBAL__brk_ptr 1897 mov_rax,[rax] 1898 pop_rbx # _common_recursion 1899 cmp_rbx,rax 1900 sete_al 1901 movzx_rax,al 1902 test_rax,rax 1903 je %ELSE_malloc_2 1904 mov_rax, %0 1905 ret 1906 jmp %_END_IF_malloc_2 1907 :ELSE_malloc_2 1908 :_END_IF_malloc_2 1909 jmp %_END_IF_malloc_1 1910 :ELSE_malloc_1 1911 :_END_IF_malloc_1 1912 # Defining local old_malloc 1913 lea_rax,[rip+DWORD] %GLOBAL__malloc_ptr 1914 mov_rax,[rax] 1915 push_rax #old_malloc 1916 lea_rax,[rip+DWORD] %GLOBAL__malloc_ptr 1917 push_rax #_common_recursion 1918 lea_rax,[rip+DWORD] %GLOBAL__malloc_ptr 1919 mov_rax,[rax] 1920 push_rax #_common_recursion 1921 lea_rax,[rbp+DWORD] %-8 1922 mov_rax,[rax] 1923 pop_rbx # _common_recursion 1924 add_rax,rbx 1925 pop_rbx # _common_recursion 1926 mov_[rbx],rax 1927 lea_rax,[rbp+DWORD] %-24 1928 mov_rax,[rax] 1929 pop_rbx # _return_result_locals 1930 ret 1931 # Defining function memset 1932 :FUNCTION_memset 1933 # Defining local s 1934 push_rax #s 1935 # FOR_initialization_memset_0 1936 lea_rax,[rbp+DWORD] %-40 1937 push_rax #_common_recursion 1938 lea_rax,[rbp+DWORD] %-8 1939 mov_rax,[rax] 1940 pop_rbx # _common_recursion 1941 mov_[rbx],rax 1942 :FOR_memset_0 1943 mov_rax, %0 1944 push_rax #_common_recursion 1945 lea_rax,[rbp+DWORD] %-24 1946 mov_rax,[rax] 1947 pop_rbx # _common_recursion 1948 cmp_rbx,rax 1949 setl_al 1950 movzx_rax,al 1951 test_rax,rax 1952 je %FOR_END_memset_0 1953 jmp %FOR_THEN_memset_0 1954 :FOR_ITER_memset_0 1955 lea_rax,[rbp+DWORD] %-24 1956 push_rax #_common_recursion 1957 lea_rax,[rbp+DWORD] %-24 1958 mov_rax,[rax] 1959 push_rax #_common_recursion 1960 mov_rax, %1 1961 pop_rbx # _common_recursion 1962 sub_rbx,rax 1963 mov_rax,rbx 1964 pop_rbx # _common_recursion 1965 mov_[rbx],rax 1966 jmp %FOR_memset_0 1967 :FOR_THEN_memset_0 1968 lea_rax,[rbp+DWORD] %-40 1969 mov_rax,[rax] 1970 push_rax #_common_recursion 1971 mov_rax, %0 1972 pop_rbx # _common_recursion 1973 add_rax,rbx 1974 push_rax #_common_recursion 1975 lea_rax,[rbp+DWORD] %-16 1976 mov_rax,[rax] 1977 pop_rbx # _common_recursion 1978 mov_[rbx],al 1979 lea_rax,[rbp+DWORD] %-40 1980 push_rax #_common_recursion 1981 lea_rax,[rbp+DWORD] %-40 1982 mov_rax,[rax] 1983 push_rax #_common_recursion 1984 mov_rax, %1 1985 pop_rbx # _common_recursion 1986 add_rax,rbx 1987 pop_rbx # _common_recursion 1988 mov_[rbx],rax 1989 jmp %FOR_ITER_memset_0 1990 :FOR_END_memset_0 1991 lea_rax,[rbp+DWORD] %-8 1992 mov_rax,[rax] 1993 pop_rbx # _return_result_locals 1994 ret 1995 # Defining function calloc 1996 :FUNCTION_calloc 1997 # Defining local ret 1998 push_rdi # Prevent overwriting in recursion 1999 push_rbp # Protect the old base pointer 2000 mov_rdi,rsp # Copy new base pointer 2001 lea_rax,[rbp+DWORD] %-8 2002 mov_rax,[rax] 2003 push_rax #_common_recursion 2004 lea_rax,[rbp+DWORD] %-16 2005 mov_rax,[rax] 2006 pop_rbx # _common_recursion 2007 imul_rbx 2008 push_rax #_process_expression1 2009 mov_rbp,rdi 2010 call %FUNCTION_malloc 2011 pop_rbx # _process_expression_locals 2012 pop_rbp # Restore old base pointer 2013 pop_rdi # Prevent overwrite 2014 push_rax #ret 2015 # IF_calloc_0 2016 mov_rax, %0 2017 push_rax #_common_recursion 2018 lea_rax,[rbp+DWORD] %-32 2019 mov_rax,[rax] 2020 pop_rbx # _common_recursion 2021 cmp_rbx,rax 2022 sete_al 2023 movzx_rax,al 2024 test_rax,rax 2025 je %ELSE_calloc_0 2026 mov_rax, %0 2027 pop_rbx # _return_result_locals 2028 ret 2029 jmp %_END_IF_calloc_0 2030 :ELSE_calloc_0 2031 :_END_IF_calloc_0 2032 push_rdi # Prevent overwriting in recursion 2033 push_rbp # Protect the old base pointer 2034 mov_rdi,rsp # Copy new base pointer 2035 lea_rax,[rbp+DWORD] %-32 2036 mov_rax,[rax] 2037 push_rax #_process_expression1 2038 mov_rax, %0 2039 push_rax #_process_expression2 2040 lea_rax,[rbp+DWORD] %-8 2041 mov_rax,[rax] 2042 push_rax #_common_recursion 2043 lea_rax,[rbp+DWORD] %-16 2044 mov_rax,[rax] 2045 pop_rbx # _common_recursion 2046 imul_rbx 2047 push_rax #_process_expression2 2048 mov_rbp,rdi 2049 call %FUNCTION_memset 2050 pop_rbx # _process_expression_locals 2051 pop_rbx # _process_expression_locals 2052 pop_rbx # _process_expression_locals 2053 pop_rbp # Restore old base pointer 2054 pop_rdi # Prevent overwrite 2055 lea_rax,[rbp+DWORD] %-32 2056 mov_rax,[rax] 2057 pop_rbx # _return_result_locals 2058 ret 2059 # Defining function __set_name 2060 :FUNCTION___set_name 2061 lea_rax,[rbp+DWORD] %-8 2062 mov_rax,[rax] 2063 push_rax #_common_recursion 2064 mov_rax, %5 2065 pop_rbx # _common_recursion 2066 add_rax,rbx 2067 push_rax #_common_recursion 2068 mov_rax, %48 2069 push_rax #_common_recursion 2070 lea_rax,[rbp+DWORD] %-16 2071 mov_rax,[rax] 2072 push_rax #_common_recursion 2073 mov_rax, %10 2074 pop_rbx # _common_recursion 2075 xchg_rbx,rax 2076 cqo 2077 idiv_rbx 2078 mov_rax,rdx 2079 pop_rbx # _common_recursion 2080 add_rax,rbx 2081 pop_rbx # _common_recursion 2082 mov_[rbx],al 2083 lea_rax,[rbp+DWORD] %-16 2084 push_rax #_common_recursion 2085 lea_rax,[rbp+DWORD] %-16 2086 mov_rax,[rax] 2087 push_rax #_common_recursion 2088 mov_rax, %10 2089 pop_rbx # _common_recursion 2090 xchg_rbx,rax 2091 cqo 2092 idiv_rbx 2093 pop_rbx # _common_recursion 2094 mov_[rbx],rax 2095 lea_rax,[rbp+DWORD] %-8 2096 mov_rax,[rax] 2097 push_rax #_common_recursion 2098 mov_rax, %4 2099 pop_rbx # _common_recursion 2100 add_rax,rbx 2101 push_rax #_common_recursion 2102 mov_rax, %48 2103 push_rax #_common_recursion 2104 lea_rax,[rbp+DWORD] %-16 2105 mov_rax,[rax] 2106 push_rax #_common_recursion 2107 mov_rax, %10 2108 pop_rbx # _common_recursion 2109 xchg_rbx,rax 2110 cqo 2111 idiv_rbx 2112 mov_rax,rdx 2113 pop_rbx # _common_recursion 2114 add_rax,rbx 2115 pop_rbx # _common_recursion 2116 mov_[rbx],al 2117 lea_rax,[rbp+DWORD] %-16 2118 push_rax #_common_recursion 2119 lea_rax,[rbp+DWORD] %-16 2120 mov_rax,[rax] 2121 push_rax #_common_recursion 2122 mov_rax, %10 2123 pop_rbx # _common_recursion 2124 xchg_rbx,rax 2125 cqo 2126 idiv_rbx 2127 pop_rbx # _common_recursion 2128 mov_[rbx],rax 2129 lea_rax,[rbp+DWORD] %-8 2130 mov_rax,[rax] 2131 push_rax #_common_recursion 2132 mov_rax, %3 2133 pop_rbx # _common_recursion 2134 add_rax,rbx 2135 push_rax #_common_recursion 2136 mov_rax, %48 2137 push_rax #_common_recursion 2138 lea_rax,[rbp+DWORD] %-16 2139 mov_rax,[rax] 2140 push_rax #_common_recursion 2141 mov_rax, %10 2142 pop_rbx # _common_recursion 2143 xchg_rbx,rax 2144 cqo 2145 idiv_rbx 2146 mov_rax,rdx 2147 pop_rbx # _common_recursion 2148 add_rax,rbx 2149 pop_rbx # _common_recursion 2150 mov_[rbx],al 2151 lea_rax,[rbp+DWORD] %-16 2152 push_rax #_common_recursion 2153 lea_rax,[rbp+DWORD] %-16 2154 mov_rax,[rax] 2155 push_rax #_common_recursion 2156 mov_rax, %10 2157 pop_rbx # _common_recursion 2158 xchg_rbx,rax 2159 cqo 2160 idiv_rbx 2161 pop_rbx # _common_recursion 2162 mov_[rbx],rax 2163 lea_rax,[rbp+DWORD] %-8 2164 mov_rax,[rax] 2165 push_rax #_common_recursion 2166 mov_rax, %2 2167 pop_rbx # _common_recursion 2168 add_rax,rbx 2169 push_rax #_common_recursion 2170 mov_rax, %48 2171 push_rax #_common_recursion 2172 lea_rax,[rbp+DWORD] %-16 2173 mov_rax,[rax] 2174 push_rax #_common_recursion 2175 mov_rax, %10 2176 pop_rbx # _common_recursion 2177 xchg_rbx,rax 2178 cqo 2179 idiv_rbx 2180 mov_rax,rdx 2181 pop_rbx # _common_recursion 2182 add_rax,rbx 2183 pop_rbx # _common_recursion 2184 mov_[rbx],al 2185 lea_rax,[rbp+DWORD] %-16 2186 push_rax #_common_recursion 2187 lea_rax,[rbp+DWORD] %-16 2188 mov_rax,[rax] 2189 push_rax #_common_recursion 2190 mov_rax, %10 2191 pop_rbx # _common_recursion 2192 xchg_rbx,rax 2193 cqo 2194 idiv_rbx 2195 pop_rbx # _common_recursion 2196 mov_[rbx],rax 2197 lea_rax,[rbp+DWORD] %-8 2198 mov_rax,[rax] 2199 push_rax #_common_recursion 2200 mov_rax, %1 2201 pop_rbx # _common_recursion 2202 add_rax,rbx 2203 push_rax #_common_recursion 2204 mov_rax, %48 2205 push_rax #_common_recursion 2206 lea_rax,[rbp+DWORD] %-16 2207 mov_rax,[rax] 2208 push_rax #_common_recursion 2209 mov_rax, %10 2210 pop_rbx # _common_recursion 2211 xchg_rbx,rax 2212 cqo 2213 idiv_rbx 2214 mov_rax,rdx 2215 pop_rbx # _common_recursion 2216 add_rax,rbx 2217 pop_rbx # _common_recursion 2218 mov_[rbx],al 2219 lea_rax,[rbp+DWORD] %-16 2220 push_rax #_common_recursion 2221 lea_rax,[rbp+DWORD] %-16 2222 mov_rax,[rax] 2223 push_rax #_common_recursion 2224 mov_rax, %10 2225 pop_rbx # _common_recursion 2226 xchg_rbx,rax 2227 cqo 2228 idiv_rbx 2229 pop_rbx # _common_recursion 2230 mov_[rbx],rax 2231 lea_rax,[rbp+DWORD] %-8 2232 mov_rax,[rax] 2233 push_rax #_common_recursion 2234 mov_rax, %0 2235 pop_rbx # _common_recursion 2236 add_rax,rbx 2237 push_rax #_common_recursion 2238 mov_rax, %48 2239 push_rax #_common_recursion 2240 lea_rax,[rbp+DWORD] %-16 2241 mov_rax,[rax] 2242 pop_rbx # _common_recursion 2243 add_rax,rbx 2244 pop_rbx # _common_recursion 2245 mov_[rbx],al 2246 ret 2247 # Defining function mkstemp 2248 :FUNCTION_mkstemp 2249 # Defining local i 2250 mov_rax, %0 2251 push_rax #i 2252 :WHILE_mkstemp_0 2253 mov_rax, %0 2254 push_rax #_common_recursion 2255 lea_rax,[rbp+DWORD] %-8 2256 mov_rax,[rax] 2257 push_rax #_common_recursion 2258 lea_rax,[rbp+DWORD] %-24 2259 mov_rax,[rax] 2260 pop_rbx # _common_recursion 2261 add_rax,rbx 2262 movsx_rax,BYTE_PTR_[rax] 2263 pop_rbx # _common_recursion 2264 cmp_rbx,rax 2265 setne_al 2266 movzx_rax,al 2267 test_rax,rax 2268 je %END_WHILE_mkstemp_0 2269 # THEN_while_mkstemp_0 2270 lea_rax,[rbp+DWORD] %-24 2271 push_rax #_common_recursion 2272 lea_rax,[rbp+DWORD] %-24 2273 mov_rax,[rax] 2274 push_rax #_common_recursion 2275 mov_rax, %1 2276 pop_rbx # _common_recursion 2277 add_rax,rbx 2278 pop_rbx # _common_recursion 2279 mov_[rbx],rax 2280 jmp %WHILE_mkstemp_0 2281 :END_WHILE_mkstemp_0 2282 lea_rax,[rbp+DWORD] %-24 2283 push_rax #_common_recursion 2284 lea_rax,[rbp+DWORD] %-24 2285 mov_rax,[rax] 2286 push_rax #_common_recursion 2287 mov_rax, %1 2288 pop_rbx # _common_recursion 2289 sub_rbx,rax 2290 mov_rax,rbx 2291 pop_rbx # _common_recursion 2292 mov_[rbx],rax 2293 # IF_mkstemp_1 2294 lea_rax,[rbp+DWORD] %-24 2295 mov_rax,[rax] 2296 push_rax #_common_recursion 2297 mov_rax, %6 2298 pop_rbx # _common_recursion 2299 cmp_rbx,rax 2300 setl_al 2301 movzx_rax,al 2302 test_rax,rax 2303 je %ELSE_mkstemp_1 2304 mov_rax, %0 2305 push_rax #_common_recursion 2306 mov_rax, %1 2307 pop_rbx # _common_recursion 2308 sub_rbx,rax 2309 mov_rax,rbx 2310 pop_rbx # _return_result_locals 2311 ret 2312 jmp %_END_IF_mkstemp_1 2313 :ELSE_mkstemp_1 2314 :_END_IF_mkstemp_1 2315 # Defining local count 2316 mov_rax, %6 2317 push_rax #count 2318 # Defining local c 2319 push_rax #c 2320 :WHILE_mkstemp_2 2321 lea_rax,[rbp+DWORD] %-32 2322 mov_rax,[rax] 2323 push_rax #_common_recursion 2324 mov_rax, %0 2325 pop_rbx # _common_recursion 2326 cmp_rbx,rax 2327 setg_al 2328 movzx_rax,al 2329 test_rax,rax 2330 je %END_WHILE_mkstemp_2 2331 # THEN_while_mkstemp_2 2332 lea_rax,[rbp+DWORD] %-40 2333 push_rax #_common_recursion 2334 lea_rax,[rbp+DWORD] %-8 2335 mov_rax,[rax] 2336 push_rax #_common_recursion 2337 lea_rax,[rbp+DWORD] %-24 2338 mov_rax,[rax] 2339 pop_rbx # _common_recursion 2340 add_rax,rbx 2341 movsx_rax,BYTE_PTR_[rax] 2342 pop_rbx # _common_recursion 2343 mov_[rbx],rax 2344 # IF_mkstemp_3 2345 mov_rax, %88 2346 push_rax #_common_recursion 2347 lea_rax,[rbp+DWORD] %-40 2348 mov_rax,[rax] 2349 pop_rbx # _common_recursion 2350 cmp_rbx,rax 2351 setne_al 2352 movzx_rax,al 2353 test_rax,rax 2354 je %ELSE_mkstemp_3 2355 mov_rax, %0 2356 push_rax #_common_recursion 2357 mov_rax, %1 2358 pop_rbx # _common_recursion 2359 sub_rbx,rax 2360 mov_rax,rbx 2361 pop_rbx # _return_result_locals 2362 pop_rbx # _return_result_locals 2363 pop_rbx # _return_result_locals 2364 ret 2365 jmp %_END_IF_mkstemp_3 2366 :ELSE_mkstemp_3 2367 :_END_IF_mkstemp_3 2368 lea_rax,[rbp+DWORD] %-8 2369 mov_rax,[rax] 2370 push_rax #_common_recursion 2371 lea_rax,[rbp+DWORD] %-24 2372 mov_rax,[rax] 2373 pop_rbx # _common_recursion 2374 add_rax,rbx 2375 push_rax #_common_recursion 2376 mov_rax, %48 2377 pop_rbx # _common_recursion 2378 mov_[rbx],al 2379 lea_rax,[rbp+DWORD] %-24 2380 push_rax #_common_recursion 2381 lea_rax,[rbp+DWORD] %-24 2382 mov_rax,[rax] 2383 push_rax #_common_recursion 2384 mov_rax, %1 2385 pop_rbx # _common_recursion 2386 sub_rbx,rax 2387 mov_rax,rbx 2388 pop_rbx # _common_recursion 2389 mov_[rbx],rax 2390 lea_rax,[rbp+DWORD] %-32 2391 push_rax #_common_recursion 2392 lea_rax,[rbp+DWORD] %-32 2393 mov_rax,[rax] 2394 push_rax #_common_recursion 2395 mov_rax, %1 2396 pop_rbx # _common_recursion 2397 sub_rbx,rax 2398 mov_rax,rbx 2399 pop_rbx # _common_recursion 2400 mov_[rbx],rax 2401 jmp %WHILE_mkstemp_2 2402 :END_WHILE_mkstemp_2 2403 # Defining local fd 2404 mov_rax, %0 2405 push_rax #_common_recursion 2406 mov_rax, %1 2407 pop_rbx # _common_recursion 2408 sub_rbx,rax 2409 mov_rax,rbx 2410 push_rax #fd 2411 lea_rax,[rbp+DWORD] %-32 2412 push_rax #_common_recursion 2413 mov_rax, %0 2414 push_rax #_common_recursion 2415 mov_rax, %1 2416 pop_rbx # _common_recursion 2417 sub_rbx,rax 2418 mov_rax,rbx 2419 pop_rbx # _common_recursion 2420 mov_[rbx],rax 2421 :WHILE_mkstemp_4 2422 mov_rax, %0 2423 push_rax #_common_recursion 2424 lea_rax,[rbp+DWORD] %-48 2425 mov_rax,[rax] 2426 pop_rbx # _common_recursion 2427 cmp_rbx,rax 2428 setg_al 2429 movzx_rax,al 2430 test_rax,rax 2431 je %END_WHILE_mkstemp_4 2432 # THEN_while_mkstemp_4 2433 # IF_mkstemp_5 2434 mov_rax, %9000 2435 push_rax #_common_recursion 2436 lea_rax,[rbp+DWORD] %-32 2437 mov_rax,[rax] 2438 pop_rbx # _common_recursion 2439 cmp_rbx,rax 2440 setl_al 2441 movzx_rax,al 2442 test_rax,rax 2443 je %ELSE_mkstemp_5 2444 mov_rax, %0 2445 push_rax #_common_recursion 2446 mov_rax, %1 2447 pop_rbx # _common_recursion 2448 sub_rbx,rax 2449 mov_rax,rbx 2450 pop_rbx # _return_result_locals 2451 pop_rbx # _return_result_locals 2452 pop_rbx # _return_result_locals 2453 pop_rbx # _return_result_locals 2454 ret 2455 jmp %_END_IF_mkstemp_5 2456 :ELSE_mkstemp_5 2457 :_END_IF_mkstemp_5 2458 lea_rax,[rbp+DWORD] %-32 2459 push_rax #_common_recursion 2460 lea_rax,[rbp+DWORD] %-32 2461 mov_rax,[rax] 2462 push_rax #_common_recursion 2463 mov_rax, %1 2464 pop_rbx # _common_recursion 2465 add_rax,rbx 2466 pop_rbx # _common_recursion 2467 mov_[rbx],rax 2468 push_rdi # Prevent overwriting in recursion 2469 push_rbp # Protect the old base pointer 2470 mov_rdi,rsp # Copy new base pointer 2471 lea_rax,[rbp+DWORD] %-8 2472 mov_rax,[rax] 2473 push_rax #_common_recursion 2474 lea_rax,[rbp+DWORD] %-24 2475 mov_rax,[rax] 2476 pop_rbx # _common_recursion 2477 add_rax,rbx 2478 push_rax #_common_recursion 2479 mov_rax, %1 2480 pop_rbx # _common_recursion 2481 add_rax,rbx 2482 push_rax #_process_expression1 2483 lea_rax,[rbp+DWORD] %-32 2484 mov_rax,[rax] 2485 push_rax #_process_expression2 2486 mov_rbp,rdi 2487 call %FUNCTION___set_name 2488 pop_rbx # _process_expression_locals 2489 pop_rbx # _process_expression_locals 2490 pop_rbp # Restore old base pointer 2491 pop_rdi # Prevent overwrite 2492 lea_rax,[rbp+DWORD] %-48 2493 push_rax #_common_recursion 2494 push_rdi # Prevent overwriting in recursion 2495 push_rbp # Protect the old base pointer 2496 mov_rdi,rsp # Copy new base pointer 2497 lea_rax,[rbp+DWORD] %-8 2498 mov_rax,[rax] 2499 push_rax #_process_expression1 2500 mov_rax, %2 2501 push_rax #_common_recursion 2502 mov_rax, %00100 2503 pop_rbx # _common_recursion 2504 or_rax,rbx 2505 push_rax #_common_recursion 2506 mov_rax, %00200 2507 pop_rbx # _common_recursion 2508 or_rax,rbx 2509 push_rax #_process_expression2 2510 mov_rax, %00600 2511 push_rax #_process_expression2 2512 mov_rbp,rdi 2513 call %FUNCTION_open 2514 pop_rbx # _process_expression_locals 2515 pop_rbx # _process_expression_locals 2516 pop_rbx # _process_expression_locals 2517 pop_rbp # Restore old base pointer 2518 pop_rdi # Prevent overwrite 2519 pop_rbx # _common_recursion 2520 mov_[rbx],rax 2521 jmp %WHILE_mkstemp_4 2522 :END_WHILE_mkstemp_4 2523 lea_rax,[rbp+DWORD] %-48 2524 mov_rax,[rax] 2525 pop_rbx # _return_result_locals 2526 pop_rbx # _return_result_locals 2527 pop_rbx # _return_result_locals 2528 pop_rbx # _return_result_locals 2529 ret 2530 # Defining function __init_io 2531 :FUNCTION___init_io 2532 lea_rax,[rip+DWORD] %GLOBAL___list 2533 push_rax #_common_recursion 2534 mov_rax, %0 2535 pop_rbx # _common_recursion 2536 mov_[rbx],rax 2537 lea_rax,[rip+DWORD] %GLOBAL_stdin 2538 push_rax #_common_recursion 2539 push_rdi # Prevent overwriting in recursion 2540 push_rbp # Protect the old base pointer 2541 mov_rdi,rsp # Copy new base pointer 2542 mov_rax, %1 2543 push_rax #_process_expression1 2544 mov_rax, %64 2545 push_rax #_process_expression2 2546 mov_rbp,rdi 2547 call %FUNCTION_calloc 2548 pop_rbx # _process_expression_locals 2549 pop_rbx # _process_expression_locals 2550 pop_rbp # Restore old base pointer 2551 pop_rdi # Prevent overwrite 2552 pop_rbx # _common_recursion 2553 mov_[rbx],rax 2554 lea_rax,[rip+DWORD] %GLOBAL_stdin 2555 mov_rax,[rax] 2556 # looking up offset 2557 push_rax #_common_recursion 2558 mov_rax, %0 2559 pop_rbx # _common_recursion 2560 mov_[rbx],rax 2561 lea_rax,[rip+DWORD] %GLOBAL_stdin 2562 mov_rax,[rax] 2563 # looking up offset 2564 # -> offset calculation 2565 mov_rbx, %8 2566 add_rax,rbx 2567 push_rax #_common_recursion 2568 mov_rax, %0 2569 pop_rbx # _common_recursion 2570 mov_[rbx],rax 2571 lea_rax,[rip+DWORD] %GLOBAL_stdin 2572 mov_rax,[rax] 2573 # looking up offset 2574 # -> offset calculation 2575 mov_rbx, %32 2576 add_rax,rbx 2577 push_rax #_common_recursion 2578 mov_rax, %1 2579 pop_rbx # _common_recursion 2580 mov_[rbx],rax 2581 lea_rax,[rip+DWORD] %GLOBAL_stdin 2582 mov_rax,[rax] 2583 # looking up offset 2584 # -> offset calculation 2585 mov_rbx, %40 2586 add_rax,rbx 2587 push_rax #_common_recursion 2588 push_rdi # Prevent overwriting in recursion 2589 push_rbp # Protect the old base pointer 2590 mov_rdi,rsp # Copy new base pointer 2591 mov_rax, %2 2592 push_rax #_process_expression1 2593 mov_rax, %1 2594 push_rax #_process_expression2 2595 mov_rbp,rdi 2596 call %FUNCTION_calloc 2597 pop_rbx # _process_expression_locals 2598 pop_rbx # _process_expression_locals 2599 pop_rbp # Restore old base pointer 2600 pop_rdi # Prevent overwrite 2601 pop_rbx # _common_recursion 2602 mov_[rbx],rax 2603 lea_rax,[rip+DWORD] %GLOBAL_stdout 2604 push_rax #_common_recursion 2605 push_rdi # Prevent overwriting in recursion 2606 push_rbp # Protect the old base pointer 2607 mov_rdi,rsp # Copy new base pointer 2608 mov_rax, %1 2609 push_rax #_process_expression1 2610 mov_rax, %64 2611 push_rax #_process_expression2 2612 mov_rbp,rdi 2613 call %FUNCTION_calloc 2614 pop_rbx # _process_expression_locals 2615 pop_rbx # _process_expression_locals 2616 pop_rbp # Restore old base pointer 2617 pop_rdi # Prevent overwrite 2618 pop_rbx # _common_recursion 2619 mov_[rbx],rax 2620 lea_rax,[rip+DWORD] %GLOBAL_stdout 2621 mov_rax,[rax] 2622 # looking up offset 2623 push_rax #_common_recursion 2624 mov_rax, %1 2625 pop_rbx # _common_recursion 2626 mov_[rbx],rax 2627 lea_rax,[rip+DWORD] %GLOBAL_stdout 2628 mov_rax,[rax] 2629 # looking up offset 2630 # -> offset calculation 2631 mov_rbx, %8 2632 add_rax,rbx 2633 push_rax #_common_recursion 2634 mov_rax, %1 2635 pop_rbx # _common_recursion 2636 mov_[rbx],rax 2637 lea_rax,[rip+DWORD] %GLOBAL_stdout 2638 mov_rax,[rax] 2639 # looking up offset 2640 # -> offset calculation 2641 mov_rbx, %32 2642 add_rax,rbx 2643 push_rax #_common_recursion 2644 mov_rax, %512 2645 pop_rbx # _common_recursion 2646 mov_[rbx],rax 2647 lea_rax,[rip+DWORD] %GLOBAL_stdout 2648 mov_rax,[rax] 2649 # looking up offset 2650 # -> offset calculation 2651 mov_rbx, %40 2652 add_rax,rbx 2653 push_rax #_common_recursion 2654 push_rdi # Prevent overwriting in recursion 2655 push_rbp # Protect the old base pointer 2656 mov_rdi,rsp # Copy new base pointer 2657 mov_rax, %514 2658 push_rax #_process_expression1 2659 mov_rax, %1 2660 push_rax #_process_expression2 2661 mov_rbp,rdi 2662 call %FUNCTION_calloc 2663 pop_rbx # _process_expression_locals 2664 pop_rbx # _process_expression_locals 2665 pop_rbp # Restore old base pointer 2666 pop_rdi # Prevent overwrite 2667 pop_rbx # _common_recursion 2668 mov_[rbx],rax 2669 lea_rax,[rip+DWORD] %GLOBAL_stderr 2670 push_rax #_common_recursion 2671 push_rdi # Prevent overwriting in recursion 2672 push_rbp # Protect the old base pointer 2673 mov_rdi,rsp # Copy new base pointer 2674 mov_rax, %1 2675 push_rax #_process_expression1 2676 mov_rax, %64 2677 push_rax #_process_expression2 2678 mov_rbp,rdi 2679 call %FUNCTION_calloc 2680 pop_rbx # _process_expression_locals 2681 pop_rbx # _process_expression_locals 2682 pop_rbp # Restore old base pointer 2683 pop_rdi # Prevent overwrite 2684 pop_rbx # _common_recursion 2685 mov_[rbx],rax 2686 lea_rax,[rip+DWORD] %GLOBAL_stderr 2687 mov_rax,[rax] 2688 # looking up offset 2689 push_rax #_common_recursion 2690 mov_rax, %2 2691 pop_rbx # _common_recursion 2692 mov_[rbx],rax 2693 lea_rax,[rip+DWORD] %GLOBAL_stderr 2694 mov_rax,[rax] 2695 # looking up offset 2696 # -> offset calculation 2697 mov_rbx, %8 2698 add_rax,rbx 2699 push_rax #_common_recursion 2700 mov_rax, %1 2701 pop_rbx # _common_recursion 2702 mov_[rbx],rax 2703 lea_rax,[rip+DWORD] %GLOBAL_stderr 2704 mov_rax,[rax] 2705 # looking up offset 2706 # -> offset calculation 2707 mov_rbx, %32 2708 add_rax,rbx 2709 push_rax #_common_recursion 2710 mov_rax, %512 2711 pop_rbx # _common_recursion 2712 mov_[rbx],rax 2713 lea_rax,[rip+DWORD] %GLOBAL_stderr 2714 mov_rax,[rax] 2715 # looking up offset 2716 # -> offset calculation 2717 mov_rbx, %40 2718 add_rax,rbx 2719 push_rax #_common_recursion 2720 push_rdi # Prevent overwriting in recursion 2721 push_rbp # Protect the old base pointer 2722 mov_rdi,rsp # Copy new base pointer 2723 mov_rax, %514 2724 push_rax #_process_expression1 2725 mov_rax, %1 2726 push_rax #_process_expression2 2727 mov_rbp,rdi 2728 call %FUNCTION_calloc 2729 pop_rbx # _process_expression_locals 2730 pop_rbx # _process_expression_locals 2731 pop_rbp # Restore old base pointer 2732 pop_rdi # Prevent overwrite 2733 pop_rbx # _common_recursion 2734 mov_[rbx],rax 2735 ret 2736 # Defining function __kill_io 2737 :FUNCTION___kill_io 2738 push_rdi # Prevent overwriting in recursion 2739 push_rbp # Protect the old base pointer 2740 mov_rdi,rsp # Copy new base pointer 2741 lea_rax,[rip+DWORD] %GLOBAL_stdout 2742 mov_rax,[rax] 2743 push_rax #_process_expression1 2744 mov_rbp,rdi 2745 call %FUNCTION_fflush 2746 pop_rbx # _process_expression_locals 2747 pop_rbp # Restore old base pointer 2748 pop_rdi # Prevent overwrite 2749 push_rdi # Prevent overwriting in recursion 2750 push_rbp # Protect the old base pointer 2751 mov_rdi,rsp # Copy new base pointer 2752 lea_rax,[rip+DWORD] %GLOBAL_stderr 2753 mov_rax,[rax] 2754 push_rax #_process_expression1 2755 mov_rbp,rdi 2756 call %FUNCTION_fflush 2757 pop_rbx # _process_expression_locals 2758 pop_rbp # Restore old base pointer 2759 pop_rdi # Prevent overwrite 2760 :WHILE___kill_io_0 2761 mov_rax, %0 2762 push_rax #_common_recursion 2763 lea_rax,[rip+DWORD] %GLOBAL___list 2764 mov_rax,[rax] 2765 pop_rbx # _common_recursion 2766 cmp_rbx,rax 2767 setne_al 2768 movzx_rax,al 2769 test_rax,rax 2770 je %END_WHILE___kill_io_0 2771 # THEN_while___kill_io_0 2772 push_rdi # Prevent overwriting in recursion 2773 push_rbp # Protect the old base pointer 2774 mov_rdi,rsp # Copy new base pointer 2775 lea_rax,[rip+DWORD] %GLOBAL___list 2776 mov_rax,[rax] 2777 push_rax #_process_expression1 2778 mov_rbp,rdi 2779 call %FUNCTION_fflush 2780 pop_rbx # _process_expression_locals 2781 pop_rbp # Restore old base pointer 2782 pop_rdi # Prevent overwrite 2783 lea_rax,[rip+DWORD] %GLOBAL___list 2784 push_rax #_common_recursion 2785 lea_rax,[rip+DWORD] %GLOBAL___list 2786 mov_rax,[rax] 2787 # looking up offset 2788 # -> offset calculation 2789 mov_rbx, %48 2790 add_rax,rbx 2791 mov_rax,[rax] 2792 pop_rbx # _common_recursion 2793 mov_[rbx],rax 2794 jmp %WHILE___kill_io_0 2795 :END_WHILE___kill_io_0 2796 ret 2797 # Defining function fgetc 2798 :FUNCTION_fgetc 2799 # IF_fgetc_0 2800 mov_rax, %1 2801 push_rax #_common_recursion 2802 lea_rax,[rbp+DWORD] %-8 2803 mov_rax,[rax] 2804 # looking up offset 2805 # -> offset calculation 2806 mov_rbx, %8 2807 add_rax,rbx 2808 mov_rax,[rax] 2809 pop_rbx # _common_recursion 2810 cmp_rbx,rax 2811 sete_al 2812 movzx_rax,al 2813 test_rax,rax 2814 je %ELSE_fgetc_0 2815 mov_rax, %0xFFFFFFFF 2816 ret 2817 jmp %_END_IF_fgetc_0 2818 :ELSE_fgetc_0 2819 :_END_IF_fgetc_0 2820 # IF_fgetc_1 2821 mov_rax, %0 2822 push_rax #_common_recursion 2823 lea_rax,[rbp+DWORD] %-8 2824 mov_rax,[rax] 2825 # looking up offset 2826 mov_rax,[rax] 2827 pop_rbx # _common_recursion 2828 cmp_rbx,rax 2829 sete_al 2830 movzx_rax,al 2831 test_rax,rax 2832 je %ELSE_fgetc_1 2833 lea_rax,[rbp+DWORD] %-8 2834 mov_rax,[rax] 2835 # looking up offset 2836 # -> offset calculation 2837 mov_rbx, %16 2838 add_rax,rbx 2839 push_rax #_common_recursion 2840 mov_rax, %0 2841 pop_rbx # _common_recursion 2842 mov_[rbx],rax 2843 # Defining local r 2844 push_rdi # Prevent overwriting in recursion 2845 push_rbp # Protect the old base pointer 2846 mov_rdi,rsp # Copy new base pointer 2847 lea_rax,[rbp+DWORD] %-8 2848 mov_rax,[rax] 2849 # looking up offset 2850 mov_rax,[rax] 2851 push_rax #_process_expression1 2852 lea_rax,[rbp+DWORD] %-8 2853 mov_rax,[rax] 2854 # looking up offset 2855 # -> offset calculation 2856 mov_rbx, %40 2857 add_rax,rbx 2858 mov_rax,[rax] 2859 push_rax #_process_expression2 2860 mov_rax, %1 2861 push_rax #_process_expression2 2862 mov_rbp,rdi 2863 call %FUNCTION_read 2864 pop_rbx # _process_expression_locals 2865 pop_rbx # _process_expression_locals 2866 pop_rbx # _process_expression_locals 2867 pop_rbp # Restore old base pointer 2868 pop_rdi # Prevent overwrite 2869 push_rax #r 2870 # IF_fgetc_2 2871 mov_rax, %0 2872 push_rax #_common_recursion 2873 lea_rax,[rbp+DWORD] %-24 2874 mov_rax,[rax] 2875 pop_rbx # _common_recursion 2876 cmp_rbx,rax 2877 sete_al 2878 movzx_rax,al 2879 test_rax,rax 2880 je %ELSE_fgetc_2 2881 mov_rax, %0xFFFFFFFF 2882 pop_rbx # _return_result_locals 2883 ret 2884 jmp %_END_IF_fgetc_2 2885 :ELSE_fgetc_2 2886 :_END_IF_fgetc_2 2887 pop_rbx # _recursive_statement_locals 2888 jmp %_END_IF_fgetc_1 2889 :ELSE_fgetc_1 2890 :_END_IF_fgetc_1 2891 # IF_fgetc_3 2892 lea_rax,[rbp+DWORD] %-8 2893 mov_rax,[rax] 2894 # looking up offset 2895 # -> offset calculation 2896 mov_rbx, %32 2897 add_rax,rbx 2898 mov_rax,[rax] 2899 push_rax #_common_recursion 2900 lea_rax,[rbp+DWORD] %-8 2901 mov_rax,[rax] 2902 # looking up offset 2903 # -> offset calculation 2904 mov_rbx, %16 2905 add_rax,rbx 2906 mov_rax,[rax] 2907 pop_rbx # _common_recursion 2908 cmp_rbx,rax 2909 setle_al 2910 movzx_rax,al 2911 test_rax,rax 2912 je %ELSE_fgetc_3 2913 mov_rax, %0xFFFFFFFF 2914 ret 2915 jmp %_END_IF_fgetc_3 2916 :ELSE_fgetc_3 2917 :_END_IF_fgetc_3 2918 # Defining local ret 2919 lea_rax,[rbp+DWORD] %-8 2920 mov_rax,[rax] 2921 # looking up offset 2922 # -> offset calculation 2923 mov_rbx, %40 2924 add_rax,rbx 2925 mov_rax,[rax] 2926 push_rax #_common_recursion 2927 lea_rax,[rbp+DWORD] %-8 2928 mov_rax,[rax] 2929 # looking up offset 2930 # -> offset calculation 2931 mov_rbx, %16 2932 add_rax,rbx 2933 mov_rax,[rax] 2934 pop_rbx # _common_recursion 2935 add_rax,rbx 2936 movsx_rax,BYTE_PTR_[rax] 2937 push_rax #ret 2938 lea_rax,[rbp+DWORD] %-8 2939 mov_rax,[rax] 2940 # looking up offset 2941 # -> offset calculation 2942 mov_rbx, %16 2943 add_rax,rbx 2944 push_rax #_common_recursion 2945 lea_rax,[rbp+DWORD] %-8 2946 mov_rax,[rax] 2947 # looking up offset 2948 # -> offset calculation 2949 mov_rbx, %16 2950 add_rax,rbx 2951 mov_rax,[rax] 2952 push_rax #_common_recursion 2953 mov_rax, %1 2954 pop_rbx # _common_recursion 2955 add_rax,rbx 2956 pop_rbx # _common_recursion 2957 mov_[rbx],rax 2958 lea_rax,[rbp+DWORD] %-24 2959 mov_rax,[rax] 2960 push_rax #_common_recursion 2961 mov_rax, %0xFF 2962 pop_rbx # _common_recursion 2963 and_rax,rbx 2964 pop_rbx # _return_result_locals 2965 ret 2966 # Defining function fread 2967 :FUNCTION_fread 2968 # IF_fread_0 2969 mov_rax, %0 2970 push_rax #_common_recursion 2971 lea_rax,[rbp+DWORD] %-16 2972 mov_rax,[rax] 2973 pop_rbx # _common_recursion 2974 cmp_rbx,rax 2975 sete_al 2976 movzx_rax,al 2977 test_rax,rax 2978 je %ELSE_fread_0 2979 mov_rax, %0 2980 ret 2981 jmp %_END_IF_fread_0 2982 :ELSE_fread_0 2983 :_END_IF_fread_0 2984 # IF_fread_1 2985 mov_rax, %0 2986 push_rax #_common_recursion 2987 lea_rax,[rbp+DWORD] %-24 2988 mov_rax,[rax] 2989 pop_rbx # _common_recursion 2990 cmp_rbx,rax 2991 sete_al 2992 movzx_rax,al 2993 test_rax,rax 2994 je %ELSE_fread_1 2995 mov_rax, %0 2996 ret 2997 jmp %_END_IF_fread_1 2998 :ELSE_fread_1 2999 :_END_IF_fread_1 3000 # Defining local n 3001 lea_rax,[rbp+DWORD] %-16 3002 mov_rax,[rax] 3003 push_rax #_common_recursion 3004 lea_rax,[rbp+DWORD] %-24 3005 mov_rax,[rax] 3006 pop_rbx # _common_recursion 3007 add_rax,rbx 3008 push_rax #_common_recursion 3009 mov_rax, %1 3010 pop_rbx # _common_recursion 3011 sub_rbx,rax 3012 mov_rax,rbx 3013 push_rax #n 3014 # Defining local p 3015 lea_rax,[rbp+DWORD] %-8 3016 mov_rax,[rax] 3017 push_rax #p 3018 # Defining local i 3019 push_rax #i 3020 # Defining local c 3021 push_rax #c 3022 # FOR_initialization_fread_2 3023 lea_rax,[rbp+DWORD] %-64 3024 push_rax #_common_recursion 3025 mov_rax, %0 3026 pop_rbx # _common_recursion 3027 mov_[rbx],rax 3028 :FOR_fread_2 3029 lea_rax,[rbp+DWORD] %-64 3030 mov_rax,[rax] 3031 push_rax #_common_recursion 3032 lea_rax,[rbp+DWORD] %-48 3033 mov_rax,[rax] 3034 pop_rbx # _common_recursion 3035 cmp_rbx,rax 3036 setl_al 3037 movzx_rax,al 3038 test_rax,rax 3039 je %FOR_END_fread_2 3040 jmp %FOR_THEN_fread_2 3041 :FOR_ITER_fread_2 3042 lea_rax,[rbp+DWORD] %-64 3043 push_rax #_common_recursion 3044 lea_rax,[rbp+DWORD] %-64 3045 mov_rax,[rax] 3046 push_rax #_common_recursion 3047 mov_rax, %1 3048 pop_rbx # _common_recursion 3049 add_rax,rbx 3050 pop_rbx # _common_recursion 3051 mov_[rbx],rax 3052 jmp %FOR_fread_2 3053 :FOR_THEN_fread_2 3054 lea_rax,[rbp+DWORD] %-72 3055 push_rax #_common_recursion 3056 push_rdi # Prevent overwriting in recursion 3057 push_rbp # Protect the old base pointer 3058 mov_rdi,rsp # Copy new base pointer 3059 lea_rax,[rbp+DWORD] %-32 3060 mov_rax,[rax] 3061 push_rax #_process_expression1 3062 mov_rbp,rdi 3063 call %FUNCTION_fgetc 3064 pop_rbx # _process_expression_locals 3065 pop_rbp # Restore old base pointer 3066 pop_rdi # Prevent overwrite 3067 pop_rbx # _common_recursion 3068 mov_[rbx],rax 3069 # IF_fread_3 3070 mov_rax, %0xFFFFFFFF 3071 push_rax #_common_recursion 3072 lea_rax,[rbp+DWORD] %-72 3073 mov_rax,[rax] 3074 pop_rbx # _common_recursion 3075 cmp_rbx,rax 3076 sete_al 3077 movzx_rax,al 3078 test_rax,rax 3079 je %ELSE_fread_3 3080 lea_rax,[rbp+DWORD] %-64 3081 mov_rax,[rax] 3082 push_rax #_common_recursion 3083 lea_rax,[rbp+DWORD] %-16 3084 mov_rax,[rax] 3085 pop_rbx # _common_recursion 3086 xchg_rbx,rax 3087 cqo 3088 idiv_rbx 3089 pop_rbx # _return_result_locals 3090 pop_rbx # _return_result_locals 3091 pop_rbx # _return_result_locals 3092 pop_rbx # _return_result_locals 3093 ret 3094 jmp %_END_IF_fread_3 3095 :ELSE_fread_3 3096 :_END_IF_fread_3 3097 lea_rax,[rbp+DWORD] %-56 3098 mov_rax,[rax] 3099 push_rax #_common_recursion 3100 lea_rax,[rbp+DWORD] %-64 3101 mov_rax,[rax] 3102 pop_rbx # _common_recursion 3103 add_rax,rbx 3104 push_rax #_common_recursion 3105 lea_rax,[rbp+DWORD] %-72 3106 mov_rax,[rax] 3107 pop_rbx # _common_recursion 3108 mov_[rbx],al 3109 jmp %FOR_ITER_fread_2 3110 :FOR_END_fread_2 3111 lea_rax,[rbp+DWORD] %-64 3112 mov_rax,[rax] 3113 push_rax #_common_recursion 3114 lea_rax,[rbp+DWORD] %-16 3115 mov_rax,[rax] 3116 pop_rbx # _common_recursion 3117 xchg_rbx,rax 3118 cqo 3119 idiv_rbx 3120 pop_rbx # _return_result_locals 3121 pop_rbx # _return_result_locals 3122 pop_rbx # _return_result_locals 3123 pop_rbx # _return_result_locals 3124 ret 3125 # Defining function getchar 3126 :FUNCTION_getchar 3127 push_rdi # Prevent overwriting in recursion 3128 push_rbp # Protect the old base pointer 3129 mov_rdi,rsp # Copy new base pointer 3130 lea_rax,[rip+DWORD] %GLOBAL_stdin 3131 mov_rax,[rax] 3132 push_rax #_process_expression1 3133 mov_rbp,rdi 3134 call %FUNCTION_fgetc 3135 pop_rbx # _process_expression_locals 3136 pop_rbp # Restore old base pointer 3137 pop_rdi # Prevent overwrite 3138 ret 3139 # Defining function fgets 3140 :FUNCTION_fgets 3141 # Defining local i 3142 mov_rax, %0 3143 push_rax #i 3144 # Defining local ch 3145 push_rax #ch 3146 :WHILE_fgets_0 3147 lea_rax,[rbp+DWORD] %-40 3148 mov_rax,[rax] 3149 push_rax #_common_recursion 3150 lea_rax,[rbp+DWORD] %-16 3151 mov_rax,[rax] 3152 pop_rbx # _common_recursion 3153 cmp_rbx,rax 3154 setl_al 3155 movzx_rax,al 3156 test_rax,rax 3157 je %END_WHILE_fgets_0 3158 # THEN_while_fgets_0 3159 lea_rax,[rbp+DWORD] %-48 3160 push_rax #_common_recursion 3161 push_rdi # Prevent overwriting in recursion 3162 push_rbp # Protect the old base pointer 3163 mov_rdi,rsp # Copy new base pointer 3164 lea_rax,[rbp+DWORD] %-24 3165 mov_rax,[rax] 3166 push_rax #_process_expression1 3167 mov_rbp,rdi 3168 call %FUNCTION_fgetc 3169 pop_rbx # _process_expression_locals 3170 pop_rbp # Restore old base pointer 3171 pop_rdi # Prevent overwrite 3172 pop_rbx # _common_recursion 3173 mov_[rbx],rax 3174 # IF_fgets_1 3175 mov_rax, %0xFFFFFFFF 3176 push_rax #_common_recursion 3177 lea_rax,[rbp+DWORD] %-48 3178 mov_rax,[rax] 3179 pop_rbx # _common_recursion 3180 cmp_rbx,rax 3181 sete_al 3182 movzx_rax,al 3183 test_rax,rax 3184 je %ELSE_fgets_1 3185 jmp %END_WHILE_fgets_0 3186 jmp %_END_IF_fgets_1 3187 :ELSE_fgets_1 3188 :_END_IF_fgets_1 3189 lea_rax,[rbp+DWORD] %-8 3190 mov_rax,[rax] 3191 push_rax #_common_recursion 3192 lea_rax,[rbp+DWORD] %-40 3193 mov_rax,[rax] 3194 pop_rbx # _common_recursion 3195 add_rax,rbx 3196 push_rax #_common_recursion 3197 lea_rax,[rbp+DWORD] %-48 3198 mov_rax,[rax] 3199 pop_rbx # _common_recursion 3200 mov_[rbx],al 3201 lea_rax,[rbp+DWORD] %-40 3202 push_rax #_common_recursion 3203 lea_rax,[rbp+DWORD] %-40 3204 mov_rax,[rax] 3205 push_rax #_common_recursion 3206 mov_rax, %1 3207 pop_rbx # _common_recursion 3208 add_rax,rbx 3209 pop_rbx # _common_recursion 3210 mov_[rbx],rax 3211 # IF_fgets_2 3212 mov_rax, %10 3213 push_rax #_common_recursion 3214 lea_rax,[rbp+DWORD] %-48 3215 mov_rax,[rax] 3216 pop_rbx # _common_recursion 3217 cmp_rbx,rax 3218 sete_al 3219 movzx_rax,al 3220 test_rax,rax 3221 je %ELSE_fgets_2 3222 jmp %END_WHILE_fgets_0 3223 jmp %_END_IF_fgets_2 3224 :ELSE_fgets_2 3225 :_END_IF_fgets_2 3226 jmp %WHILE_fgets_0 3227 :END_WHILE_fgets_0 3228 lea_rax,[rbp+DWORD] %-8 3229 mov_rax,[rax] 3230 pop_rbx # _return_result_locals 3231 pop_rbx # _return_result_locals 3232 ret 3233 # Defining function fputc 3234 :FUNCTION_fputc 3235 # IF_fputc_0 3236 mov_rax, %0 3237 push_rax #_common_recursion 3238 lea_rax,[rbp+DWORD] %-16 3239 mov_rax,[rax] 3240 # looking up offset 3241 # -> offset calculation 3242 mov_rbx, %8 3243 add_rax,rbx 3244 mov_rax,[rax] 3245 pop_rbx # _common_recursion 3246 cmp_rbx,rax 3247 sete_al 3248 movzx_rax,al 3249 test_rax,rax 3250 je %ELSE_fputc_0 3251 ret 3252 jmp %_END_IF_fputc_0 3253 :ELSE_fputc_0 3254 :_END_IF_fputc_0 3255 lea_rax,[rbp+DWORD] %-16 3256 mov_rax,[rax] 3257 # looking up offset 3258 # -> offset calculation 3259 mov_rbx, %40 3260 add_rax,rbx 3261 mov_rax,[rax] 3262 push_rax #_common_recursion 3263 lea_rax,[rbp+DWORD] %-16 3264 mov_rax,[rax] 3265 # looking up offset 3266 # -> offset calculation 3267 mov_rbx, %16 3268 add_rax,rbx 3269 mov_rax,[rax] 3270 pop_rbx # _common_recursion 3271 add_rax,rbx 3272 push_rax #_common_recursion 3273 lea_rax,[rbp+DWORD] %-8 3274 movsx_rax,BYTE_PTR_[rax] 3275 pop_rbx # _common_recursion 3276 mov_[rbx],al 3277 lea_rax,[rbp+DWORD] %-16 3278 mov_rax,[rax] 3279 # looking up offset 3280 # -> offset calculation 3281 mov_rbx, %16 3282 add_rax,rbx 3283 push_rax #_common_recursion 3284 lea_rax,[rbp+DWORD] %-16 3285 mov_rax,[rax] 3286 # looking up offset 3287 # -> offset calculation 3288 mov_rbx, %16 3289 add_rax,rbx 3290 mov_rax,[rax] 3291 push_rax #_common_recursion 3292 mov_rax, %1 3293 pop_rbx # _common_recursion 3294 add_rax,rbx 3295 pop_rbx # _common_recursion 3296 mov_[rbx],rax 3297 # IF_fputc_1 3298 lea_rax,[rbp+DWORD] %-16 3299 mov_rax,[rax] 3300 # looking up offset 3301 # -> offset calculation 3302 mov_rbx, %16 3303 add_rax,rbx 3304 mov_rax,[rax] 3305 push_rax #_common_recursion 3306 lea_rax,[rbp+DWORD] %-16 3307 mov_rax,[rax] 3308 # looking up offset 3309 # -> offset calculation 3310 mov_rbx, %32 3311 add_rax,rbx 3312 mov_rax,[rax] 3313 pop_rbx # _common_recursion 3314 cmp_rbx,rax 3315 sete_al 3316 movzx_rax,al 3317 test_rax,rax 3318 je %ELSE_fputc_1 3319 push_rdi # Prevent overwriting in recursion 3320 push_rbp # Protect the old base pointer 3321 mov_rdi,rsp # Copy new base pointer 3322 lea_rax,[rbp+DWORD] %-16 3323 mov_rax,[rax] 3324 push_rax #_process_expression1 3325 mov_rbp,rdi 3326 call %FUNCTION_fflush 3327 pop_rbx # _process_expression_locals 3328 pop_rbp # Restore old base pointer 3329 pop_rdi # Prevent overwrite 3330 jmp %_END_IF_fputc_1 3331 :ELSE_fputc_1 3332 # IF_fputc_2 3333 mov_rax, %10 3334 push_rax #_common_recursion 3335 lea_rax,[rbp+DWORD] %-8 3336 movsx_rax,BYTE_PTR_[rax] 3337 pop_rbx # _common_recursion 3338 cmp_rbx,rax 3339 sete_al 3340 movzx_rax,al 3341 push_rax #_common_recursion 3342 mov_rax, %2 3343 push_rax #_common_recursion 3344 lea_rax,[rbp+DWORD] %-16 3345 mov_rax,[rax] 3346 # looking up offset 3347 mov_rax,[rax] 3348 pop_rbx # _common_recursion 3349 cmp_rbx,rax 3350 setge_al 3351 movzx_rax,al 3352 pop_rbx # _common_recursion 3353 and_rax,rbx 3354 test_rax,rax 3355 je %ELSE_fputc_2 3356 push_rdi # Prevent overwriting in recursion 3357 push_rbp # Protect the old base pointer 3358 mov_rdi,rsp # Copy new base pointer 3359 lea_rax,[rbp+DWORD] %-16 3360 mov_rax,[rax] 3361 push_rax #_process_expression1 3362 mov_rbp,rdi 3363 call %FUNCTION_fflush 3364 pop_rbx # _process_expression_locals 3365 pop_rbp # Restore old base pointer 3366 pop_rdi # Prevent overwrite 3367 jmp %_END_IF_fputc_2 3368 :ELSE_fputc_2 3369 :_END_IF_fputc_2 3370 :_END_IF_fputc_1 3371 ret 3372 # Defining function fwrite 3373 :FUNCTION_fwrite 3374 # Defining local n 3375 lea_rax,[rbp+DWORD] %-16 3376 mov_rax,[rax] 3377 push_rax #_common_recursion 3378 lea_rax,[rbp+DWORD] %-24 3379 mov_rax,[rax] 3380 pop_rbx # _common_recursion 3381 mul_rbx 3382 push_rax #n 3383 # IF_fwrite_0 3384 mov_rax, %0 3385 push_rax #_common_recursion 3386 lea_rax,[rbp+DWORD] %-48 3387 mov_rax,[rax] 3388 pop_rbx # _common_recursion 3389 cmp_rbx,rax 3390 sete_al 3391 movzx_rax,al 3392 test_rax,rax 3393 je %ELSE_fwrite_0 3394 mov_rax, %0 3395 pop_rbx # _return_result_locals 3396 ret 3397 jmp %_END_IF_fwrite_0 3398 :ELSE_fwrite_0 3399 :_END_IF_fwrite_0 3400 # Defining local p 3401 lea_rax,[rbp+DWORD] %-8 3402 mov_rax,[rax] 3403 push_rax #p 3404 # Defining local c 3405 push_rax #c 3406 # Defining local i 3407 push_rax #i 3408 # FOR_initialization_fwrite_1 3409 lea_rax,[rbp+DWORD] %-72 3410 push_rax #_common_recursion 3411 mov_rax, %0 3412 pop_rbx # _common_recursion 3413 mov_[rbx],rax 3414 :FOR_fwrite_1 3415 lea_rax,[rbp+DWORD] %-72 3416 mov_rax,[rax] 3417 push_rax #_common_recursion 3418 lea_rax,[rbp+DWORD] %-48 3419 mov_rax,[rax] 3420 pop_rbx # _common_recursion 3421 cmp_rbx,rax 3422 setl_al 3423 movzx_rax,al 3424 test_rax,rax 3425 je %FOR_END_fwrite_1 3426 jmp %FOR_THEN_fwrite_1 3427 :FOR_ITER_fwrite_1 3428 lea_rax,[rbp+DWORD] %-72 3429 push_rax #_common_recursion 3430 lea_rax,[rbp+DWORD] %-72 3431 mov_rax,[rax] 3432 push_rax #_common_recursion 3433 mov_rax, %1 3434 pop_rbx # _common_recursion 3435 add_rax,rbx 3436 pop_rbx # _common_recursion 3437 mov_[rbx],rax 3438 jmp %FOR_fwrite_1 3439 :FOR_THEN_fwrite_1 3440 lea_rax,[rbp+DWORD] %-64 3441 push_rax #_common_recursion 3442 lea_rax,[rbp+DWORD] %-56 3443 mov_rax,[rax] 3444 push_rax #_common_recursion 3445 lea_rax,[rbp+DWORD] %-72 3446 mov_rax,[rax] 3447 pop_rbx # _common_recursion 3448 add_rax,rbx 3449 movsx_rax,BYTE_PTR_[rax] 3450 pop_rbx # _common_recursion 3451 mov_[rbx],rax 3452 push_rdi # Prevent overwriting in recursion 3453 push_rbp # Protect the old base pointer 3454 mov_rdi,rsp # Copy new base pointer 3455 lea_rax,[rbp+DWORD] %-64 3456 mov_rax,[rax] 3457 push_rax #_process_expression1 3458 lea_rax,[rbp+DWORD] %-32 3459 mov_rax,[rax] 3460 push_rax #_process_expression2 3461 mov_rbp,rdi 3462 call %FUNCTION_fputc 3463 pop_rbx # _process_expression_locals 3464 pop_rbx # _process_expression_locals 3465 pop_rbp # Restore old base pointer 3466 pop_rdi # Prevent overwrite 3467 jmp %FOR_ITER_fwrite_1 3468 :FOR_END_fwrite_1 3469 lea_rax,[rbp+DWORD] %-72 3470 mov_rax,[rax] 3471 push_rax #_common_recursion 3472 lea_rax,[rbp+DWORD] %-16 3473 mov_rax,[rax] 3474 pop_rbx # _common_recursion 3475 xchg_rbx,rax 3476 cqo 3477 idiv_rbx 3478 pop_rbx # _return_result_locals 3479 pop_rbx # _return_result_locals 3480 pop_rbx # _return_result_locals 3481 pop_rbx # _return_result_locals 3482 ret 3483 # Defining function putchar 3484 :FUNCTION_putchar 3485 push_rdi # Prevent overwriting in recursion 3486 push_rbp # Protect the old base pointer 3487 mov_rdi,rsp # Copy new base pointer 3488 lea_rax,[rbp+DWORD] %-8 3489 movsx_rax,BYTE_PTR_[rax] 3490 push_rax #_process_expression1 3491 lea_rax,[rip+DWORD] %GLOBAL_stdout 3492 mov_rax,[rax] 3493 push_rax #_process_expression2 3494 mov_rbp,rdi 3495 call %FUNCTION_fputc 3496 pop_rbx # _process_expression_locals 3497 pop_rbx # _process_expression_locals 3498 pop_rbp # Restore old base pointer 3499 pop_rdi # Prevent overwrite 3500 ret 3501 # Defining function fputs 3502 :FUNCTION_fputs 3503 :WHILE_fputs_0 3504 mov_rax, %0 3505 push_rax #_common_recursion 3506 lea_rax,[rbp+DWORD] %-8 3507 mov_rax,[rax] 3508 push_rax #_common_recursion 3509 mov_rax, %0 3510 pop_rbx # _common_recursion 3511 add_rax,rbx 3512 movsx_rax,BYTE_PTR_[rax] 3513 pop_rbx # _common_recursion 3514 cmp_rbx,rax 3515 setne_al 3516 movzx_rax,al 3517 test_rax,rax 3518 je %END_WHILE_fputs_0 3519 # THEN_while_fputs_0 3520 push_rdi # Prevent overwriting in recursion 3521 push_rbp # Protect the old base pointer 3522 mov_rdi,rsp # Copy new base pointer 3523 lea_rax,[rbp+DWORD] %-8 3524 mov_rax,[rax] 3525 push_rax #_common_recursion 3526 mov_rax, %0 3527 pop_rbx # _common_recursion 3528 add_rax,rbx 3529 movsx_rax,BYTE_PTR_[rax] 3530 push_rax #_process_expression1 3531 lea_rax,[rbp+DWORD] %-16 3532 mov_rax,[rax] 3533 push_rax #_process_expression2 3534 mov_rbp,rdi 3535 call %FUNCTION_fputc 3536 pop_rbx # _process_expression_locals 3537 pop_rbx # _process_expression_locals 3538 pop_rbp # Restore old base pointer 3539 pop_rdi # Prevent overwrite 3540 lea_rax,[rbp+DWORD] %-8 3541 push_rax #_common_recursion 3542 lea_rax,[rbp+DWORD] %-8 3543 mov_rax,[rax] 3544 push_rax #_common_recursion 3545 mov_rax, %1 3546 pop_rbx # _common_recursion 3547 add_rax,rbx 3548 pop_rbx # _common_recursion 3549 mov_[rbx],rax 3550 jmp %WHILE_fputs_0 3551 :END_WHILE_fputs_0 3552 mov_rax, %0 3553 ret 3554 # Defining function puts 3555 :FUNCTION_puts 3556 push_rdi # Prevent overwriting in recursion 3557 push_rbp # Protect the old base pointer 3558 mov_rdi,rsp # Copy new base pointer 3559 lea_rax,[rbp+DWORD] %-8 3560 mov_rax,[rax] 3561 push_rax #_process_expression1 3562 lea_rax,[rip+DWORD] %GLOBAL_stdout 3563 mov_rax,[rax] 3564 push_rax #_process_expression2 3565 mov_rbp,rdi 3566 call %FUNCTION_fputs 3567 pop_rbx # _process_expression_locals 3568 pop_rbx # _process_expression_locals 3569 pop_rbp # Restore old base pointer 3570 pop_rdi # Prevent overwrite 3571 push_rdi # Prevent overwriting in recursion 3572 push_rbp # Protect the old base pointer 3573 mov_rdi,rsp # Copy new base pointer 3574 mov_rax, %10 3575 push_rax #_process_expression1 3576 lea_rax,[rip+DWORD] %GLOBAL_stdout 3577 mov_rax,[rax] 3578 push_rax #_process_expression2 3579 mov_rbp,rdi 3580 call %FUNCTION_fputc 3581 pop_rbx # _process_expression_locals 3582 pop_rbx # _process_expression_locals 3583 pop_rbp # Restore old base pointer 3584 pop_rdi # Prevent overwrite 3585 mov_rax, %0 3586 ret 3587 # Defining function fopen 3588 :FUNCTION_fopen 3589 # Defining local f 3590 push_rax #f 3591 # Defining local fi 3592 push_rdi # Prevent overwriting in recursion 3593 push_rbp # Protect the old base pointer 3594 mov_rdi,rsp # Copy new base pointer 3595 mov_rax, %1 3596 push_rax #_process_expression1 3597 mov_rax, %64 3598 push_rax #_process_expression2 3599 mov_rbp,rdi 3600 call %FUNCTION_calloc 3601 pop_rbx # _process_expression_locals 3602 pop_rbx # _process_expression_locals 3603 pop_rbp # Restore old base pointer 3604 pop_rdi # Prevent overwrite 3605 push_rax #fi 3606 lea_rax,[rbp+DWORD] %-40 3607 mov_rax,[rax] 3608 # looking up offset 3609 # -> offset calculation 3610 mov_rbx, %48 3611 add_rax,rbx 3612 push_rax #_common_recursion 3613 lea_rax,[rip+DWORD] %GLOBAL___list 3614 mov_rax,[rax] 3615 pop_rbx # _common_recursion 3616 mov_[rbx],rax 3617 # IF_fopen_0 3618 mov_rax, %0 3619 push_rax #_common_recursion 3620 lea_rax,[rip+DWORD] %GLOBAL___list 3621 mov_rax,[rax] 3622 pop_rbx # _common_recursion 3623 cmp_rbx,rax 3624 setne_al 3625 movzx_rax,al 3626 test_rax,rax 3627 je %ELSE_fopen_0 3628 lea_rax,[rip+DWORD] %GLOBAL___list 3629 mov_rax,[rax] 3630 # looking up offset 3631 # -> offset calculation 3632 mov_rbx, %56 3633 add_rax,rbx 3634 push_rax #_common_recursion 3635 lea_rax,[rbp+DWORD] %-40 3636 mov_rax,[rax] 3637 pop_rbx # _common_recursion 3638 mov_[rbx],rax 3639 jmp %_END_IF_fopen_0 3640 :ELSE_fopen_0 3641 :_END_IF_fopen_0 3642 lea_rax,[rip+DWORD] %GLOBAL___list 3643 push_rax #_common_recursion 3644 lea_rax,[rbp+DWORD] %-40 3645 mov_rax,[rax] 3646 pop_rbx # _common_recursion 3647 mov_[rbx],rax 3648 # Defining local size 3649 push_rax #size 3650 # IF_fopen_1 3651 mov_rax, %119 3652 push_rax #_common_recursion 3653 lea_rax,[rbp+DWORD] %-16 3654 mov_rax,[rax] 3655 push_rax #_common_recursion 3656 mov_rax, %0 3657 pop_rbx # _common_recursion 3658 add_rax,rbx 3659 movsx_rax,BYTE_PTR_[rax] 3660 pop_rbx # _common_recursion 3661 cmp_rbx,rax 3662 sete_al 3663 movzx_rax,al 3664 test_rax,rax 3665 je %ELSE_fopen_1 3666 lea_rax,[rbp+DWORD] %-32 3667 push_rax #_common_recursion 3668 push_rdi # Prevent overwriting in recursion 3669 push_rbp # Protect the old base pointer 3670 mov_rdi,rsp # Copy new base pointer 3671 lea_rax,[rbp+DWORD] %-8 3672 mov_rax,[rax] 3673 push_rax #_process_expression1 3674 mov_rax, %1 3675 push_rax #_common_recursion 3676 mov_rax, %00100 3677 pop_rbx # _common_recursion 3678 or_rax,rbx 3679 push_rax #_common_recursion 3680 mov_rax, %001000 3681 pop_rbx # _common_recursion 3682 or_rax,rbx 3683 push_rax #_process_expression2 3684 mov_rax, %00600 3685 push_rax #_process_expression2 3686 mov_rbp,rdi 3687 call %FUNCTION_open 3688 pop_rbx # _process_expression_locals 3689 pop_rbx # _process_expression_locals 3690 pop_rbx # _process_expression_locals 3691 pop_rbp # Restore old base pointer 3692 pop_rdi # Prevent overwrite 3693 pop_rbx # _common_recursion 3694 mov_[rbx],rax 3695 jmp %_END_IF_fopen_1 3696 :ELSE_fopen_1 3697 lea_rax,[rbp+DWORD] %-32 3698 push_rax #_common_recursion 3699 push_rdi # Prevent overwriting in recursion 3700 push_rbp # Protect the old base pointer 3701 mov_rdi,rsp # Copy new base pointer 3702 lea_rax,[rbp+DWORD] %-8 3703 mov_rax,[rax] 3704 push_rax #_process_expression1 3705 mov_rax, %0 3706 push_rax #_process_expression2 3707 mov_rax, %0 3708 push_rax #_process_expression2 3709 mov_rbp,rdi 3710 call %FUNCTION_open 3711 pop_rbx # _process_expression_locals 3712 pop_rbx # _process_expression_locals 3713 pop_rbx # _process_expression_locals 3714 pop_rbp # Restore old base pointer 3715 pop_rdi # Prevent overwrite 3716 pop_rbx # _common_recursion 3717 mov_[rbx],rax 3718 :_END_IF_fopen_1 3719 # IF_fopen_2 3720 mov_rax, %0 3721 push_rax #_common_recursion 3722 lea_rax,[rbp+DWORD] %-32 3723 mov_rax,[rax] 3724 pop_rbx # _common_recursion 3725 cmp_rbx,rax 3726 setg_al 3727 movzx_rax,al 3728 test_rax,rax 3729 je %ELSE_fopen_2 3730 mov_rax, %0 3731 pop_rbx # _return_result_locals 3732 pop_rbx # _return_result_locals 3733 pop_rbx # _return_result_locals 3734 ret 3735 jmp %_END_IF_fopen_2 3736 :ELSE_fopen_2 3737 :_END_IF_fopen_2 3738 # IF_fopen_3 3739 mov_rax, %119 3740 push_rax #_common_recursion 3741 lea_rax,[rbp+DWORD] %-16 3742 mov_rax,[rax] 3743 push_rax #_common_recursion 3744 mov_rax, %0 3745 pop_rbx # _common_recursion 3746 add_rax,rbx 3747 movsx_rax,BYTE_PTR_[rax] 3748 pop_rbx # _common_recursion 3749 cmp_rbx,rax 3750 sete_al 3751 movzx_rax,al 3752 test_rax,rax 3753 je %ELSE_fopen_3 3754 lea_rax,[rbp+DWORD] %-40 3755 mov_rax,[rax] 3756 # looking up offset 3757 # -> offset calculation 3758 mov_rbx, %40 3759 add_rax,rbx 3760 push_rax #_common_recursion 3761 push_rdi # Prevent overwriting in recursion 3762 push_rbp # Protect the old base pointer 3763 mov_rdi,rsp # Copy new base pointer 3764 mov_rax, %0x1000 3765 push_rax #_common_recursion 3766 mov_rax, %1 3767 pop_rbx # _common_recursion 3768 imul_rbx 3769 push_rax #_process_expression1 3770 mov_rbp,rdi 3771 call %FUNCTION_malloc 3772 pop_rbx # _process_expression_locals 3773 pop_rbp # Restore old base pointer 3774 pop_rdi # Prevent overwrite 3775 pop_rbx # _common_recursion 3776 mov_[rbx],rax 3777 lea_rax,[rbp+DWORD] %-40 3778 mov_rax,[rax] 3779 # looking up offset 3780 # -> offset calculation 3781 mov_rbx, %32 3782 add_rax,rbx 3783 push_rax #_common_recursion 3784 mov_rax, %0x1000 3785 pop_rbx # _common_recursion 3786 mov_[rbx],rax 3787 lea_rax,[rbp+DWORD] %-40 3788 mov_rax,[rax] 3789 # looking up offset 3790 # -> offset calculation 3791 mov_rbx, %8 3792 add_rax,rbx 3793 push_rax #_common_recursion 3794 mov_rax, %1 3795 pop_rbx # _common_recursion 3796 mov_[rbx],rax 3797 jmp %_END_IF_fopen_3 3798 :ELSE_fopen_3 3799 lea_rax,[rbp+DWORD] %-48 3800 push_rax #_common_recursion 3801 push_rdi # Prevent overwriting in recursion 3802 push_rbp # Protect the old base pointer 3803 mov_rdi,rsp # Copy new base pointer 3804 lea_rax,[rbp+DWORD] %-32 3805 mov_rax,[rax] 3806 push_rax #_process_expression1 3807 mov_rax, %0 3808 push_rax #_process_expression2 3809 mov_rax, %2 3810 push_rax #_process_expression2 3811 mov_rbp,rdi 3812 call %FUNCTION_lseek 3813 pop_rbx # _process_expression_locals 3814 pop_rbx # _process_expression_locals 3815 pop_rbx # _process_expression_locals 3816 pop_rbp # Restore old base pointer 3817 pop_rdi # Prevent overwrite 3818 pop_rbx # _common_recursion 3819 mov_[rbx],rax 3820 lea_rax,[rbp+DWORD] %-40 3821 mov_rax,[rax] 3822 # looking up offset 3823 # -> offset calculation 3824 mov_rbx, %40 3825 add_rax,rbx 3826 push_rax #_common_recursion 3827 push_rdi # Prevent overwriting in recursion 3828 push_rbp # Protect the old base pointer 3829 mov_rdi,rsp # Copy new base pointer 3830 lea_rax,[rbp+DWORD] %-48 3831 mov_rax,[rax] 3832 push_rax #_common_recursion 3833 mov_rax, %1 3834 pop_rbx # _common_recursion 3835 add_rax,rbx 3836 push_rax #_common_recursion 3837 mov_rax, %1 3838 pop_rbx # _common_recursion 3839 imul_rbx 3840 push_rax #_process_expression1 3841 mov_rbp,rdi 3842 call %FUNCTION_malloc 3843 pop_rbx # _process_expression_locals 3844 pop_rbp # Restore old base pointer 3845 pop_rdi # Prevent overwrite 3846 pop_rbx # _common_recursion 3847 mov_[rbx],rax 3848 lea_rax,[rbp+DWORD] %-40 3849 mov_rax,[rax] 3850 # looking up offset 3851 # -> offset calculation 3852 mov_rbx, %32 3853 add_rax,rbx 3854 push_rax #_common_recursion 3855 lea_rax,[rbp+DWORD] %-48 3856 mov_rax,[rax] 3857 pop_rbx # _common_recursion 3858 mov_[rbx],rax 3859 lea_rax,[rbp+DWORD] %-40 3860 mov_rax,[rax] 3861 # looking up offset 3862 # -> offset calculation 3863 mov_rbx, %8 3864 add_rax,rbx 3865 push_rax #_common_recursion 3866 mov_rax, %0 3867 pop_rbx # _common_recursion 3868 mov_[rbx],rax 3869 push_rdi # Prevent overwriting in recursion 3870 push_rbp # Protect the old base pointer 3871 mov_rdi,rsp # Copy new base pointer 3872 lea_rax,[rbp+DWORD] %-32 3873 mov_rax,[rax] 3874 push_rax #_process_expression1 3875 mov_rax, %0 3876 push_rax #_process_expression2 3877 mov_rax, %0 3878 push_rax #_process_expression2 3879 mov_rbp,rdi 3880 call %FUNCTION_lseek 3881 pop_rbx # _process_expression_locals 3882 pop_rbx # _process_expression_locals 3883 pop_rbx # _process_expression_locals 3884 pop_rbp # Restore old base pointer 3885 pop_rdi # Prevent overwrite 3886 push_rdi # Prevent overwriting in recursion 3887 push_rbp # Protect the old base pointer 3888 mov_rdi,rsp # Copy new base pointer 3889 lea_rax,[rbp+DWORD] %-32 3890 mov_rax,[rax] 3891 push_rax #_process_expression1 3892 lea_rax,[rbp+DWORD] %-40 3893 mov_rax,[rax] 3894 # looking up offset 3895 # -> offset calculation 3896 mov_rbx, %40 3897 add_rax,rbx 3898 mov_rax,[rax] 3899 push_rax #_process_expression2 3900 lea_rax,[rbp+DWORD] %-48 3901 mov_rax,[rax] 3902 push_rax #_process_expression2 3903 mov_rbp,rdi 3904 call %FUNCTION_read 3905 pop_rbx # _process_expression_locals 3906 pop_rbx # _process_expression_locals 3907 pop_rbx # _process_expression_locals 3908 pop_rbp # Restore old base pointer 3909 pop_rdi # Prevent overwrite 3910 :_END_IF_fopen_3 3911 lea_rax,[rbp+DWORD] %-40 3912 mov_rax,[rax] 3913 # looking up offset 3914 push_rax #_common_recursion 3915 lea_rax,[rbp+DWORD] %-32 3916 mov_rax,[rax] 3917 pop_rbx # _common_recursion 3918 mov_[rbx],rax 3919 lea_rax,[rbp+DWORD] %-40 3920 mov_rax,[rax] 3921 pop_rbx # _return_result_locals 3922 pop_rbx # _return_result_locals 3923 pop_rbx # _return_result_locals 3924 ret 3925 # Defining function fdopen 3926 :FUNCTION_fdopen 3927 # Defining local fi 3928 push_rdi # Prevent overwriting in recursion 3929 push_rbp # Protect the old base pointer 3930 mov_rdi,rsp # Copy new base pointer 3931 mov_rax, %1 3932 push_rax #_process_expression1 3933 mov_rax, %64 3934 push_rax #_process_expression2 3935 mov_rbp,rdi 3936 call %FUNCTION_calloc 3937 pop_rbx # _process_expression_locals 3938 pop_rbx # _process_expression_locals 3939 pop_rbp # Restore old base pointer 3940 pop_rdi # Prevent overwrite 3941 push_rax #fi 3942 lea_rax,[rbp+DWORD] %-32 3943 mov_rax,[rax] 3944 # looking up offset 3945 # -> offset calculation 3946 mov_rbx, %48 3947 add_rax,rbx 3948 push_rax #_common_recursion 3949 lea_rax,[rip+DWORD] %GLOBAL___list 3950 mov_rax,[rax] 3951 pop_rbx # _common_recursion 3952 mov_[rbx],rax 3953 # IF_fdopen_0 3954 mov_rax, %0 3955 push_rax #_common_recursion 3956 lea_rax,[rip+DWORD] %GLOBAL___list 3957 mov_rax,[rax] 3958 pop_rbx # _common_recursion 3959 cmp_rbx,rax 3960 setne_al 3961 movzx_rax,al 3962 test_rax,rax 3963 je %ELSE_fdopen_0 3964 lea_rax,[rip+DWORD] %GLOBAL___list 3965 mov_rax,[rax] 3966 # looking up offset 3967 # -> offset calculation 3968 mov_rbx, %56 3969 add_rax,rbx 3970 push_rax #_common_recursion 3971 lea_rax,[rbp+DWORD] %-32 3972 mov_rax,[rax] 3973 pop_rbx # _common_recursion 3974 mov_[rbx],rax 3975 jmp %_END_IF_fdopen_0 3976 :ELSE_fdopen_0 3977 :_END_IF_fdopen_0 3978 lea_rax,[rip+DWORD] %GLOBAL___list 3979 push_rax #_common_recursion 3980 lea_rax,[rbp+DWORD] %-32 3981 mov_rax,[rax] 3982 pop_rbx # _common_recursion 3983 mov_[rbx],rax 3984 # Defining local size 3985 push_rax #size 3986 # IF_fdopen_1 3987 mov_rax, %119 3988 push_rax #_common_recursion 3989 lea_rax,[rbp+DWORD] %-16 3990 mov_rax,[rax] 3991 push_rax #_common_recursion 3992 mov_rax, %0 3993 pop_rbx # _common_recursion 3994 add_rax,rbx 3995 movsx_rax,BYTE_PTR_[rax] 3996 pop_rbx # _common_recursion 3997 cmp_rbx,rax 3998 sete_al 3999 movzx_rax,al 4000 test_rax,rax 4001 je %ELSE_fdopen_1 4002 lea_rax,[rbp+DWORD] %-32 4003 mov_rax,[rax] 4004 # looking up offset 4005 # -> offset calculation 4006 mov_rbx, %40 4007 add_rax,rbx 4008 push_rax #_common_recursion 4009 push_rdi # Prevent overwriting in recursion 4010 push_rbp # Protect the old base pointer 4011 mov_rdi,rsp # Copy new base pointer 4012 mov_rax, %0x1000 4013 push_rax #_common_recursion 4014 mov_rax, %1 4015 pop_rbx # _common_recursion 4016 imul_rbx 4017 push_rax #_process_expression1 4018 mov_rbp,rdi 4019 call %FUNCTION_malloc 4020 pop_rbx # _process_expression_locals 4021 pop_rbp # Restore old base pointer 4022 pop_rdi # Prevent overwrite 4023 pop_rbx # _common_recursion 4024 mov_[rbx],rax 4025 lea_rax,[rbp+DWORD] %-32 4026 mov_rax,[rax] 4027 # looking up offset 4028 # -> offset calculation 4029 mov_rbx, %32 4030 add_rax,rbx 4031 push_rax #_common_recursion 4032 mov_rax, %0x1000 4033 pop_rbx # _common_recursion 4034 mov_[rbx],rax 4035 lea_rax,[rbp+DWORD] %-32 4036 mov_rax,[rax] 4037 # looking up offset 4038 # -> offset calculation 4039 mov_rbx, %8 4040 add_rax,rbx 4041 push_rax #_common_recursion 4042 mov_rax, %1 4043 pop_rbx # _common_recursion 4044 mov_[rbx],rax 4045 jmp %_END_IF_fdopen_1 4046 :ELSE_fdopen_1 4047 lea_rax,[rbp+DWORD] %-40 4048 push_rax #_common_recursion 4049 push_rdi # Prevent overwriting in recursion 4050 push_rbp # Protect the old base pointer 4051 mov_rdi,rsp # Copy new base pointer 4052 lea_rax,[rbp+DWORD] %-8 4053 mov_rax,[rax] 4054 push_rax #_process_expression1 4055 mov_rax, %0 4056 push_rax #_process_expression2 4057 mov_rax, %2 4058 push_rax #_process_expression2 4059 mov_rbp,rdi 4060 call %FUNCTION_lseek 4061 pop_rbx # _process_expression_locals 4062 pop_rbx # _process_expression_locals 4063 pop_rbx # _process_expression_locals 4064 pop_rbp # Restore old base pointer 4065 pop_rdi # Prevent overwrite 4066 pop_rbx # _common_recursion 4067 mov_[rbx],rax 4068 lea_rax,[rbp+DWORD] %-32 4069 mov_rax,[rax] 4070 # looking up offset 4071 # -> offset calculation 4072 mov_rbx, %40 4073 add_rax,rbx 4074 push_rax #_common_recursion 4075 push_rdi # Prevent overwriting in recursion 4076 push_rbp # Protect the old base pointer 4077 mov_rdi,rsp # Copy new base pointer 4078 lea_rax,[rbp+DWORD] %-40 4079 mov_rax,[rax] 4080 push_rax #_common_recursion 4081 mov_rax, %1 4082 pop_rbx # _common_recursion 4083 add_rax,rbx 4084 push_rax #_common_recursion 4085 mov_rax, %1 4086 pop_rbx # _common_recursion 4087 imul_rbx 4088 push_rax #_process_expression1 4089 mov_rbp,rdi 4090 call %FUNCTION_malloc 4091 pop_rbx # _process_expression_locals 4092 pop_rbp # Restore old base pointer 4093 pop_rdi # Prevent overwrite 4094 pop_rbx # _common_recursion 4095 mov_[rbx],rax 4096 lea_rax,[rbp+DWORD] %-32 4097 mov_rax,[rax] 4098 # looking up offset 4099 # -> offset calculation 4100 mov_rbx, %32 4101 add_rax,rbx 4102 push_rax #_common_recursion 4103 lea_rax,[rbp+DWORD] %-40 4104 mov_rax,[rax] 4105 pop_rbx # _common_recursion 4106 mov_[rbx],rax 4107 lea_rax,[rbp+DWORD] %-32 4108 mov_rax,[rax] 4109 # looking up offset 4110 # -> offset calculation 4111 mov_rbx, %8 4112 add_rax,rbx 4113 push_rax #_common_recursion 4114 mov_rax, %0 4115 pop_rbx # _common_recursion 4116 mov_[rbx],rax 4117 push_rdi # Prevent overwriting in recursion 4118 push_rbp # Protect the old base pointer 4119 mov_rdi,rsp # Copy new base pointer 4120 lea_rax,[rbp+DWORD] %-8 4121 mov_rax,[rax] 4122 push_rax #_process_expression1 4123 mov_rax, %0 4124 push_rax #_process_expression2 4125 mov_rax, %0 4126 push_rax #_process_expression2 4127 mov_rbp,rdi 4128 call %FUNCTION_lseek 4129 pop_rbx # _process_expression_locals 4130 pop_rbx # _process_expression_locals 4131 pop_rbx # _process_expression_locals 4132 pop_rbp # Restore old base pointer 4133 pop_rdi # Prevent overwrite 4134 push_rdi # Prevent overwriting in recursion 4135 push_rbp # Protect the old base pointer 4136 mov_rdi,rsp # Copy new base pointer 4137 lea_rax,[rbp+DWORD] %-8 4138 mov_rax,[rax] 4139 push_rax #_process_expression1 4140 lea_rax,[rbp+DWORD] %-32 4141 mov_rax,[rax] 4142 # looking up offset 4143 # -> offset calculation 4144 mov_rbx, %40 4145 add_rax,rbx 4146 mov_rax,[rax] 4147 push_rax #_process_expression2 4148 lea_rax,[rbp+DWORD] %-40 4149 mov_rax,[rax] 4150 push_rax #_process_expression2 4151 mov_rbp,rdi 4152 call %FUNCTION_read 4153 pop_rbx # _process_expression_locals 4154 pop_rbx # _process_expression_locals 4155 pop_rbx # _process_expression_locals 4156 pop_rbp # Restore old base pointer 4157 pop_rdi # Prevent overwrite 4158 :_END_IF_fdopen_1 4159 lea_rax,[rbp+DWORD] %-32 4160 mov_rax,[rax] 4161 # looking up offset 4162 push_rax #_common_recursion 4163 lea_rax,[rbp+DWORD] %-8 4164 mov_rax,[rax] 4165 pop_rbx # _common_recursion 4166 mov_[rbx],rax 4167 lea_rax,[rbp+DWORD] %-32 4168 mov_rax,[rax] 4169 pop_rbx # _return_result_locals 4170 pop_rbx # _return_result_locals 4171 ret 4172 # Defining function fflush 4173 :FUNCTION_fflush 4174 # IF_fflush_0 4175 mov_rax, %0 4176 push_rax #_common_recursion 4177 lea_rax,[rbp+DWORD] %-8 4178 mov_rax,[rax] 4179 # looking up offset 4180 # -> offset calculation 4181 mov_rbx, %8 4182 add_rax,rbx 4183 mov_rax,[rax] 4184 pop_rbx # _common_recursion 4185 cmp_rbx,rax 4186 sete_al 4187 movzx_rax,al 4188 test_rax,rax 4189 je %ELSE_fflush_0 4190 mov_rax, %0 4191 ret 4192 jmp %_END_IF_fflush_0 4193 :ELSE_fflush_0 4194 :_END_IF_fflush_0 4195 # IF_fflush_1 4196 mov_rax, %0 4197 push_rax #_common_recursion 4198 lea_rax,[rbp+DWORD] %-8 4199 mov_rax,[rax] 4200 # looking up offset 4201 # -> offset calculation 4202 mov_rbx, %16 4203 add_rax,rbx 4204 mov_rax,[rax] 4205 pop_rbx # _common_recursion 4206 cmp_rbx,rax 4207 sete_al 4208 movzx_rax,al 4209 test_rax,rax 4210 je %ELSE_fflush_1 4211 mov_rax, %0 4212 ret 4213 jmp %_END_IF_fflush_1 4214 :ELSE_fflush_1 4215 :_END_IF_fflush_1 4216 # Defining local error 4217 push_rdi # Prevent overwriting in recursion 4218 push_rbp # Protect the old base pointer 4219 mov_rdi,rsp # Copy new base pointer 4220 lea_rax,[rbp+DWORD] %-8 4221 mov_rax,[rax] 4222 # looking up offset 4223 mov_rax,[rax] 4224 push_rax #_process_expression1 4225 lea_rax,[rbp+DWORD] %-8 4226 mov_rax,[rax] 4227 # looking up offset 4228 # -> offset calculation 4229 mov_rbx, %40 4230 add_rax,rbx 4231 mov_rax,[rax] 4232 push_rax #_process_expression2 4233 lea_rax,[rbp+DWORD] %-8 4234 mov_rax,[rax] 4235 # looking up offset 4236 # -> offset calculation 4237 mov_rbx, %16 4238 add_rax,rbx 4239 mov_rax,[rax] 4240 push_rax #_process_expression2 4241 mov_rbp,rdi 4242 call %FUNCTION_write 4243 pop_rbx # _process_expression_locals 4244 pop_rbx # _process_expression_locals 4245 pop_rbx # _process_expression_locals 4246 pop_rbp # Restore old base pointer 4247 pop_rdi # Prevent overwrite 4248 push_rax #error 4249 lea_rax,[rbp+DWORD] %-8 4250 mov_rax,[rax] 4251 # looking up offset 4252 # -> offset calculation 4253 mov_rbx, %24 4254 add_rax,rbx 4255 push_rax #_common_recursion 4256 lea_rax,[rbp+DWORD] %-8 4257 mov_rax,[rax] 4258 # looking up offset 4259 # -> offset calculation 4260 mov_rbx, %24 4261 add_rax,rbx 4262 mov_rax,[rax] 4263 push_rax #_common_recursion 4264 lea_rax,[rbp+DWORD] %-8 4265 mov_rax,[rax] 4266 # looking up offset 4267 # -> offset calculation 4268 mov_rbx, %16 4269 add_rax,rbx 4270 mov_rax,[rax] 4271 pop_rbx # _common_recursion 4272 add_rax,rbx 4273 pop_rbx # _common_recursion 4274 mov_[rbx],rax 4275 lea_rax,[rbp+DWORD] %-8 4276 mov_rax,[rax] 4277 # looking up offset 4278 # -> offset calculation 4279 mov_rbx, %16 4280 add_rax,rbx 4281 push_rax #_common_recursion 4282 mov_rax, %0 4283 pop_rbx # _common_recursion 4284 mov_[rbx],rax 4285 lea_rax,[rbp+DWORD] %-24 4286 mov_rax,[rax] 4287 pop_rbx # _return_result_locals 4288 ret 4289 # Defining function fclose 4290 :FUNCTION_fclose 4291 # IF_fclose_0 4292 mov_rax, %2 4293 push_rax #_common_recursion 4294 lea_rax,[rbp+DWORD] %-8 4295 mov_rax,[rax] 4296 # looking up offset 4297 mov_rax,[rax] 4298 pop_rbx # _common_recursion 4299 cmp_rbx,rax 4300 setge_al 4301 movzx_rax,al 4302 test_rax,rax 4303 je %ELSE_fclose_0 4304 mov_rax, %0 4305 ret 4306 jmp %_END_IF_fclose_0 4307 :ELSE_fclose_0 4308 :_END_IF_fclose_0 4309 # IF_fclose_1 4310 mov_rax, %1 4311 push_rax #_common_recursion 4312 lea_rax,[rbp+DWORD] %-8 4313 mov_rax,[rax] 4314 # looking up offset 4315 # -> offset calculation 4316 mov_rbx, %8 4317 add_rax,rbx 4318 mov_rax,[rax] 4319 pop_rbx # _common_recursion 4320 cmp_rbx,rax 4321 sete_al 4322 movzx_rax,al 4323 test_rax,rax 4324 je %ELSE_fclose_1 4325 push_rdi # Prevent overwriting in recursion 4326 push_rbp # Protect the old base pointer 4327 mov_rdi,rsp # Copy new base pointer 4328 lea_rax,[rbp+DWORD] %-8 4329 mov_rax,[rax] 4330 push_rax #_process_expression1 4331 mov_rbp,rdi 4332 call %FUNCTION_fflush 4333 pop_rbx # _process_expression_locals 4334 pop_rbp # Restore old base pointer 4335 pop_rdi # Prevent overwrite 4336 jmp %_END_IF_fclose_1 4337 :ELSE_fclose_1 4338 :_END_IF_fclose_1 4339 # Defining local fd 4340 lea_rax,[rbp+DWORD] %-8 4341 mov_rax,[rax] 4342 # looking up offset 4343 mov_rax,[rax] 4344 push_rax #fd 4345 # IF_fclose_2 4346 mov_rax, %0 4347 push_rax #_common_recursion 4348 lea_rax,[rbp+DWORD] %-8 4349 mov_rax,[rax] 4350 # looking up offset 4351 # -> offset calculation 4352 mov_rbx, %56 4353 add_rax,rbx 4354 mov_rax,[rax] 4355 pop_rbx # _common_recursion 4356 cmp_rbx,rax 4357 setne_al 4358 movzx_rax,al 4359 test_rax,rax 4360 je %ELSE_fclose_2 4361 lea_rax,[rbp+DWORD] %-8 4362 mov_rax,[rax] 4363 # looking up offset 4364 # -> offset calculation 4365 mov_rbx, %56 4366 add_rax,rbx 4367 mov_rax,[rax] 4368 # looking up offset 4369 # -> offset calculation 4370 mov_rbx, %48 4371 add_rax,rbx 4372 push_rax #_common_recursion 4373 lea_rax,[rbp+DWORD] %-8 4374 mov_rax,[rax] 4375 # looking up offset 4376 # -> offset calculation 4377 mov_rbx, %48 4378 add_rax,rbx 4379 mov_rax,[rax] 4380 pop_rbx # _common_recursion 4381 mov_[rbx],rax 4382 jmp %_END_IF_fclose_2 4383 :ELSE_fclose_2 4384 :_END_IF_fclose_2 4385 # IF_fclose_3 4386 mov_rax, %0 4387 push_rax #_common_recursion 4388 lea_rax,[rbp+DWORD] %-8 4389 mov_rax,[rax] 4390 # looking up offset 4391 # -> offset calculation 4392 mov_rbx, %48 4393 add_rax,rbx 4394 mov_rax,[rax] 4395 pop_rbx # _common_recursion 4396 cmp_rbx,rax 4397 setne_al 4398 movzx_rax,al 4399 test_rax,rax 4400 je %ELSE_fclose_3 4401 lea_rax,[rbp+DWORD] %-8 4402 mov_rax,[rax] 4403 # looking up offset 4404 # -> offset calculation 4405 mov_rbx, %48 4406 add_rax,rbx 4407 mov_rax,[rax] 4408 # looking up offset 4409 # -> offset calculation 4410 mov_rbx, %56 4411 add_rax,rbx 4412 push_rax #_common_recursion 4413 lea_rax,[rbp+DWORD] %-8 4414 mov_rax,[rax] 4415 # looking up offset 4416 # -> offset calculation 4417 mov_rbx, %56 4418 add_rax,rbx 4419 mov_rax,[rax] 4420 pop_rbx # _common_recursion 4421 mov_[rbx],rax 4422 jmp %_END_IF_fclose_3 4423 :ELSE_fclose_3 4424 :_END_IF_fclose_3 4425 # IF_fclose_4 4426 lea_rax,[rip+DWORD] %GLOBAL___list 4427 mov_rax,[rax] 4428 push_rax #_common_recursion 4429 lea_rax,[rbp+DWORD] %-8 4430 mov_rax,[rax] 4431 pop_rbx # _common_recursion 4432 cmp_rbx,rax 4433 sete_al 4434 movzx_rax,al 4435 test_rax,rax 4436 je %ELSE_fclose_4 4437 lea_rax,[rip+DWORD] %GLOBAL___list 4438 push_rax #_common_recursion 4439 lea_rax,[rip+DWORD] %GLOBAL___list 4440 mov_rax,[rax] 4441 # looking up offset 4442 # -> offset calculation 4443 mov_rbx, %48 4444 add_rax,rbx 4445 mov_rax,[rax] 4446 pop_rbx # _common_recursion 4447 mov_[rbx],rax 4448 jmp %_END_IF_fclose_4 4449 :ELSE_fclose_4 4450 :_END_IF_fclose_4 4451 push_rdi # Prevent overwriting in recursion 4452 push_rbp # Protect the old base pointer 4453 mov_rdi,rsp # Copy new base pointer 4454 lea_rax,[rbp+DWORD] %-8 4455 mov_rax,[rax] 4456 # looking up offset 4457 # -> offset calculation 4458 mov_rbx, %40 4459 add_rax,rbx 4460 mov_rax,[rax] 4461 push_rax #_process_expression1 4462 mov_rbp,rdi 4463 call %FUNCTION_free 4464 pop_rbx # _process_expression_locals 4465 pop_rbp # Restore old base pointer 4466 pop_rdi # Prevent overwrite 4467 push_rdi # Prevent overwriting in recursion 4468 push_rbp # Protect the old base pointer 4469 mov_rdi,rsp # Copy new base pointer 4470 lea_rax,[rbp+DWORD] %-8 4471 mov_rax,[rax] 4472 push_rax #_process_expression1 4473 mov_rbp,rdi 4474 call %FUNCTION_free 4475 pop_rbx # _process_expression_locals 4476 pop_rbp # Restore old base pointer 4477 pop_rdi # Prevent overwrite 4478 push_rdi # Prevent overwriting in recursion 4479 push_rbp # Protect the old base pointer 4480 mov_rdi,rsp # Copy new base pointer 4481 lea_rax,[rbp+DWORD] %-24 4482 mov_rax,[rax] 4483 push_rax #_process_expression1 4484 mov_rbp,rdi 4485 call %FUNCTION_close 4486 pop_rbx # _process_expression_locals 4487 pop_rbp # Restore old base pointer 4488 pop_rdi # Prevent overwrite 4489 pop_rbx # _return_result_locals 4490 ret 4491 # Defining function remove 4492 :FUNCTION_remove 4493 push_rdi # Prevent overwriting in recursion 4494 push_rbp # Protect the old base pointer 4495 mov_rdi,rsp # Copy new base pointer 4496 lea_rax,[rbp+DWORD] %-8 4497 mov_rax,[rax] 4498 push_rax #_process_expression1 4499 mov_rbp,rdi 4500 call %FUNCTION_unlink 4501 pop_rbx # _process_expression_locals 4502 pop_rbp # Restore old base pointer 4503 pop_rdi # Prevent overwrite 4504 ret 4505 # Defining function ungetc 4506 :FUNCTION_ungetc 4507 # IF_ungetc_0 4508 mov_rax, %2 4509 push_rax #_common_recursion 4510 lea_rax,[rbp+DWORD] %-16 4511 mov_rax,[rax] 4512 # looking up offset 4513 mov_rax,[rax] 4514 pop_rbx # _common_recursion 4515 cmp_rbx,rax 4516 setge_al 4517 movzx_rax,al 4518 test_rax,rax 4519 je %ELSE_ungetc_0 4520 mov_rax, %0xFFFFFFFF 4521 ret 4522 jmp %_END_IF_ungetc_0 4523 :ELSE_ungetc_0 4524 :_END_IF_ungetc_0 4525 # IF_ungetc_1 4526 mov_rax, %1 4527 push_rax #_common_recursion 4528 lea_rax,[rbp+DWORD] %-16 4529 mov_rax,[rax] 4530 # looking up offset 4531 # -> offset calculation 4532 mov_rbx, %8 4533 add_rax,rbx 4534 mov_rax,[rax] 4535 pop_rbx # _common_recursion 4536 cmp_rbx,rax 4537 sete_al 4538 movzx_rax,al 4539 test_rax,rax 4540 je %ELSE_ungetc_1 4541 mov_rax, %0xFFFFFFFF 4542 ret 4543 jmp %_END_IF_ungetc_1 4544 :ELSE_ungetc_1 4545 :_END_IF_ungetc_1 4546 # IF_ungetc_2 4547 mov_rax, %0 4548 push_rax #_common_recursion 4549 lea_rax,[rbp+DWORD] %-16 4550 mov_rax,[rax] 4551 # looking up offset 4552 # -> offset calculation 4553 mov_rbx, %16 4554 add_rax,rbx 4555 mov_rax,[rax] 4556 pop_rbx # _common_recursion 4557 cmp_rbx,rax 4558 sete_al 4559 movzx_rax,al 4560 test_rax,rax 4561 je %ELSE_ungetc_2 4562 mov_rax, %0xFFFFFFFF 4563 ret 4564 jmp %_END_IF_ungetc_2 4565 :ELSE_ungetc_2 4566 :_END_IF_ungetc_2 4567 # IF_ungetc_3 4568 lea_rax,[rbp+DWORD] %-16 4569 mov_rax,[rax] 4570 # looking up offset 4571 # -> offset calculation 4572 mov_rbx, %40 4573 add_rax,rbx 4574 mov_rax,[rax] 4575 push_rax #_common_recursion 4576 lea_rax,[rbp+DWORD] %-16 4577 mov_rax,[rax] 4578 # looking up offset 4579 # -> offset calculation 4580 mov_rbx, %16 4581 add_rax,rbx 4582 mov_rax,[rax] 4583 push_rax #_common_recursion 4584 mov_rax, %1 4585 pop_rbx # _common_recursion 4586 sub_rbx,rax 4587 mov_rax,rbx 4588 pop_rbx # _common_recursion 4589 add_rax,rbx 4590 movsx_rax,BYTE_PTR_[rax] 4591 push_rax #_common_recursion 4592 lea_rax,[rbp+DWORD] %-8 4593 mov_rax,[rax] 4594 pop_rbx # _common_recursion 4595 cmp_rbx,rax 4596 setne_al 4597 movzx_rax,al 4598 test_rax,rax 4599 je %ELSE_ungetc_3 4600 mov_rax, %0xFFFFFFFF 4601 ret 4602 jmp %_END_IF_ungetc_3 4603 :ELSE_ungetc_3 4604 :_END_IF_ungetc_3 4605 lea_rax,[rbp+DWORD] %-16 4606 mov_rax,[rax] 4607 # looking up offset 4608 # -> offset calculation 4609 mov_rbx, %16 4610 add_rax,rbx 4611 push_rax #_common_recursion 4612 lea_rax,[rbp+DWORD] %-16 4613 mov_rax,[rax] 4614 # looking up offset 4615 # -> offset calculation 4616 mov_rbx, %16 4617 add_rax,rbx 4618 mov_rax,[rax] 4619 push_rax #_common_recursion 4620 mov_rax, %1 4621 pop_rbx # _common_recursion 4622 sub_rbx,rax 4623 mov_rax,rbx 4624 pop_rbx # _common_recursion 4625 mov_[rbx],rax 4626 lea_rax,[rbp+DWORD] %-8 4627 mov_rax,[rax] 4628 ret 4629 # Defining function ftell 4630 :FUNCTION_ftell 4631 # IF_ftell_0 4632 mov_rax, %2 4633 push_rax #_common_recursion 4634 lea_rax,[rbp+DWORD] %-8 4635 mov_rax,[rax] 4636 # looking up offset 4637 mov_rax,[rax] 4638 pop_rbx # _common_recursion 4639 cmp_rbx,rax 4640 setge_al 4641 movzx_rax,al 4642 test_rax,rax 4643 je %ELSE_ftell_0 4644 mov_rax, %0 4645 ret 4646 jmp %_END_IF_ftell_0 4647 :ELSE_ftell_0 4648 :_END_IF_ftell_0 4649 # IF_ftell_1 4650 mov_rax, %1 4651 push_rax #_common_recursion 4652 lea_rax,[rbp+DWORD] %-8 4653 mov_rax,[rax] 4654 # looking up offset 4655 # -> offset calculation 4656 mov_rbx, %8 4657 add_rax,rbx 4658 mov_rax,[rax] 4659 pop_rbx # _common_recursion 4660 cmp_rbx,rax 4661 sete_al 4662 movzx_rax,al 4663 test_rax,rax 4664 je %ELSE_ftell_1 4665 lea_rax,[rbp+DWORD] %-8 4666 mov_rax,[rax] 4667 # looking up offset 4668 # -> offset calculation 4669 mov_rbx, %24 4670 add_rax,rbx 4671 mov_rax,[rax] 4672 push_rax #_common_recursion 4673 lea_rax,[rbp+DWORD] %-8 4674 mov_rax,[rax] 4675 # looking up offset 4676 # -> offset calculation 4677 mov_rbx, %16 4678 add_rax,rbx 4679 mov_rax,[rax] 4680 pop_rbx # _common_recursion 4681 add_rax,rbx 4682 ret 4683 jmp %_END_IF_ftell_1 4684 :ELSE_ftell_1 4685 :_END_IF_ftell_1 4686 lea_rax,[rbp+DWORD] %-8 4687 mov_rax,[rax] 4688 # looking up offset 4689 # -> offset calculation 4690 mov_rbx, %16 4691 add_rax,rbx 4692 mov_rax,[rax] 4693 ret 4694 # Defining function fseek 4695 :FUNCTION_fseek 4696 # IF_fseek_0 4697 mov_rax, %2 4698 push_rax #_common_recursion 4699 lea_rax,[rbp+DWORD] %-8 4700 mov_rax,[rax] 4701 # looking up offset 4702 mov_rax,[rax] 4703 pop_rbx # _common_recursion 4704 cmp_rbx,rax 4705 setge_al 4706 movzx_rax,al 4707 test_rax,rax 4708 je %ELSE_fseek_0 4709 mov_rax, %0 4710 ret 4711 jmp %_END_IF_fseek_0 4712 :ELSE_fseek_0 4713 :_END_IF_fseek_0 4714 # IF_fseek_1 4715 mov_rax, %1 4716 push_rax #_common_recursion 4717 lea_rax,[rbp+DWORD] %-8 4718 mov_rax,[rax] 4719 # looking up offset 4720 # -> offset calculation 4721 mov_rbx, %8 4722 add_rax,rbx 4723 mov_rax,[rax] 4724 pop_rbx # _common_recursion 4725 cmp_rbx,rax 4726 sete_al 4727 movzx_rax,al 4728 test_rax,rax 4729 je %ELSE_fseek_1 4730 push_rdi # Prevent overwriting in recursion 4731 push_rbp # Protect the old base pointer 4732 mov_rdi,rsp # Copy new base pointer 4733 lea_rax,[rbp+DWORD] %-8 4734 mov_rax,[rax] 4735 push_rax #_process_expression1 4736 mov_rbp,rdi 4737 call %FUNCTION_fflush 4738 pop_rbx # _process_expression_locals 4739 pop_rbp # Restore old base pointer 4740 pop_rdi # Prevent overwrite 4741 push_rdi # Prevent overwriting in recursion 4742 push_rbp # Protect the old base pointer 4743 mov_rdi,rsp # Copy new base pointer 4744 lea_rax,[rbp+DWORD] %-8 4745 mov_rax,[rax] 4746 # looking up offset 4747 mov_rax,[rax] 4748 push_rax #_process_expression1 4749 lea_rax,[rbp+DWORD] %-16 4750 mov_rax,[rax] 4751 push_rax #_process_expression2 4752 lea_rax,[rbp+DWORD] %-24 4753 mov_rax,[rax] 4754 push_rax #_process_expression2 4755 mov_rbp,rdi 4756 call %FUNCTION_lseek 4757 pop_rbx # _process_expression_locals 4758 pop_rbx # _process_expression_locals 4759 pop_rbx # _process_expression_locals 4760 pop_rbp # Restore old base pointer 4761 pop_rdi # Prevent overwrite 4762 ret 4763 jmp %_END_IF_fseek_1 4764 :ELSE_fseek_1 4765 :_END_IF_fseek_1 4766 # Defining local pos 4767 push_rax #pos 4768 # IF_fseek_2 4769 mov_rax, %0 4770 push_rax #_common_recursion 4771 lea_rax,[rbp+DWORD] %-24 4772 mov_rax,[rax] 4773 pop_rbx # _common_recursion 4774 cmp_rbx,rax 4775 sete_al 4776 movzx_rax,al 4777 test_rax,rax 4778 je %ELSE_fseek_2 4779 lea_rax,[rbp+DWORD] %-40 4780 push_rax #_common_recursion 4781 lea_rax,[rbp+DWORD] %-16 4782 mov_rax,[rax] 4783 pop_rbx # _common_recursion 4784 mov_[rbx],rax 4785 jmp %_END_IF_fseek_2 4786 :ELSE_fseek_2 4787 # IF_fseek_3 4788 mov_rax, %1 4789 push_rax #_common_recursion 4790 lea_rax,[rbp+DWORD] %-24 4791 mov_rax,[rax] 4792 pop_rbx # _common_recursion 4793 cmp_rbx,rax 4794 sete_al 4795 movzx_rax,al 4796 test_rax,rax 4797 je %ELSE_fseek_3 4798 lea_rax,[rbp+DWORD] %-40 4799 push_rax #_common_recursion 4800 lea_rax,[rbp+DWORD] %-8 4801 mov_rax,[rax] 4802 # looking up offset 4803 # -> offset calculation 4804 mov_rbx, %16 4805 add_rax,rbx 4806 mov_rax,[rax] 4807 push_rax #_common_recursion 4808 lea_rax,[rbp+DWORD] %-16 4809 mov_rax,[rax] 4810 pop_rbx # _common_recursion 4811 add_rax,rbx 4812 pop_rbx # _common_recursion 4813 mov_[rbx],rax 4814 jmp %_END_IF_fseek_3 4815 :ELSE_fseek_3 4816 # IF_fseek_4 4817 mov_rax, %2 4818 push_rax #_common_recursion 4819 lea_rax,[rbp+DWORD] %-24 4820 mov_rax,[rax] 4821 pop_rbx # _common_recursion 4822 cmp_rbx,rax 4823 sete_al 4824 movzx_rax,al 4825 test_rax,rax 4826 je %ELSE_fseek_4 4827 lea_rax,[rbp+DWORD] %-40 4828 push_rax #_common_recursion 4829 lea_rax,[rbp+DWORD] %-8 4830 mov_rax,[rax] 4831 # looking up offset 4832 # -> offset calculation 4833 mov_rbx, %32 4834 add_rax,rbx 4835 mov_rax,[rax] 4836 push_rax #_common_recursion 4837 lea_rax,[rbp+DWORD] %-16 4838 mov_rax,[rax] 4839 pop_rbx # _common_recursion 4840 add_rax,rbx 4841 pop_rbx # _common_recursion 4842 mov_[rbx],rax 4843 jmp %_END_IF_fseek_4 4844 :ELSE_fseek_4 4845 mov_rax, %0 4846 push_rax #_common_recursion 4847 mov_rax, %1 4848 pop_rbx # _common_recursion 4849 sub_rbx,rax 4850 mov_rax,rbx 4851 pop_rbx # _return_result_locals 4852 ret 4853 :_END_IF_fseek_4 4854 :_END_IF_fseek_3 4855 :_END_IF_fseek_2 4856 # IF_fseek_5 4857 lea_rax,[rbp+DWORD] %-40 4858 mov_rax,[rax] 4859 push_rax #_common_recursion 4860 mov_rax, %0 4861 pop_rbx # _common_recursion 4862 cmp_rbx,rax 4863 setl_al 4864 movzx_rax,al 4865 test_rax,rax 4866 je %ELSE_fseek_5 4867 mov_rax, %0 4868 push_rax #_common_recursion 4869 mov_rax, %1 4870 pop_rbx # _common_recursion 4871 sub_rbx,rax 4872 mov_rax,rbx 4873 pop_rbx # _return_result_locals 4874 ret 4875 jmp %_END_IF_fseek_5 4876 :ELSE_fseek_5 4877 :_END_IF_fseek_5 4878 # IF_fseek_6 4879 lea_rax,[rbp+DWORD] %-40 4880 mov_rax,[rax] 4881 push_rax #_common_recursion 4882 lea_rax,[rbp+DWORD] %-8 4883 mov_rax,[rax] 4884 # looking up offset 4885 # -> offset calculation 4886 mov_rbx, %32 4887 add_rax,rbx 4888 mov_rax,[rax] 4889 pop_rbx # _common_recursion 4890 cmp_rbx,rax 4891 setg_al 4892 movzx_rax,al 4893 test_rax,rax 4894 je %ELSE_fseek_6 4895 mov_rax, %0 4896 push_rax #_common_recursion 4897 mov_rax, %1 4898 pop_rbx # _common_recursion 4899 sub_rbx,rax 4900 mov_rax,rbx 4901 pop_rbx # _return_result_locals 4902 ret 4903 jmp %_END_IF_fseek_6 4904 :ELSE_fseek_6 4905 :_END_IF_fseek_6 4906 lea_rax,[rbp+DWORD] %-8 4907 mov_rax,[rax] 4908 # looking up offset 4909 # -> offset calculation 4910 mov_rbx, %16 4911 add_rax,rbx 4912 push_rax #_common_recursion 4913 lea_rax,[rbp+DWORD] %-40 4914 mov_rax,[rax] 4915 pop_rbx # _common_recursion 4916 mov_[rbx],rax 4917 lea_rax,[rbp+DWORD] %-40 4918 mov_rax,[rax] 4919 pop_rbx # _return_result_locals 4920 ret 4921 # Defining function rewind 4922 :FUNCTION_rewind 4923 push_rdi # Prevent overwriting in recursion 4924 push_rbp # Protect the old base pointer 4925 mov_rdi,rsp # Copy new base pointer 4926 lea_rax,[rbp+DWORD] %-8 4927 mov_rax,[rax] 4928 push_rax #_process_expression1 4929 mov_rax, %0 4930 push_rax #_process_expression2 4931 mov_rax, %0 4932 push_rax #_process_expression2 4933 mov_rbp,rdi 4934 call %FUNCTION_fseek 4935 pop_rbx # _process_expression_locals 4936 pop_rbx # _process_expression_locals 4937 pop_rbx # _process_expression_locals 4938 pop_rbp # Restore old base pointer 4939 pop_rdi # Prevent overwrite 4940 ret 4941 # Defining function require 4942 :FUNCTION_require 4943 # IF_require_0 4944 mov_rax, %1 4945 push_rax #_common_recursion 4946 lea_rax,[rbp+DWORD] %-8 4947 mov_rax,[rax] 4948 pop_rbx # _common_recursion 4949 cmp_rbx,rax 4950 seta_al 4951 movzx_rax,al 4952 test_rax,rax 4953 je %ELSE_require_0 4954 push_rdi # Prevent overwriting in recursion 4955 push_rbp # Protect the old base pointer 4956 mov_rdi,rsp # Copy new base pointer 4957 lea_rax,[rbp+DWORD] %-16 4958 mov_rax,[rax] 4959 push_rax #_process_expression1 4960 lea_rax,[rip+DWORD] %GLOBAL_stderr 4961 mov_rax,[rax] 4962 push_rax #_process_expression2 4963 mov_rbp,rdi 4964 call %FUNCTION_fputs 4965 pop_rbx # _process_expression_locals 4966 pop_rbx # _process_expression_locals 4967 pop_rbp # Restore old base pointer 4968 pop_rdi # Prevent overwrite 4969 push_rdi # Prevent overwriting in recursion 4970 push_rbp # Protect the old base pointer 4971 mov_rdi,rsp # Copy new base pointer 4972 mov_rax, %1 4973 push_rax #_process_expression1 4974 mov_rbp,rdi 4975 call %FUNCTION_exit 4976 pop_rbx # _process_expression_locals 4977 pop_rbp # Restore old base pointer 4978 pop_rdi # Prevent overwrite 4979 jmp %_END_IF_require_0 4980 :ELSE_require_0 4981 :_END_IF_require_0 4982 ret 4983 # Defining function match 4984 :FUNCTION_match 4985 # IF_match_0 4986 mov_rax, %0 4987 push_rax #_common_recursion 4988 lea_rax,[rbp+DWORD] %-8 4989 mov_rax,[rax] 4990 pop_rbx # _common_recursion 4991 cmp_rbx,rax 4992 sete_al 4993 movzx_rax,al 4994 push_rax #_common_recursion 4995 mov_rax, %0 4996 push_rax #_common_recursion 4997 lea_rax,[rbp+DWORD] %-16 4998 mov_rax,[rax] 4999 pop_rbx # _common_recursion 5000 cmp_rbx,rax 5001 sete_al 5002 movzx_rax,al 5003 pop_rbx # _common_recursion 5004 and_rax,rbx 5005 test_rax,rax 5006 je %ELSE_match_0 5007 mov_rax, %1 5008 ret 5009 jmp %_END_IF_match_0 5010 :ELSE_match_0 5011 :_END_IF_match_0 5012 # IF_match_1 5013 mov_rax, %0 5014 push_rax #_common_recursion 5015 lea_rax,[rbp+DWORD] %-8 5016 mov_rax,[rax] 5017 pop_rbx # _common_recursion 5018 cmp_rbx,rax 5019 sete_al 5020 movzx_rax,al 5021 test_rax,rax 5022 je %ELSE_match_1 5023 mov_rax, %0 5024 ret 5025 jmp %_END_IF_match_1 5026 :ELSE_match_1 5027 :_END_IF_match_1 5028 # IF_match_2 5029 mov_rax, %0 5030 push_rax #_common_recursion 5031 lea_rax,[rbp+DWORD] %-16 5032 mov_rax,[rax] 5033 pop_rbx # _common_recursion 5034 cmp_rbx,rax 5035 sete_al 5036 movzx_rax,al 5037 test_rax,rax 5038 je %ELSE_match_2 5039 mov_rax, %0 5040 ret 5041 jmp %_END_IF_match_2 5042 :ELSE_match_2 5043 :_END_IF_match_2 5044 # Defining local i 5045 mov_rax, %0 5046 push_rax #_common_recursion 5047 mov_rax, %1 5048 pop_rbx # _common_recursion 5049 sub_rbx,rax 5050 mov_rax,rbx 5051 push_rax #i 5052 :DO_match_3 5053 lea_rax,[rbp+DWORD] %-32 5054 push_rax #_common_recursion 5055 lea_rax,[rbp+DWORD] %-32 5056 mov_rax,[rax] 5057 push_rax #_common_recursion 5058 mov_rax, %1 5059 pop_rbx # _common_recursion 5060 add_rax,rbx 5061 pop_rbx # _common_recursion 5062 mov_[rbx],rax 5063 # IF_match_4 5064 lea_rax,[rbp+DWORD] %-8 5065 mov_rax,[rax] 5066 push_rax #_common_recursion 5067 lea_rax,[rbp+DWORD] %-32 5068 mov_rax,[rax] 5069 pop_rbx # _common_recursion 5070 add_rax,rbx 5071 movsx_rax,BYTE_PTR_[rax] 5072 push_rax #_common_recursion 5073 lea_rax,[rbp+DWORD] %-16 5074 mov_rax,[rax] 5075 push_rax #_common_recursion 5076 lea_rax,[rbp+DWORD] %-32 5077 mov_rax,[rax] 5078 pop_rbx # _common_recursion 5079 add_rax,rbx 5080 movsx_rax,BYTE_PTR_[rax] 5081 pop_rbx # _common_recursion 5082 cmp_rbx,rax 5083 setne_al 5084 movzx_rax,al 5085 test_rax,rax 5086 je %ELSE_match_4 5087 mov_rax, %0 5088 pop_rbx # _return_result_locals 5089 ret 5090 jmp %_END_IF_match_4 5091 :ELSE_match_4 5092 :_END_IF_match_4 5093 :DO_TEST_match_3 5094 mov_rax, %0 5095 push_rax #_common_recursion 5096 lea_rax,[rbp+DWORD] %-8 5097 mov_rax,[rax] 5098 push_rax #_common_recursion 5099 lea_rax,[rbp+DWORD] %-32 5100 mov_rax,[rax] 5101 pop_rbx # _common_recursion 5102 add_rax,rbx 5103 movsx_rax,BYTE_PTR_[rax] 5104 pop_rbx # _common_recursion 5105 cmp_rbx,rax 5106 setne_al 5107 movzx_rax,al 5108 push_rax #_common_recursion 5109 mov_rax, %0 5110 push_rax #_common_recursion 5111 lea_rax,[rbp+DWORD] %-16 5112 mov_rax,[rax] 5113 push_rax #_common_recursion 5114 lea_rax,[rbp+DWORD] %-32 5115 mov_rax,[rax] 5116 pop_rbx # _common_recursion 5117 add_rax,rbx 5118 movsx_rax,BYTE_PTR_[rax] 5119 pop_rbx # _common_recursion 5120 cmp_rbx,rax 5121 setne_al 5122 movzx_rax,al 5123 pop_rbx # _common_recursion 5124 and_rax,rbx 5125 test_rax,rax 5126 jne %DO_match_3 5127 :DO_END_match_3 5128 mov_rax, %1 5129 pop_rbx # _return_result_locals 5130 ret 5131 # Defining function in_set 5132 :FUNCTION_in_set 5133 # IF_in_set_0 5134 mov_rax, %0 5135 push_rax #_common_recursion 5136 lea_rax,[rbp+DWORD] %-16 5137 mov_rax,[rax] 5138 pop_rbx # _common_recursion 5139 cmp_rbx,rax 5140 sete_al 5141 movzx_rax,al 5142 test_rax,rax 5143 je %ELSE_in_set_0 5144 mov_rax, %0 5145 ret 5146 jmp %_END_IF_in_set_0 5147 :ELSE_in_set_0 5148 :_END_IF_in_set_0 5149 :WHILE_in_set_1 5150 mov_rax, %0 5151 push_rax #_common_recursion 5152 lea_rax,[rbp+DWORD] %-16 5153 mov_rax,[rax] 5154 push_rax #_common_recursion 5155 mov_rax, %0 5156 pop_rbx # _common_recursion 5157 add_rax,rbx 5158 movsx_rax,BYTE_PTR_[rax] 5159 pop_rbx # _common_recursion 5160 cmp_rbx,rax 5161 setne_al 5162 movzx_rax,al 5163 test_rax,rax 5164 je %END_WHILE_in_set_1 5165 # THEN_while_in_set_1 5166 # IF_in_set_2 5167 lea_rax,[rbp+DWORD] %-8 5168 mov_rax,[rax] 5169 push_rax #_common_recursion 5170 lea_rax,[rbp+DWORD] %-16 5171 mov_rax,[rax] 5172 push_rax #_common_recursion 5173 mov_rax, %0 5174 pop_rbx # _common_recursion 5175 add_rax,rbx 5176 movsx_rax,BYTE_PTR_[rax] 5177 pop_rbx # _common_recursion 5178 cmp_rbx,rax 5179 sete_al 5180 movzx_rax,al 5181 test_rax,rax 5182 je %ELSE_in_set_2 5183 mov_rax, %1 5184 ret 5185 jmp %_END_IF_in_set_2 5186 :ELSE_in_set_2 5187 :_END_IF_in_set_2 5188 lea_rax,[rbp+DWORD] %-16 5189 push_rax #_common_recursion 5190 lea_rax,[rbp+DWORD] %-16 5191 mov_rax,[rax] 5192 push_rax #_common_recursion 5193 mov_rax, %1 5194 pop_rbx # _common_recursion 5195 add_rax,rbx 5196 pop_rbx # _common_recursion 5197 mov_[rbx],rax 5198 jmp %WHILE_in_set_1 5199 :END_WHILE_in_set_1 5200 mov_rax, %0 5201 ret 5202 # Defining function __index_number 5203 :FUNCTION___index_number 5204 # Defining local i 5205 mov_rax, %0 5206 push_rax #i 5207 :WHILE___index_number_0 5208 lea_rax,[rbp+DWORD] %-8 5209 mov_rax,[rax] 5210 push_rax #_common_recursion 5211 lea_rax,[rbp+DWORD] %-32 5212 mov_rax,[rax] 5213 pop_rbx # _common_recursion 5214 add_rax,rbx 5215 movsx_rax,BYTE_PTR_[rax] 5216 push_rax #_common_recursion 5217 lea_rax,[rbp+DWORD] %-16 5218 movsx_rax,BYTE_PTR_[rax] 5219 pop_rbx # _common_recursion 5220 cmp_rbx,rax 5221 setne_al 5222 movzx_rax,al 5223 test_rax,rax 5224 je %END_WHILE___index_number_0 5225 # THEN_while___index_number_0 5226 lea_rax,[rbp+DWORD] %-32 5227 push_rax #_common_recursion 5228 lea_rax,[rbp+DWORD] %-32 5229 mov_rax,[rax] 5230 push_rax #_common_recursion 5231 mov_rax, %1 5232 pop_rbx # _common_recursion 5233 add_rax,rbx 5234 pop_rbx # _common_recursion 5235 mov_[rbx],rax 5236 # IF___index_number_1 5237 mov_rax, %0 5238 push_rax #_common_recursion 5239 lea_rax,[rbp+DWORD] %-8 5240 mov_rax,[rax] 5241 push_rax #_common_recursion 5242 lea_rax,[rbp+DWORD] %-32 5243 mov_rax,[rax] 5244 pop_rbx # _common_recursion 5245 add_rax,rbx 5246 movsx_rax,BYTE_PTR_[rax] 5247 pop_rbx # _common_recursion 5248 cmp_rbx,rax 5249 sete_al 5250 movzx_rax,al 5251 test_rax,rax 5252 je %ELSE___index_number_1 5253 mov_rax, %0 5254 push_rax #_common_recursion 5255 mov_rax, %1 5256 pop_rbx # _common_recursion 5257 sub_rbx,rax 5258 mov_rax,rbx 5259 pop_rbx # _return_result_locals 5260 ret 5261 jmp %_END_IF___index_number_1 5262 :ELSE___index_number_1 5263 :_END_IF___index_number_1 5264 jmp %WHILE___index_number_0 5265 :END_WHILE___index_number_0 5266 lea_rax,[rbp+DWORD] %-32 5267 mov_rax,[rax] 5268 pop_rbx # _return_result_locals 5269 ret 5270 # Defining function __toupper 5271 :FUNCTION___toupper 5272 # IF___toupper_0 5273 push_rdi # Prevent overwriting in recursion 5274 push_rbp # Protect the old base pointer 5275 mov_rdi,rsp # Copy new base pointer 5276 lea_rax,[rbp+DWORD] %-8 5277 mov_rax,[rax] 5278 push_rax #_process_expression1 5279 lea_rax,[rip+DWORD] %STRING___toupper_1 5280 push_rax #_process_expression2 5281 mov_rbp,rdi 5282 call %FUNCTION_in_set 5283 pop_rbx # _process_expression_locals 5284 pop_rbx # _process_expression_locals 5285 pop_rbp # Restore old base pointer 5286 pop_rdi # Prevent overwrite 5287 test_rax,rax 5288 je %ELSE___toupper_0 5289 lea_rax,[rbp+DWORD] %-8 5290 mov_rax,[rax] 5291 push_rax #_common_recursion 5292 mov_rax, %0xDF 5293 pop_rbx # _common_recursion 5294 and_rax,rbx 5295 ret 5296 jmp %_END_IF___toupper_0 5297 :ELSE___toupper_0 5298 :_END_IF___toupper_0 5299 lea_rax,[rbp+DWORD] %-8 5300 mov_rax,[rax] 5301 ret 5302 # Defining function __set_reader 5303 :FUNCTION___set_reader 5304 # Defining local n 5305 mov_rax, %0 5306 push_rax #n 5307 # Defining local i 5308 mov_rax, %0 5309 push_rax #i 5310 # Defining local hold 5311 push_rax #hold 5312 # Defining local negative_p 5313 mov_rax, %0 5314 push_rax #negative_p 5315 # IF___set_reader_0 5316 lea_rax,[rbp+DWORD] %-24 5317 mov_rax,[rax] 5318 push_rax #_common_recursion 5319 mov_rax, %0 5320 pop_rbx # _common_recursion 5321 add_rax,rbx 5322 movsx_rax,BYTE_PTR_[rax] 5323 push_rax #_common_recursion 5324 mov_rax, %45 5325 pop_rbx # _common_recursion 5326 cmp_rbx,rax 5327 sete_al 5328 movzx_rax,al 5329 test_rax,rax 5330 je %ELSE___set_reader_0 5331 lea_rax,[rbp+DWORD] %-64 5332 push_rax #_common_recursion 5333 mov_rax, %1 5334 pop_rbx # _common_recursion 5335 mov_[rbx],rax 5336 lea_rax,[rbp+DWORD] %-48 5337 push_rax #_common_recursion 5338 lea_rax,[rbp+DWORD] %-48 5339 mov_rax,[rax] 5340 push_rax #_common_recursion 5341 mov_rax, %1 5342 pop_rbx # _common_recursion 5343 add_rax,rbx 5344 pop_rbx # _common_recursion 5345 mov_[rbx],rax 5346 jmp %_END_IF___set_reader_0 5347 :ELSE___set_reader_0 5348 :_END_IF___set_reader_0 5349 :WHILE___set_reader_1 5350 push_rdi # Prevent overwriting in recursion 5351 push_rbp # Protect the old base pointer 5352 mov_rdi,rsp # Copy new base pointer 5353 lea_rax,[rbp+DWORD] %-24 5354 mov_rax,[rax] 5355 push_rax #_common_recursion 5356 lea_rax,[rbp+DWORD] %-48 5357 mov_rax,[rax] 5358 pop_rbx # _common_recursion 5359 add_rax,rbx 5360 movsx_rax,BYTE_PTR_[rax] 5361 push_rax #_process_expression1 5362 lea_rax,[rbp+DWORD] %-8 5363 mov_rax,[rax] 5364 push_rax #_process_expression2 5365 mov_rbp,rdi 5366 call %FUNCTION_in_set 5367 pop_rbx # _process_expression_locals 5368 pop_rbx # _process_expression_locals 5369 pop_rbp # Restore old base pointer 5370 pop_rdi # Prevent overwrite 5371 test_rax,rax 5372 je %END_WHILE___set_reader_1 5373 # THEN_while___set_reader_1 5374 lea_rax,[rbp+DWORD] %-40 5375 push_rax #_common_recursion 5376 lea_rax,[rbp+DWORD] %-40 5377 mov_rax,[rax] 5378 push_rax #_common_recursion 5379 lea_rax,[rbp+DWORD] %-16 5380 mov_rax,[rax] 5381 pop_rbx # _common_recursion 5382 imul_rbx 5383 pop_rbx # _common_recursion 5384 mov_[rbx],rax 5385 lea_rax,[rbp+DWORD] %-56 5386 push_rax #_common_recursion 5387 push_rdi # Prevent overwriting in recursion 5388 push_rbp # Protect the old base pointer 5389 mov_rdi,rsp # Copy new base pointer 5390 lea_rax,[rbp+DWORD] %-8 5391 mov_rax,[rax] 5392 push_rax #_process_expression1 5393 push_rdi # Prevent overwriting in recursion 5394 push_rbp # Protect the old base pointer 5395 mov_rdi,rsp # Copy new base pointer 5396 lea_rax,[rbp+DWORD] %-24 5397 mov_rax,[rax] 5398 push_rax #_common_recursion 5399 lea_rax,[rbp+DWORD] %-48 5400 mov_rax,[rax] 5401 pop_rbx # _common_recursion 5402 add_rax,rbx 5403 movsx_rax,BYTE_PTR_[rax] 5404 push_rax #_process_expression1 5405 mov_rbp,rdi 5406 call %FUNCTION___toupper 5407 pop_rbx # _process_expression_locals 5408 pop_rbp # Restore old base pointer 5409 pop_rdi # Prevent overwrite 5410 push_rax #_process_expression2 5411 mov_rbp,rdi 5412 call %FUNCTION___index_number 5413 pop_rbx # _process_expression_locals 5414 pop_rbx # _process_expression_locals 5415 pop_rbp # Restore old base pointer 5416 pop_rdi # Prevent overwrite 5417 pop_rbx # _common_recursion 5418 mov_[rbx],rax 5419 # IF___set_reader_2 5420 mov_rax, %0 5421 push_rax #_common_recursion 5422 mov_rax, %1 5423 pop_rbx # _common_recursion 5424 sub_rbx,rax 5425 mov_rax,rbx 5426 push_rax #_common_recursion 5427 lea_rax,[rbp+DWORD] %-56 5428 mov_rax,[rax] 5429 pop_rbx # _common_recursion 5430 cmp_rbx,rax 5431 sete_al 5432 movzx_rax,al 5433 test_rax,rax 5434 je %ELSE___set_reader_2 5435 mov_rax, %0 5436 pop_rbx # _return_result_locals 5437 pop_rbx # _return_result_locals 5438 pop_rbx # _return_result_locals 5439 pop_rbx # _return_result_locals 5440 ret 5441 jmp %_END_IF___set_reader_2 5442 :ELSE___set_reader_2 5443 :_END_IF___set_reader_2 5444 lea_rax,[rbp+DWORD] %-40 5445 push_rax #_common_recursion 5446 lea_rax,[rbp+DWORD] %-40 5447 mov_rax,[rax] 5448 push_rax #_common_recursion 5449 lea_rax,[rbp+DWORD] %-56 5450 mov_rax,[rax] 5451 pop_rbx # _common_recursion 5452 add_rax,rbx 5453 pop_rbx # _common_recursion 5454 mov_[rbx],rax 5455 lea_rax,[rbp+DWORD] %-48 5456 push_rax #_common_recursion 5457 lea_rax,[rbp+DWORD] %-48 5458 mov_rax,[rax] 5459 push_rax #_common_recursion 5460 mov_rax, %1 5461 pop_rbx # _common_recursion 5462 add_rax,rbx 5463 pop_rbx # _common_recursion 5464 mov_[rbx],rax 5465 jmp %WHILE___set_reader_1 5466 :END_WHILE___set_reader_1 5467 # IF___set_reader_3 5468 mov_rax, %0 5469 push_rax #_common_recursion 5470 lea_rax,[rbp+DWORD] %-24 5471 mov_rax,[rax] 5472 push_rax #_common_recursion 5473 lea_rax,[rbp+DWORD] %-48 5474 mov_rax,[rax] 5475 pop_rbx # _common_recursion 5476 add_rax,rbx 5477 movsx_rax,BYTE_PTR_[rax] 5478 pop_rbx # _common_recursion 5479 cmp_rbx,rax 5480 setne_al 5481 movzx_rax,al 5482 test_rax,rax 5483 je %ELSE___set_reader_3 5484 mov_rax, %0 5485 pop_rbx # _return_result_locals 5486 pop_rbx # _return_result_locals 5487 pop_rbx # _return_result_locals 5488 pop_rbx # _return_result_locals 5489 ret 5490 jmp %_END_IF___set_reader_3 5491 :ELSE___set_reader_3 5492 :_END_IF___set_reader_3 5493 # IF___set_reader_4 5494 lea_rax,[rbp+DWORD] %-64 5495 mov_rax,[rax] 5496 test_rax,rax 5497 je %ELSE___set_reader_4 5498 lea_rax,[rbp+DWORD] %-40 5499 push_rax #_common_recursion 5500 mov_rax, %0 5501 push_rax #_common_recursion 5502 lea_rax,[rbp+DWORD] %-40 5503 mov_rax,[rax] 5504 pop_rbx # _common_recursion 5505 sub_rbx,rax 5506 mov_rax,rbx 5507 pop_rbx # _common_recursion 5508 mov_[rbx],rax 5509 jmp %_END_IF___set_reader_4 5510 :ELSE___set_reader_4 5511 :_END_IF___set_reader_4 5512 lea_rax,[rbp+DWORD] %-40 5513 mov_rax,[rax] 5514 pop_rbx # _return_result_locals 5515 pop_rbx # _return_result_locals 5516 pop_rbx # _return_result_locals 5517 pop_rbx # _return_result_locals 5518 ret 5519 # Defining function strtoint 5520 :FUNCTION_strtoint 5521 # Defining local result 5522 mov_rax, %0 5523 push_rax #result 5524 # IF_strtoint_0 5525 mov_rax, %0 5526 push_rax #_common_recursion 5527 lea_rax,[rbp+DWORD] %-8 5528 mov_rax,[rax] 5529 push_rax #_common_recursion 5530 mov_rax, %0 5531 pop_rbx # _common_recursion 5532 add_rax,rbx 5533 movsx_rax,BYTE_PTR_[rax] 5534 pop_rbx # _common_recursion 5535 cmp_rbx,rax 5536 sete_al 5537 movzx_rax,al 5538 test_rax,rax 5539 je %ELSE_strtoint_0 5540 lea_rax,[rbp+DWORD] %-24 5541 push_rax #_common_recursion 5542 mov_rax, %0 5543 pop_rbx # _common_recursion 5544 mov_[rbx],rax 5545 jmp %_END_IF_strtoint_0 5546 :ELSE_strtoint_0 5547 # IF_strtoint_1 5548 mov_rax, %48 5549 push_rax #_common_recursion 5550 lea_rax,[rbp+DWORD] %-8 5551 mov_rax,[rax] 5552 push_rax #_common_recursion 5553 mov_rax, %0 5554 pop_rbx # _common_recursion 5555 add_rax,rbx 5556 movsx_rax,BYTE_PTR_[rax] 5557 pop_rbx # _common_recursion 5558 cmp_rbx,rax 5559 sete_al 5560 movzx_rax,al 5561 push_rax #_common_recursion 5562 mov_rax, %98 5563 push_rax #_common_recursion 5564 lea_rax,[rbp+DWORD] %-8 5565 mov_rax,[rax] 5566 push_rax #_common_recursion 5567 mov_rax, %1 5568 pop_rbx # _common_recursion 5569 add_rax,rbx 5570 movsx_rax,BYTE_PTR_[rax] 5571 pop_rbx # _common_recursion 5572 cmp_rbx,rax 5573 sete_al 5574 movzx_rax,al 5575 pop_rbx # _common_recursion 5576 and_rax,rbx 5577 test_rax,rax 5578 je %ELSE_strtoint_1 5579 lea_rax,[rbp+DWORD] %-24 5580 push_rax #_common_recursion 5581 push_rdi # Prevent overwriting in recursion 5582 push_rbp # Protect the old base pointer 5583 mov_rdi,rsp # Copy new base pointer 5584 lea_rax,[rip+DWORD] %STRING_strtoint_2 5585 push_rax #_process_expression1 5586 mov_rax, %2 5587 push_rax #_process_expression2 5588 lea_rax,[rbp+DWORD] %-8 5589 mov_rax,[rax] 5590 push_rax #_common_recursion 5591 mov_rax, %2 5592 pop_rbx # _common_recursion 5593 add_rax,rbx 5594 push_rax #_process_expression2 5595 mov_rbp,rdi 5596 call %FUNCTION___set_reader 5597 pop_rbx # _process_expression_locals 5598 pop_rbx # _process_expression_locals 5599 pop_rbx # _process_expression_locals 5600 pop_rbp # Restore old base pointer 5601 pop_rdi # Prevent overwrite 5602 pop_rbx # _common_recursion 5603 mov_[rbx],rax 5604 jmp %_END_IF_strtoint_1 5605 :ELSE_strtoint_1 5606 # IF_strtoint_3 5607 mov_rax, %48 5608 push_rax #_common_recursion 5609 lea_rax,[rbp+DWORD] %-8 5610 mov_rax,[rax] 5611 push_rax #_common_recursion 5612 mov_rax, %0 5613 pop_rbx # _common_recursion 5614 add_rax,rbx 5615 movsx_rax,BYTE_PTR_[rax] 5616 pop_rbx # _common_recursion 5617 cmp_rbx,rax 5618 sete_al 5619 movzx_rax,al 5620 push_rax #_common_recursion 5621 mov_rax, %120 5622 push_rax #_common_recursion 5623 lea_rax,[rbp+DWORD] %-8 5624 mov_rax,[rax] 5625 push_rax #_common_recursion 5626 mov_rax, %1 5627 pop_rbx # _common_recursion 5628 add_rax,rbx 5629 movsx_rax,BYTE_PTR_[rax] 5630 pop_rbx # _common_recursion 5631 cmp_rbx,rax 5632 sete_al 5633 movzx_rax,al 5634 pop_rbx # _common_recursion 5635 and_rax,rbx 5636 test_rax,rax 5637 je %ELSE_strtoint_3 5638 lea_rax,[rbp+DWORD] %-24 5639 push_rax #_common_recursion 5640 push_rdi # Prevent overwriting in recursion 5641 push_rbp # Protect the old base pointer 5642 mov_rdi,rsp # Copy new base pointer 5643 lea_rax,[rip+DWORD] %STRING_strtoint_4 5644 push_rax #_process_expression1 5645 mov_rax, %16 5646 push_rax #_process_expression2 5647 lea_rax,[rbp+DWORD] %-8 5648 mov_rax,[rax] 5649 push_rax #_common_recursion 5650 mov_rax, %2 5651 pop_rbx # _common_recursion 5652 add_rax,rbx 5653 push_rax #_process_expression2 5654 mov_rbp,rdi 5655 call %FUNCTION___set_reader 5656 pop_rbx # _process_expression_locals 5657 pop_rbx # _process_expression_locals 5658 pop_rbx # _process_expression_locals 5659 pop_rbp # Restore old base pointer 5660 pop_rdi # Prevent overwrite 5661 pop_rbx # _common_recursion 5662 mov_[rbx],rax 5663 jmp %_END_IF_strtoint_3 5664 :ELSE_strtoint_3 5665 # IF_strtoint_5 5666 mov_rax, %48 5667 push_rax #_common_recursion 5668 lea_rax,[rbp+DWORD] %-8 5669 mov_rax,[rax] 5670 push_rax #_common_recursion 5671 mov_rax, %0 5672 pop_rbx # _common_recursion 5673 add_rax,rbx 5674 movsx_rax,BYTE_PTR_[rax] 5675 pop_rbx # _common_recursion 5676 cmp_rbx,rax 5677 sete_al 5678 movzx_rax,al 5679 test_rax,rax 5680 je %ELSE_strtoint_5 5681 lea_rax,[rbp+DWORD] %-24 5682 push_rax #_common_recursion 5683 push_rdi # Prevent overwriting in recursion 5684 push_rbp # Protect the old base pointer 5685 mov_rdi,rsp # Copy new base pointer 5686 lea_rax,[rip+DWORD] %STRING_strtoint_6 5687 push_rax #_process_expression1 5688 mov_rax, %8 5689 push_rax #_process_expression2 5690 lea_rax,[rbp+DWORD] %-8 5691 mov_rax,[rax] 5692 push_rax #_common_recursion 5693 mov_rax, %1 5694 pop_rbx # _common_recursion 5695 add_rax,rbx 5696 push_rax #_process_expression2 5697 mov_rbp,rdi 5698 call %FUNCTION___set_reader 5699 pop_rbx # _process_expression_locals 5700 pop_rbx # _process_expression_locals 5701 pop_rbx # _process_expression_locals 5702 pop_rbp # Restore old base pointer 5703 pop_rdi # Prevent overwrite 5704 pop_rbx # _common_recursion 5705 mov_[rbx],rax 5706 jmp %_END_IF_strtoint_5 5707 :ELSE_strtoint_5 5708 lea_rax,[rbp+DWORD] %-24 5709 push_rax #_common_recursion 5710 push_rdi # Prevent overwriting in recursion 5711 push_rbp # Protect the old base pointer 5712 mov_rdi,rsp # Copy new base pointer 5713 lea_rax,[rip+DWORD] %STRING_strtoint_7 5714 push_rax #_process_expression1 5715 mov_rax, %10 5716 push_rax #_process_expression2 5717 lea_rax,[rbp+DWORD] %-8 5718 mov_rax,[rax] 5719 push_rax #_process_expression2 5720 mov_rbp,rdi 5721 call %FUNCTION___set_reader 5722 pop_rbx # _process_expression_locals 5723 pop_rbx # _process_expression_locals 5724 pop_rbx # _process_expression_locals 5725 pop_rbp # Restore old base pointer 5726 pop_rdi # Prevent overwrite 5727 pop_rbx # _common_recursion 5728 mov_[rbx],rax 5729 :_END_IF_strtoint_5 5730 :_END_IF_strtoint_3 5731 :_END_IF_strtoint_1 5732 :_END_IF_strtoint_0 5733 # IF_strtoint_8 5734 mov_rax, %0 5735 push_rax #_common_recursion 5736 mov_rax, %0x80000000 5737 push_rax #_common_recursion 5738 lea_rax,[rbp+DWORD] %-24 5739 mov_rax,[rax] 5740 pop_rbx # _common_recursion 5741 and_rax,rbx 5742 pop_rbx # _common_recursion 5743 cmp_rbx,rax 5744 setne_al 5745 movzx_rax,al 5746 test_rax,rax 5747 je %ELSE_strtoint_8 5748 lea_rax,[rbp+DWORD] %-24 5749 push_rax #_common_recursion 5750 mov_rax, %0xFFFFFFFF 5751 push_rax #_common_recursion 5752 mov_rax, %31 5753 pop_rbx # _common_recursion 5754 mov_rcx,rax 5755 mov_rax,rbx 5756 sal_rax,cl 5757 push_rax #_common_recursion 5758 lea_rax,[rbp+DWORD] %-24 5759 mov_rax,[rax] 5760 pop_rbx # _common_recursion 5761 or_rax,rbx 5762 pop_rbx # _common_recursion 5763 mov_[rbx],rax 5764 jmp %_END_IF_strtoint_8 5765 :ELSE_strtoint_8 5766 :_END_IF_strtoint_8 5767 lea_rax,[rbp+DWORD] %-24 5768 mov_rax,[rax] 5769 pop_rbx # _return_result_locals 5770 ret 5771 # Defining function int2str 5772 :FUNCTION_int2str 5773 push_rdi # Prevent overwriting in recursion 5774 push_rbp # Protect the old base pointer 5775 mov_rdi,rsp # Copy new base pointer 5776 mov_rax, %1 5777 push_rax #_common_recursion 5778 lea_rax,[rbp+DWORD] %-16 5779 mov_rax,[rax] 5780 pop_rbx # _common_recursion 5781 cmp_rbx,rax 5782 setl_al 5783 movzx_rax,al 5784 push_rax #_process_expression1 5785 lea_rax,[rip+DWORD] %STRING_int2str_0 5786 push_rax #_process_expression2 5787 mov_rbp,rdi 5788 call %FUNCTION_require 5789 pop_rbx # _process_expression_locals 5790 pop_rbx # _process_expression_locals 5791 pop_rbp # Restore old base pointer 5792 pop_rdi # Prevent overwrite 5793 push_rdi # Prevent overwriting in recursion 5794 push_rbp # Protect the old base pointer 5795 mov_rdi,rsp # Copy new base pointer 5796 mov_rax, %37 5797 push_rax #_common_recursion 5798 lea_rax,[rbp+DWORD] %-16 5799 mov_rax,[rax] 5800 pop_rbx # _common_recursion 5801 cmp_rbx,rax 5802 setg_al 5803 movzx_rax,al 5804 push_rax #_process_expression1 5805 lea_rax,[rip+DWORD] %STRING_int2str_1 5806 push_rax #_process_expression2 5807 mov_rbp,rdi 5808 call %FUNCTION_require 5809 pop_rbx # _process_expression_locals 5810 pop_rbx # _process_expression_locals 5811 pop_rbp # Restore old base pointer 5812 pop_rdi # Prevent overwrite 5813 # Defining local p 5814 push_rdi # Prevent overwriting in recursion 5815 push_rbp # Protect the old base pointer 5816 mov_rdi,rsp # Copy new base pointer 5817 mov_rax, %34 5818 push_rax #_process_expression1 5819 mov_rax, %1 5820 push_rax #_process_expression2 5821 mov_rbp,rdi 5822 call %FUNCTION_calloc 5823 pop_rbx # _process_expression_locals 5824 pop_rbx # _process_expression_locals 5825 pop_rbp # Restore old base pointer 5826 pop_rdi # Prevent overwrite 5827 push_rax #p 5828 # IF_int2str_2 5829 mov_rax, %0 5830 push_rax #_common_recursion 5831 lea_rax,[rbp+DWORD] %-40 5832 mov_rax,[rax] 5833 pop_rbx # _common_recursion 5834 cmp_rbx,rax 5835 sete_al 5836 movzx_rax,al 5837 test_rax,rax 5838 je %ELSE_int2str_2 5839 lea_rax,[rbp+DWORD] %-40 5840 mov_rax,[rax] 5841 pop_rbx # _return_result_locals 5842 ret 5843 jmp %_END_IF_int2str_2 5844 :ELSE_int2str_2 5845 :_END_IF_int2str_2 5846 lea_rax,[rbp+DWORD] %-40 5847 push_rax #_common_recursion 5848 lea_rax,[rbp+DWORD] %-40 5849 mov_rax,[rax] 5850 push_rax #_common_recursion 5851 mov_rax, %32 5852 pop_rbx # _common_recursion 5853 add_rax,rbx 5854 pop_rbx # _common_recursion 5855 mov_[rbx],rax 5856 # Defining local i 5857 push_rax #i 5858 # Defining local sign_p 5859 mov_rax, %0 5860 push_rax #sign_p 5861 # Defining local table 5862 lea_rax,[rip+DWORD] %STRING_int2str_3 5863 push_rax #table 5864 # IF_int2str_4 5865 lea_rax,[rbp+DWORD] %-24 5866 mov_rax,[rax] 5867 push_rax #_common_recursion 5868 mov_rax, %10 5869 push_rax #_common_recursion 5870 lea_rax,[rbp+DWORD] %-16 5871 mov_rax,[rax] 5872 pop_rbx # _common_recursion 5873 cmp_rbx,rax 5874 sete_al 5875 movzx_rax,al 5876 pop_rbx # _common_recursion 5877 and_rax,rbx 5878 push_rax #_common_recursion 5879 mov_rax, %0 5880 push_rax #_common_recursion 5881 lea_rax,[rbp+DWORD] %-8 5882 mov_rax,[rax] 5883 push_rax #_common_recursion 5884 mov_rax, %0x80000000 5885 pop_rbx # _common_recursion 5886 and_rax,rbx 5887 pop_rbx # _common_recursion 5888 cmp_rbx,rax 5889 setne_al 5890 movzx_rax,al 5891 pop_rbx # _common_recursion 5892 and_rax,rbx 5893 test_rax,rax 5894 je %ELSE_int2str_4 5895 lea_rax,[rbp+DWORD] %-48 5896 push_rax #_common_recursion 5897 mov_rax, %0 5898 push_rax #_common_recursion 5899 lea_rax,[rbp+DWORD] %-8 5900 mov_rax,[rax] 5901 pop_rbx # _common_recursion 5902 sub_rbx,rax 5903 mov_rax,rbx 5904 push_rax #_common_recursion 5905 mov_rax, %0x7FFFFFFF 5906 pop_rbx # _common_recursion 5907 and_rax,rbx 5908 pop_rbx # _common_recursion 5909 mov_[rbx],rax 5910 # IF_int2str_5 5911 mov_rax, %0 5912 push_rax #_common_recursion 5913 lea_rax,[rbp+DWORD] %-48 5914 mov_rax,[rax] 5915 pop_rbx # _common_recursion 5916 cmp_rbx,rax 5917 sete_al 5918 movzx_rax,al 5919 test_rax,rax 5920 je %ELSE_int2str_5 5921 lea_rax,[rip+DWORD] %STRING_int2str_6 5922 pop_rbx # _return_result_locals 5923 pop_rbx # _return_result_locals 5924 pop_rbx # _return_result_locals 5925 pop_rbx # _return_result_locals 5926 ret 5927 jmp %_END_IF_int2str_5 5928 :ELSE_int2str_5 5929 :_END_IF_int2str_5 5930 lea_rax,[rbp+DWORD] %-56 5931 push_rax #_common_recursion 5932 mov_rax, %1 5933 pop_rbx # _common_recursion 5934 mov_[rbx],rax 5935 jmp %_END_IF_int2str_4 5936 :ELSE_int2str_4 5937 lea_rax,[rbp+DWORD] %-48 5938 push_rax #_common_recursion 5939 lea_rax,[rbp+DWORD] %-8 5940 mov_rax,[rax] 5941 push_rax #_common_recursion 5942 mov_rax, %0x7FFFFFFF 5943 push_rax #_common_recursion 5944 mov_rax, %1 5945 push_rax #_common_recursion 5946 mov_rax, %31 5947 pop_rbx # _common_recursion 5948 mov_rcx,rax 5949 mov_rax,rbx 5950 sal_rax,cl 5951 pop_rbx # _common_recursion 5952 or_rax,rbx 5953 pop_rbx # _common_recursion 5954 and_rax,rbx 5955 pop_rbx # _common_recursion 5956 mov_[rbx],rax 5957 :_END_IF_int2str_4 5958 :DO_int2str_7 5959 lea_rax,[rbp+DWORD] %-40 5960 mov_rax,[rax] 5961 push_rax #_common_recursion 5962 mov_rax, %0 5963 pop_rbx # _common_recursion 5964 add_rax,rbx 5965 push_rax #_common_recursion 5966 lea_rax,[rbp+DWORD] %-64 5967 mov_rax,[rax] 5968 push_rax #_common_recursion 5969 lea_rax,[rbp+DWORD] %-48 5970 mov_rax,[rax] 5971 push_rax #_common_recursion 5972 lea_rax,[rbp+DWORD] %-16 5973 mov_rax,[rax] 5974 pop_rbx # _common_recursion 5975 xchg_rbx,rax 5976 mov_rdx, %0 5977 div_rbx 5978 mov_rax,rdx 5979 pop_rbx # _common_recursion 5980 add_rax,rbx 5981 movsx_rax,BYTE_PTR_[rax] 5982 pop_rbx # _common_recursion 5983 mov_[rbx],al 5984 lea_rax,[rbp+DWORD] %-40 5985 push_rax #_common_recursion 5986 lea_rax,[rbp+DWORD] %-40 5987 mov_rax,[rax] 5988 push_rax #_common_recursion 5989 mov_rax, %1 5990 pop_rbx # _common_recursion 5991 sub_rbx,rax 5992 mov_rax,rbx 5993 pop_rbx # _common_recursion 5994 mov_[rbx],rax 5995 lea_rax,[rbp+DWORD] %-48 5996 push_rax #_common_recursion 5997 lea_rax,[rbp+DWORD] %-48 5998 mov_rax,[rax] 5999 push_rax #_common_recursion 6000 lea_rax,[rbp+DWORD] %-16 6001 mov_rax,[rax] 6002 pop_rbx # _common_recursion 6003 xchg_rbx,rax 6004 mov_rdx, %0 6005 div_rbx 6006 pop_rbx # _common_recursion 6007 mov_[rbx],rax 6008 :DO_TEST_int2str_7 6009 mov_rax, %0 6010 push_rax #_common_recursion 6011 lea_rax,[rbp+DWORD] %-48 6012 mov_rax,[rax] 6013 pop_rbx # _common_recursion 6014 cmp_rbx,rax 6015 setb_al 6016 movzx_rax,al 6017 test_rax,rax 6018 jne %DO_int2str_7 6019 :DO_END_int2str_7 6020 # IF_int2str_8 6021 lea_rax,[rbp+DWORD] %-56 6022 mov_rax,[rax] 6023 test_rax,rax 6024 je %ELSE_int2str_8 6025 lea_rax,[rbp+DWORD] %-40 6026 mov_rax,[rax] 6027 push_rax #_common_recursion 6028 mov_rax, %0 6029 pop_rbx # _common_recursion 6030 add_rax,rbx 6031 push_rax #_common_recursion 6032 mov_rax, %45 6033 pop_rbx # _common_recursion 6034 mov_[rbx],al 6035 lea_rax,[rbp+DWORD] %-40 6036 push_rax #_common_recursion 6037 lea_rax,[rbp+DWORD] %-40 6038 mov_rax,[rax] 6039 push_rax #_common_recursion 6040 mov_rax, %1 6041 pop_rbx # _common_recursion 6042 sub_rbx,rax 6043 mov_rax,rbx 6044 pop_rbx # _common_recursion 6045 mov_[rbx],rax 6046 jmp %_END_IF_int2str_8 6047 :ELSE_int2str_8 6048 :_END_IF_int2str_8 6049 lea_rax,[rbp+DWORD] %-40 6050 mov_rax,[rax] 6051 push_rax #_common_recursion 6052 mov_rax, %1 6053 pop_rbx # _common_recursion 6054 add_rax,rbx 6055 pop_rbx # _return_result_locals 6056 pop_rbx # _return_result_locals 6057 pop_rbx # _return_result_locals 6058 pop_rbx # _return_result_locals 6059 ret 6060 # Defining function init_k 6061 :FUNCTION_init_k 6062 # Defining local k 6063 push_rdi # Prevent overwriting in recursion 6064 push_rbp # Protect the old base pointer 6065 mov_rdi,rsp # Copy new base pointer 6066 mov_rax, %65 6067 push_rax #_process_expression1 6068 mov_rax, %8 6069 push_rax #_process_expression2 6070 mov_rbp,rdi 6071 call %FUNCTION_calloc 6072 pop_rbx # _process_expression_locals 6073 pop_rbx # _process_expression_locals 6074 pop_rbp # Restore old base pointer 6075 pop_rdi # Prevent overwrite 6076 push_rax #k 6077 lea_rax,[rbp+DWORD] %-16 6078 mov_rax,[rax] 6079 push_rax #_common_recursion 6080 mov_rax, %0 6081 pop_rbx # _common_recursion 6082 push_rbx 6083 mov_rbx, %8 6084 mul_rbx 6085 pop_rbx 6086 add_rax,rbx 6087 push_rax #_common_recursion 6088 mov_rax, %0x428a2f98 6089 pop_rbx # _common_recursion 6090 mov_[rbx],rax 6091 lea_rax,[rbp+DWORD] %-16 6092 mov_rax,[rax] 6093 push_rax #_common_recursion 6094 mov_rax, %1 6095 pop_rbx # _common_recursion 6096 push_rbx 6097 mov_rbx, %8 6098 mul_rbx 6099 pop_rbx 6100 add_rax,rbx 6101 push_rax #_common_recursion 6102 mov_rax, %0x71374491 6103 pop_rbx # _common_recursion 6104 mov_[rbx],rax 6105 lea_rax,[rbp+DWORD] %-16 6106 mov_rax,[rax] 6107 push_rax #_common_recursion 6108 mov_rax, %2 6109 pop_rbx # _common_recursion 6110 push_rbx 6111 mov_rbx, %8 6112 mul_rbx 6113 pop_rbx 6114 add_rax,rbx 6115 push_rax #_common_recursion 6116 mov_rax, %0xb5c0fbcf 6117 pop_rbx # _common_recursion 6118 mov_[rbx],rax 6119 lea_rax,[rbp+DWORD] %-16 6120 mov_rax,[rax] 6121 push_rax #_common_recursion 6122 mov_rax, %3 6123 pop_rbx # _common_recursion 6124 push_rbx 6125 mov_rbx, %8 6126 mul_rbx 6127 pop_rbx 6128 add_rax,rbx 6129 push_rax #_common_recursion 6130 mov_rax, %0xe9b5dba5 6131 pop_rbx # _common_recursion 6132 mov_[rbx],rax 6133 lea_rax,[rbp+DWORD] %-16 6134 mov_rax,[rax] 6135 push_rax #_common_recursion 6136 mov_rax, %4 6137 pop_rbx # _common_recursion 6138 push_rbx 6139 mov_rbx, %8 6140 mul_rbx 6141 pop_rbx 6142 add_rax,rbx 6143 push_rax #_common_recursion 6144 mov_rax, %0x3956c25b 6145 pop_rbx # _common_recursion 6146 mov_[rbx],rax 6147 lea_rax,[rbp+DWORD] %-16 6148 mov_rax,[rax] 6149 push_rax #_common_recursion 6150 mov_rax, %5 6151 pop_rbx # _common_recursion 6152 push_rbx 6153 mov_rbx, %8 6154 mul_rbx 6155 pop_rbx 6156 add_rax,rbx 6157 push_rax #_common_recursion 6158 mov_rax, %0x59f111f1 6159 pop_rbx # _common_recursion 6160 mov_[rbx],rax 6161 lea_rax,[rbp+DWORD] %-16 6162 mov_rax,[rax] 6163 push_rax #_common_recursion 6164 mov_rax, %6 6165 pop_rbx # _common_recursion 6166 push_rbx 6167 mov_rbx, %8 6168 mul_rbx 6169 pop_rbx 6170 add_rax,rbx 6171 push_rax #_common_recursion 6172 mov_rax, %0x923f82a4 6173 pop_rbx # _common_recursion 6174 mov_[rbx],rax 6175 lea_rax,[rbp+DWORD] %-16 6176 mov_rax,[rax] 6177 push_rax #_common_recursion 6178 mov_rax, %7 6179 pop_rbx # _common_recursion 6180 push_rbx 6181 mov_rbx, %8 6182 mul_rbx 6183 pop_rbx 6184 add_rax,rbx 6185 push_rax #_common_recursion 6186 mov_rax, %0xab1c5ed5 6187 pop_rbx # _common_recursion 6188 mov_[rbx],rax 6189 lea_rax,[rbp+DWORD] %-16 6190 mov_rax,[rax] 6191 push_rax #_common_recursion 6192 mov_rax, %8 6193 pop_rbx # _common_recursion 6194 push_rbx 6195 mov_rbx, %8 6196 mul_rbx 6197 pop_rbx 6198 add_rax,rbx 6199 push_rax #_common_recursion 6200 mov_rax, %0xd807aa98 6201 pop_rbx # _common_recursion 6202 mov_[rbx],rax 6203 lea_rax,[rbp+DWORD] %-16 6204 mov_rax,[rax] 6205 push_rax #_common_recursion 6206 mov_rax, %9 6207 pop_rbx # _common_recursion 6208 push_rbx 6209 mov_rbx, %8 6210 mul_rbx 6211 pop_rbx 6212 add_rax,rbx 6213 push_rax #_common_recursion 6214 mov_rax, %0x12835b01 6215 pop_rbx # _common_recursion 6216 mov_[rbx],rax 6217 lea_rax,[rbp+DWORD] %-16 6218 mov_rax,[rax] 6219 push_rax #_common_recursion 6220 mov_rax, %10 6221 pop_rbx # _common_recursion 6222 push_rbx 6223 mov_rbx, %8 6224 mul_rbx 6225 pop_rbx 6226 add_rax,rbx 6227 push_rax #_common_recursion 6228 mov_rax, %0x243185be 6229 pop_rbx # _common_recursion 6230 mov_[rbx],rax 6231 lea_rax,[rbp+DWORD] %-16 6232 mov_rax,[rax] 6233 push_rax #_common_recursion 6234 mov_rax, %11 6235 pop_rbx # _common_recursion 6236 push_rbx 6237 mov_rbx, %8 6238 mul_rbx 6239 pop_rbx 6240 add_rax,rbx 6241 push_rax #_common_recursion 6242 mov_rax, %0x550c7dc3 6243 pop_rbx # _common_recursion 6244 mov_[rbx],rax 6245 lea_rax,[rbp+DWORD] %-16 6246 mov_rax,[rax] 6247 push_rax #_common_recursion 6248 mov_rax, %12 6249 pop_rbx # _common_recursion 6250 push_rbx 6251 mov_rbx, %8 6252 mul_rbx 6253 pop_rbx 6254 add_rax,rbx 6255 push_rax #_common_recursion 6256 mov_rax, %0x72be5d74 6257 pop_rbx # _common_recursion 6258 mov_[rbx],rax 6259 lea_rax,[rbp+DWORD] %-16 6260 mov_rax,[rax] 6261 push_rax #_common_recursion 6262 mov_rax, %13 6263 pop_rbx # _common_recursion 6264 push_rbx 6265 mov_rbx, %8 6266 mul_rbx 6267 pop_rbx 6268 add_rax,rbx 6269 push_rax #_common_recursion 6270 mov_rax, %0x80deb1fe 6271 pop_rbx # _common_recursion 6272 mov_[rbx],rax 6273 lea_rax,[rbp+DWORD] %-16 6274 mov_rax,[rax] 6275 push_rax #_common_recursion 6276 mov_rax, %14 6277 pop_rbx # _common_recursion 6278 push_rbx 6279 mov_rbx, %8 6280 mul_rbx 6281 pop_rbx 6282 add_rax,rbx 6283 push_rax #_common_recursion 6284 mov_rax, %0x9bdc06a7 6285 pop_rbx # _common_recursion 6286 mov_[rbx],rax 6287 lea_rax,[rbp+DWORD] %-16 6288 mov_rax,[rax] 6289 push_rax #_common_recursion 6290 mov_rax, %15 6291 pop_rbx # _common_recursion 6292 push_rbx 6293 mov_rbx, %8 6294 mul_rbx 6295 pop_rbx 6296 add_rax,rbx 6297 push_rax #_common_recursion 6298 mov_rax, %0xc19bf174 6299 pop_rbx # _common_recursion 6300 mov_[rbx],rax 6301 lea_rax,[rbp+DWORD] %-16 6302 mov_rax,[rax] 6303 push_rax #_common_recursion 6304 mov_rax, %16 6305 pop_rbx # _common_recursion 6306 push_rbx 6307 mov_rbx, %8 6308 mul_rbx 6309 pop_rbx 6310 add_rax,rbx 6311 push_rax #_common_recursion 6312 mov_rax, %0xe49b69c1 6313 pop_rbx # _common_recursion 6314 mov_[rbx],rax 6315 lea_rax,[rbp+DWORD] %-16 6316 mov_rax,[rax] 6317 push_rax #_common_recursion 6318 mov_rax, %17 6319 pop_rbx # _common_recursion 6320 push_rbx 6321 mov_rbx, %8 6322 mul_rbx 6323 pop_rbx 6324 add_rax,rbx 6325 push_rax #_common_recursion 6326 mov_rax, %0xefbe4786 6327 pop_rbx # _common_recursion 6328 mov_[rbx],rax 6329 lea_rax,[rbp+DWORD] %-16 6330 mov_rax,[rax] 6331 push_rax #_common_recursion 6332 mov_rax, %18 6333 pop_rbx # _common_recursion 6334 push_rbx 6335 mov_rbx, %8 6336 mul_rbx 6337 pop_rbx 6338 add_rax,rbx 6339 push_rax #_common_recursion 6340 mov_rax, %0x0fc19dc6 6341 pop_rbx # _common_recursion 6342 mov_[rbx],rax 6343 lea_rax,[rbp+DWORD] %-16 6344 mov_rax,[rax] 6345 push_rax #_common_recursion 6346 mov_rax, %19 6347 pop_rbx # _common_recursion 6348 push_rbx 6349 mov_rbx, %8 6350 mul_rbx 6351 pop_rbx 6352 add_rax,rbx 6353 push_rax #_common_recursion 6354 mov_rax, %0x240ca1cc 6355 pop_rbx # _common_recursion 6356 mov_[rbx],rax 6357 lea_rax,[rbp+DWORD] %-16 6358 mov_rax,[rax] 6359 push_rax #_common_recursion 6360 mov_rax, %20 6361 pop_rbx # _common_recursion 6362 push_rbx 6363 mov_rbx, %8 6364 mul_rbx 6365 pop_rbx 6366 add_rax,rbx 6367 push_rax #_common_recursion 6368 mov_rax, %0x2de92c6f 6369 pop_rbx # _common_recursion 6370 mov_[rbx],rax 6371 lea_rax,[rbp+DWORD] %-16 6372 mov_rax,[rax] 6373 push_rax #_common_recursion 6374 mov_rax, %21 6375 pop_rbx # _common_recursion 6376 push_rbx 6377 mov_rbx, %8 6378 mul_rbx 6379 pop_rbx 6380 add_rax,rbx 6381 push_rax #_common_recursion 6382 mov_rax, %0x4a7484aa 6383 pop_rbx # _common_recursion 6384 mov_[rbx],rax 6385 lea_rax,[rbp+DWORD] %-16 6386 mov_rax,[rax] 6387 push_rax #_common_recursion 6388 mov_rax, %22 6389 pop_rbx # _common_recursion 6390 push_rbx 6391 mov_rbx, %8 6392 mul_rbx 6393 pop_rbx 6394 add_rax,rbx 6395 push_rax #_common_recursion 6396 mov_rax, %0x5cb0a9dc 6397 pop_rbx # _common_recursion 6398 mov_[rbx],rax 6399 lea_rax,[rbp+DWORD] %-16 6400 mov_rax,[rax] 6401 push_rax #_common_recursion 6402 mov_rax, %23 6403 pop_rbx # _common_recursion 6404 push_rbx 6405 mov_rbx, %8 6406 mul_rbx 6407 pop_rbx 6408 add_rax,rbx 6409 push_rax #_common_recursion 6410 mov_rax, %0x76f988da 6411 pop_rbx # _common_recursion 6412 mov_[rbx],rax 6413 lea_rax,[rbp+DWORD] %-16 6414 mov_rax,[rax] 6415 push_rax #_common_recursion 6416 mov_rax, %24 6417 pop_rbx # _common_recursion 6418 push_rbx 6419 mov_rbx, %8 6420 mul_rbx 6421 pop_rbx 6422 add_rax,rbx 6423 push_rax #_common_recursion 6424 mov_rax, %0x983e5152 6425 pop_rbx # _common_recursion 6426 mov_[rbx],rax 6427 lea_rax,[rbp+DWORD] %-16 6428 mov_rax,[rax] 6429 push_rax #_common_recursion 6430 mov_rax, %25 6431 pop_rbx # _common_recursion 6432 push_rbx 6433 mov_rbx, %8 6434 mul_rbx 6435 pop_rbx 6436 add_rax,rbx 6437 push_rax #_common_recursion 6438 mov_rax, %0xa831c66d 6439 pop_rbx # _common_recursion 6440 mov_[rbx],rax 6441 lea_rax,[rbp+DWORD] %-16 6442 mov_rax,[rax] 6443 push_rax #_common_recursion 6444 mov_rax, %26 6445 pop_rbx # _common_recursion 6446 push_rbx 6447 mov_rbx, %8 6448 mul_rbx 6449 pop_rbx 6450 add_rax,rbx 6451 push_rax #_common_recursion 6452 mov_rax, %0xb00327c8 6453 pop_rbx # _common_recursion 6454 mov_[rbx],rax 6455 lea_rax,[rbp+DWORD] %-16 6456 mov_rax,[rax] 6457 push_rax #_common_recursion 6458 mov_rax, %27 6459 pop_rbx # _common_recursion 6460 push_rbx 6461 mov_rbx, %8 6462 mul_rbx 6463 pop_rbx 6464 add_rax,rbx 6465 push_rax #_common_recursion 6466 mov_rax, %0xbf597fc7 6467 pop_rbx # _common_recursion 6468 mov_[rbx],rax 6469 lea_rax,[rbp+DWORD] %-16 6470 mov_rax,[rax] 6471 push_rax #_common_recursion 6472 mov_rax, %28 6473 pop_rbx # _common_recursion 6474 push_rbx 6475 mov_rbx, %8 6476 mul_rbx 6477 pop_rbx 6478 add_rax,rbx 6479 push_rax #_common_recursion 6480 mov_rax, %0xc6e00bf3 6481 pop_rbx # _common_recursion 6482 mov_[rbx],rax 6483 lea_rax,[rbp+DWORD] %-16 6484 mov_rax,[rax] 6485 push_rax #_common_recursion 6486 mov_rax, %29 6487 pop_rbx # _common_recursion 6488 push_rbx 6489 mov_rbx, %8 6490 mul_rbx 6491 pop_rbx 6492 add_rax,rbx 6493 push_rax #_common_recursion 6494 mov_rax, %0xd5a79147 6495 pop_rbx # _common_recursion 6496 mov_[rbx],rax 6497 lea_rax,[rbp+DWORD] %-16 6498 mov_rax,[rax] 6499 push_rax #_common_recursion 6500 mov_rax, %30 6501 pop_rbx # _common_recursion 6502 push_rbx 6503 mov_rbx, %8 6504 mul_rbx 6505 pop_rbx 6506 add_rax,rbx 6507 push_rax #_common_recursion 6508 mov_rax, %0x06ca6351 6509 pop_rbx # _common_recursion 6510 mov_[rbx],rax 6511 lea_rax,[rbp+DWORD] %-16 6512 mov_rax,[rax] 6513 push_rax #_common_recursion 6514 mov_rax, %31 6515 pop_rbx # _common_recursion 6516 push_rbx 6517 mov_rbx, %8 6518 mul_rbx 6519 pop_rbx 6520 add_rax,rbx 6521 push_rax #_common_recursion 6522 mov_rax, %0x14292967 6523 pop_rbx # _common_recursion 6524 mov_[rbx],rax 6525 lea_rax,[rbp+DWORD] %-16 6526 mov_rax,[rax] 6527 push_rax #_common_recursion 6528 mov_rax, %32 6529 pop_rbx # _common_recursion 6530 push_rbx 6531 mov_rbx, %8 6532 mul_rbx 6533 pop_rbx 6534 add_rax,rbx 6535 push_rax #_common_recursion 6536 mov_rax, %0x27b70a85 6537 pop_rbx # _common_recursion 6538 mov_[rbx],rax 6539 lea_rax,[rbp+DWORD] %-16 6540 mov_rax,[rax] 6541 push_rax #_common_recursion 6542 mov_rax, %33 6543 pop_rbx # _common_recursion 6544 push_rbx 6545 mov_rbx, %8 6546 mul_rbx 6547 pop_rbx 6548 add_rax,rbx 6549 push_rax #_common_recursion 6550 mov_rax, %0x2e1b2138 6551 pop_rbx # _common_recursion 6552 mov_[rbx],rax 6553 lea_rax,[rbp+DWORD] %-16 6554 mov_rax,[rax] 6555 push_rax #_common_recursion 6556 mov_rax, %34 6557 pop_rbx # _common_recursion 6558 push_rbx 6559 mov_rbx, %8 6560 mul_rbx 6561 pop_rbx 6562 add_rax,rbx 6563 push_rax #_common_recursion 6564 mov_rax, %0x4d2c6dfc 6565 pop_rbx # _common_recursion 6566 mov_[rbx],rax 6567 lea_rax,[rbp+DWORD] %-16 6568 mov_rax,[rax] 6569 push_rax #_common_recursion 6570 mov_rax, %35 6571 pop_rbx # _common_recursion 6572 push_rbx 6573 mov_rbx, %8 6574 mul_rbx 6575 pop_rbx 6576 add_rax,rbx 6577 push_rax #_common_recursion 6578 mov_rax, %0x53380d13 6579 pop_rbx # _common_recursion 6580 mov_[rbx],rax 6581 lea_rax,[rbp+DWORD] %-16 6582 mov_rax,[rax] 6583 push_rax #_common_recursion 6584 mov_rax, %36 6585 pop_rbx # _common_recursion 6586 push_rbx 6587 mov_rbx, %8 6588 mul_rbx 6589 pop_rbx 6590 add_rax,rbx 6591 push_rax #_common_recursion 6592 mov_rax, %0x650a7354 6593 pop_rbx # _common_recursion 6594 mov_[rbx],rax 6595 lea_rax,[rbp+DWORD] %-16 6596 mov_rax,[rax] 6597 push_rax #_common_recursion 6598 mov_rax, %37 6599 pop_rbx # _common_recursion 6600 push_rbx 6601 mov_rbx, %8 6602 mul_rbx 6603 pop_rbx 6604 add_rax,rbx 6605 push_rax #_common_recursion 6606 mov_rax, %0x766a0abb 6607 pop_rbx # _common_recursion 6608 mov_[rbx],rax 6609 lea_rax,[rbp+DWORD] %-16 6610 mov_rax,[rax] 6611 push_rax #_common_recursion 6612 mov_rax, %38 6613 pop_rbx # _common_recursion 6614 push_rbx 6615 mov_rbx, %8 6616 mul_rbx 6617 pop_rbx 6618 add_rax,rbx 6619 push_rax #_common_recursion 6620 mov_rax, %0x81c2c92e 6621 pop_rbx # _common_recursion 6622 mov_[rbx],rax 6623 lea_rax,[rbp+DWORD] %-16 6624 mov_rax,[rax] 6625 push_rax #_common_recursion 6626 mov_rax, %39 6627 pop_rbx # _common_recursion 6628 push_rbx 6629 mov_rbx, %8 6630 mul_rbx 6631 pop_rbx 6632 add_rax,rbx 6633 push_rax #_common_recursion 6634 mov_rax, %0x92722c85 6635 pop_rbx # _common_recursion 6636 mov_[rbx],rax 6637 lea_rax,[rbp+DWORD] %-16 6638 mov_rax,[rax] 6639 push_rax #_common_recursion 6640 mov_rax, %40 6641 pop_rbx # _common_recursion 6642 push_rbx 6643 mov_rbx, %8 6644 mul_rbx 6645 pop_rbx 6646 add_rax,rbx 6647 push_rax #_common_recursion 6648 mov_rax, %0xa2bfe8a1 6649 pop_rbx # _common_recursion 6650 mov_[rbx],rax 6651 lea_rax,[rbp+DWORD] %-16 6652 mov_rax,[rax] 6653 push_rax #_common_recursion 6654 mov_rax, %41 6655 pop_rbx # _common_recursion 6656 push_rbx 6657 mov_rbx, %8 6658 mul_rbx 6659 pop_rbx 6660 add_rax,rbx 6661 push_rax #_common_recursion 6662 mov_rax, %0xa81a664b 6663 pop_rbx # _common_recursion 6664 mov_[rbx],rax 6665 lea_rax,[rbp+DWORD] %-16 6666 mov_rax,[rax] 6667 push_rax #_common_recursion 6668 mov_rax, %42 6669 pop_rbx # _common_recursion 6670 push_rbx 6671 mov_rbx, %8 6672 mul_rbx 6673 pop_rbx 6674 add_rax,rbx 6675 push_rax #_common_recursion 6676 mov_rax, %0xc24b8b70 6677 pop_rbx # _common_recursion 6678 mov_[rbx],rax 6679 lea_rax,[rbp+DWORD] %-16 6680 mov_rax,[rax] 6681 push_rax #_common_recursion 6682 mov_rax, %43 6683 pop_rbx # _common_recursion 6684 push_rbx 6685 mov_rbx, %8 6686 mul_rbx 6687 pop_rbx 6688 add_rax,rbx 6689 push_rax #_common_recursion 6690 mov_rax, %0xc76c51a3 6691 pop_rbx # _common_recursion 6692 mov_[rbx],rax 6693 lea_rax,[rbp+DWORD] %-16 6694 mov_rax,[rax] 6695 push_rax #_common_recursion 6696 mov_rax, %44 6697 pop_rbx # _common_recursion 6698 push_rbx 6699 mov_rbx, %8 6700 mul_rbx 6701 pop_rbx 6702 add_rax,rbx 6703 push_rax #_common_recursion 6704 mov_rax, %0xd192e819 6705 pop_rbx # _common_recursion 6706 mov_[rbx],rax 6707 lea_rax,[rbp+DWORD] %-16 6708 mov_rax,[rax] 6709 push_rax #_common_recursion 6710 mov_rax, %45 6711 pop_rbx # _common_recursion 6712 push_rbx 6713 mov_rbx, %8 6714 mul_rbx 6715 pop_rbx 6716 add_rax,rbx 6717 push_rax #_common_recursion 6718 mov_rax, %0xd6990624 6719 pop_rbx # _common_recursion 6720 mov_[rbx],rax 6721 lea_rax,[rbp+DWORD] %-16 6722 mov_rax,[rax] 6723 push_rax #_common_recursion 6724 mov_rax, %46 6725 pop_rbx # _common_recursion 6726 push_rbx 6727 mov_rbx, %8 6728 mul_rbx 6729 pop_rbx 6730 add_rax,rbx 6731 push_rax #_common_recursion 6732 mov_rax, %0xf40e3585 6733 pop_rbx # _common_recursion 6734 mov_[rbx],rax 6735 lea_rax,[rbp+DWORD] %-16 6736 mov_rax,[rax] 6737 push_rax #_common_recursion 6738 mov_rax, %47 6739 pop_rbx # _common_recursion 6740 push_rbx 6741 mov_rbx, %8 6742 mul_rbx 6743 pop_rbx 6744 add_rax,rbx 6745 push_rax #_common_recursion 6746 mov_rax, %0x106aa070 6747 pop_rbx # _common_recursion 6748 mov_[rbx],rax 6749 lea_rax,[rbp+DWORD] %-16 6750 mov_rax,[rax] 6751 push_rax #_common_recursion 6752 mov_rax, %48 6753 pop_rbx # _common_recursion 6754 push_rbx 6755 mov_rbx, %8 6756 mul_rbx 6757 pop_rbx 6758 add_rax,rbx 6759 push_rax #_common_recursion 6760 mov_rax, %0x19a4c116 6761 pop_rbx # _common_recursion 6762 mov_[rbx],rax 6763 lea_rax,[rbp+DWORD] %-16 6764 mov_rax,[rax] 6765 push_rax #_common_recursion 6766 mov_rax, %49 6767 pop_rbx # _common_recursion 6768 push_rbx 6769 mov_rbx, %8 6770 mul_rbx 6771 pop_rbx 6772 add_rax,rbx 6773 push_rax #_common_recursion 6774 mov_rax, %0x1e376c08 6775 pop_rbx # _common_recursion 6776 mov_[rbx],rax 6777 lea_rax,[rbp+DWORD] %-16 6778 mov_rax,[rax] 6779 push_rax #_common_recursion 6780 mov_rax, %50 6781 pop_rbx # _common_recursion 6782 push_rbx 6783 mov_rbx, %8 6784 mul_rbx 6785 pop_rbx 6786 add_rax,rbx 6787 push_rax #_common_recursion 6788 mov_rax, %0x2748774c 6789 pop_rbx # _common_recursion 6790 mov_[rbx],rax 6791 lea_rax,[rbp+DWORD] %-16 6792 mov_rax,[rax] 6793 push_rax #_common_recursion 6794 mov_rax, %51 6795 pop_rbx # _common_recursion 6796 push_rbx 6797 mov_rbx, %8 6798 mul_rbx 6799 pop_rbx 6800 add_rax,rbx 6801 push_rax #_common_recursion 6802 mov_rax, %0x34b0bcb5 6803 pop_rbx # _common_recursion 6804 mov_[rbx],rax 6805 lea_rax,[rbp+DWORD] %-16 6806 mov_rax,[rax] 6807 push_rax #_common_recursion 6808 mov_rax, %52 6809 pop_rbx # _common_recursion 6810 push_rbx 6811 mov_rbx, %8 6812 mul_rbx 6813 pop_rbx 6814 add_rax,rbx 6815 push_rax #_common_recursion 6816 mov_rax, %0x391c0cb3 6817 pop_rbx # _common_recursion 6818 mov_[rbx],rax 6819 lea_rax,[rbp+DWORD] %-16 6820 mov_rax,[rax] 6821 push_rax #_common_recursion 6822 mov_rax, %53 6823 pop_rbx # _common_recursion 6824 push_rbx 6825 mov_rbx, %8 6826 mul_rbx 6827 pop_rbx 6828 add_rax,rbx 6829 push_rax #_common_recursion 6830 mov_rax, %0x4ed8aa4a 6831 pop_rbx # _common_recursion 6832 mov_[rbx],rax 6833 lea_rax,[rbp+DWORD] %-16 6834 mov_rax,[rax] 6835 push_rax #_common_recursion 6836 mov_rax, %54 6837 pop_rbx # _common_recursion 6838 push_rbx 6839 mov_rbx, %8 6840 mul_rbx 6841 pop_rbx 6842 add_rax,rbx 6843 push_rax #_common_recursion 6844 mov_rax, %0x5b9cca4f 6845 pop_rbx # _common_recursion 6846 mov_[rbx],rax 6847 lea_rax,[rbp+DWORD] %-16 6848 mov_rax,[rax] 6849 push_rax #_common_recursion 6850 mov_rax, %55 6851 pop_rbx # _common_recursion 6852 push_rbx 6853 mov_rbx, %8 6854 mul_rbx 6855 pop_rbx 6856 add_rax,rbx 6857 push_rax #_common_recursion 6858 mov_rax, %0x682e6ff3 6859 pop_rbx # _common_recursion 6860 mov_[rbx],rax 6861 lea_rax,[rbp+DWORD] %-16 6862 mov_rax,[rax] 6863 push_rax #_common_recursion 6864 mov_rax, %56 6865 pop_rbx # _common_recursion 6866 push_rbx 6867 mov_rbx, %8 6868 mul_rbx 6869 pop_rbx 6870 add_rax,rbx 6871 push_rax #_common_recursion 6872 mov_rax, %0x748f82ee 6873 pop_rbx # _common_recursion 6874 mov_[rbx],rax 6875 lea_rax,[rbp+DWORD] %-16 6876 mov_rax,[rax] 6877 push_rax #_common_recursion 6878 mov_rax, %57 6879 pop_rbx # _common_recursion 6880 push_rbx 6881 mov_rbx, %8 6882 mul_rbx 6883 pop_rbx 6884 add_rax,rbx 6885 push_rax #_common_recursion 6886 mov_rax, %0x78a5636f 6887 pop_rbx # _common_recursion 6888 mov_[rbx],rax 6889 lea_rax,[rbp+DWORD] %-16 6890 mov_rax,[rax] 6891 push_rax #_common_recursion 6892 mov_rax, %58 6893 pop_rbx # _common_recursion 6894 push_rbx 6895 mov_rbx, %8 6896 mul_rbx 6897 pop_rbx 6898 add_rax,rbx 6899 push_rax #_common_recursion 6900 mov_rax, %0x84c87814 6901 pop_rbx # _common_recursion 6902 mov_[rbx],rax 6903 lea_rax,[rbp+DWORD] %-16 6904 mov_rax,[rax] 6905 push_rax #_common_recursion 6906 mov_rax, %59 6907 pop_rbx # _common_recursion 6908 push_rbx 6909 mov_rbx, %8 6910 mul_rbx 6911 pop_rbx 6912 add_rax,rbx 6913 push_rax #_common_recursion 6914 mov_rax, %0x8cc70208 6915 pop_rbx # _common_recursion 6916 mov_[rbx],rax 6917 lea_rax,[rbp+DWORD] %-16 6918 mov_rax,[rax] 6919 push_rax #_common_recursion 6920 mov_rax, %60 6921 pop_rbx # _common_recursion 6922 push_rbx 6923 mov_rbx, %8 6924 mul_rbx 6925 pop_rbx 6926 add_rax,rbx 6927 push_rax #_common_recursion 6928 mov_rax, %0x90befffa 6929 pop_rbx # _common_recursion 6930 mov_[rbx],rax 6931 lea_rax,[rbp+DWORD] %-16 6932 mov_rax,[rax] 6933 push_rax #_common_recursion 6934 mov_rax, %61 6935 pop_rbx # _common_recursion 6936 push_rbx 6937 mov_rbx, %8 6938 mul_rbx 6939 pop_rbx 6940 add_rax,rbx 6941 push_rax #_common_recursion 6942 mov_rax, %0xa4506ceb 6943 pop_rbx # _common_recursion 6944 mov_[rbx],rax 6945 lea_rax,[rbp+DWORD] %-16 6946 mov_rax,[rax] 6947 push_rax #_common_recursion 6948 mov_rax, %62 6949 pop_rbx # _common_recursion 6950 push_rbx 6951 mov_rbx, %8 6952 mul_rbx 6953 pop_rbx 6954 add_rax,rbx 6955 push_rax #_common_recursion 6956 mov_rax, %0xbef9a3f7 6957 pop_rbx # _common_recursion 6958 mov_[rbx],rax 6959 lea_rax,[rbp+DWORD] %-16 6960 mov_rax,[rax] 6961 push_rax #_common_recursion 6962 mov_rax, %63 6963 pop_rbx # _common_recursion 6964 push_rbx 6965 mov_rbx, %8 6966 mul_rbx 6967 pop_rbx 6968 add_rax,rbx 6969 push_rax #_common_recursion 6970 mov_rax, %0xc67178f2 6971 pop_rbx # _common_recursion 6972 mov_[rbx],rax 6973 lea_rax,[rbp+DWORD] %-16 6974 mov_rax,[rax] 6975 pop_rbx # _return_result_locals 6976 ret 6977 # Defining function init_h 6978 :FUNCTION_init_h 6979 # Defining local h 6980 push_rdi # Prevent overwriting in recursion 6981 push_rbp # Protect the old base pointer 6982 mov_rdi,rsp # Copy new base pointer 6983 mov_rax, %9 6984 push_rax #_process_expression1 6985 mov_rax, %8 6986 push_rax #_process_expression2 6987 mov_rbp,rdi 6988 call %FUNCTION_calloc 6989 pop_rbx # _process_expression_locals 6990 pop_rbx # _process_expression_locals 6991 pop_rbp # Restore old base pointer 6992 pop_rdi # Prevent overwrite 6993 push_rax #h 6994 lea_rax,[rbp+DWORD] %-16 6995 mov_rax,[rax] 6996 push_rax #_common_recursion 6997 mov_rax, %0 6998 pop_rbx # _common_recursion 6999 push_rbx 7000 mov_rbx, %8 7001 mul_rbx 7002 pop_rbx 7003 add_rax,rbx 7004 push_rax #_common_recursion 7005 mov_rax, %0x6a09e667 7006 pop_rbx # _common_recursion 7007 mov_[rbx],rax 7008 lea_rax,[rbp+DWORD] %-16 7009 mov_rax,[rax] 7010 push_rax #_common_recursion 7011 mov_rax, %1 7012 pop_rbx # _common_recursion 7013 push_rbx 7014 mov_rbx, %8 7015 mul_rbx 7016 pop_rbx 7017 add_rax,rbx 7018 push_rax #_common_recursion 7019 mov_rax, %0xbb67ae85 7020 pop_rbx # _common_recursion 7021 mov_[rbx],rax 7022 lea_rax,[rbp+DWORD] %-16 7023 mov_rax,[rax] 7024 push_rax #_common_recursion 7025 mov_rax, %2 7026 pop_rbx # _common_recursion 7027 push_rbx 7028 mov_rbx, %8 7029 mul_rbx 7030 pop_rbx 7031 add_rax,rbx 7032 push_rax #_common_recursion 7033 mov_rax, %0x3c6ef372 7034 pop_rbx # _common_recursion 7035 mov_[rbx],rax 7036 lea_rax,[rbp+DWORD] %-16 7037 mov_rax,[rax] 7038 push_rax #_common_recursion 7039 mov_rax, %3 7040 pop_rbx # _common_recursion 7041 push_rbx 7042 mov_rbx, %8 7043 mul_rbx 7044 pop_rbx 7045 add_rax,rbx 7046 push_rax #_common_recursion 7047 mov_rax, %0xa54ff53a 7048 pop_rbx # _common_recursion 7049 mov_[rbx],rax 7050 lea_rax,[rbp+DWORD] %-16 7051 mov_rax,[rax] 7052 push_rax #_common_recursion 7053 mov_rax, %4 7054 pop_rbx # _common_recursion 7055 push_rbx 7056 mov_rbx, %8 7057 mul_rbx 7058 pop_rbx 7059 add_rax,rbx 7060 push_rax #_common_recursion 7061 mov_rax, %0x510e527f 7062 pop_rbx # _common_recursion 7063 mov_[rbx],rax 7064 lea_rax,[rbp+DWORD] %-16 7065 mov_rax,[rax] 7066 push_rax #_common_recursion 7067 mov_rax, %5 7068 pop_rbx # _common_recursion 7069 push_rbx 7070 mov_rbx, %8 7071 mul_rbx 7072 pop_rbx 7073 add_rax,rbx 7074 push_rax #_common_recursion 7075 mov_rax, %0x9b05688c 7076 pop_rbx # _common_recursion 7077 mov_[rbx],rax 7078 lea_rax,[rbp+DWORD] %-16 7079 mov_rax,[rax] 7080 push_rax #_common_recursion 7081 mov_rax, %6 7082 pop_rbx # _common_recursion 7083 push_rbx 7084 mov_rbx, %8 7085 mul_rbx 7086 pop_rbx 7087 add_rax,rbx 7088 push_rax #_common_recursion 7089 mov_rax, %0x1f83d9ab 7090 pop_rbx # _common_recursion 7091 mov_[rbx],rax 7092 lea_rax,[rbp+DWORD] %-16 7093 mov_rax,[rax] 7094 push_rax #_common_recursion 7095 mov_rax, %7 7096 pop_rbx # _common_recursion 7097 push_rbx 7098 mov_rbx, %8 7099 mul_rbx 7100 pop_rbx 7101 add_rax,rbx 7102 push_rax #_common_recursion 7103 mov_rax, %0x5be0cd19 7104 pop_rbx # _common_recursion 7105 mov_[rbx],rax 7106 lea_rax,[rbp+DWORD] %-16 7107 mov_rax,[rax] 7108 pop_rbx # _return_result_locals 7109 ret 7110 # Defining function right_rot 7111 :FUNCTION_right_rot 7112 lea_rax,[rbp+DWORD] %-8 7113 push_rax #_common_recursion 7114 lea_rax,[rip+DWORD] %GLOBAL_mask 7115 mov_rax,[rax] 7116 pop_rbx # _common_recursion 7117 push_rbx 7118 mov_rbx,[rbx] 7119 and_rax,rbx 7120 pop_rbx 7121 mov_[rbx],rax 7122 # Defining local hold1 7123 lea_rax,[rbp+DWORD] %-8 7124 mov_rax,[rax] 7125 push_rax #_common_recursion 7126 lea_rax,[rbp+DWORD] %-16 7127 mov_rax,[rax] 7128 pop_rbx # _common_recursion 7129 mov_rcx,rax 7130 mov_rax,rbx 7131 shr_rax,cl 7132 push_rax #_common_recursion 7133 lea_rax,[rip+DWORD] %GLOBAL_mask 7134 mov_rax,[rax] 7135 pop_rbx # _common_recursion 7136 and_rax,rbx 7137 push_rax #hold1 7138 # Defining local hold2 7139 lea_rax,[rbp+DWORD] %-8 7140 mov_rax,[rax] 7141 push_rax #_common_recursion 7142 mov_rax, %32 7143 push_rax #_common_recursion 7144 lea_rax,[rbp+DWORD] %-16 7145 mov_rax,[rax] 7146 pop_rbx # _common_recursion 7147 sub_rbx,rax 7148 mov_rax,rbx 7149 pop_rbx # _common_recursion 7150 mov_rcx,rax 7151 mov_rax,rbx 7152 shl_rax,cl 7153 push_rax #_common_recursion 7154 lea_rax,[rip+DWORD] %GLOBAL_mask 7155 mov_rax,[rax] 7156 pop_rbx # _common_recursion 7157 and_rax,rbx 7158 push_rax #hold2 7159 # Defining local hold 7160 lea_rax,[rbp+DWORD] %-32 7161 mov_rax,[rax] 7162 push_rax #_common_recursion 7163 lea_rax,[rbp+DWORD] %-40 7164 mov_rax,[rax] 7165 pop_rbx # _common_recursion 7166 or_rax,rbx 7167 push_rax #_common_recursion 7168 lea_rax,[rip+DWORD] %GLOBAL_mask 7169 mov_rax,[rax] 7170 pop_rbx # _common_recursion 7171 and_rax,rbx 7172 push_rax #hold 7173 lea_rax,[rbp+DWORD] %-48 7174 mov_rax,[rax] 7175 pop_rbx # _return_result_locals 7176 pop_rbx # _return_result_locals 7177 pop_rbx # _return_result_locals 7178 ret 7179 # Defining function init_buf_state 7180 :FUNCTION_init_buf_state 7181 lea_rax,[rbp+DWORD] %-8 7182 mov_rax,[rax] 7183 # looking up offset 7184 push_rax #_common_recursion 7185 lea_rax,[rbp+DWORD] %-16 7186 mov_rax,[rax] 7187 pop_rbx # _common_recursion 7188 mov_[rbx],rax 7189 lea_rax,[rbp+DWORD] %-8 7190 mov_rax,[rax] 7191 # looking up offset 7192 # -> offset calculation 7193 mov_rbx, %8 7194 add_rax,rbx 7195 push_rax #_common_recursion 7196 lea_rax,[rbp+DWORD] %-24 7197 mov_rax,[rax] 7198 pop_rbx # _common_recursion 7199 mov_[rbx],rax 7200 lea_rax,[rbp+DWORD] %-8 7201 mov_rax,[rax] 7202 # looking up offset 7203 # -> offset calculation 7204 mov_rbx, %16 7205 add_rax,rbx 7206 push_rax #_common_recursion 7207 lea_rax,[rbp+DWORD] %-24 7208 mov_rax,[rax] 7209 pop_rbx # _common_recursion 7210 mov_[rbx],rax 7211 lea_rax,[rbp+DWORD] %-8 7212 mov_rax,[rax] 7213 # looking up offset 7214 # -> offset calculation 7215 mov_rbx, %24 7216 add_rax,rbx 7217 push_rax #_common_recursion 7218 mov_rax, %0 7219 pop_rbx # _common_recursion 7220 mov_[rbx],rax 7221 lea_rax,[rbp+DWORD] %-8 7222 mov_rax,[rax] 7223 # looking up offset 7224 # -> offset calculation 7225 mov_rbx, %32 7226 add_rax,rbx 7227 push_rax #_common_recursion 7228 mov_rax, %0 7229 pop_rbx # _common_recursion 7230 mov_[rbx],rax 7231 ret 7232 # Defining function calc_chunk 7233 :FUNCTION_calc_chunk 7234 # Defining local space_in_chunk 7235 push_rax #space_in_chunk 7236 # IF_calc_chunk_0 7237 lea_rax,[rbp+DWORD] %-16 7238 mov_rax,[rax] 7239 # looking up offset 7240 # -> offset calculation 7241 mov_rbx, %32 7242 add_rax,rbx 7243 mov_rax,[rax] 7244 test_rax,rax 7245 je %ELSE_calc_chunk_0 7246 mov_rax, %0 7247 pop_rbx # _return_result_locals 7248 ret 7249 jmp %_END_IF_calc_chunk_0 7250 :ELSE_calc_chunk_0 7251 :_END_IF_calc_chunk_0 7252 # IF_calc_chunk_1 7253 lea_rax,[rbp+DWORD] %-16 7254 mov_rax,[rax] 7255 # looking up offset 7256 # -> offset calculation 7257 mov_rbx, %8 7258 add_rax,rbx 7259 mov_rax,[rax] 7260 push_rax #_common_recursion 7261 mov_rax, %64 7262 pop_rbx # _common_recursion 7263 cmp_rbx,rax 7264 setae_al 7265 movzx_rax,al 7266 test_rax,rax 7267 je %ELSE_calc_chunk_1 7268 push_rdi # Prevent overwriting in recursion 7269 push_rbp # Protect the old base pointer 7270 mov_rdi,rsp # Copy new base pointer 7271 lea_rax,[rbp+DWORD] %-8 7272 mov_rax,[rax] 7273 push_rax #_process_expression1 7274 lea_rax,[rbp+DWORD] %-16 7275 mov_rax,[rax] 7276 # looking up offset 7277 mov_rax,[rax] 7278 push_rax #_process_expression2 7279 mov_rax, %64 7280 push_rax #_process_expression2 7281 mov_rbp,rdi 7282 call %FUNCTION_memcpy 7283 pop_rbx # _process_expression_locals 7284 pop_rbx # _process_expression_locals 7285 pop_rbx # _process_expression_locals 7286 pop_rbp # Restore old base pointer 7287 pop_rdi # Prevent overwrite 7288 lea_rax,[rbp+DWORD] %-16 7289 mov_rax,[rax] 7290 # looking up offset 7291 push_rax #_common_recursion 7292 mov_rax, %64 7293 pop_rbx # _common_recursion 7294 push_rbx 7295 mov_rbx,[rbx] 7296 add_rax,rbx 7297 pop_rbx 7298 mov_[rbx],rax 7299 lea_rax,[rbp+DWORD] %-16 7300 mov_rax,[rax] 7301 # looking up offset 7302 # -> offset calculation 7303 mov_rbx, %8 7304 add_rax,rbx 7305 push_rax #_common_recursion 7306 mov_rax, %64 7307 pop_rbx # _common_recursion 7308 push_rbx 7309 mov_rbx,[rbx] 7310 sub_rbx,rax 7311 mov_rax,rbx 7312 pop_rbx 7313 mov_[rbx],rax 7314 mov_rax, %1 7315 pop_rbx # _return_result_locals 7316 ret 7317 jmp %_END_IF_calc_chunk_1 7318 :ELSE_calc_chunk_1 7319 :_END_IF_calc_chunk_1 7320 push_rdi # Prevent overwriting in recursion 7321 push_rbp # Protect the old base pointer 7322 mov_rdi,rsp # Copy new base pointer 7323 lea_rax,[rbp+DWORD] %-8 7324 mov_rax,[rax] 7325 push_rax #_process_expression1 7326 lea_rax,[rbp+DWORD] %-16 7327 mov_rax,[rax] 7328 # looking up offset 7329 mov_rax,[rax] 7330 push_rax #_process_expression2 7331 lea_rax,[rbp+DWORD] %-16 7332 mov_rax,[rax] 7333 # looking up offset 7334 # -> offset calculation 7335 mov_rbx, %8 7336 add_rax,rbx 7337 mov_rax,[rax] 7338 push_rax #_process_expression2 7339 mov_rbp,rdi 7340 call %FUNCTION_memcpy 7341 pop_rbx # _process_expression_locals 7342 pop_rbx # _process_expression_locals 7343 pop_rbx # _process_expression_locals 7344 pop_rbp # Restore old base pointer 7345 pop_rdi # Prevent overwrite 7346 lea_rax,[rbp+DWORD] %-8 7347 push_rax #_common_recursion 7348 lea_rax,[rbp+DWORD] %-16 7349 mov_rax,[rax] 7350 # looking up offset 7351 # -> offset calculation 7352 mov_rbx, %8 7353 add_rax,rbx 7354 mov_rax,[rax] 7355 pop_rbx # _common_recursion 7356 push_rbx 7357 mov_rbx,[rbx] 7358 add_rax,rbx 7359 pop_rbx 7360 mov_[rbx],rax 7361 lea_rax,[rbp+DWORD] %-32 7362 push_rax #_common_recursion 7363 mov_rax, %64 7364 push_rax #_common_recursion 7365 lea_rax,[rbp+DWORD] %-16 7366 mov_rax,[rax] 7367 # looking up offset 7368 # -> offset calculation 7369 mov_rbx, %8 7370 add_rax,rbx 7371 mov_rax,[rax] 7372 pop_rbx # _common_recursion 7373 sub_rbx,rax 7374 mov_rax,rbx 7375 pop_rbx # _common_recursion 7376 mov_[rbx],rax 7377 lea_rax,[rbp+DWORD] %-16 7378 mov_rax,[rax] 7379 # looking up offset 7380 push_rax #_common_recursion 7381 lea_rax,[rbp+DWORD] %-16 7382 mov_rax,[rax] 7383 # looking up offset 7384 # -> offset calculation 7385 mov_rbx, %8 7386 add_rax,rbx 7387 mov_rax,[rax] 7388 pop_rbx # _common_recursion 7389 push_rbx 7390 mov_rbx,[rbx] 7391 add_rax,rbx 7392 pop_rbx 7393 mov_[rbx],rax 7394 lea_rax,[rbp+DWORD] %-16 7395 mov_rax,[rax] 7396 # looking up offset 7397 # -> offset calculation 7398 mov_rbx, %8 7399 add_rax,rbx 7400 push_rax #_common_recursion 7401 mov_rax, %0 7402 pop_rbx # _common_recursion 7403 mov_[rbx],rax 7404 # IF_calc_chunk_2 7405 mov_rax, %1 7406 push_rax #_common_recursion 7407 lea_rax,[rbp+DWORD] %-16 7408 mov_rax,[rax] 7409 # looking up offset 7410 # -> offset calculation 7411 mov_rbx, %24 7412 add_rax,rbx 7413 mov_rax,[rax] 7414 pop_rbx # _common_recursion 7415 cmp_rbx,rax 7416 seta_al 7417 movzx_rax,al 7418 test_rax,rax 7419 je %ELSE_calc_chunk_2 7420 lea_rax,[rbp+DWORD] %-8 7421 mov_rax,[rax] 7422 push_rax #_common_recursion 7423 mov_rax, %0 7424 pop_rbx # _common_recursion 7425 add_rax,rbx 7426 push_rax #_common_recursion 7427 mov_rax, %0x80 7428 pop_rbx # _common_recursion 7429 mov_[rbx],al 7430 lea_rax,[rbp+DWORD] %-8 7431 push_rax #_common_recursion 7432 mov_rax, %1 7433 pop_rbx # _common_recursion 7434 push_rbx 7435 mov_rbx,[rbx] 7436 add_rax,rbx 7437 pop_rbx 7438 mov_[rbx],rax 7439 lea_rax,[rbp+DWORD] %-32 7440 push_rax #_common_recursion 7441 mov_rax, %1 7442 pop_rbx # _common_recursion 7443 push_rbx 7444 mov_rbx,[rbx] 7445 sub_rbx,rax 7446 mov_rax,rbx 7447 pop_rbx 7448 mov_[rbx],rax 7449 lea_rax,[rbp+DWORD] %-16 7450 mov_rax,[rax] 7451 # looking up offset 7452 # -> offset calculation 7453 mov_rbx, %24 7454 add_rax,rbx 7455 push_rax #_common_recursion 7456 mov_rax, %1 7457 pop_rbx # _common_recursion 7458 mov_[rbx],rax 7459 jmp %_END_IF_calc_chunk_2 7460 :ELSE_calc_chunk_2 7461 :_END_IF_calc_chunk_2 7462 # IF_calc_chunk_3 7463 lea_rax,[rbp+DWORD] %-32 7464 mov_rax,[rax] 7465 push_rax #_common_recursion 7466 mov_rax, %8 7467 pop_rbx # _common_recursion 7468 cmp_rbx,rax 7469 setae_al 7470 movzx_rax,al 7471 test_rax,rax 7472 je %ELSE_calc_chunk_3 7473 # Defining local left 7474 lea_rax,[rbp+DWORD] %-32 7475 mov_rax,[rax] 7476 push_rax #_common_recursion 7477 mov_rax, %8 7478 pop_rbx # _common_recursion 7479 sub_rbx,rax 7480 mov_rax,rbx 7481 push_rax #left 7482 # Defining local len 7483 lea_rax,[rbp+DWORD] %-16 7484 mov_rax,[rax] 7485 # looking up offset 7486 # -> offset calculation 7487 mov_rbx, %16 7488 add_rax,rbx 7489 mov_rax,[rax] 7490 push_rax #len 7491 # Defining local i 7492 push_rax #i 7493 push_rdi # Prevent overwriting in recursion 7494 push_rbp # Protect the old base pointer 7495 mov_rdi,rsp # Copy new base pointer 7496 lea_rax,[rbp+DWORD] %-8 7497 mov_rax,[rax] 7498 push_rax #_process_expression1 7499 mov_rax, %0x00 7500 push_rax #_process_expression2 7501 lea_rax,[rbp+DWORD] %-40 7502 mov_rax,[rax] 7503 push_rax #_process_expression2 7504 mov_rbp,rdi 7505 call %FUNCTION_memset 7506 pop_rbx # _process_expression_locals 7507 pop_rbx # _process_expression_locals 7508 pop_rbx # _process_expression_locals 7509 pop_rbp # Restore old base pointer 7510 pop_rdi # Prevent overwrite 7511 lea_rax,[rbp+DWORD] %-8 7512 push_rax #_common_recursion 7513 lea_rax,[rbp+DWORD] %-40 7514 mov_rax,[rax] 7515 pop_rbx # _common_recursion 7516 push_rbx 7517 mov_rbx,[rbx] 7518 add_rax,rbx 7519 pop_rbx 7520 mov_[rbx],rax 7521 lea_rax,[rbp+DWORD] %-8 7522 mov_rax,[rax] 7523 push_rax #_common_recursion 7524 mov_rax, %7 7525 pop_rbx # _common_recursion 7526 add_rax,rbx 7527 push_rax #_common_recursion 7528 lea_rax,[rbp+DWORD] %-48 7529 mov_rax,[rax] 7530 push_rax #_common_recursion 7531 mov_rax, %3 7532 pop_rbx # _common_recursion 7533 mov_rcx,rax 7534 mov_rax,rbx 7535 shl_rax,cl 7536 pop_rbx # _common_recursion 7537 mov_[rbx],al 7538 lea_rax,[rbp+DWORD] %-48 7539 push_rax #_common_recursion 7540 mov_rax, %5 7541 pop_rbx # _common_recursion 7542 push_rbx 7543 mov_rbx,[rbx] 7544 mov_rcx,rax 7545 mov_rax,rbx 7546 shr_rax,cl 7547 pop_rbx 7548 mov_[rbx],rax 7549 # FOR_initialization_calc_chunk_4 7550 lea_rax,[rbp+DWORD] %-56 7551 push_rax #_common_recursion 7552 mov_rax, %6 7553 pop_rbx # _common_recursion 7554 mov_[rbx],rax 7555 :FOR_calc_chunk_4 7556 lea_rax,[rbp+DWORD] %-56 7557 mov_rax,[rax] 7558 push_rax #_common_recursion 7559 mov_rax, %0 7560 pop_rbx # _common_recursion 7561 cmp_rbx,rax 7562 setge_al 7563 movzx_rax,al 7564 test_rax,rax 7565 je %FOR_END_calc_chunk_4 7566 jmp %FOR_THEN_calc_chunk_4 7567 :FOR_ITER_calc_chunk_4 7568 lea_rax,[rbp+DWORD] %-56 7569 push_rax #_common_recursion 7570 mov_rax, %1 7571 pop_rbx # _common_recursion 7572 push_rbx 7573 mov_rbx,[rbx] 7574 sub_rbx,rax 7575 mov_rax,rbx 7576 pop_rbx 7577 mov_[rbx],rax 7578 jmp %FOR_calc_chunk_4 7579 :FOR_THEN_calc_chunk_4 7580 lea_rax,[rbp+DWORD] %-8 7581 mov_rax,[rax] 7582 push_rax #_common_recursion 7583 lea_rax,[rbp+DWORD] %-56 7584 mov_rax,[rax] 7585 pop_rbx # _common_recursion 7586 add_rax,rbx 7587 push_rax #_common_recursion 7588 lea_rax,[rbp+DWORD] %-48 7589 mov_rax,[rax] 7590 pop_rbx # _common_recursion 7591 mov_[rbx],al 7592 lea_rax,[rbp+DWORD] %-48 7593 push_rax #_common_recursion 7594 mov_rax, %8 7595 pop_rbx # _common_recursion 7596 push_rbx 7597 mov_rbx,[rbx] 7598 mov_rcx,rax 7599 mov_rax,rbx 7600 shr_rax,cl 7601 pop_rbx 7602 mov_[rbx],rax 7603 jmp %FOR_ITER_calc_chunk_4 7604 :FOR_END_calc_chunk_4 7605 lea_rax,[rbp+DWORD] %-16 7606 mov_rax,[rax] 7607 # looking up offset 7608 # -> offset calculation 7609 mov_rbx, %32 7610 add_rax,rbx 7611 push_rax #_common_recursion 7612 mov_rax, %1 7613 pop_rbx # _common_recursion 7614 mov_[rbx],rax 7615 pop_rbx # _recursive_statement_locals 7616 pop_rbx # _recursive_statement_locals 7617 pop_rbx # _recursive_statement_locals 7618 jmp %_END_IF_calc_chunk_3 7619 :ELSE_calc_chunk_3 7620 push_rdi # Prevent overwriting in recursion 7621 push_rbp # Protect the old base pointer 7622 mov_rdi,rsp # Copy new base pointer 7623 lea_rax,[rbp+DWORD] %-8 7624 mov_rax,[rax] 7625 push_rax #_process_expression1 7626 mov_rax, %0x00 7627 push_rax #_process_expression2 7628 lea_rax,[rbp+DWORD] %-32 7629 mov_rax,[rax] 7630 push_rax #_process_expression2 7631 mov_rbp,rdi 7632 call %FUNCTION_memset 7633 pop_rbx # _process_expression_locals 7634 pop_rbx # _process_expression_locals 7635 pop_rbx # _process_expression_locals 7636 pop_rbp # Restore old base pointer 7637 pop_rdi # Prevent overwrite 7638 :_END_IF_calc_chunk_3 7639 mov_rax, %1 7640 pop_rbx # _return_result_locals 7641 ret 7642 # Defining function calc_sha_256 7643 :FUNCTION_calc_sha_256 7644 # Defining local k 7645 push_rdi # Prevent overwriting in recursion 7646 push_rbp # Protect the old base pointer 7647 mov_rdi,rsp # Copy new base pointer 7648 mov_rbp,rdi 7649 call %FUNCTION_init_k 7650 pop_rbp # Restore old base pointer 7651 pop_rdi # Prevent overwrite 7652 push_rax #k 7653 # Defining local h 7654 push_rdi # Prevent overwriting in recursion 7655 push_rbp # Protect the old base pointer 7656 mov_rdi,rsp # Copy new base pointer 7657 mov_rbp,rdi 7658 call %FUNCTION_init_h 7659 pop_rbp # Restore old base pointer 7660 pop_rdi # Prevent overwrite 7661 push_rax #h 7662 # Defining local i 7663 push_rax #i 7664 # Defining local j 7665 push_rax #j 7666 # Defining local hold1 7667 push_rax #hold1 7668 # Defining local hold2 7669 push_rax #hold2 7670 # Defining local chunk 7671 push_rdi # Prevent overwriting in recursion 7672 push_rbp # Protect the old base pointer 7673 mov_rdi,rsp # Copy new base pointer 7674 mov_rax, %65 7675 push_rax #_process_expression1 7676 mov_rax, %1 7677 push_rax #_process_expression2 7678 mov_rbp,rdi 7679 call %FUNCTION_calloc 7680 pop_rbx # _process_expression_locals 7681 pop_rbx # _process_expression_locals 7682 pop_rbp # Restore old base pointer 7683 pop_rdi # Prevent overwrite 7684 push_rax #chunk 7685 # Defining local state 7686 push_rdi # Prevent overwriting in recursion 7687 push_rbp # Protect the old base pointer 7688 mov_rdi,rsp # Copy new base pointer 7689 mov_rax, %1 7690 push_rax #_process_expression1 7691 mov_rax, %40 7692 push_rax #_process_expression2 7693 mov_rbp,rdi 7694 call %FUNCTION_calloc 7695 pop_rbx # _process_expression_locals 7696 pop_rbx # _process_expression_locals 7697 pop_rbp # Restore old base pointer 7698 pop_rdi # Prevent overwrite 7699 push_rax #state 7700 push_rdi # Prevent overwriting in recursion 7701 push_rbp # Protect the old base pointer 7702 mov_rdi,rsp # Copy new base pointer 7703 lea_rax,[rbp+DWORD] %-96 7704 mov_rax,[rax] 7705 push_rax #_process_expression1 7706 lea_rax,[rbp+DWORD] %-16 7707 mov_rax,[rax] 7708 push_rax #_process_expression2 7709 lea_rax,[rbp+DWORD] %-24 7710 mov_rax,[rax] 7711 push_rax #_process_expression2 7712 mov_rbp,rdi 7713 call %FUNCTION_init_buf_state 7714 pop_rbx # _process_expression_locals 7715 pop_rbx # _process_expression_locals 7716 pop_rbx # _process_expression_locals 7717 pop_rbp # Restore old base pointer 7718 pop_rdi # Prevent overwrite 7719 # Defining local ah 7720 push_rdi # Prevent overwriting in recursion 7721 push_rbp # Protect the old base pointer 7722 mov_rdi,rsp # Copy new base pointer 7723 mov_rax, %9 7724 push_rax #_process_expression1 7725 mov_rax, %8 7726 push_rax #_process_expression2 7727 mov_rbp,rdi 7728 call %FUNCTION_calloc 7729 pop_rbx # _process_expression_locals 7730 pop_rbx # _process_expression_locals 7731 pop_rbp # Restore old base pointer 7732 pop_rdi # Prevent overwrite 7733 push_rax #ah 7734 # Defining local p 7735 push_rax #p 7736 # Defining local w 7737 push_rdi # Prevent overwriting in recursion 7738 push_rbp # Protect the old base pointer 7739 mov_rdi,rsp # Copy new base pointer 7740 mov_rax, %17 7741 push_rax #_process_expression1 7742 mov_rax, %8 7743 push_rax #_process_expression2 7744 mov_rbp,rdi 7745 call %FUNCTION_calloc 7746 pop_rbx # _process_expression_locals 7747 pop_rbx # _process_expression_locals 7748 pop_rbp # Restore old base pointer 7749 pop_rdi # Prevent overwrite 7750 push_rax #w 7751 # Defining local s0 7752 push_rax #s0 7753 # Defining local s1 7754 push_rax #s1 7755 # Defining local ch 7756 push_rax #ch 7757 # Defining local temp1 7758 push_rax #temp1 7759 # Defining local temp2 7760 push_rax #temp2 7761 # Defining local maj 7762 push_rax #maj 7763 :WHILE_calc_sha_256_0 7764 push_rdi # Prevent overwriting in recursion 7765 push_rbp # Protect the old base pointer 7766 mov_rdi,rsp # Copy new base pointer 7767 lea_rax,[rbp+DWORD] %-88 7768 mov_rax,[rax] 7769 push_rax #_process_expression1 7770 lea_rax,[rbp+DWORD] %-96 7771 mov_rax,[rax] 7772 push_rax #_process_expression2 7773 mov_rbp,rdi 7774 call %FUNCTION_calc_chunk 7775 pop_rbx # _process_expression_locals 7776 pop_rbx # _process_expression_locals 7777 pop_rbp # Restore old base pointer 7778 pop_rdi # Prevent overwrite 7779 test_rax,rax 7780 je %END_WHILE_calc_sha_256_0 7781 # THEN_while_calc_sha_256_0 7782 lea_rax,[rbp+DWORD] %-112 7783 push_rax #_common_recursion 7784 lea_rax,[rbp+DWORD] %-88 7785 mov_rax,[rax] 7786 pop_rbx # _common_recursion 7787 mov_[rbx],rax 7788 # FOR_initialization_calc_sha_256_1 7789 lea_rax,[rbp+DWORD] %-56 7790 push_rax #_common_recursion 7791 mov_rax, %0 7792 pop_rbx # _common_recursion 7793 mov_[rbx],rax 7794 :FOR_calc_sha_256_1 7795 lea_rax,[rbp+DWORD] %-56 7796 mov_rax,[rax] 7797 push_rax #_common_recursion 7798 mov_rax, %8 7799 pop_rbx # _common_recursion 7800 cmp_rbx,rax 7801 setb_al 7802 movzx_rax,al 7803 test_rax,rax 7804 je %FOR_END_calc_sha_256_1 7805 jmp %FOR_THEN_calc_sha_256_1 7806 :FOR_ITER_calc_sha_256_1 7807 lea_rax,[rbp+DWORD] %-56 7808 push_rax #_common_recursion 7809 mov_rax, %1 7810 pop_rbx # _common_recursion 7811 push_rbx 7812 mov_rbx,[rbx] 7813 add_rax,rbx 7814 pop_rbx 7815 mov_[rbx],rax 7816 jmp %FOR_calc_sha_256_1 7817 :FOR_THEN_calc_sha_256_1 7818 lea_rax,[rbp+DWORD] %-104 7819 mov_rax,[rax] 7820 push_rax #_common_recursion 7821 lea_rax,[rbp+DWORD] %-56 7822 mov_rax,[rax] 7823 pop_rbx # _common_recursion 7824 push_rbx 7825 mov_rbx, %8 7826 mul_rbx 7827 pop_rbx 7828 add_rax,rbx 7829 push_rax #_common_recursion 7830 lea_rax,[rbp+DWORD] %-48 7831 mov_rax,[rax] 7832 push_rax #_common_recursion 7833 lea_rax,[rbp+DWORD] %-56 7834 mov_rax,[rax] 7835 pop_rbx # _common_recursion 7836 push_rbx 7837 mov_rbx, %8 7838 mul_rbx 7839 pop_rbx 7840 add_rax,rbx 7841 mov_rax,[rax] 7842 pop_rbx # _common_recursion 7843 mov_[rbx],rax 7844 jmp %FOR_ITER_calc_sha_256_1 7845 :FOR_END_calc_sha_256_1 7846 # FOR_initialization_calc_sha_256_2 7847 lea_rax,[rbp+DWORD] %-56 7848 push_rax #_common_recursion 7849 mov_rax, %0 7850 pop_rbx # _common_recursion 7851 mov_[rbx],rax 7852 :FOR_calc_sha_256_2 7853 lea_rax,[rbp+DWORD] %-56 7854 mov_rax,[rax] 7855 push_rax #_common_recursion 7856 mov_rax, %4 7857 pop_rbx # _common_recursion 7858 cmp_rbx,rax 7859 setb_al 7860 movzx_rax,al 7861 test_rax,rax 7862 je %FOR_END_calc_sha_256_2 7863 jmp %FOR_THEN_calc_sha_256_2 7864 :FOR_ITER_calc_sha_256_2 7865 lea_rax,[rbp+DWORD] %-56 7866 push_rax #_common_recursion 7867 mov_rax, %1 7868 pop_rbx # _common_recursion 7869 push_rbx 7870 mov_rbx,[rbx] 7871 add_rax,rbx 7872 pop_rbx 7873 mov_[rbx],rax 7874 jmp %FOR_calc_sha_256_2 7875 :FOR_THEN_calc_sha_256_2 7876 # FOR_initialization_calc_sha_256_3 7877 lea_rax,[rbp+DWORD] %-64 7878 push_rax #_common_recursion 7879 mov_rax, %0 7880 pop_rbx # _common_recursion 7881 mov_[rbx],rax 7882 :FOR_calc_sha_256_3 7883 lea_rax,[rbp+DWORD] %-64 7884 mov_rax,[rax] 7885 push_rax #_common_recursion 7886 mov_rax, %16 7887 pop_rbx # _common_recursion 7888 cmp_rbx,rax 7889 setb_al 7890 movzx_rax,al 7891 test_rax,rax 7892 je %FOR_END_calc_sha_256_3 7893 jmp %FOR_THEN_calc_sha_256_3 7894 :FOR_ITER_calc_sha_256_3 7895 lea_rax,[rbp+DWORD] %-64 7896 push_rax #_common_recursion 7897 mov_rax, %1 7898 pop_rbx # _common_recursion 7899 push_rbx 7900 mov_rbx,[rbx] 7901 add_rax,rbx 7902 pop_rbx 7903 mov_[rbx],rax 7904 jmp %FOR_calc_sha_256_3 7905 :FOR_THEN_calc_sha_256_3 7906 # IF_calc_sha_256_4 7907 lea_rax,[rbp+DWORD] %-56 7908 mov_rax,[rax] 7909 push_rax #_common_recursion 7910 mov_rax, %0 7911 pop_rbx # _common_recursion 7912 cmp_rbx,rax 7913 sete_al 7914 movzx_rax,al 7915 test_rax,rax 7916 je %ELSE_calc_sha_256_4 7917 lea_rax,[rbp+DWORD] %-120 7918 mov_rax,[rax] 7919 push_rax #_common_recursion 7920 lea_rax,[rbp+DWORD] %-64 7921 mov_rax,[rax] 7922 pop_rbx # _common_recursion 7923 push_rbx 7924 mov_rbx, %8 7925 mul_rbx 7926 pop_rbx 7927 add_rax,rbx 7928 push_rax #_common_recursion 7929 lea_rax,[rbp+DWORD] %-112 7930 mov_rax,[rax] 7931 push_rax #_common_recursion 7932 mov_rax, %0 7933 pop_rbx # _common_recursion 7934 add_rax,rbx 7935 movsx_rax,BYTE_PTR_[rax] 7936 push_rax #_common_recursion 7937 mov_rax, %0xFF 7938 pop_rbx # _common_recursion 7939 and_rax,rbx 7940 push_rax #_common_recursion 7941 mov_rax, %24 7942 pop_rbx # _common_recursion 7943 mov_rcx,rax 7944 mov_rax,rbx 7945 sal_rax,cl 7946 push_rax #_common_recursion 7947 lea_rax,[rbp+DWORD] %-112 7948 mov_rax,[rax] 7949 push_rax #_common_recursion 7950 mov_rax, %1 7951 pop_rbx # _common_recursion 7952 add_rax,rbx 7953 movsx_rax,BYTE_PTR_[rax] 7954 push_rax #_common_recursion 7955 mov_rax, %0xFF 7956 pop_rbx # _common_recursion 7957 and_rax,rbx 7958 push_rax #_common_recursion 7959 mov_rax, %16 7960 pop_rbx # _common_recursion 7961 mov_rcx,rax 7962 mov_rax,rbx 7963 sal_rax,cl 7964 pop_rbx # _common_recursion 7965 or_rax,rbx 7966 push_rax #_common_recursion 7967 lea_rax,[rbp+DWORD] %-112 7968 mov_rax,[rax] 7969 push_rax #_common_recursion 7970 mov_rax, %2 7971 pop_rbx # _common_recursion 7972 add_rax,rbx 7973 movsx_rax,BYTE_PTR_[rax] 7974 push_rax #_common_recursion 7975 mov_rax, %0xFF 7976 pop_rbx # _common_recursion 7977 and_rax,rbx 7978 push_rax #_common_recursion 7979 mov_rax, %8 7980 pop_rbx # _common_recursion 7981 mov_rcx,rax 7982 mov_rax,rbx 7983 sal_rax,cl 7984 pop_rbx # _common_recursion 7985 or_rax,rbx 7986 push_rax #_common_recursion 7987 lea_rax,[rbp+DWORD] %-112 7988 mov_rax,[rax] 7989 push_rax #_common_recursion 7990 mov_rax, %3 7991 pop_rbx # _common_recursion 7992 add_rax,rbx 7993 movsx_rax,BYTE_PTR_[rax] 7994 push_rax #_common_recursion 7995 mov_rax, %0xFF 7996 pop_rbx # _common_recursion 7997 and_rax,rbx 7998 pop_rbx # _common_recursion 7999 or_rax,rbx 8000 pop_rbx # _common_recursion 8001 mov_[rbx],rax 8002 lea_rax,[rbp+DWORD] %-112 8003 push_rax #_common_recursion 8004 mov_rax, %4 8005 pop_rbx # _common_recursion 8006 push_rbx 8007 mov_rbx,[rbx] 8008 add_rax,rbx 8009 pop_rbx 8010 mov_[rbx],rax 8011 jmp %_END_IF_calc_sha_256_4 8012 :ELSE_calc_sha_256_4 8013 lea_rax,[rbp+DWORD] %-72 8014 push_rax #_common_recursion 8015 lea_rax,[rbp+DWORD] %-64 8016 mov_rax,[rax] 8017 push_rax #_common_recursion 8018 mov_rax, %1 8019 pop_rbx # _common_recursion 8020 add_rax,rbx 8021 push_rax #_common_recursion 8022 mov_rax, %0xf 8023 pop_rbx # _common_recursion 8024 and_rax,rbx 8025 pop_rbx # _common_recursion 8026 mov_[rbx],rax 8027 lea_rax,[rbp+DWORD] %-80 8028 push_rax #_common_recursion 8029 lea_rax,[rbp+DWORD] %-120 8030 mov_rax,[rax] 8031 push_rax #_common_recursion 8032 lea_rax,[rbp+DWORD] %-72 8033 mov_rax,[rax] 8034 pop_rbx # _common_recursion 8035 push_rbx 8036 mov_rbx, %8 8037 mul_rbx 8038 pop_rbx 8039 add_rax,rbx 8040 mov_rax,[rax] 8041 pop_rbx # _common_recursion 8042 mov_[rbx],rax 8043 lea_rax,[rbp+DWORD] %-128 8044 push_rax #_common_recursion 8045 push_rdi # Prevent overwriting in recursion 8046 push_rbp # Protect the old base pointer 8047 mov_rdi,rsp # Copy new base pointer 8048 lea_rax,[rbp+DWORD] %-80 8049 mov_rax,[rax] 8050 push_rax #_process_expression1 8051 mov_rax, %7 8052 push_rax #_process_expression2 8053 mov_rbp,rdi 8054 call %FUNCTION_right_rot 8055 pop_rbx # _process_expression_locals 8056 pop_rbx # _process_expression_locals 8057 pop_rbp # Restore old base pointer 8058 pop_rdi # Prevent overwrite 8059 push_rax #_common_recursion 8060 push_rdi # Prevent overwriting in recursion 8061 push_rbp # Protect the old base pointer 8062 mov_rdi,rsp # Copy new base pointer 8063 lea_rax,[rbp+DWORD] %-80 8064 mov_rax,[rax] 8065 push_rax #_process_expression1 8066 mov_rax, %18 8067 push_rax #_process_expression2 8068 mov_rbp,rdi 8069 call %FUNCTION_right_rot 8070 pop_rbx # _process_expression_locals 8071 pop_rbx # _process_expression_locals 8072 pop_rbp # Restore old base pointer 8073 pop_rdi # Prevent overwrite 8074 pop_rbx # _common_recursion 8075 xor_rax,rbx 8076 push_rax #_common_recursion 8077 lea_rax,[rbp+DWORD] %-80 8078 mov_rax,[rax] 8079 push_rax #_common_recursion 8080 lea_rax,[rip+DWORD] %GLOBAL_mask 8081 mov_rax,[rax] 8082 pop_rbx # _common_recursion 8083 and_rax,rbx 8084 push_rax #_common_recursion 8085 mov_rax, %3 8086 pop_rbx # _common_recursion 8087 mov_rcx,rax 8088 mov_rax,rbx 8089 shr_rax,cl 8090 pop_rbx # _common_recursion 8091 xor_rax,rbx 8092 pop_rbx # _common_recursion 8093 mov_[rbx],rax 8094 lea_rax,[rbp+DWORD] %-72 8095 push_rax #_common_recursion 8096 lea_rax,[rbp+DWORD] %-64 8097 mov_rax,[rax] 8098 push_rax #_common_recursion 8099 mov_rax, %14 8100 pop_rbx # _common_recursion 8101 add_rax,rbx 8102 push_rax #_common_recursion 8103 mov_rax, %0xf 8104 pop_rbx # _common_recursion 8105 and_rax,rbx 8106 pop_rbx # _common_recursion 8107 mov_[rbx],rax 8108 lea_rax,[rbp+DWORD] %-80 8109 push_rax #_common_recursion 8110 lea_rax,[rbp+DWORD] %-120 8111 mov_rax,[rax] 8112 push_rax #_common_recursion 8113 lea_rax,[rbp+DWORD] %-72 8114 mov_rax,[rax] 8115 pop_rbx # _common_recursion 8116 push_rbx 8117 mov_rbx, %8 8118 mul_rbx 8119 pop_rbx 8120 add_rax,rbx 8121 mov_rax,[rax] 8122 pop_rbx # _common_recursion 8123 mov_[rbx],rax 8124 lea_rax,[rbp+DWORD] %-136 8125 push_rax #_common_recursion 8126 push_rdi # Prevent overwriting in recursion 8127 push_rbp # Protect the old base pointer 8128 mov_rdi,rsp # Copy new base pointer 8129 lea_rax,[rbp+DWORD] %-80 8130 mov_rax,[rax] 8131 push_rax #_process_expression1 8132 mov_rax, %17 8133 push_rax #_process_expression2 8134 mov_rbp,rdi 8135 call %FUNCTION_right_rot 8136 pop_rbx # _process_expression_locals 8137 pop_rbx # _process_expression_locals 8138 pop_rbp # Restore old base pointer 8139 pop_rdi # Prevent overwrite 8140 push_rax #_common_recursion 8141 push_rdi # Prevent overwriting in recursion 8142 push_rbp # Protect the old base pointer 8143 mov_rdi,rsp # Copy new base pointer 8144 lea_rax,[rbp+DWORD] %-80 8145 mov_rax,[rax] 8146 push_rax #_process_expression1 8147 mov_rax, %19 8148 push_rax #_process_expression2 8149 mov_rbp,rdi 8150 call %FUNCTION_right_rot 8151 pop_rbx # _process_expression_locals 8152 pop_rbx # _process_expression_locals 8153 pop_rbp # Restore old base pointer 8154 pop_rdi # Prevent overwrite 8155 pop_rbx # _common_recursion 8156 xor_rax,rbx 8157 push_rax #_common_recursion 8158 lea_rax,[rbp+DWORD] %-80 8159 mov_rax,[rax] 8160 push_rax #_common_recursion 8161 lea_rax,[rip+DWORD] %GLOBAL_mask 8162 mov_rax,[rax] 8163 pop_rbx # _common_recursion 8164 and_rax,rbx 8165 push_rax #_common_recursion 8166 mov_rax, %10 8167 pop_rbx # _common_recursion 8168 mov_rcx,rax 8169 mov_rax,rbx 8170 shr_rax,cl 8171 pop_rbx # _common_recursion 8172 xor_rax,rbx 8173 pop_rbx # _common_recursion 8174 mov_[rbx],rax 8175 lea_rax,[rbp+DWORD] %-120 8176 mov_rax,[rax] 8177 push_rax #_common_recursion 8178 lea_rax,[rbp+DWORD] %-64 8179 mov_rax,[rax] 8180 pop_rbx # _common_recursion 8181 push_rbx 8182 mov_rbx, %8 8183 mul_rbx 8184 pop_rbx 8185 add_rax,rbx 8186 push_rax #_common_recursion 8187 lea_rax,[rbp+DWORD] %-128 8188 mov_rax,[rax] 8189 push_rax #_common_recursion 8190 lea_rax,[rbp+DWORD] %-120 8191 mov_rax,[rax] 8192 push_rax #_common_recursion 8193 lea_rax,[rbp+DWORD] %-64 8194 mov_rax,[rax] 8195 push_rax #_common_recursion 8196 mov_rax, %9 8197 pop_rbx # _common_recursion 8198 add_rax,rbx 8199 push_rax #_common_recursion 8200 mov_rax, %0xf 8201 pop_rbx # _common_recursion 8202 and_rax,rbx 8203 pop_rbx # _common_recursion 8204 push_rbx 8205 mov_rbx, %8 8206 mul_rbx 8207 pop_rbx 8208 add_rax,rbx 8209 mov_rax,[rax] 8210 pop_rbx # _common_recursion 8211 add_rax,rbx 8212 push_rax #_common_recursion 8213 lea_rax,[rbp+DWORD] %-136 8214 mov_rax,[rax] 8215 pop_rbx # _common_recursion 8216 add_rax,rbx 8217 pop_rbx # _common_recursion 8218 push_rbx 8219 mov_rbx,[rbx] 8220 add_rax,rbx 8221 pop_rbx 8222 mov_[rbx],rax 8223 :_END_IF_calc_sha_256_4 8224 lea_rax,[rbp+DWORD] %-136 8225 push_rax #_common_recursion 8226 push_rdi # Prevent overwriting in recursion 8227 push_rbp # Protect the old base pointer 8228 mov_rdi,rsp # Copy new base pointer 8229 lea_rax,[rbp+DWORD] %-104 8230 mov_rax,[rax] 8231 push_rax #_common_recursion 8232 mov_rax, %4 8233 pop_rbx # _common_recursion 8234 push_rbx 8235 mov_rbx, %8 8236 mul_rbx 8237 pop_rbx 8238 add_rax,rbx 8239 mov_rax,[rax] 8240 push_rax #_process_expression1 8241 mov_rax, %6 8242 push_rax #_process_expression2 8243 mov_rbp,rdi 8244 call %FUNCTION_right_rot 8245 pop_rbx # _process_expression_locals 8246 pop_rbx # _process_expression_locals 8247 pop_rbp # Restore old base pointer 8248 pop_rdi # Prevent overwrite 8249 push_rax #_common_recursion 8250 push_rdi # Prevent overwriting in recursion 8251 push_rbp # Protect the old base pointer 8252 mov_rdi,rsp # Copy new base pointer 8253 lea_rax,[rbp+DWORD] %-104 8254 mov_rax,[rax] 8255 push_rax #_common_recursion 8256 mov_rax, %4 8257 pop_rbx # _common_recursion 8258 push_rbx 8259 mov_rbx, %8 8260 mul_rbx 8261 pop_rbx 8262 add_rax,rbx 8263 mov_rax,[rax] 8264 push_rax #_process_expression1 8265 mov_rax, %11 8266 push_rax #_process_expression2 8267 mov_rbp,rdi 8268 call %FUNCTION_right_rot 8269 pop_rbx # _process_expression_locals 8270 pop_rbx # _process_expression_locals 8271 pop_rbp # Restore old base pointer 8272 pop_rdi # Prevent overwrite 8273 pop_rbx # _common_recursion 8274 xor_rax,rbx 8275 push_rax #_common_recursion 8276 push_rdi # Prevent overwriting in recursion 8277 push_rbp # Protect the old base pointer 8278 mov_rdi,rsp # Copy new base pointer 8279 lea_rax,[rbp+DWORD] %-104 8280 mov_rax,[rax] 8281 push_rax #_common_recursion 8282 mov_rax, %4 8283 pop_rbx # _common_recursion 8284 push_rbx 8285 mov_rbx, %8 8286 mul_rbx 8287 pop_rbx 8288 add_rax,rbx 8289 mov_rax,[rax] 8290 push_rax #_process_expression1 8291 mov_rax, %25 8292 push_rax #_process_expression2 8293 mov_rbp,rdi 8294 call %FUNCTION_right_rot 8295 pop_rbx # _process_expression_locals 8296 pop_rbx # _process_expression_locals 8297 pop_rbp # Restore old base pointer 8298 pop_rdi # Prevent overwrite 8299 pop_rbx # _common_recursion 8300 xor_rax,rbx 8301 pop_rbx # _common_recursion 8302 mov_[rbx],rax 8303 lea_rax,[rbp+DWORD] %-144 8304 push_rax #_common_recursion 8305 lea_rax,[rbp+DWORD] %-104 8306 mov_rax,[rax] 8307 push_rax #_common_recursion 8308 mov_rax, %4 8309 pop_rbx # _common_recursion 8310 push_rbx 8311 mov_rbx, %8 8312 mul_rbx 8313 pop_rbx 8314 add_rax,rbx 8315 mov_rax,[rax] 8316 push_rax #_common_recursion 8317 lea_rax,[rbp+DWORD] %-104 8318 mov_rax,[rax] 8319 push_rax #_common_recursion 8320 mov_rax, %5 8321 pop_rbx # _common_recursion 8322 push_rbx 8323 mov_rbx, %8 8324 mul_rbx 8325 pop_rbx 8326 add_rax,rbx 8327 mov_rax,[rax] 8328 pop_rbx # _common_recursion 8329 and_rax,rbx 8330 push_rax #_common_recursion 8331 push_rax #_common_recursion 8332 lea_rax,[rbp+DWORD] %-104 8333 mov_rax,[rax] 8334 push_rax #_common_recursion 8335 mov_rax, %4 8336 pop_rbx # _common_recursion 8337 push_rbx 8338 mov_rbx, %8 8339 mul_rbx 8340 pop_rbx 8341 add_rax,rbx 8342 mov_rax,[rax] 8343 pop_rbx # _common_recursion 8344 not_rax 8345 push_rax #_common_recursion 8346 lea_rax,[rbp+DWORD] %-104 8347 mov_rax,[rax] 8348 push_rax #_common_recursion 8349 mov_rax, %6 8350 pop_rbx # _common_recursion 8351 push_rbx 8352 mov_rbx, %8 8353 mul_rbx 8354 pop_rbx 8355 add_rax,rbx 8356 mov_rax,[rax] 8357 pop_rbx # _common_recursion 8358 and_rax,rbx 8359 pop_rbx # _common_recursion 8360 xor_rax,rbx 8361 pop_rbx # _common_recursion 8362 mov_[rbx],rax 8363 lea_rax,[rbp+DWORD] %-152 8364 push_rax #_common_recursion 8365 lea_rax,[rbp+DWORD] %-104 8366 mov_rax,[rax] 8367 push_rax #_common_recursion 8368 mov_rax, %7 8369 pop_rbx # _common_recursion 8370 push_rbx 8371 mov_rbx, %8 8372 mul_rbx 8373 pop_rbx 8374 add_rax,rbx 8375 mov_rax,[rax] 8376 push_rax #_common_recursion 8377 lea_rax,[rbp+DWORD] %-136 8378 mov_rax,[rax] 8379 pop_rbx # _common_recursion 8380 add_rax,rbx 8381 push_rax #_common_recursion 8382 lea_rax,[rbp+DWORD] %-144 8383 mov_rax,[rax] 8384 pop_rbx # _common_recursion 8385 add_rax,rbx 8386 push_rax #_common_recursion 8387 lea_rax,[rbp+DWORD] %-40 8388 mov_rax,[rax] 8389 push_rax #_common_recursion 8390 lea_rax,[rbp+DWORD] %-56 8391 mov_rax,[rax] 8392 push_rax #_common_recursion 8393 mov_rax, %4 8394 pop_rbx # _common_recursion 8395 mov_rcx,rax 8396 mov_rax,rbx 8397 shl_rax,cl 8398 push_rax #_common_recursion 8399 lea_rax,[rbp+DWORD] %-64 8400 mov_rax,[rax] 8401 pop_rbx # _common_recursion 8402 or_rax,rbx 8403 pop_rbx # _common_recursion 8404 push_rbx 8405 mov_rbx, %8 8406 mul_rbx 8407 pop_rbx 8408 add_rax,rbx 8409 mov_rax,[rax] 8410 pop_rbx # _common_recursion 8411 add_rax,rbx 8412 push_rax #_common_recursion 8413 lea_rax,[rbp+DWORD] %-120 8414 mov_rax,[rax] 8415 push_rax #_common_recursion 8416 lea_rax,[rbp+DWORD] %-64 8417 mov_rax,[rax] 8418 pop_rbx # _common_recursion 8419 push_rbx 8420 mov_rbx, %8 8421 mul_rbx 8422 pop_rbx 8423 add_rax,rbx 8424 mov_rax,[rax] 8425 pop_rbx # _common_recursion 8426 add_rax,rbx 8427 pop_rbx # _common_recursion 8428 mov_[rbx],rax 8429 lea_rax,[rbp+DWORD] %-128 8430 push_rax #_common_recursion 8431 push_rdi # Prevent overwriting in recursion 8432 push_rbp # Protect the old base pointer 8433 mov_rdi,rsp # Copy new base pointer 8434 lea_rax,[rbp+DWORD] %-104 8435 mov_rax,[rax] 8436 push_rax #_common_recursion 8437 mov_rax, %0 8438 pop_rbx # _common_recursion 8439 push_rbx 8440 mov_rbx, %8 8441 mul_rbx 8442 pop_rbx 8443 add_rax,rbx 8444 mov_rax,[rax] 8445 push_rax #_process_expression1 8446 mov_rax, %2 8447 push_rax #_process_expression2 8448 mov_rbp,rdi 8449 call %FUNCTION_right_rot 8450 pop_rbx # _process_expression_locals 8451 pop_rbx # _process_expression_locals 8452 pop_rbp # Restore old base pointer 8453 pop_rdi # Prevent overwrite 8454 push_rax #_common_recursion 8455 push_rdi # Prevent overwriting in recursion 8456 push_rbp # Protect the old base pointer 8457 mov_rdi,rsp # Copy new base pointer 8458 lea_rax,[rbp+DWORD] %-104 8459 mov_rax,[rax] 8460 push_rax #_common_recursion 8461 mov_rax, %0 8462 pop_rbx # _common_recursion 8463 push_rbx 8464 mov_rbx, %8 8465 mul_rbx 8466 pop_rbx 8467 add_rax,rbx 8468 mov_rax,[rax] 8469 push_rax #_process_expression1 8470 mov_rax, %13 8471 push_rax #_process_expression2 8472 mov_rbp,rdi 8473 call %FUNCTION_right_rot 8474 pop_rbx # _process_expression_locals 8475 pop_rbx # _process_expression_locals 8476 pop_rbp # Restore old base pointer 8477 pop_rdi # Prevent overwrite 8478 pop_rbx # _common_recursion 8479 xor_rax,rbx 8480 push_rax #_common_recursion 8481 push_rdi # Prevent overwriting in recursion 8482 push_rbp # Protect the old base pointer 8483 mov_rdi,rsp # Copy new base pointer 8484 lea_rax,[rbp+DWORD] %-104 8485 mov_rax,[rax] 8486 push_rax #_common_recursion 8487 mov_rax, %0 8488 pop_rbx # _common_recursion 8489 push_rbx 8490 mov_rbx, %8 8491 mul_rbx 8492 pop_rbx 8493 add_rax,rbx 8494 mov_rax,[rax] 8495 push_rax #_process_expression1 8496 mov_rax, %22 8497 push_rax #_process_expression2 8498 mov_rbp,rdi 8499 call %FUNCTION_right_rot 8500 pop_rbx # _process_expression_locals 8501 pop_rbx # _process_expression_locals 8502 pop_rbp # Restore old base pointer 8503 pop_rdi # Prevent overwrite 8504 pop_rbx # _common_recursion 8505 xor_rax,rbx 8506 pop_rbx # _common_recursion 8507 mov_[rbx],rax 8508 lea_rax,[rbp+DWORD] %-168 8509 push_rax #_common_recursion 8510 lea_rax,[rbp+DWORD] %-104 8511 mov_rax,[rax] 8512 push_rax #_common_recursion 8513 mov_rax, %0 8514 pop_rbx # _common_recursion 8515 push_rbx 8516 mov_rbx, %8 8517 mul_rbx 8518 pop_rbx 8519 add_rax,rbx 8520 mov_rax,[rax] 8521 push_rax #_common_recursion 8522 lea_rax,[rbp+DWORD] %-104 8523 mov_rax,[rax] 8524 push_rax #_common_recursion 8525 mov_rax, %1 8526 pop_rbx # _common_recursion 8527 push_rbx 8528 mov_rbx, %8 8529 mul_rbx 8530 pop_rbx 8531 add_rax,rbx 8532 mov_rax,[rax] 8533 pop_rbx # _common_recursion 8534 and_rax,rbx 8535 push_rax #_common_recursion 8536 lea_rax,[rbp+DWORD] %-104 8537 mov_rax,[rax] 8538 push_rax #_common_recursion 8539 mov_rax, %0 8540 pop_rbx # _common_recursion 8541 push_rbx 8542 mov_rbx, %8 8543 mul_rbx 8544 pop_rbx 8545 add_rax,rbx 8546 mov_rax,[rax] 8547 push_rax #_common_recursion 8548 lea_rax,[rbp+DWORD] %-104 8549 mov_rax,[rax] 8550 push_rax #_common_recursion 8551 mov_rax, %2 8552 pop_rbx # _common_recursion 8553 push_rbx 8554 mov_rbx, %8 8555 mul_rbx 8556 pop_rbx 8557 add_rax,rbx 8558 mov_rax,[rax] 8559 pop_rbx # _common_recursion 8560 and_rax,rbx 8561 pop_rbx # _common_recursion 8562 xor_rax,rbx 8563 push_rax #_common_recursion 8564 lea_rax,[rbp+DWORD] %-104 8565 mov_rax,[rax] 8566 push_rax #_common_recursion 8567 mov_rax, %1 8568 pop_rbx # _common_recursion 8569 push_rbx 8570 mov_rbx, %8 8571 mul_rbx 8572 pop_rbx 8573 add_rax,rbx 8574 mov_rax,[rax] 8575 push_rax #_common_recursion 8576 lea_rax,[rbp+DWORD] %-104 8577 mov_rax,[rax] 8578 push_rax #_common_recursion 8579 mov_rax, %2 8580 pop_rbx # _common_recursion 8581 push_rbx 8582 mov_rbx, %8 8583 mul_rbx 8584 pop_rbx 8585 add_rax,rbx 8586 mov_rax,[rax] 8587 pop_rbx # _common_recursion 8588 and_rax,rbx 8589 pop_rbx # _common_recursion 8590 xor_rax,rbx 8591 pop_rbx # _common_recursion 8592 mov_[rbx],rax 8593 lea_rax,[rbp+DWORD] %-160 8594 push_rax #_common_recursion 8595 lea_rax,[rbp+DWORD] %-128 8596 mov_rax,[rax] 8597 push_rax #_common_recursion 8598 lea_rax,[rbp+DWORD] %-168 8599 mov_rax,[rax] 8600 pop_rbx # _common_recursion 8601 add_rax,rbx 8602 pop_rbx # _common_recursion 8603 mov_[rbx],rax 8604 lea_rax,[rbp+DWORD] %-104 8605 mov_rax,[rax] 8606 push_rax #_common_recursion 8607 mov_rax, %7 8608 pop_rbx # _common_recursion 8609 push_rbx 8610 mov_rbx, %8 8611 mul_rbx 8612 pop_rbx 8613 add_rax,rbx 8614 push_rax #_common_recursion 8615 lea_rax,[rbp+DWORD] %-104 8616 mov_rax,[rax] 8617 push_rax #_common_recursion 8618 mov_rax, %6 8619 pop_rbx # _common_recursion 8620 push_rbx 8621 mov_rbx, %8 8622 mul_rbx 8623 pop_rbx 8624 add_rax,rbx 8625 mov_rax,[rax] 8626 pop_rbx # _common_recursion 8627 mov_[rbx],rax 8628 lea_rax,[rbp+DWORD] %-104 8629 mov_rax,[rax] 8630 push_rax #_common_recursion 8631 mov_rax, %6 8632 pop_rbx # _common_recursion 8633 push_rbx 8634 mov_rbx, %8 8635 mul_rbx 8636 pop_rbx 8637 add_rax,rbx 8638 push_rax #_common_recursion 8639 lea_rax,[rbp+DWORD] %-104 8640 mov_rax,[rax] 8641 push_rax #_common_recursion 8642 mov_rax, %5 8643 pop_rbx # _common_recursion 8644 push_rbx 8645 mov_rbx, %8 8646 mul_rbx 8647 pop_rbx 8648 add_rax,rbx 8649 mov_rax,[rax] 8650 pop_rbx # _common_recursion 8651 mov_[rbx],rax 8652 lea_rax,[rbp+DWORD] %-104 8653 mov_rax,[rax] 8654 push_rax #_common_recursion 8655 mov_rax, %5 8656 pop_rbx # _common_recursion 8657 push_rbx 8658 mov_rbx, %8 8659 mul_rbx 8660 pop_rbx 8661 add_rax,rbx 8662 push_rax #_common_recursion 8663 lea_rax,[rbp+DWORD] %-104 8664 mov_rax,[rax] 8665 push_rax #_common_recursion 8666 mov_rax, %4 8667 pop_rbx # _common_recursion 8668 push_rbx 8669 mov_rbx, %8 8670 mul_rbx 8671 pop_rbx 8672 add_rax,rbx 8673 mov_rax,[rax] 8674 pop_rbx # _common_recursion 8675 mov_[rbx],rax 8676 lea_rax,[rbp+DWORD] %-104 8677 mov_rax,[rax] 8678 push_rax #_common_recursion 8679 mov_rax, %4 8680 pop_rbx # _common_recursion 8681 push_rbx 8682 mov_rbx, %8 8683 mul_rbx 8684 pop_rbx 8685 add_rax,rbx 8686 push_rax #_common_recursion 8687 lea_rax,[rbp+DWORD] %-104 8688 mov_rax,[rax] 8689 push_rax #_common_recursion 8690 mov_rax, %3 8691 pop_rbx # _common_recursion 8692 push_rbx 8693 mov_rbx, %8 8694 mul_rbx 8695 pop_rbx 8696 add_rax,rbx 8697 mov_rax,[rax] 8698 push_rax #_common_recursion 8699 lea_rax,[rbp+DWORD] %-152 8700 mov_rax,[rax] 8701 pop_rbx # _common_recursion 8702 add_rax,rbx 8703 pop_rbx # _common_recursion 8704 mov_[rbx],rax 8705 lea_rax,[rbp+DWORD] %-104 8706 mov_rax,[rax] 8707 push_rax #_common_recursion 8708 mov_rax, %3 8709 pop_rbx # _common_recursion 8710 push_rbx 8711 mov_rbx, %8 8712 mul_rbx 8713 pop_rbx 8714 add_rax,rbx 8715 push_rax #_common_recursion 8716 lea_rax,[rbp+DWORD] %-104 8717 mov_rax,[rax] 8718 push_rax #_common_recursion 8719 mov_rax, %2 8720 pop_rbx # _common_recursion 8721 push_rbx 8722 mov_rbx, %8 8723 mul_rbx 8724 pop_rbx 8725 add_rax,rbx 8726 mov_rax,[rax] 8727 pop_rbx # _common_recursion 8728 mov_[rbx],rax 8729 lea_rax,[rbp+DWORD] %-104 8730 mov_rax,[rax] 8731 push_rax #_common_recursion 8732 mov_rax, %2 8733 pop_rbx # _common_recursion 8734 push_rbx 8735 mov_rbx, %8 8736 mul_rbx 8737 pop_rbx 8738 add_rax,rbx 8739 push_rax #_common_recursion 8740 lea_rax,[rbp+DWORD] %-104 8741 mov_rax,[rax] 8742 push_rax #_common_recursion 8743 mov_rax, %1 8744 pop_rbx # _common_recursion 8745 push_rbx 8746 mov_rbx, %8 8747 mul_rbx 8748 pop_rbx 8749 add_rax,rbx 8750 mov_rax,[rax] 8751 pop_rbx # _common_recursion 8752 mov_[rbx],rax 8753 lea_rax,[rbp+DWORD] %-104 8754 mov_rax,[rax] 8755 push_rax #_common_recursion 8756 mov_rax, %1 8757 pop_rbx # _common_recursion 8758 push_rbx 8759 mov_rbx, %8 8760 mul_rbx 8761 pop_rbx 8762 add_rax,rbx 8763 push_rax #_common_recursion 8764 lea_rax,[rbp+DWORD] %-104 8765 mov_rax,[rax] 8766 push_rax #_common_recursion 8767 mov_rax, %0 8768 pop_rbx # _common_recursion 8769 push_rbx 8770 mov_rbx, %8 8771 mul_rbx 8772 pop_rbx 8773 add_rax,rbx 8774 mov_rax,[rax] 8775 pop_rbx # _common_recursion 8776 mov_[rbx],rax 8777 lea_rax,[rbp+DWORD] %-104 8778 mov_rax,[rax] 8779 push_rax #_common_recursion 8780 mov_rax, %0 8781 pop_rbx # _common_recursion 8782 push_rbx 8783 mov_rbx, %8 8784 mul_rbx 8785 pop_rbx 8786 add_rax,rbx 8787 push_rax #_common_recursion 8788 lea_rax,[rbp+DWORD] %-152 8789 mov_rax,[rax] 8790 push_rax #_common_recursion 8791 lea_rax,[rbp+DWORD] %-160 8792 mov_rax,[rax] 8793 pop_rbx # _common_recursion 8794 add_rax,rbx 8795 pop_rbx # _common_recursion 8796 mov_[rbx],rax 8797 jmp %FOR_ITER_calc_sha_256_3 8798 :FOR_END_calc_sha_256_3 8799 jmp %FOR_ITER_calc_sha_256_2 8800 :FOR_END_calc_sha_256_2 8801 # FOR_initialization_calc_sha_256_5 8802 lea_rax,[rbp+DWORD] %-56 8803 push_rax #_common_recursion 8804 mov_rax, %0 8805 pop_rbx # _common_recursion 8806 mov_[rbx],rax 8807 :FOR_calc_sha_256_5 8808 lea_rax,[rbp+DWORD] %-56 8809 mov_rax,[rax] 8810 push_rax #_common_recursion 8811 mov_rax, %8 8812 pop_rbx # _common_recursion 8813 cmp_rbx,rax 8814 setb_al 8815 movzx_rax,al 8816 test_rax,rax 8817 je %FOR_END_calc_sha_256_5 8818 jmp %FOR_THEN_calc_sha_256_5 8819 :FOR_ITER_calc_sha_256_5 8820 lea_rax,[rbp+DWORD] %-56 8821 push_rax #_common_recursion 8822 mov_rax, %1 8823 pop_rbx # _common_recursion 8824 push_rbx 8825 mov_rbx,[rbx] 8826 add_rax,rbx 8827 pop_rbx 8828 mov_[rbx],rax 8829 jmp %FOR_calc_sha_256_5 8830 :FOR_THEN_calc_sha_256_5 8831 lea_rax,[rbp+DWORD] %-48 8832 mov_rax,[rax] 8833 push_rax #_common_recursion 8834 lea_rax,[rbp+DWORD] %-56 8835 mov_rax,[rax] 8836 pop_rbx # _common_recursion 8837 push_rbx 8838 mov_rbx, %8 8839 mul_rbx 8840 pop_rbx 8841 add_rax,rbx 8842 push_rax #_common_recursion 8843 lea_rax,[rbp+DWORD] %-104 8844 mov_rax,[rax] 8845 push_rax #_common_recursion 8846 lea_rax,[rbp+DWORD] %-56 8847 mov_rax,[rax] 8848 pop_rbx # _common_recursion 8849 push_rbx 8850 mov_rbx, %8 8851 mul_rbx 8852 pop_rbx 8853 add_rax,rbx 8854 mov_rax,[rax] 8855 pop_rbx # _common_recursion 8856 push_rbx 8857 mov_rbx,[rbx] 8858 add_rax,rbx 8859 pop_rbx 8860 mov_[rbx],rax 8861 jmp %FOR_ITER_calc_sha_256_5 8862 :FOR_END_calc_sha_256_5 8863 jmp %WHILE_calc_sha_256_0 8864 :END_WHILE_calc_sha_256_0 8865 lea_rax,[rbp+DWORD] %-56 8866 push_rax #_common_recursion 8867 mov_rax, %0 8868 pop_rbx # _common_recursion 8869 mov_[rbx],rax 8870 # FOR_initialization_calc_sha_256_6 8871 lea_rax,[rbp+DWORD] %-64 8872 push_rax #_common_recursion 8873 mov_rax, %0 8874 pop_rbx # _common_recursion 8875 mov_[rbx],rax 8876 :FOR_calc_sha_256_6 8877 lea_rax,[rbp+DWORD] %-56 8878 mov_rax,[rax] 8879 push_rax #_common_recursion 8880 mov_rax, %8 8881 pop_rbx # _common_recursion 8882 cmp_rbx,rax 8883 setb_al 8884 movzx_rax,al 8885 test_rax,rax 8886 je %FOR_END_calc_sha_256_6 8887 jmp %FOR_THEN_calc_sha_256_6 8888 :FOR_ITER_calc_sha_256_6 8889 lea_rax,[rbp+DWORD] %-56 8890 push_rax #_common_recursion 8891 mov_rax, %1 8892 pop_rbx # _common_recursion 8893 push_rbx 8894 mov_rbx,[rbx] 8895 add_rax,rbx 8896 pop_rbx 8897 mov_[rbx],rax 8898 jmp %FOR_calc_sha_256_6 8899 :FOR_THEN_calc_sha_256_6 8900 lea_rax,[rbp+DWORD] %-8 8901 mov_rax,[rax] 8902 push_rax #_common_recursion 8903 lea_rax,[rbp+DWORD] %-64 8904 mov_rax,[rax] 8905 pop_rbx # _common_recursion 8906 add_rax,rbx 8907 push_rax #_common_recursion 8908 lea_rax,[rbp+DWORD] %-48 8909 mov_rax,[rax] 8910 push_rax #_common_recursion 8911 lea_rax,[rbp+DWORD] %-56 8912 mov_rax,[rax] 8913 pop_rbx # _common_recursion 8914 push_rbx 8915 mov_rbx, %8 8916 mul_rbx 8917 pop_rbx 8918 add_rax,rbx 8919 mov_rax,[rax] 8920 push_rax #_common_recursion 8921 mov_rax, %24 8922 pop_rbx # _common_recursion 8923 mov_rcx,rax 8924 mov_rax,rbx 8925 shr_rax,cl 8926 push_rax #_common_recursion 8927 mov_rax, %0xFF 8928 pop_rbx # _common_recursion 8929 and_rax,rbx 8930 pop_rbx # _common_recursion 8931 mov_[rbx],al 8932 lea_rax,[rbp+DWORD] %-64 8933 push_rax #_common_recursion 8934 mov_rax, %1 8935 pop_rbx # _common_recursion 8936 push_rbx 8937 mov_rbx,[rbx] 8938 add_rax,rbx 8939 pop_rbx 8940 mov_[rbx],rax 8941 lea_rax,[rbp+DWORD] %-8 8942 mov_rax,[rax] 8943 push_rax #_common_recursion 8944 lea_rax,[rbp+DWORD] %-64 8945 mov_rax,[rax] 8946 pop_rbx # _common_recursion 8947 add_rax,rbx 8948 push_rax #_common_recursion 8949 lea_rax,[rbp+DWORD] %-48 8950 mov_rax,[rax] 8951 push_rax #_common_recursion 8952 lea_rax,[rbp+DWORD] %-56 8953 mov_rax,[rax] 8954 pop_rbx # _common_recursion 8955 push_rbx 8956 mov_rbx, %8 8957 mul_rbx 8958 pop_rbx 8959 add_rax,rbx 8960 mov_rax,[rax] 8961 push_rax #_common_recursion 8962 mov_rax, %16 8963 pop_rbx # _common_recursion 8964 mov_rcx,rax 8965 mov_rax,rbx 8966 shr_rax,cl 8967 push_rax #_common_recursion 8968 mov_rax, %0xFF 8969 pop_rbx # _common_recursion 8970 and_rax,rbx 8971 pop_rbx # _common_recursion 8972 mov_[rbx],al 8973 lea_rax,[rbp+DWORD] %-64 8974 push_rax #_common_recursion 8975 mov_rax, %1 8976 pop_rbx # _common_recursion 8977 push_rbx 8978 mov_rbx,[rbx] 8979 add_rax,rbx 8980 pop_rbx 8981 mov_[rbx],rax 8982 lea_rax,[rbp+DWORD] %-8 8983 mov_rax,[rax] 8984 push_rax #_common_recursion 8985 lea_rax,[rbp+DWORD] %-64 8986 mov_rax,[rax] 8987 pop_rbx # _common_recursion 8988 add_rax,rbx 8989 push_rax #_common_recursion 8990 lea_rax,[rbp+DWORD] %-48 8991 mov_rax,[rax] 8992 push_rax #_common_recursion 8993 lea_rax,[rbp+DWORD] %-56 8994 mov_rax,[rax] 8995 pop_rbx # _common_recursion 8996 push_rbx 8997 mov_rbx, %8 8998 mul_rbx 8999 pop_rbx 9000 add_rax,rbx 9001 mov_rax,[rax] 9002 push_rax #_common_recursion 9003 mov_rax, %8 9004 pop_rbx # _common_recursion 9005 mov_rcx,rax 9006 mov_rax,rbx 9007 shr_rax,cl 9008 push_rax #_common_recursion 9009 mov_rax, %0xFF 9010 pop_rbx # _common_recursion 9011 and_rax,rbx 9012 pop_rbx # _common_recursion 9013 mov_[rbx],al 9014 lea_rax,[rbp+DWORD] %-64 9015 push_rax #_common_recursion 9016 mov_rax, %1 9017 pop_rbx # _common_recursion 9018 push_rbx 9019 mov_rbx,[rbx] 9020 add_rax,rbx 9021 pop_rbx 9022 mov_[rbx],rax 9023 lea_rax,[rbp+DWORD] %-8 9024 mov_rax,[rax] 9025 push_rax #_common_recursion 9026 lea_rax,[rbp+DWORD] %-64 9027 mov_rax,[rax] 9028 pop_rbx # _common_recursion 9029 add_rax,rbx 9030 push_rax #_common_recursion 9031 lea_rax,[rbp+DWORD] %-48 9032 mov_rax,[rax] 9033 push_rax #_common_recursion 9034 lea_rax,[rbp+DWORD] %-56 9035 mov_rax,[rax] 9036 pop_rbx # _common_recursion 9037 push_rbx 9038 mov_rbx, %8 9039 mul_rbx 9040 pop_rbx 9041 add_rax,rbx 9042 mov_rax,[rax] 9043 push_rax #_common_recursion 9044 mov_rax, %0xFF 9045 pop_rbx # _common_recursion 9046 and_rax,rbx 9047 pop_rbx # _common_recursion 9048 mov_[rbx],al 9049 lea_rax,[rbp+DWORD] %-64 9050 push_rax #_common_recursion 9051 mov_rax, %1 9052 pop_rbx # _common_recursion 9053 push_rbx 9054 mov_rbx,[rbx] 9055 add_rax,rbx 9056 pop_rbx 9057 mov_[rbx],rax 9058 jmp %FOR_ITER_calc_sha_256_6 9059 :FOR_END_calc_sha_256_6 9060 pop_rbx # _recursive_statement_locals 9061 pop_rbx # _recursive_statement_locals 9062 pop_rbx # _recursive_statement_locals 9063 pop_rbx # _recursive_statement_locals 9064 pop_rbx # _recursive_statement_locals 9065 pop_rbx # _recursive_statement_locals 9066 pop_rbx # _recursive_statement_locals 9067 pop_rbx # _recursive_statement_locals 9068 pop_rbx # _recursive_statement_locals 9069 pop_rbx # _recursive_statement_locals 9070 pop_rbx # _recursive_statement_locals 9071 pop_rbx # _recursive_statement_locals 9072 pop_rbx # _recursive_statement_locals 9073 pop_rbx # _recursive_statement_locals 9074 pop_rbx # _recursive_statement_locals 9075 pop_rbx # _recursive_statement_locals 9076 pop_rbx # _recursive_statement_locals 9077 ret 9078 # Defining function bad_checkfile 9079 :FUNCTION_bad_checkfile 9080 push_rdi # Prevent overwriting in recursion 9081 push_rbp # Protect the old base pointer 9082 mov_rdi,rsp # Copy new base pointer 9083 lea_rax,[rbp+DWORD] %-8 9084 mov_rax,[rax] 9085 push_rax #_process_expression1 9086 lea_rax,[rip+DWORD] %GLOBAL_stdout 9087 mov_rax,[rax] 9088 push_rax #_process_expression2 9089 mov_rbp,rdi 9090 call %FUNCTION_fputs 9091 pop_rbx # _process_expression_locals 9092 pop_rbx # _process_expression_locals 9093 pop_rbp # Restore old base pointer 9094 pop_rdi # Prevent overwrite 9095 push_rdi # Prevent overwriting in recursion 9096 push_rbp # Protect the old base pointer 9097 mov_rdi,rsp # Copy new base pointer 9098 lea_rax,[rip+DWORD] %STRING_bad_checkfile_0 9099 push_rax #_process_expression1 9100 mov_rbp,rdi 9101 call %FUNCTION_puts 9102 pop_rbx # _process_expression_locals 9103 pop_rbp # Restore old base pointer 9104 pop_rdi # Prevent overwrite 9105 ret 9106 # Defining function hex2int 9107 :FUNCTION_hex2int 9108 # IF_hex2int_0 9109 lea_rax,[rbp+DWORD] %-8 9110 movsx_rax,BYTE_PTR_[rax] 9111 push_rax #_common_recursion 9112 mov_rax, %48 9113 pop_rbx # _common_recursion 9114 cmp_rbx,rax 9115 setge_al 9116 movzx_rax,al 9117 push_rax #_common_recursion 9118 lea_rax,[rbp+DWORD] %-8 9119 movsx_rax,BYTE_PTR_[rax] 9120 push_rax #_common_recursion 9121 mov_rax, %57 9122 pop_rbx # _common_recursion 9123 cmp_rbx,rax 9124 setle_al 9125 movzx_rax,al 9126 pop_rbx # _common_recursion 9127 and_rax,rbx 9128 test_rax,rax 9129 je %ELSE_hex2int_0 9130 lea_rax,[rbp+DWORD] %-8 9131 movsx_rax,BYTE_PTR_[rax] 9132 push_rax #_common_recursion 9133 mov_rax, %48 9134 pop_rbx # _common_recursion 9135 sub_rbx,rax 9136 mov_rax,rbx 9137 ret 9138 jmp %_END_IF_hex2int_0 9139 :ELSE_hex2int_0 9140 # IF_hex2int_1 9141 lea_rax,[rbp+DWORD] %-8 9142 movsx_rax,BYTE_PTR_[rax] 9143 push_rax #_common_recursion 9144 mov_rax, %97 9145 pop_rbx # _common_recursion 9146 cmp_rbx,rax 9147 setge_al 9148 movzx_rax,al 9149 push_rax #_common_recursion 9150 lea_rax,[rbp+DWORD] %-8 9151 movsx_rax,BYTE_PTR_[rax] 9152 push_rax #_common_recursion 9153 mov_rax, %102 9154 pop_rbx # _common_recursion 9155 cmp_rbx,rax 9156 setle_al 9157 movzx_rax,al 9158 pop_rbx # _common_recursion 9159 and_rax,rbx 9160 test_rax,rax 9161 je %ELSE_hex2int_1 9162 lea_rax,[rbp+DWORD] %-8 9163 movsx_rax,BYTE_PTR_[rax] 9164 push_rax #_common_recursion 9165 mov_rax, %87 9166 pop_rbx # _common_recursion 9167 sub_rbx,rax 9168 mov_rax,rbx 9169 ret 9170 jmp %_END_IF_hex2int_1 9171 :ELSE_hex2int_1 9172 # IF_hex2int_2 9173 lea_rax,[rbp+DWORD] %-8 9174 movsx_rax,BYTE_PTR_[rax] 9175 push_rax #_common_recursion 9176 mov_rax, %70 9177 pop_rbx # _common_recursion 9178 cmp_rbx,rax 9179 setge_al 9180 movzx_rax,al 9181 push_rax #_common_recursion 9182 lea_rax,[rbp+DWORD] %-8 9183 movsx_rax,BYTE_PTR_[rax] 9184 push_rax #_common_recursion 9185 mov_rax, %70 9186 pop_rbx # _common_recursion 9187 cmp_rbx,rax 9188 setle_al 9189 movzx_rax,al 9190 pop_rbx # _common_recursion 9191 and_rax,rbx 9192 test_rax,rax 9193 je %ELSE_hex2int_2 9194 lea_rax,[rbp+DWORD] %-8 9195 movsx_rax,BYTE_PTR_[rax] 9196 push_rax #_common_recursion 9197 mov_rax, %55 9198 pop_rbx # _common_recursion 9199 sub_rbx,rax 9200 mov_rax,rbx 9201 ret 9202 jmp %_END_IF_hex2int_2 9203 :ELSE_hex2int_2 9204 :_END_IF_hex2int_2 9205 :_END_IF_hex2int_1 9206 :_END_IF_hex2int_0 9207 push_rdi # Prevent overwriting in recursion 9208 push_rbp # Protect the old base pointer 9209 mov_rdi,rsp # Copy new base pointer 9210 lea_rax,[rbp+DWORD] %-16 9211 mov_rax,[rax] 9212 push_rax #_process_expression1 9213 mov_rbp,rdi 9214 call %FUNCTION_bad_checkfile 9215 pop_rbx # _process_expression_locals 9216 pop_rbp # Restore old base pointer 9217 pop_rdi # Prevent overwrite 9218 push_rdi # Prevent overwriting in recursion 9219 push_rbp # Protect the old base pointer 9220 mov_rdi,rsp # Copy new base pointer 9221 mov_rax, %1 9222 push_rax #_process_expression1 9223 mov_rbp,rdi 9224 call %FUNCTION_exit 9225 pop_rbx # _process_expression_locals 9226 pop_rbp # Restore old base pointer 9227 pop_rdi # Prevent overwrite 9228 ret 9229 # Defining function hash_to_string 9230 :FUNCTION_hash_to_string 9231 # Defining local table 9232 lea_rax,[rip+DWORD] %STRING_hash_to_string_0 9233 push_rax #table 9234 # Defining local r 9235 push_rdi # Prevent overwriting in recursion 9236 push_rbp # Protect the old base pointer 9237 mov_rdi,rsp # Copy new base pointer 9238 mov_rax, %66 9239 push_rax #_process_expression1 9240 mov_rax, %1 9241 push_rax #_process_expression2 9242 mov_rbp,rdi 9243 call %FUNCTION_calloc 9244 pop_rbx # _process_expression_locals 9245 pop_rbx # _process_expression_locals 9246 pop_rbp # Restore old base pointer 9247 pop_rdi # Prevent overwrite 9248 push_rax #r 9249 # Defining local i 9250 push_rax #i 9251 # Defining local j 9252 mov_rax, %0 9253 push_rax #j 9254 # Defining local c 9255 push_rax #c 9256 # FOR_initialization_hash_to_string_1 9257 lea_rax,[rbp+DWORD] %-40 9258 push_rax #_common_recursion 9259 mov_rax, %0 9260 pop_rbx # _common_recursion 9261 mov_[rbx],rax 9262 :FOR_hash_to_string_1 9263 lea_rax,[rbp+DWORD] %-40 9264 mov_rax,[rax] 9265 push_rax #_common_recursion 9266 mov_rax, %32 9267 pop_rbx # _common_recursion 9268 cmp_rbx,rax 9269 setl_al 9270 movzx_rax,al 9271 test_rax,rax 9272 je %FOR_END_hash_to_string_1 9273 jmp %FOR_THEN_hash_to_string_1 9274 :FOR_ITER_hash_to_string_1 9275 lea_rax,[rbp+DWORD] %-40 9276 push_rax #_common_recursion 9277 mov_rax, %1 9278 pop_rbx # _common_recursion 9279 push_rbx 9280 mov_rbx,[rbx] 9281 add_rax,rbx 9282 pop_rbx 9283 mov_[rbx],rax 9284 jmp %FOR_hash_to_string_1 9285 :FOR_THEN_hash_to_string_1 9286 lea_rax,[rbp+DWORD] %-56 9287 push_rax #_common_recursion 9288 lea_rax,[rbp+DWORD] %-8 9289 mov_rax,[rax] 9290 push_rax #_common_recursion 9291 lea_rax,[rbp+DWORD] %-40 9292 mov_rax,[rax] 9293 pop_rbx # _common_recursion 9294 add_rax,rbx 9295 movsx_rax,BYTE_PTR_[rax] 9296 push_rax #_common_recursion 9297 mov_rax, %0xFF 9298 pop_rbx # _common_recursion 9299 and_rax,rbx 9300 pop_rbx # _common_recursion 9301 mov_[rbx],rax 9302 lea_rax,[rbp+DWORD] %-32 9303 mov_rax,[rax] 9304 push_rax #_common_recursion 9305 lea_rax,[rbp+DWORD] %-48 9306 mov_rax,[rax] 9307 pop_rbx # _common_recursion 9308 add_rax,rbx 9309 push_rax #_common_recursion 9310 lea_rax,[rbp+DWORD] %-24 9311 mov_rax,[rax] 9312 push_rax #_common_recursion 9313 lea_rax,[rbp+DWORD] %-56 9314 mov_rax,[rax] 9315 push_rax #_common_recursion 9316 mov_rax, %4 9317 pop_rbx # _common_recursion 9318 mov_rcx,rax 9319 mov_rax,rbx 9320 sar_rax,cl 9321 pop_rbx # _common_recursion 9322 add_rax,rbx 9323 movsx_rax,BYTE_PTR_[rax] 9324 pop_rbx # _common_recursion 9325 mov_[rbx],al 9326 lea_rax,[rbp+DWORD] %-48 9327 push_rax #_common_recursion 9328 mov_rax, %1 9329 pop_rbx # _common_recursion 9330 push_rbx 9331 mov_rbx,[rbx] 9332 add_rax,rbx 9333 pop_rbx 9334 mov_[rbx],rax 9335 lea_rax,[rbp+DWORD] %-32 9336 mov_rax,[rax] 9337 push_rax #_common_recursion 9338 lea_rax,[rbp+DWORD] %-48 9339 mov_rax,[rax] 9340 pop_rbx # _common_recursion 9341 add_rax,rbx 9342 push_rax #_common_recursion 9343 lea_rax,[rbp+DWORD] %-24 9344 mov_rax,[rax] 9345 push_rax #_common_recursion 9346 lea_rax,[rbp+DWORD] %-56 9347 mov_rax,[rax] 9348 push_rax #_common_recursion 9349 mov_rax, %0xF 9350 pop_rbx # _common_recursion 9351 and_rax,rbx 9352 pop_rbx # _common_recursion 9353 add_rax,rbx 9354 movsx_rax,BYTE_PTR_[rax] 9355 pop_rbx # _common_recursion 9356 mov_[rbx],al 9357 lea_rax,[rbp+DWORD] %-48 9358 push_rax #_common_recursion 9359 mov_rax, %1 9360 pop_rbx # _common_recursion 9361 push_rbx 9362 mov_rbx,[rbx] 9363 add_rax,rbx 9364 pop_rbx 9365 mov_[rbx],rax 9366 jmp %FOR_ITER_hash_to_string_1 9367 :FOR_END_hash_to_string_1 9368 lea_rax,[rbp+DWORD] %-32 9369 mov_rax,[rax] 9370 pop_rbx # _return_result_locals 9371 pop_rbx # _return_result_locals 9372 pop_rbx # _return_result_locals 9373 pop_rbx # _return_result_locals 9374 pop_rbx # _return_result_locals 9375 ret 9376 # Defining function check_file 9377 :FUNCTION_check_file 9378 # Defining local r 9379 mov_rax, %1 9380 push_rax #r 9381 # Defining local i 9382 push_rax #i 9383 # Defining local hold1 9384 push_rax #hold1 9385 # Defining local hold2 9386 push_rax #hold2 9387 # Defining local f 9388 push_rax #f 9389 # Defining local name 9390 push_rdi # Prevent overwriting in recursion 9391 push_rbp # Protect the old base pointer 9392 mov_rdi,rsp # Copy new base pointer 9393 mov_rax, %4097 9394 push_rax #_process_expression1 9395 mov_rax, %1 9396 push_rax #_process_expression2 9397 mov_rbp,rdi 9398 call %FUNCTION_calloc 9399 pop_rbx # _process_expression_locals 9400 pop_rbx # _process_expression_locals 9401 pop_rbp # Restore old base pointer 9402 pop_rdi # Prevent overwrite 9403 push_rax #name 9404 # Defining local hash 9405 push_rdi # Prevent overwriting in recursion 9406 push_rbp # Protect the old base pointer 9407 mov_rdi,rsp # Copy new base pointer 9408 mov_rax, %33 9409 push_rax #_process_expression1 9410 mov_rax, %1 9411 push_rax #_process_expression2 9412 mov_rbp,rdi 9413 call %FUNCTION_calloc 9414 pop_rbx # _process_expression_locals 9415 pop_rbx # _process_expression_locals 9416 pop_rbp # Restore old base pointer 9417 pop_rdi # Prevent overwrite 9418 push_rax #hash 9419 # Defining local hash2 9420 push_rdi # Prevent overwriting in recursion 9421 push_rbp # Protect the old base pointer 9422 mov_rdi,rsp # Copy new base pointer 9423 mov_rax, %33 9424 push_rax #_process_expression1 9425 mov_rax, %1 9426 push_rax #_process_expression2 9427 mov_rbp,rdi 9428 call %FUNCTION_calloc 9429 pop_rbx # _process_expression_locals 9430 pop_rbx # _process_expression_locals 9431 pop_rbp # Restore old base pointer 9432 pop_rdi # Prevent overwrite 9433 push_rax #hash2 9434 # Defining local size 9435 push_rax #size 9436 # Defining local buffer 9437 push_rax #buffer 9438 :go_again #C goto label 9439 # FOR_initialization_check_file_0 9440 lea_rax,[rbp+DWORD] %-40 9441 push_rax #_common_recursion 9442 mov_rax, %0 9443 pop_rbx # _common_recursion 9444 mov_[rbx],rax 9445 :FOR_check_file_0 9446 lea_rax,[rbp+DWORD] %-40 9447 mov_rax,[rax] 9448 push_rax #_common_recursion 9449 mov_rax, %32 9450 pop_rbx # _common_recursion 9451 cmp_rbx,rax 9452 setb_al 9453 movzx_rax,al 9454 test_rax,rax 9455 je %FOR_END_check_file_0 9456 jmp %FOR_THEN_check_file_0 9457 :FOR_ITER_check_file_0 9458 lea_rax,[rbp+DWORD] %-40 9459 push_rax #_common_recursion 9460 mov_rax, %1 9461 pop_rbx # _common_recursion 9462 push_rbx 9463 mov_rbx,[rbx] 9464 add_rax,rbx 9465 pop_rbx 9466 mov_[rbx],rax 9467 jmp %FOR_check_file_0 9468 :FOR_THEN_check_file_0 9469 lea_rax,[rbp+DWORD] %-48 9470 push_rax #_common_recursion 9471 push_rdi # Prevent overwriting in recursion 9472 push_rbp # Protect the old base pointer 9473 mov_rdi,rsp # Copy new base pointer 9474 lea_rax,[rbp+DWORD] %-8 9475 mov_rax,[rax] 9476 push_rax #_common_recursion 9477 mov_rax, %0 9478 pop_rbx # _common_recursion 9479 add_rax,rbx 9480 movsx_rax,BYTE_PTR_[rax] 9481 push_rax #_process_expression1 9482 lea_rax,[rbp+DWORD] %-16 9483 mov_rax,[rax] 9484 push_rax #_process_expression2 9485 mov_rbp,rdi 9486 call %FUNCTION_hex2int 9487 pop_rbx # _process_expression_locals 9488 pop_rbx # _process_expression_locals 9489 pop_rbp # Restore old base pointer 9490 pop_rdi # Prevent overwrite 9491 pop_rbx # _common_recursion 9492 mov_[rbx],rax 9493 lea_rax,[rbp+DWORD] %-56 9494 push_rax #_common_recursion 9495 push_rdi # Prevent overwriting in recursion 9496 push_rbp # Protect the old base pointer 9497 mov_rdi,rsp # Copy new base pointer 9498 lea_rax,[rbp+DWORD] %-8 9499 mov_rax,[rax] 9500 push_rax #_common_recursion 9501 mov_rax, %1 9502 pop_rbx # _common_recursion 9503 add_rax,rbx 9504 movsx_rax,BYTE_PTR_[rax] 9505 push_rax #_process_expression1 9506 lea_rax,[rbp+DWORD] %-16 9507 mov_rax,[rax] 9508 push_rax #_process_expression2 9509 mov_rbp,rdi 9510 call %FUNCTION_hex2int 9511 pop_rbx # _process_expression_locals 9512 pop_rbx # _process_expression_locals 9513 pop_rbp # Restore old base pointer 9514 pop_rdi # Prevent overwrite 9515 pop_rbx # _common_recursion 9516 mov_[rbx],rax 9517 lea_rax,[rbp+DWORD] %-80 9518 mov_rax,[rax] 9519 push_rax #_common_recursion 9520 lea_rax,[rbp+DWORD] %-40 9521 mov_rax,[rax] 9522 pop_rbx # _common_recursion 9523 add_rax,rbx 9524 push_rax #_common_recursion 9525 lea_rax,[rbp+DWORD] %-48 9526 mov_rax,[rax] 9527 push_rax #_common_recursion 9528 mov_rax, %4 9529 pop_rbx # _common_recursion 9530 mov_rcx,rax 9531 mov_rax,rbx 9532 sal_rax,cl 9533 push_rax #_common_recursion 9534 lea_rax,[rbp+DWORD] %-56 9535 mov_rax,[rax] 9536 pop_rbx # _common_recursion 9537 add_rax,rbx 9538 pop_rbx # _common_recursion 9539 mov_[rbx],al 9540 lea_rax,[rbp+DWORD] %-8 9541 push_rax #_common_recursion 9542 mov_rax, %2 9543 pop_rbx # _common_recursion 9544 push_rbx 9545 mov_rbx,[rbx] 9546 add_rax,rbx 9547 pop_rbx 9548 mov_[rbx],rax 9549 jmp %FOR_ITER_check_file_0 9550 :FOR_END_check_file_0 9551 # IF_check_file_1 9552 mov_rax, %32 9553 push_rax #_common_recursion 9554 lea_rax,[rbp+DWORD] %-8 9555 mov_rax,[rax] 9556 push_rax #_common_recursion 9557 mov_rax, %0 9558 pop_rbx # _common_recursion 9559 add_rax,rbx 9560 movsx_rax,BYTE_PTR_[rax] 9561 pop_rbx # _common_recursion 9562 cmp_rbx,rax 9563 setne_al 9564 movzx_rax,al 9565 push_rax #_common_recursion 9566 mov_rax, %32 9567 push_rax #_common_recursion 9568 lea_rax,[rbp+DWORD] %-8 9569 mov_rax,[rax] 9570 push_rax #_common_recursion 9571 mov_rax, %1 9572 pop_rbx # _common_recursion 9573 add_rax,rbx 9574 movsx_rax,BYTE_PTR_[rax] 9575 pop_rbx # _common_recursion 9576 cmp_rbx,rax 9577 setne_al 9578 movzx_rax,al 9579 pop_rbx # _common_recursion 9580 or_rax,rbx 9581 test_rax,rax 9582 je %ELSE_check_file_1 9583 push_rdi # Prevent overwriting in recursion 9584 push_rbp # Protect the old base pointer 9585 mov_rdi,rsp # Copy new base pointer 9586 lea_rax,[rbp+DWORD] %-16 9587 mov_rax,[rax] 9588 push_rax #_process_expression1 9589 mov_rbp,rdi 9590 call %FUNCTION_bad_checkfile 9591 pop_rbx # _process_expression_locals 9592 pop_rbp # Restore old base pointer 9593 pop_rdi # Prevent overwrite 9594 push_rdi # Prevent overwriting in recursion 9595 push_rbp # Protect the old base pointer 9596 mov_rdi,rsp # Copy new base pointer 9597 mov_rax, %1 9598 push_rax #_process_expression1 9599 mov_rbp,rdi 9600 call %FUNCTION_exit 9601 pop_rbx # _process_expression_locals 9602 pop_rbp # Restore old base pointer 9603 pop_rdi # Prevent overwrite 9604 jmp %_END_IF_check_file_1 9605 :ELSE_check_file_1 9606 :_END_IF_check_file_1 9607 lea_rax,[rbp+DWORD] %-8 9608 push_rax #_common_recursion 9609 mov_rax, %2 9610 pop_rbx # _common_recursion 9611 push_rbx 9612 mov_rbx,[rbx] 9613 add_rax,rbx 9614 pop_rbx 9615 mov_[rbx],rax 9616 # FOR_initialization_check_file_2 9617 lea_rax,[rbp+DWORD] %-40 9618 push_rax #_common_recursion 9619 mov_rax, %0 9620 pop_rbx # _common_recursion 9621 mov_[rbx],rax 9622 :FOR_check_file_2 9623 lea_rax,[rbp+DWORD] %-40 9624 mov_rax,[rax] 9625 push_rax #_common_recursion 9626 mov_rax, %4096 9627 pop_rbx # _common_recursion 9628 cmp_rbx,rax 9629 setb_al 9630 movzx_rax,al 9631 test_rax,rax 9632 je %FOR_END_check_file_2 9633 jmp %FOR_THEN_check_file_2 9634 :FOR_ITER_check_file_2 9635 lea_rax,[rbp+DWORD] %-40 9636 push_rax #_common_recursion 9637 mov_rax, %1 9638 pop_rbx # _common_recursion 9639 push_rbx 9640 mov_rbx,[rbx] 9641 add_rax,rbx 9642 pop_rbx 9643 mov_[rbx],rax 9644 jmp %FOR_check_file_2 9645 :FOR_THEN_check_file_2 9646 # IF_check_file_3 9647 mov_rax, %10 9648 push_rax #_common_recursion 9649 lea_rax,[rbp+DWORD] %-8 9650 mov_rax,[rax] 9651 push_rax #_common_recursion 9652 mov_rax, %0 9653 pop_rbx # _common_recursion 9654 add_rax,rbx 9655 movsx_rax,BYTE_PTR_[rax] 9656 pop_rbx # _common_recursion 9657 cmp_rbx,rax 9658 sete_al 9659 movzx_rax,al 9660 test_rax,rax 9661 je %ELSE_check_file_3 9662 lea_rax,[rbp+DWORD] %-72 9663 mov_rax,[rax] 9664 push_rax #_common_recursion 9665 lea_rax,[rbp+DWORD] %-40 9666 mov_rax,[rax] 9667 pop_rbx # _common_recursion 9668 add_rax,rbx 9669 push_rax #_common_recursion 9670 mov_rax, %0 9671 pop_rbx # _common_recursion 9672 mov_[rbx],al 9673 lea_rax,[rbp+DWORD] %-8 9674 push_rax #_common_recursion 9675 mov_rax, %1 9676 pop_rbx # _common_recursion 9677 push_rbx 9678 mov_rbx,[rbx] 9679 add_rax,rbx 9680 pop_rbx 9681 mov_[rbx],rax 9682 jmp %FOR_END_check_file_2 9683 jmp %_END_IF_check_file_3 9684 :ELSE_check_file_3 9685 :_END_IF_check_file_3 9686 lea_rax,[rbp+DWORD] %-72 9687 mov_rax,[rax] 9688 push_rax #_common_recursion 9689 lea_rax,[rbp+DWORD] %-40 9690 mov_rax,[rax] 9691 pop_rbx # _common_recursion 9692 add_rax,rbx 9693 push_rax #_common_recursion 9694 lea_rax,[rbp+DWORD] %-8 9695 mov_rax,[rax] 9696 push_rax #_common_recursion 9697 mov_rax, %0 9698 pop_rbx # _common_recursion 9699 add_rax,rbx 9700 movsx_rax,BYTE_PTR_[rax] 9701 pop_rbx # _common_recursion 9702 mov_[rbx],al 9703 lea_rax,[rbp+DWORD] %-8 9704 push_rax #_common_recursion 9705 mov_rax, %1 9706 pop_rbx # _common_recursion 9707 push_rbx 9708 mov_rbx,[rbx] 9709 add_rax,rbx 9710 pop_rbx 9711 mov_[rbx],rax 9712 jmp %FOR_ITER_check_file_2 9713 :FOR_END_check_file_2 9714 lea_rax,[rbp+DWORD] %-64 9715 push_rax #_common_recursion 9716 push_rdi # Prevent overwriting in recursion 9717 push_rbp # Protect the old base pointer 9718 mov_rdi,rsp # Copy new base pointer 9719 lea_rax,[rbp+DWORD] %-72 9720 mov_rax,[rax] 9721 push_rax #_process_expression1 9722 lea_rax,[rip+DWORD] %STRING_check_file_4 9723 push_rax #_process_expression2 9724 mov_rbp,rdi 9725 call %FUNCTION_fopen 9726 pop_rbx # _process_expression_locals 9727 pop_rbx # _process_expression_locals 9728 pop_rbp # Restore old base pointer 9729 pop_rdi # Prevent overwrite 9730 pop_rbx # _common_recursion 9731 mov_[rbx],rax 9732 # IF_check_file_5 9733 mov_rax, %0 9734 push_rax #_common_recursion 9735 lea_rax,[rbp+DWORD] %-64 9736 mov_rax,[rax] 9737 pop_rbx # _common_recursion 9738 cmp_rbx,rax 9739 sete_al 9740 movzx_rax,al 9741 test_rax,rax 9742 je %ELSE_check_file_5 9743 push_rdi # Prevent overwriting in recursion 9744 push_rbp # Protect the old base pointer 9745 mov_rdi,rsp # Copy new base pointer 9746 lea_rax,[rbp+DWORD] %-72 9747 mov_rax,[rax] 9748 push_rax #_process_expression1 9749 lea_rax,[rip+DWORD] %GLOBAL_stdout 9750 mov_rax,[rax] 9751 push_rax #_process_expression2 9752 mov_rbp,rdi 9753 call %FUNCTION_fputs 9754 pop_rbx # _process_expression_locals 9755 pop_rbx # _process_expression_locals 9756 pop_rbp # Restore old base pointer 9757 pop_rdi # Prevent overwrite 9758 push_rdi # Prevent overwriting in recursion 9759 push_rbp # Protect the old base pointer 9760 mov_rdi,rsp # Copy new base pointer 9761 lea_rax,[rip+DWORD] %STRING_check_file_6 9762 push_rax #_process_expression1 9763 mov_rbp,rdi 9764 call %FUNCTION_puts 9765 pop_rbx # _process_expression_locals 9766 pop_rbp # Restore old base pointer 9767 pop_rdi # Prevent overwrite 9768 push_rdi # Prevent overwriting in recursion 9769 push_rbp # Protect the old base pointer 9770 mov_rdi,rsp # Copy new base pointer 9771 mov_rax, %1 9772 push_rax #_process_expression1 9773 mov_rbp,rdi 9774 call %FUNCTION_exit 9775 pop_rbx # _process_expression_locals 9776 pop_rbp # Restore old base pointer 9777 pop_rdi # Prevent overwrite 9778 jmp %_END_IF_check_file_5 9779 :ELSE_check_file_5 9780 push_rdi # Prevent overwriting in recursion 9781 push_rbp # Protect the old base pointer 9782 mov_rdi,rsp # Copy new base pointer 9783 lea_rax,[rbp+DWORD] %-64 9784 mov_rax,[rax] 9785 push_rax #_process_expression1 9786 mov_rax, %0 9787 push_rax #_process_expression2 9788 mov_rax, %2 9789 push_rax #_process_expression2 9790 mov_rbp,rdi 9791 call %FUNCTION_fseek 9792 pop_rbx # _process_expression_locals 9793 pop_rbx # _process_expression_locals 9794 pop_rbx # _process_expression_locals 9795 pop_rbp # Restore old base pointer 9796 pop_rdi # Prevent overwrite 9797 lea_rax,[rbp+DWORD] %-96 9798 push_rax #_common_recursion 9799 push_rdi # Prevent overwriting in recursion 9800 push_rbp # Protect the old base pointer 9801 mov_rdi,rsp # Copy new base pointer 9802 lea_rax,[rbp+DWORD] %-64 9803 mov_rax,[rax] 9804 push_rax #_process_expression1 9805 mov_rbp,rdi 9806 call %FUNCTION_ftell 9807 pop_rbx # _process_expression_locals 9808 pop_rbp # Restore old base pointer 9809 pop_rdi # Prevent overwrite 9810 pop_rbx # _common_recursion 9811 mov_[rbx],rax 9812 push_rdi # Prevent overwriting in recursion 9813 push_rbp # Protect the old base pointer 9814 mov_rdi,rsp # Copy new base pointer 9815 lea_rax,[rbp+DWORD] %-64 9816 mov_rax,[rax] 9817 push_rax #_process_expression1 9818 mov_rbp,rdi 9819 call %FUNCTION_rewind 9820 pop_rbx # _process_expression_locals 9821 pop_rbp # Restore old base pointer 9822 pop_rdi # Prevent overwrite 9823 lea_rax,[rbp+DWORD] %-104 9824 push_rax #_common_recursion 9825 push_rdi # Prevent overwriting in recursion 9826 push_rbp # Protect the old base pointer 9827 mov_rdi,rsp # Copy new base pointer 9828 lea_rax,[rbp+DWORD] %-96 9829 mov_rax,[rax] 9830 push_rax #_common_recursion 9831 mov_rax, %1 9832 pop_rbx # _common_recursion 9833 add_rax,rbx 9834 push_rax #_process_expression1 9835 mov_rax, %1 9836 push_rax #_process_expression2 9837 mov_rbp,rdi 9838 call %FUNCTION_calloc 9839 pop_rbx # _process_expression_locals 9840 pop_rbx # _process_expression_locals 9841 pop_rbp # Restore old base pointer 9842 pop_rdi # Prevent overwrite 9843 pop_rbx # _common_recursion 9844 mov_[rbx],rax 9845 push_rdi # Prevent overwriting in recursion 9846 push_rbp # Protect the old base pointer 9847 mov_rdi,rsp # Copy new base pointer 9848 lea_rax,[rbp+DWORD] %-104 9849 mov_rax,[rax] 9850 push_rax #_process_expression1 9851 mov_rax, %1 9852 push_rax #_process_expression2 9853 lea_rax,[rbp+DWORD] %-96 9854 mov_rax,[rax] 9855 push_rax #_process_expression2 9856 lea_rax,[rbp+DWORD] %-64 9857 mov_rax,[rax] 9858 push_rax #_process_expression2 9859 mov_rbp,rdi 9860 call %FUNCTION_fread 9861 pop_rbx # _process_expression_locals 9862 pop_rbx # _process_expression_locals 9863 pop_rbx # _process_expression_locals 9864 pop_rbx # _process_expression_locals 9865 pop_rbp # Restore old base pointer 9866 pop_rdi # Prevent overwrite 9867 push_rdi # Prevent overwriting in recursion 9868 push_rbp # Protect the old base pointer 9869 mov_rdi,rsp # Copy new base pointer 9870 lea_rax,[rbp+DWORD] %-88 9871 mov_rax,[rax] 9872 push_rax #_process_expression1 9873 lea_rax,[rbp+DWORD] %-104 9874 mov_rax,[rax] 9875 push_rax #_process_expression2 9876 lea_rax,[rbp+DWORD] %-96 9877 mov_rax,[rax] 9878 push_rax #_process_expression2 9879 mov_rbp,rdi 9880 call %FUNCTION_calc_sha_256 9881 pop_rbx # _process_expression_locals 9882 pop_rbx # _process_expression_locals 9883 pop_rbx # _process_expression_locals 9884 pop_rbp # Restore old base pointer 9885 pop_rdi # Prevent overwrite 9886 # IF_check_file_7 9887 push_rdi # Prevent overwriting in recursion 9888 push_rbp # Protect the old base pointer 9889 mov_rdi,rsp # Copy new base pointer 9890 push_rdi # Prevent overwriting in recursion 9891 push_rbp # Protect the old base pointer 9892 mov_rdi,rsp # Copy new base pointer 9893 lea_rax,[rbp+DWORD] %-80 9894 mov_rax,[rax] 9895 push_rax #_process_expression1 9896 mov_rbp,rdi 9897 call %FUNCTION_hash_to_string 9898 pop_rbx # _process_expression_locals 9899 pop_rbp # Restore old base pointer 9900 pop_rdi # Prevent overwrite 9901 push_rax #_process_expression1 9902 push_rdi # Prevent overwriting in recursion 9903 push_rbp # Protect the old base pointer 9904 mov_rdi,rsp # Copy new base pointer 9905 lea_rax,[rbp+DWORD] %-88 9906 mov_rax,[rax] 9907 push_rax #_process_expression1 9908 mov_rbp,rdi 9909 call %FUNCTION_hash_to_string 9910 pop_rbx # _process_expression_locals 9911 pop_rbp # Restore old base pointer 9912 pop_rdi # Prevent overwrite 9913 push_rax #_process_expression2 9914 mov_rbp,rdi 9915 call %FUNCTION_match 9916 pop_rbx # _process_expression_locals 9917 pop_rbx # _process_expression_locals 9918 pop_rbp # Restore old base pointer 9919 pop_rdi # Prevent overwrite 9920 test_rax,rax 9921 je %ELSE_check_file_7 9922 push_rdi # Prevent overwriting in recursion 9923 push_rbp # Protect the old base pointer 9924 mov_rdi,rsp # Copy new base pointer 9925 lea_rax,[rbp+DWORD] %-72 9926 mov_rax,[rax] 9927 push_rax #_process_expression1 9928 lea_rax,[rip+DWORD] %GLOBAL_stdout 9929 mov_rax,[rax] 9930 push_rax #_process_expression2 9931 mov_rbp,rdi 9932 call %FUNCTION_fputs 9933 pop_rbx # _process_expression_locals 9934 pop_rbx # _process_expression_locals 9935 pop_rbp # Restore old base pointer 9936 pop_rdi # Prevent overwrite 9937 push_rdi # Prevent overwriting in recursion 9938 push_rbp # Protect the old base pointer 9939 mov_rdi,rsp # Copy new base pointer 9940 lea_rax,[rip+DWORD] %STRING_check_file_8 9941 push_rax #_process_expression1 9942 mov_rbp,rdi 9943 call %FUNCTION_puts 9944 pop_rbx # _process_expression_locals 9945 pop_rbp # Restore old base pointer 9946 pop_rdi # Prevent overwrite 9947 jmp %_END_IF_check_file_7 9948 :ELSE_check_file_7 9949 push_rdi # Prevent overwriting in recursion 9950 push_rbp # Protect the old base pointer 9951 mov_rdi,rsp # Copy new base pointer 9952 lea_rax,[rbp+DWORD] %-72 9953 mov_rax,[rax] 9954 push_rax #_process_expression1 9955 lea_rax,[rip+DWORD] %GLOBAL_stdout 9956 mov_rax,[rax] 9957 push_rax #_process_expression2 9958 mov_rbp,rdi 9959 call %FUNCTION_fputs 9960 pop_rbx # _process_expression_locals 9961 pop_rbx # _process_expression_locals 9962 pop_rbp # Restore old base pointer 9963 pop_rdi # Prevent overwrite 9964 push_rdi # Prevent overwriting in recursion 9965 push_rbp # Protect the old base pointer 9966 mov_rdi,rsp # Copy new base pointer 9967 lea_rax,[rip+DWORD] %STRING_check_file_9 9968 push_rax #_process_expression1 9969 lea_rax,[rip+DWORD] %GLOBAL_stdout 9970 mov_rax,[rax] 9971 push_rax #_process_expression2 9972 mov_rbp,rdi 9973 call %FUNCTION_fputs 9974 pop_rbx # _process_expression_locals 9975 pop_rbx # _process_expression_locals 9976 pop_rbp # Restore old base pointer 9977 pop_rdi # Prevent overwrite 9978 push_rdi # Prevent overwriting in recursion 9979 push_rbp # Protect the old base pointer 9980 mov_rdi,rsp # Copy new base pointer 9981 push_rdi # Prevent overwriting in recursion 9982 push_rbp # Protect the old base pointer 9983 mov_rdi,rsp # Copy new base pointer 9984 lea_rax,[rbp+DWORD] %-80 9985 mov_rax,[rax] 9986 push_rax #_process_expression1 9987 mov_rbp,rdi 9988 call %FUNCTION_hash_to_string 9989 pop_rbx # _process_expression_locals 9990 pop_rbp # Restore old base pointer 9991 pop_rdi # Prevent overwrite 9992 push_rax #_process_expression1 9993 lea_rax,[rip+DWORD] %GLOBAL_stdout 9994 mov_rax,[rax] 9995 push_rax #_process_expression2 9996 mov_rbp,rdi 9997 call %FUNCTION_fputs 9998 pop_rbx # _process_expression_locals 9999 pop_rbx # _process_expression_locals 10000 pop_rbp # Restore old base pointer 10001 pop_rdi # Prevent overwrite 10002 push_rdi # Prevent overwriting in recursion 10003 push_rbp # Protect the old base pointer 10004 mov_rdi,rsp # Copy new base pointer 10005 lea_rax,[rip+DWORD] %STRING_check_file_10 10006 push_rax #_process_expression1 10007 lea_rax,[rip+DWORD] %GLOBAL_stdout 10008 mov_rax,[rax] 10009 push_rax #_process_expression2 10010 mov_rbp,rdi 10011 call %FUNCTION_fputs 10012 pop_rbx # _process_expression_locals 10013 pop_rbx # _process_expression_locals 10014 pop_rbp # Restore old base pointer 10015 pop_rdi # Prevent overwrite 10016 push_rdi # Prevent overwriting in recursion 10017 push_rbp # Protect the old base pointer 10018 mov_rdi,rsp # Copy new base pointer 10019 push_rdi # Prevent overwriting in recursion 10020 push_rbp # Protect the old base pointer 10021 mov_rdi,rsp # Copy new base pointer 10022 lea_rax,[rbp+DWORD] %-88 10023 mov_rax,[rax] 10024 push_rax #_process_expression1 10025 mov_rbp,rdi 10026 call %FUNCTION_hash_to_string 10027 pop_rbx # _process_expression_locals 10028 pop_rbp # Restore old base pointer 10029 pop_rdi # Prevent overwrite 10030 push_rax #_process_expression1 10031 mov_rbp,rdi 10032 call %FUNCTION_puts 10033 pop_rbx # _process_expression_locals 10034 pop_rbp # Restore old base pointer 10035 pop_rdi # Prevent overwrite 10036 lea_rax,[rbp+DWORD] %-32 10037 push_rax #_common_recursion 10038 mov_rax, %0 10039 pop_rbx # _common_recursion 10040 mov_[rbx],rax 10041 :_END_IF_check_file_7 10042 :_END_IF_check_file_5 10043 # IF_check_file_11 10044 mov_rax, %0 10045 push_rax #_common_recursion 10046 lea_rax,[rbp+DWORD] %-8 10047 mov_rax,[rax] 10048 push_rax #_common_recursion 10049 mov_rax, %0 10050 pop_rbx # _common_recursion 10051 add_rax,rbx 10052 movsx_rax,BYTE_PTR_[rax] 10053 pop_rbx # _common_recursion 10054 cmp_rbx,rax 10055 sete_al 10056 movzx_rax,al 10057 test_rax,rax 10058 je %ELSE_check_file_11 10059 lea_rax,[rbp+DWORD] %-32 10060 mov_rax,[rax] 10061 pop_rbx # _return_result_locals 10062 pop_rbx # _return_result_locals 10063 pop_rbx # _return_result_locals 10064 pop_rbx # _return_result_locals 10065 pop_rbx # _return_result_locals 10066 pop_rbx # _return_result_locals 10067 pop_rbx # _return_result_locals 10068 pop_rbx # _return_result_locals 10069 pop_rbx # _return_result_locals 10070 pop_rbx # _return_result_locals 10071 ret 10072 jmp %_END_IF_check_file_11 10073 :ELSE_check_file_11 10074 :_END_IF_check_file_11 10075 jmp %go_again 10076 pop_rbx # _recursive_statement_locals 10077 pop_rbx # _recursive_statement_locals 10078 pop_rbx # _recursive_statement_locals 10079 pop_rbx # _recursive_statement_locals 10080 pop_rbx # _recursive_statement_locals 10081 pop_rbx # _recursive_statement_locals 10082 pop_rbx # _recursive_statement_locals 10083 pop_rbx # _recursive_statement_locals 10084 pop_rbx # _recursive_statement_locals 10085 pop_rbx # _recursive_statement_locals 10086 ret 10087 # Defining function reverse 10088 :FUNCTION_reverse 10089 # Defining local prev 10090 mov_rax, %0 10091 push_rax #prev 10092 # Defining local current 10093 lea_rax,[rbp+DWORD] %-8 10094 mov_rax,[rax] 10095 mov_rax,[rax] 10096 push_rax #current 10097 # Defining local next 10098 mov_rax, %0 10099 push_rax #next 10100 :WHILE_reverse_0 10101 lea_rax,[rbp+DWORD] %-32 10102 mov_rax,[rax] 10103 push_rax #_common_recursion 10104 mov_rax, %0 10105 pop_rbx # _common_recursion 10106 cmp_rbx,rax 10107 setne_al 10108 movzx_rax,al 10109 test_rax,rax 10110 je %END_WHILE_reverse_0 10111 # THEN_while_reverse_0 10112 lea_rax,[rbp+DWORD] %-40 10113 push_rax #_common_recursion 10114 lea_rax,[rbp+DWORD] %-32 10115 mov_rax,[rax] 10116 # looking up offset 10117 # -> offset calculation 10118 mov_rbx, %48 10119 add_rax,rbx 10120 mov_rax,[rax] 10121 pop_rbx # _common_recursion 10122 mov_[rbx],rax 10123 lea_rax,[rbp+DWORD] %-32 10124 mov_rax,[rax] 10125 # looking up offset 10126 # -> offset calculation 10127 mov_rbx, %48 10128 add_rax,rbx 10129 push_rax #_common_recursion 10130 lea_rax,[rbp+DWORD] %-24 10131 mov_rax,[rax] 10132 pop_rbx # _common_recursion 10133 mov_[rbx],rax 10134 lea_rax,[rbp+DWORD] %-24 10135 push_rax #_common_recursion 10136 lea_rax,[rbp+DWORD] %-32 10137 mov_rax,[rax] 10138 pop_rbx # _common_recursion 10139 mov_[rbx],rax 10140 lea_rax,[rbp+DWORD] %-32 10141 push_rax #_common_recursion 10142 lea_rax,[rbp+DWORD] %-40 10143 mov_rax,[rax] 10144 pop_rbx # _common_recursion 10145 mov_[rbx],rax 10146 jmp %WHILE_reverse_0 10147 :END_WHILE_reverse_0 10148 lea_rax,[rbp+DWORD] %-8 10149 mov_rax,[rax] 10150 push_rax #_common_recursion 10151 lea_rax,[rbp+DWORD] %-24 10152 mov_rax,[rax] 10153 pop_rbx # _common_recursion 10154 mov_[rbx],rax 10155 pop_rbx # _recursive_statement_locals 10156 pop_rbx # _recursive_statement_locals 10157 pop_rbx # _recursive_statement_locals 10158 ret 10159 # Defining function main 10160 :FUNCTION_main 10161 # Defining local l 10162 mov_rax, %0 10163 push_rax #l 10164 # Defining local t 10165 mov_rax, %0 10166 push_rax #t 10167 # Defining local read 10168 push_rax #read 10169 # Defining local check 10170 mov_rax, %0 10171 push_rax #check 10172 # Defining local r 10173 mov_rax, %1 10174 push_rax #r 10175 # Defining local output_file 10176 lea_rax,[rip+DWORD] %STRING_main_0 10177 push_rax #output_file 10178 # Defining local output 10179 lea_rax,[rip+DWORD] %GLOBAL_stdout 10180 mov_rax,[rax] 10181 push_rax #output 10182 lea_rax,[rip+DWORD] %GLOBAL_mask 10183 push_rax #_common_recursion 10184 mov_rax, %0x7FFFFFFF 10185 push_rax #_common_recursion 10186 mov_rax, %1 10187 pop_rbx # _common_recursion 10188 mov_rcx,rax 10189 mov_rax,rbx 10190 sal_rax,cl 10191 push_rax #_common_recursion 10192 mov_rax, %0x1 10193 pop_rbx # _common_recursion 10194 or_rax,rbx 10195 pop_rbx # _common_recursion 10196 mov_[rbx],rax 10197 # Defining local i 10198 mov_rax, %1 10199 push_rax #i 10200 :WHILE_main_1 10201 lea_rax,[rbp+DWORD] %-96 10202 mov_rax,[rax] 10203 push_rax #_common_recursion 10204 lea_rax,[rbp+DWORD] %-8 10205 mov_rax,[rax] 10206 pop_rbx # _common_recursion 10207 cmp_rbx,rax 10208 setle_al 10209 movzx_rax,al 10210 test_rax,rax 10211 je %END_WHILE_main_1 10212 # THEN_while_main_1 10213 # IF_main_2 10214 mov_rax, %0 10215 push_rax #_common_recursion 10216 lea_rax,[rbp+DWORD] %-16 10217 mov_rax,[rax] 10218 push_rax #_common_recursion 10219 lea_rax,[rbp+DWORD] %-96 10220 mov_rax,[rax] 10221 pop_rbx # _common_recursion 10222 push_rbx 10223 mov_rbx, %8 10224 mul_rbx 10225 pop_rbx 10226 add_rax,rbx 10227 mov_rax,[rax] 10228 pop_rbx # _common_recursion 10229 cmp_rbx,rax 10230 sete_al 10231 movzx_rax,al 10232 test_rax,rax 10233 je %ELSE_main_2 10234 lea_rax,[rbp+DWORD] %-96 10235 push_rax #_common_recursion 10236 mov_rax, %1 10237 pop_rbx # _common_recursion 10238 push_rbx 10239 mov_rbx,[rbx] 10240 add_rax,rbx 10241 pop_rbx 10242 mov_[rbx],rax 10243 jmp %_END_IF_main_2 10244 :ELSE_main_2 10245 # IF_main_3 10246 push_rdi # Prevent overwriting in recursion 10247 push_rbp # Protect the old base pointer 10248 mov_rdi,rsp # Copy new base pointer 10249 lea_rax,[rbp+DWORD] %-16 10250 mov_rax,[rax] 10251 push_rax #_common_recursion 10252 lea_rax,[rbp+DWORD] %-96 10253 mov_rax,[rax] 10254 pop_rbx # _common_recursion 10255 push_rbx 10256 mov_rbx, %8 10257 mul_rbx 10258 pop_rbx 10259 add_rax,rbx 10260 mov_rax,[rax] 10261 push_rax #_process_expression1 10262 lea_rax,[rip+DWORD] %STRING_main_4 10263 push_rax #_process_expression2 10264 mov_rbp,rdi 10265 call %FUNCTION_match 10266 pop_rbx # _process_expression_locals 10267 pop_rbx # _process_expression_locals 10268 pop_rbp # Restore old base pointer 10269 pop_rdi # Prevent overwrite 10270 push_rax #_common_recursion 10271 push_rdi # Prevent overwriting in recursion 10272 push_rbp # Protect the old base pointer 10273 mov_rdi,rsp # Copy new base pointer 10274 lea_rax,[rbp+DWORD] %-16 10275 mov_rax,[rax] 10276 push_rax #_common_recursion 10277 lea_rax,[rbp+DWORD] %-96 10278 mov_rax,[rax] 10279 pop_rbx # _common_recursion 10280 push_rbx 10281 mov_rbx, %8 10282 mul_rbx 10283 pop_rbx 10284 add_rax,rbx 10285 mov_rax,[rax] 10286 push_rax #_process_expression1 10287 lea_rax,[rip+DWORD] %STRING_main_5 10288 push_rax #_process_expression2 10289 mov_rbp,rdi 10290 call %FUNCTION_match 10291 pop_rbx # _process_expression_locals 10292 pop_rbx # _process_expression_locals 10293 pop_rbp # Restore old base pointer 10294 pop_rdi # Prevent overwrite 10295 pop_rbx # _common_recursion 10296 or_rax,rbx 10297 test_rax,rax 10298 je %ELSE_main_3 10299 lea_rax,[rbp+DWORD] %-64 10300 push_rax #_common_recursion 10301 mov_rax, %1 10302 pop_rbx # _common_recursion 10303 mov_[rbx],rax 10304 lea_rax,[rbp+DWORD] %-96 10305 push_rax #_common_recursion 10306 mov_rax, %1 10307 pop_rbx # _common_recursion 10308 push_rbx 10309 mov_rbx,[rbx] 10310 add_rax,rbx 10311 pop_rbx 10312 mov_[rbx],rax 10313 jmp %_END_IF_main_3 10314 :ELSE_main_3 10315 # IF_main_6 10316 push_rdi # Prevent overwriting in recursion 10317 push_rbp # Protect the old base pointer 10318 mov_rdi,rsp # Copy new base pointer 10319 lea_rax,[rbp+DWORD] %-16 10320 mov_rax,[rax] 10321 push_rax #_common_recursion 10322 lea_rax,[rbp+DWORD] %-96 10323 mov_rax,[rax] 10324 pop_rbx # _common_recursion 10325 push_rbx 10326 mov_rbx, %8 10327 mul_rbx 10328 pop_rbx 10329 add_rax,rbx 10330 mov_rax,[rax] 10331 push_rax #_process_expression1 10332 lea_rax,[rip+DWORD] %STRING_main_7 10333 push_rax #_process_expression2 10334 mov_rbp,rdi 10335 call %FUNCTION_match 10336 pop_rbx # _process_expression_locals 10337 pop_rbx # _process_expression_locals 10338 pop_rbp # Restore old base pointer 10339 pop_rdi # Prevent overwrite 10340 push_rax #_common_recursion 10341 push_rdi # Prevent overwriting in recursion 10342 push_rbp # Protect the old base pointer 10343 mov_rdi,rsp # Copy new base pointer 10344 lea_rax,[rbp+DWORD] %-16 10345 mov_rax,[rax] 10346 push_rax #_common_recursion 10347 lea_rax,[rbp+DWORD] %-96 10348 mov_rax,[rax] 10349 pop_rbx # _common_recursion 10350 push_rbx 10351 mov_rbx, %8 10352 mul_rbx 10353 pop_rbx 10354 add_rax,rbx 10355 mov_rax,[rax] 10356 push_rax #_process_expression1 10357 lea_rax,[rip+DWORD] %STRING_main_8 10358 push_rax #_process_expression2 10359 mov_rbp,rdi 10360 call %FUNCTION_match 10361 pop_rbx # _process_expression_locals 10362 pop_rbx # _process_expression_locals 10363 pop_rbp # Restore old base pointer 10364 pop_rdi # Prevent overwrite 10365 pop_rbx # _common_recursion 10366 or_rax,rbx 10367 test_rax,rax 10368 je %ELSE_main_6 10369 lea_rax,[rbp+DWORD] %-80 10370 push_rax #_common_recursion 10371 lea_rax,[rbp+DWORD] %-16 10372 mov_rax,[rax] 10373 push_rax #_common_recursion 10374 lea_rax,[rbp+DWORD] %-96 10375 mov_rax,[rax] 10376 push_rax #_common_recursion 10377 mov_rax, %1 10378 pop_rbx # _common_recursion 10379 add_rax,rbx 10380 pop_rbx # _common_recursion 10381 push_rbx 10382 mov_rbx, %8 10383 mul_rbx 10384 pop_rbx 10385 add_rax,rbx 10386 mov_rax,[rax] 10387 pop_rbx # _common_recursion 10388 mov_[rbx],rax 10389 lea_rax,[rbp+DWORD] %-96 10390 push_rax #_common_recursion 10391 mov_rax, %2 10392 pop_rbx # _common_recursion 10393 push_rbx 10394 mov_rbx,[rbx] 10395 add_rax,rbx 10396 pop_rbx 10397 mov_[rbx],rax 10398 # IF_main_9 10399 lea_rax,[rbp+DWORD] %-88 10400 mov_rax,[rax] 10401 push_rax #_common_recursion 10402 lea_rax,[rip+DWORD] %GLOBAL_stdout 10403 mov_rax,[rax] 10404 pop_rbx # _common_recursion 10405 cmp_rbx,rax 10406 setne_al 10407 movzx_rax,al 10408 test_rax,rax 10409 je %ELSE_main_9 10410 push_rdi # Prevent overwriting in recursion 10411 push_rbp # Protect the old base pointer 10412 mov_rdi,rsp # Copy new base pointer 10413 lea_rax,[rbp+DWORD] %-88 10414 mov_rax,[rax] 10415 push_rax #_process_expression1 10416 mov_rbp,rdi 10417 call %FUNCTION_fclose 10418 pop_rbx # _process_expression_locals 10419 pop_rbp # Restore old base pointer 10420 pop_rdi # Prevent overwrite 10421 jmp %_END_IF_main_9 10422 :ELSE_main_9 10423 :_END_IF_main_9 10424 lea_rax,[rbp+DWORD] %-88 10425 push_rax #_common_recursion 10426 push_rdi # Prevent overwriting in recursion 10427 push_rbp # Protect the old base pointer 10428 mov_rdi,rsp # Copy new base pointer 10429 lea_rax,[rbp+DWORD] %-80 10430 mov_rax,[rax] 10431 push_rax #_process_expression1 10432 lea_rax,[rip+DWORD] %STRING_main_10 10433 push_rax #_process_expression2 10434 mov_rbp,rdi 10435 call %FUNCTION_fopen 10436 pop_rbx # _process_expression_locals 10437 pop_rbx # _process_expression_locals 10438 pop_rbp # Restore old base pointer 10439 pop_rdi # Prevent overwrite 10440 pop_rbx # _common_recursion 10441 mov_[rbx],rax 10442 push_rdi # Prevent overwriting in recursion 10443 push_rbp # Protect the old base pointer 10444 mov_rdi,rsp # Copy new base pointer 10445 lea_rax,[rbp+DWORD] %-88 10446 mov_rax,[rax] 10447 push_rax #_common_recursion 10448 mov_rax, %0 10449 pop_rbx # _common_recursion 10450 cmp_rbx,rax 10451 setne_al 10452 movzx_rax,al 10453 push_rax #_process_expression1 10454 lea_rax,[rip+DWORD] %STRING_main_11 10455 push_rax #_process_expression2 10456 mov_rbp,rdi 10457 call %FUNCTION_require 10458 pop_rbx # _process_expression_locals 10459 pop_rbx # _process_expression_locals 10460 pop_rbp # Restore old base pointer 10461 pop_rdi # Prevent overwrite 10462 jmp %_END_IF_main_6 10463 :ELSE_main_6 10464 # IF_main_12 10465 push_rdi # Prevent overwriting in recursion 10466 push_rbp # Protect the old base pointer 10467 mov_rdi,rsp # Copy new base pointer 10468 lea_rax,[rbp+DWORD] %-16 10469 mov_rax,[rax] 10470 push_rax #_common_recursion 10471 lea_rax,[rbp+DWORD] %-96 10472 mov_rax,[rax] 10473 pop_rbx # _common_recursion 10474 push_rbx 10475 mov_rbx, %8 10476 mul_rbx 10477 pop_rbx 10478 add_rax,rbx 10479 mov_rax,[rax] 10480 push_rax #_process_expression1 10481 lea_rax,[rip+DWORD] %STRING_main_13 10482 push_rax #_process_expression2 10483 mov_rbp,rdi 10484 call %FUNCTION_match 10485 pop_rbx # _process_expression_locals 10486 pop_rbx # _process_expression_locals 10487 pop_rbp # Restore old base pointer 10488 pop_rdi # Prevent overwrite 10489 push_rax #_common_recursion 10490 push_rdi # Prevent overwriting in recursion 10491 push_rbp # Protect the old base pointer 10492 mov_rdi,rsp # Copy new base pointer 10493 lea_rax,[rbp+DWORD] %-16 10494 mov_rax,[rax] 10495 push_rax #_common_recursion 10496 lea_rax,[rbp+DWORD] %-96 10497 mov_rax,[rax] 10498 pop_rbx # _common_recursion 10499 push_rbx 10500 mov_rbx, %8 10501 mul_rbx 10502 pop_rbx 10503 add_rax,rbx 10504 mov_rax,[rax] 10505 push_rax #_process_expression1 10506 lea_rax,[rip+DWORD] %STRING_main_14 10507 push_rax #_process_expression2 10508 mov_rbp,rdi 10509 call %FUNCTION_match 10510 pop_rbx # _process_expression_locals 10511 pop_rbx # _process_expression_locals 10512 pop_rbp # Restore old base pointer 10513 pop_rdi # Prevent overwrite 10514 pop_rbx # _common_recursion 10515 or_rax,rbx 10516 test_rax,rax 10517 je %ELSE_main_12 10518 push_rdi # Prevent overwriting in recursion 10519 push_rbp # Protect the old base pointer 10520 mov_rdi,rsp # Copy new base pointer 10521 lea_rax,[rip+DWORD] %STRING_main_15 10522 push_rax #_process_expression1 10523 mov_rbp,rdi 10524 call %FUNCTION_puts 10525 pop_rbx # _process_expression_locals 10526 pop_rbp # Restore old base pointer 10527 pop_rdi # Prevent overwrite 10528 push_rdi # Prevent overwriting in recursion 10529 push_rbp # Protect the old base pointer 10530 mov_rdi,rsp # Copy new base pointer 10531 mov_rax, %0 10532 push_rax #_process_expression1 10533 mov_rbp,rdi 10534 call %FUNCTION_exit 10535 pop_rbx # _process_expression_locals 10536 pop_rbp # Restore old base pointer 10537 pop_rdi # Prevent overwrite 10538 jmp %_END_IF_main_12 10539 :ELSE_main_12 10540 lea_rax,[rbp+DWORD] %-48 10541 push_rax #_common_recursion 10542 push_rdi # Prevent overwriting in recursion 10543 push_rbp # Protect the old base pointer 10544 mov_rdi,rsp # Copy new base pointer 10545 mov_rax, %1 10546 push_rax #_process_expression1 10547 mov_rax, %56 10548 push_rax #_process_expression2 10549 mov_rbp,rdi 10550 call %FUNCTION_calloc 10551 pop_rbx # _process_expression_locals 10552 pop_rbx # _process_expression_locals 10553 pop_rbp # Restore old base pointer 10554 pop_rdi # Prevent overwrite 10555 pop_rbx # _common_recursion 10556 mov_[rbx],rax 10557 lea_rax,[rbp+DWORD] %-48 10558 mov_rax,[rax] 10559 # looking up offset 10560 # -> offset calculation 10561 mov_rbx, %40 10562 add_rax,rbx 10563 push_rax #_common_recursion 10564 push_rdi # Prevent overwriting in recursion 10565 push_rbp # Protect the old base pointer 10566 mov_rdi,rsp # Copy new base pointer 10567 mov_rax, %33 10568 push_rax #_process_expression1 10569 mov_rax, %1 10570 push_rax #_process_expression2 10571 mov_rbp,rdi 10572 call %FUNCTION_calloc 10573 pop_rbx # _process_expression_locals 10574 pop_rbx # _process_expression_locals 10575 pop_rbp # Restore old base pointer 10576 pop_rdi # Prevent overwrite 10577 pop_rbx # _common_recursion 10578 mov_[rbx],rax 10579 lea_rax,[rbp+DWORD] %-48 10580 mov_rax,[rax] 10581 # looking up offset 10582 # -> offset calculation 10583 mov_rbx, %8 10584 add_rax,rbx 10585 push_rax #_common_recursion 10586 lea_rax,[rbp+DWORD] %-16 10587 mov_rax,[rax] 10588 push_rax #_common_recursion 10589 lea_rax,[rbp+DWORD] %-96 10590 mov_rax,[rax] 10591 pop_rbx # _common_recursion 10592 push_rbx 10593 mov_rbx, %8 10594 mul_rbx 10595 pop_rbx 10596 add_rax,rbx 10597 mov_rax,[rax] 10598 pop_rbx # _common_recursion 10599 mov_[rbx],rax 10600 lea_rax,[rbp+DWORD] %-48 10601 mov_rax,[rax] 10602 # looking up offset 10603 # -> offset calculation 10604 mov_rbx, %16 10605 add_rax,rbx 10606 push_rax #_common_recursion 10607 push_rdi # Prevent overwriting in recursion 10608 push_rbp # Protect the old base pointer 10609 mov_rdi,rsp # Copy new base pointer 10610 lea_rax,[rbp+DWORD] %-48 10611 mov_rax,[rax] 10612 # looking up offset 10613 # -> offset calculation 10614 mov_rbx, %8 10615 add_rax,rbx 10616 mov_rax,[rax] 10617 push_rax #_process_expression1 10618 lea_rax,[rip+DWORD] %STRING_main_16 10619 push_rax #_process_expression2 10620 mov_rbp,rdi 10621 call %FUNCTION_fopen 10622 pop_rbx # _process_expression_locals 10623 pop_rbx # _process_expression_locals 10624 pop_rbp # Restore old base pointer 10625 pop_rdi # Prevent overwrite 10626 pop_rbx # _common_recursion 10627 mov_[rbx],rax 10628 # IF_main_17 10629 mov_rax, %0 10630 push_rax #_common_recursion 10631 lea_rax,[rbp+DWORD] %-48 10632 mov_rax,[rax] 10633 # looking up offset 10634 # -> offset calculation 10635 mov_rbx, %16 10636 add_rax,rbx 10637 mov_rax,[rax] 10638 pop_rbx # _common_recursion 10639 cmp_rbx,rax 10640 setne_al 10641 movzx_rax,al 10642 test_rax,rax 10643 je %ELSE_main_17 10644 lea_rax,[rbp+DWORD] %-48 10645 mov_rax,[rax] 10646 # looking up offset 10647 push_rax #_common_recursion 10648 mov_rax, %1 10649 pop_rbx # _common_recursion 10650 mov_[rbx],rax 10651 push_rdi # Prevent overwriting in recursion 10652 push_rbp # Protect the old base pointer 10653 mov_rdi,rsp # Copy new base pointer 10654 lea_rax,[rbp+DWORD] %-48 10655 mov_rax,[rax] 10656 # looking up offset 10657 # -> offset calculation 10658 mov_rbx, %16 10659 add_rax,rbx 10660 mov_rax,[rax] 10661 push_rax #_process_expression1 10662 mov_rax, %0 10663 push_rax #_process_expression2 10664 mov_rax, %2 10665 push_rax #_process_expression2 10666 mov_rbp,rdi 10667 call %FUNCTION_fseek 10668 pop_rbx # _process_expression_locals 10669 pop_rbx # _process_expression_locals 10670 pop_rbx # _process_expression_locals 10671 pop_rbp # Restore old base pointer 10672 pop_rdi # Prevent overwrite 10673 lea_rax,[rbp+DWORD] %-48 10674 mov_rax,[rax] 10675 # looking up offset 10676 # -> offset calculation 10677 mov_rbx, %24 10678 add_rax,rbx 10679 push_rax #_common_recursion 10680 push_rdi # Prevent overwriting in recursion 10681 push_rbp # Protect the old base pointer 10682 mov_rdi,rsp # Copy new base pointer 10683 lea_rax,[rbp+DWORD] %-48 10684 mov_rax,[rax] 10685 # looking up offset 10686 # -> offset calculation 10687 mov_rbx, %16 10688 add_rax,rbx 10689 mov_rax,[rax] 10690 push_rax #_process_expression1 10691 mov_rbp,rdi 10692 call %FUNCTION_ftell 10693 pop_rbx # _process_expression_locals 10694 pop_rbp # Restore old base pointer 10695 pop_rdi # Prevent overwrite 10696 pop_rbx # _common_recursion 10697 mov_[rbx],rax 10698 push_rdi # Prevent overwriting in recursion 10699 push_rbp # Protect the old base pointer 10700 mov_rdi,rsp # Copy new base pointer 10701 lea_rax,[rbp+DWORD] %-48 10702 mov_rax,[rax] 10703 # looking up offset 10704 # -> offset calculation 10705 mov_rbx, %16 10706 add_rax,rbx 10707 mov_rax,[rax] 10708 push_rax #_process_expression1 10709 mov_rbp,rdi 10710 call %FUNCTION_rewind 10711 pop_rbx # _process_expression_locals 10712 pop_rbp # Restore old base pointer 10713 pop_rdi # Prevent overwrite 10714 lea_rax,[rbp+DWORD] %-48 10715 mov_rax,[rax] 10716 # looking up offset 10717 # -> offset calculation 10718 mov_rbx, %32 10719 add_rax,rbx 10720 push_rax #_common_recursion 10721 push_rdi # Prevent overwriting in recursion 10722 push_rbp # Protect the old base pointer 10723 mov_rdi,rsp # Copy new base pointer 10724 lea_rax,[rbp+DWORD] %-48 10725 mov_rax,[rax] 10726 # looking up offset 10727 # -> offset calculation 10728 mov_rbx, %24 10729 add_rax,rbx 10730 mov_rax,[rax] 10731 push_rax #_common_recursion 10732 mov_rax, %1 10733 pop_rbx # _common_recursion 10734 add_rax,rbx 10735 push_rax #_process_expression1 10736 mov_rax, %1 10737 push_rax #_process_expression2 10738 mov_rbp,rdi 10739 call %FUNCTION_calloc 10740 pop_rbx # _process_expression_locals 10741 pop_rbx # _process_expression_locals 10742 pop_rbp # Restore old base pointer 10743 pop_rdi # Prevent overwrite 10744 pop_rbx # _common_recursion 10745 mov_[rbx],rax 10746 lea_rax,[rbp+DWORD] %-56 10747 push_rax #_common_recursion 10748 push_rdi # Prevent overwriting in recursion 10749 push_rbp # Protect the old base pointer 10750 mov_rdi,rsp # Copy new base pointer 10751 lea_rax,[rbp+DWORD] %-48 10752 mov_rax,[rax] 10753 # looking up offset 10754 # -> offset calculation 10755 mov_rbx, %32 10756 add_rax,rbx 10757 mov_rax,[rax] 10758 push_rax #_process_expression1 10759 mov_rax, %1 10760 push_rax #_process_expression2 10761 lea_rax,[rbp+DWORD] %-48 10762 mov_rax,[rax] 10763 # looking up offset 10764 # -> offset calculation 10765 mov_rbx, %24 10766 add_rax,rbx 10767 mov_rax,[rax] 10768 push_rax #_process_expression2 10769 lea_rax,[rbp+DWORD] %-48 10770 mov_rax,[rax] 10771 # looking up offset 10772 # -> offset calculation 10773 mov_rbx, %16 10774 add_rax,rbx 10775 mov_rax,[rax] 10776 push_rax #_process_expression2 10777 mov_rbp,rdi 10778 call %FUNCTION_fread 10779 pop_rbx # _process_expression_locals 10780 pop_rbx # _process_expression_locals 10781 pop_rbx # _process_expression_locals 10782 pop_rbx # _process_expression_locals 10783 pop_rbp # Restore old base pointer 10784 pop_rdi # Prevent overwrite 10785 pop_rbx # _common_recursion 10786 mov_[rbx],rax 10787 jmp %_END_IF_main_17 10788 :ELSE_main_17 10789 :_END_IF_main_17 10790 lea_rax,[rbp+DWORD] %-48 10791 mov_rax,[rax] 10792 # looking up offset 10793 # -> offset calculation 10794 mov_rbx, %48 10795 add_rax,rbx 10796 push_rax #_common_recursion 10797 lea_rax,[rbp+DWORD] %-40 10798 mov_rax,[rax] 10799 pop_rbx # _common_recursion 10800 mov_[rbx],rax 10801 lea_rax,[rbp+DWORD] %-40 10802 push_rax #_common_recursion 10803 lea_rax,[rbp+DWORD] %-48 10804 mov_rax,[rax] 10805 pop_rbx # _common_recursion 10806 mov_[rbx],rax 10807 lea_rax,[rbp+DWORD] %-96 10808 push_rax #_common_recursion 10809 mov_rax, %1 10810 pop_rbx # _common_recursion 10811 push_rbx 10812 mov_rbx,[rbx] 10813 add_rax,rbx 10814 pop_rbx 10815 mov_[rbx],rax 10816 :_END_IF_main_12 10817 :_END_IF_main_6 10818 :_END_IF_main_3 10819 :_END_IF_main_2 10820 jmp %WHILE_main_1 10821 :END_WHILE_main_1 10822 push_rdi # Prevent overwriting in recursion 10823 push_rbp # Protect the old base pointer 10824 mov_rdi,rsp # Copy new base pointer 10825 lea_rax,[rbp+DWORD] %-40 10826 push_rax #_process_expression1 10827 mov_rbp,rdi 10828 call %FUNCTION_reverse 10829 pop_rbx # _process_expression_locals 10830 pop_rbp # Restore old base pointer 10831 pop_rdi # Prevent overwrite 10832 # IF_main_18 10833 lea_rax,[rbp+DWORD] %-64 10834 mov_rax,[rax] 10835 test_rax,rax 10836 je %ELSE_main_18 10837 :WHILE_main_19 10838 mov_rax, %0 10839 push_rax #_common_recursion 10840 lea_rax,[rbp+DWORD] %-40 10841 mov_rax,[rax] 10842 pop_rbx # _common_recursion 10843 cmp_rbx,rax 10844 setne_al 10845 movzx_rax,al 10846 test_rax,rax 10847 je %END_WHILE_main_19 10848 # THEN_while_main_19 10849 # IF_main_20 10850 lea_rax,[rbp+DWORD] %-40 10851 mov_rax,[rax] 10852 # looking up offset 10853 mov_rax,[rax] 10854 test_rax,rax 10855 je %ELSE_main_20 10856 # IF_main_21 10857 mov_rax, %1 10858 push_rax #_common_recursion 10859 push_rdi # Prevent overwriting in recursion 10860 push_rbp # Protect the old base pointer 10861 mov_rdi,rsp # Copy new base pointer 10862 lea_rax,[rbp+DWORD] %-40 10863 mov_rax,[rax] 10864 # looking up offset 10865 # -> offset calculation 10866 mov_rbx, %32 10867 add_rax,rbx 10868 mov_rax,[rax] 10869 push_rax #_process_expression1 10870 lea_rax,[rbp+DWORD] %-40 10871 mov_rax,[rax] 10872 # looking up offset 10873 # -> offset calculation 10874 mov_rbx, %8 10875 add_rax,rbx 10876 mov_rax,[rax] 10877 push_rax #_process_expression2 10878 mov_rbp,rdi 10879 call %FUNCTION_check_file 10880 pop_rbx # _process_expression_locals 10881 pop_rbx # _process_expression_locals 10882 pop_rbp # Restore old base pointer 10883 pop_rdi # Prevent overwrite 10884 pop_rbx # _common_recursion 10885 cmp_rbx,rax 10886 seta_al 10887 movzx_rax,al 10888 test_rax,rax 10889 je %ELSE_main_21 10890 lea_rax,[rbp+DWORD] %-72 10891 push_rax #_common_recursion 10892 mov_rax, %0 10893 pop_rbx # _common_recursion 10894 mov_[rbx],rax 10895 jmp %_END_IF_main_21 10896 :ELSE_main_21 10897 :_END_IF_main_21 10898 jmp %_END_IF_main_20 10899 :ELSE_main_20 10900 push_rdi # Prevent overwriting in recursion 10901 push_rbp # Protect the old base pointer 10902 mov_rdi,rsp # Copy new base pointer 10903 lea_rax,[rbp+DWORD] %-40 10904 mov_rax,[rax] 10905 # looking up offset 10906 # -> offset calculation 10907 mov_rbx, %8 10908 add_rax,rbx 10909 mov_rax,[rax] 10910 push_rax #_process_expression1 10911 lea_rax,[rip+DWORD] %GLOBAL_stdout 10912 mov_rax,[rax] 10913 push_rax #_process_expression2 10914 mov_rbp,rdi 10915 call %FUNCTION_fputs 10916 pop_rbx # _process_expression_locals 10917 pop_rbx # _process_expression_locals 10918 pop_rbp # Restore old base pointer 10919 pop_rdi # Prevent overwrite 10920 push_rdi # Prevent overwriting in recursion 10921 push_rbp # Protect the old base pointer 10922 mov_rdi,rsp # Copy new base pointer 10923 lea_rax,[rip+DWORD] %STRING_main_22 10924 push_rax #_process_expression1 10925 mov_rbp,rdi 10926 call %FUNCTION_puts 10927 pop_rbx # _process_expression_locals 10928 pop_rbp # Restore old base pointer 10929 pop_rdi # Prevent overwrite 10930 push_rdi # Prevent overwriting in recursion 10931 push_rbp # Protect the old base pointer 10932 mov_rdi,rsp # Copy new base pointer 10933 mov_rax, %1 10934 push_rax #_process_expression1 10935 mov_rbp,rdi 10936 call %FUNCTION_exit 10937 pop_rbx # _process_expression_locals 10938 pop_rbp # Restore old base pointer 10939 pop_rdi # Prevent overwrite 10940 :_END_IF_main_20 10941 lea_rax,[rbp+DWORD] %-40 10942 push_rax #_common_recursion 10943 lea_rax,[rbp+DWORD] %-40 10944 mov_rax,[rax] 10945 # looking up offset 10946 # -> offset calculation 10947 mov_rbx, %48 10948 add_rax,rbx 10949 mov_rax,[rax] 10950 pop_rbx # _common_recursion 10951 mov_[rbx],rax 10952 jmp %WHILE_main_19 10953 :END_WHILE_main_19 10954 jmp %_END_IF_main_18 10955 :ELSE_main_18 10956 :WHILE_main_23 10957 mov_rax, %0 10958 push_rax #_common_recursion 10959 lea_rax,[rbp+DWORD] %-40 10960 mov_rax,[rax] 10961 pop_rbx # _common_recursion 10962 cmp_rbx,rax 10963 setne_al 10964 movzx_rax,al 10965 test_rax,rax 10966 je %END_WHILE_main_23 10967 # THEN_while_main_23 10968 # IF_main_24 10969 lea_rax,[rbp+DWORD] %-40 10970 mov_rax,[rax] 10971 # looking up offset 10972 mov_rax,[rax] 10973 test_rax,rax 10974 je %ELSE_main_24 10975 push_rdi # Prevent overwriting in recursion 10976 push_rbp # Protect the old base pointer 10977 mov_rdi,rsp # Copy new base pointer 10978 lea_rax,[rbp+DWORD] %-40 10979 mov_rax,[rax] 10980 # looking up offset 10981 # -> offset calculation 10982 mov_rbx, %40 10983 add_rax,rbx 10984 mov_rax,[rax] 10985 push_rax #_process_expression1 10986 lea_rax,[rbp+DWORD] %-40 10987 mov_rax,[rax] 10988 # looking up offset 10989 # -> offset calculation 10990 mov_rbx, %32 10991 add_rax,rbx 10992 mov_rax,[rax] 10993 push_rax #_process_expression2 10994 lea_rax,[rbp+DWORD] %-40 10995 mov_rax,[rax] 10996 # looking up offset 10997 # -> offset calculation 10998 mov_rbx, %24 10999 add_rax,rbx 11000 mov_rax,[rax] 11001 push_rax #_process_expression2 11002 mov_rbp,rdi 11003 call %FUNCTION_calc_sha_256 11004 pop_rbx # _process_expression_locals 11005 pop_rbx # _process_expression_locals 11006 pop_rbx # _process_expression_locals 11007 pop_rbp # Restore old base pointer 11008 pop_rdi # Prevent overwrite 11009 push_rdi # Prevent overwriting in recursion 11010 push_rbp # Protect the old base pointer 11011 mov_rdi,rsp # Copy new base pointer 11012 push_rdi # Prevent overwriting in recursion 11013 push_rbp # Protect the old base pointer 11014 mov_rdi,rsp # Copy new base pointer 11015 lea_rax,[rbp+DWORD] %-40 11016 mov_rax,[rax] 11017 # looking up offset 11018 # -> offset calculation 11019 mov_rbx, %40 11020 add_rax,rbx 11021 mov_rax,[rax] 11022 push_rax #_process_expression1 11023 mov_rbp,rdi 11024 call %FUNCTION_hash_to_string 11025 pop_rbx # _process_expression_locals 11026 pop_rbp # Restore old base pointer 11027 pop_rdi # Prevent overwrite 11028 push_rax #_process_expression1 11029 lea_rax,[rbp+DWORD] %-88 11030 mov_rax,[rax] 11031 push_rax #_process_expression2 11032 mov_rbp,rdi 11033 call %FUNCTION_fputs 11034 pop_rbx # _process_expression_locals 11035 pop_rbx # _process_expression_locals 11036 pop_rbp # Restore old base pointer 11037 pop_rdi # Prevent overwrite 11038 push_rdi # Prevent overwriting in recursion 11039 push_rbp # Protect the old base pointer 11040 mov_rdi,rsp # Copy new base pointer 11041 lea_rax,[rip+DWORD] %STRING_main_25 11042 push_rax #_process_expression1 11043 lea_rax,[rbp+DWORD] %-88 11044 mov_rax,[rax] 11045 push_rax #_process_expression2 11046 mov_rbp,rdi 11047 call %FUNCTION_fputs 11048 pop_rbx # _process_expression_locals 11049 pop_rbx # _process_expression_locals 11050 pop_rbp # Restore old base pointer 11051 pop_rdi # Prevent overwrite 11052 push_rdi # Prevent overwriting in recursion 11053 push_rbp # Protect the old base pointer 11054 mov_rdi,rsp # Copy new base pointer 11055 lea_rax,[rbp+DWORD] %-40 11056 mov_rax,[rax] 11057 # looking up offset 11058 # -> offset calculation 11059 mov_rbx, %8 11060 add_rax,rbx 11061 mov_rax,[rax] 11062 push_rax #_process_expression1 11063 lea_rax,[rbp+DWORD] %-88 11064 mov_rax,[rax] 11065 push_rax #_process_expression2 11066 mov_rbp,rdi 11067 call %FUNCTION_fputs 11068 pop_rbx # _process_expression_locals 11069 pop_rbx # _process_expression_locals 11070 pop_rbp # Restore old base pointer 11071 pop_rdi # Prevent overwrite 11072 push_rdi # Prevent overwriting in recursion 11073 push_rbp # Protect the old base pointer 11074 mov_rdi,rsp # Copy new base pointer 11075 mov_rax, %10 11076 push_rax #_process_expression1 11077 lea_rax,[rbp+DWORD] %-88 11078 mov_rax,[rax] 11079 push_rax #_process_expression2 11080 mov_rbp,rdi 11081 call %FUNCTION_fputc 11082 pop_rbx # _process_expression_locals 11083 pop_rbx # _process_expression_locals 11084 pop_rbp # Restore old base pointer 11085 pop_rdi # Prevent overwrite 11086 jmp %_END_IF_main_24 11087 :ELSE_main_24 11088 push_rdi # Prevent overwriting in recursion 11089 push_rbp # Protect the old base pointer 11090 mov_rdi,rsp # Copy new base pointer 11091 lea_rax,[rbp+DWORD] %-40 11092 mov_rax,[rax] 11093 # looking up offset 11094 # -> offset calculation 11095 mov_rbx, %8 11096 add_rax,rbx 11097 mov_rax,[rax] 11098 push_rax #_process_expression1 11099 lea_rax,[rbp+DWORD] %-88 11100 mov_rax,[rax] 11101 push_rax #_process_expression2 11102 mov_rbp,rdi 11103 call %FUNCTION_fputs 11104 pop_rbx # _process_expression_locals 11105 pop_rbx # _process_expression_locals 11106 pop_rbp # Restore old base pointer 11107 pop_rdi # Prevent overwrite 11108 push_rdi # Prevent overwriting in recursion 11109 push_rbp # Protect the old base pointer 11110 mov_rdi,rsp # Copy new base pointer 11111 lea_rax,[rip+DWORD] %STRING_main_26 11112 push_rax #_process_expression1 11113 lea_rax,[rbp+DWORD] %-88 11114 mov_rax,[rax] 11115 push_rax #_process_expression2 11116 mov_rbp,rdi 11117 call %FUNCTION_fputs 11118 pop_rbx # _process_expression_locals 11119 pop_rbx # _process_expression_locals 11120 pop_rbp # Restore old base pointer 11121 pop_rdi # Prevent overwrite 11122 push_rdi # Prevent overwriting in recursion 11123 push_rbp # Protect the old base pointer 11124 mov_rdi,rsp # Copy new base pointer 11125 mov_rax, %1 11126 push_rax #_process_expression1 11127 mov_rbp,rdi 11128 call %FUNCTION_exit 11129 pop_rbx # _process_expression_locals 11130 pop_rbp # Restore old base pointer 11131 pop_rdi # Prevent overwrite 11132 :_END_IF_main_24 11133 lea_rax,[rbp+DWORD] %-40 11134 push_rax #_common_recursion 11135 lea_rax,[rbp+DWORD] %-40 11136 mov_rax,[rax] 11137 # looking up offset 11138 # -> offset calculation 11139 mov_rbx, %48 11140 add_rax,rbx 11141 mov_rax,[rax] 11142 pop_rbx # _common_recursion 11143 mov_[rbx],rax 11144 jmp %WHILE_main_23 11145 :END_WHILE_main_23 11146 :_END_IF_main_18 11147 # IF_main_27 11148 lea_rax,[rbp+DWORD] %-88 11149 mov_rax,[rax] 11150 push_rax #_common_recursion 11151 lea_rax,[rip+DWORD] %GLOBAL_stdout 11152 mov_rax,[rax] 11153 pop_rbx # _common_recursion 11154 cmp_rbx,rax 11155 setne_al 11156 movzx_rax,al 11157 test_rax,rax 11158 je %ELSE_main_27 11159 push_rdi # Prevent overwriting in recursion 11160 push_rbp # Protect the old base pointer 11161 mov_rdi,rsp # Copy new base pointer 11162 lea_rax,[rbp+DWORD] %-88 11163 mov_rax,[rax] 11164 push_rax #_process_expression1 11165 mov_rbp,rdi 11166 call %FUNCTION_fclose 11167 pop_rbx # _process_expression_locals 11168 pop_rbp # Restore old base pointer 11169 pop_rdi # Prevent overwrite 11170 jmp %_END_IF_main_27 11171 :ELSE_main_27 11172 :_END_IF_main_27 11173 # IF_main_28 11174 lea_rax,[rbp+DWORD] %-72 11175 mov_rax,[rax] 11176 test_rax,rax 11177 je %ELSE_main_28 11178 mov_rax, %0 11179 pop_rbx # _return_result_locals 11180 pop_rbx # _return_result_locals 11181 pop_rbx # _return_result_locals 11182 pop_rbx # _return_result_locals 11183 pop_rbx # _return_result_locals 11184 pop_rbx # _return_result_locals 11185 pop_rbx # _return_result_locals 11186 pop_rbx # _return_result_locals 11187 ret 11188 jmp %_END_IF_main_28 11189 :ELSE_main_28 11190 mov_rax, %1 11191 pop_rbx # _return_result_locals 11192 pop_rbx # _return_result_locals 11193 pop_rbx # _return_result_locals 11194 pop_rbx # _return_result_locals 11195 pop_rbx # _return_result_locals 11196 pop_rbx # _return_result_locals 11197 pop_rbx # _return_result_locals 11198 pop_rbx # _return_result_locals 11199 ret 11200 :_END_IF_main_28 11201 pop_rbx # _recursive_statement_locals 11202 pop_rbx # _recursive_statement_locals 11203 pop_rbx # _recursive_statement_locals 11204 pop_rbx # _recursive_statement_locals 11205 pop_rbx # _recursive_statement_locals 11206 pop_rbx # _recursive_statement_locals 11207 pop_rbx # _recursive_statement_locals 11208 pop_rbx # _recursive_statement_locals 11209 ret 11210 11211 :ELF_data 11212 11213 # Program global variables 11214 :GLOBAL__malloc_ptr 11215 NULL 11216 :GLOBAL__brk_ptr 11217 NULL 11218 :GLOBAL_stdin 11219 NULL 11220 :GLOBAL_stdout 11221 NULL 11222 :GLOBAL_stderr 11223 NULL 11224 :GLOBAL___list 11225 NULL 11226 :GLOBAL_mask 11227 NULL 11228 11229 # Program strings 11230 :STRING___toupper_1 11231 "abcdefghijklmnopqrstuvwxyz" 11232 :STRING_strtoint_2 11233 "01" 11234 :STRING_strtoint_4 11235 "0123456789ABCDEFabcdef" 11236 :STRING_strtoint_6 11237 "01234567" 11238 :STRING_strtoint_7 11239 "0123456789" 11240 :STRING_int2str_0 11241 "int2str doesn't support a base less than 2 11242 " 11243 :STRING_int2str_1 11244 "int2str doesn't support a base more than 36 11245 " 11246 :STRING_int2str_3 11247 "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ" 11248 :STRING_int2str_6 11249 "-2147483648" 11250 :STRING_bad_checkfile_0 11251 ": no properly formatted SHA256 checksum lines found" 11252 :STRING_hash_to_string_0 11253 "0123456789abcdef" 11254 :STRING_check_file_4 11255 "r" 11256 :STRING_check_file_6 11257 ": No such file or directory" 11258 :STRING_check_file_8 11259 ": OK" 11260 :STRING_check_file_9 11261 ": FAILED 11262 Wanted: " 11263 :STRING_check_file_10 11264 " 11265 Received: " 11266 :STRING_main_0 11267 "" 11268 :STRING_main_4 11269 "-c" 11270 :STRING_main_5 11271 "--check" 11272 :STRING_main_7 11273 "-o" 11274 :STRING_main_8 11275 "--output" 11276 :STRING_main_10 11277 "w" 11278 :STRING_main_11 11279 "Output file cannot be opened! 11280 " 11281 :STRING_main_13 11282 "-h" 11283 :STRING_main_14 11284 "--help" 11285 :STRING_main_15 11286 "Usage: sha256sum [--check]" 11287 :STRING_main_16 11288 "r" 11289 :STRING_main_22 11290 ": No such file or directory" 11291 :STRING_main_25 11292 " " 11293 :STRING_main_26 11294 ": No such file or directory 11295 "