PageRenderTime 68ms CodeModel.GetById 15ms RepoModel.GetById 1ms app.codeStats 3ms

/09/Square/Square.asm

http://github.com/tianyicui/No.658659
Assembly | 49964 lines | 49964 code | 0 blank | 0 comment | 0 complexity | 33efa8563f02807d3f34ca0062ccadb2 MD5 | raw file

Large files files are truncated, but you can click here to view the full file

  1. // #0
  2. @261
  3. // #1
  4. D=A
  5. // #2
  6. @SP
  7. // #3
  8. M=D //SP=261
  9. // #4
  10. @Sys.init
  11. // #5
  12. 0;JMP
  13. //
  14. //// function Array.new 0
  15. (Array.new)
  16. //
  17. //// push argument 0
  18. //^^ push_from_ram(ARG, 0)
  19. // #6
  20. @ARG
  21. // #7
  22. D=M
  23. // #8
  24. @0
  25. // #9
  26. A=D+A
  27. // #10
  28. D=M
  29. //^^ push_d_to_stack
  30. // #11
  31. @SP
  32. // #12
  33. A=M
  34. // #13
  35. M=D
  36. // #14
  37. @SP
  38. // #15
  39. M=M+1
  40. //vv push_d_to_stack
  41. //vv push_from_ram(ARG, 0)
  42. //
  43. //// push constant 0
  44. //^^ push_constant(0)
  45. // #16
  46. @0
  47. // #17
  48. D=A
  49. //^^ push_d_to_stack
  50. // #18
  51. @SP
  52. // #19
  53. A=M
  54. // #20
  55. M=D
  56. // #21
  57. @SP
  58. // #22
  59. M=M+1
  60. //vv push_d_to_stack
  61. //vv push_constant(0)
  62. //
  63. //// gt
  64. //^^ arith_cmp_op(JGT)
  65. //^^ pop_stack_to_d
  66. // #23
  67. @SP
  68. // #24
  69. M=M-1
  70. // #25
  71. A=M
  72. // #26
  73. D=M
  74. //vv pop_stack_to_d
  75. //^^ arith_d_with_stack_top(D-M)
  76. // #27
  77. @R13
  78. // #28
  79. M=D
  80. //^^ pop_stack_to_d
  81. // #29
  82. @SP
  83. // #30
  84. M=M-1
  85. // #31
  86. A=M
  87. // #32
  88. D=M
  89. //vv pop_stack_to_d
  90. // #33
  91. @R13
  92. // #34
  93. D=D-M
  94. // #35
  95. @R13
  96. // #36
  97. M=0
  98. //vv arith_d_with_stack_top(D-M)
  99. // #37
  100. @PUT_TRUE_1
  101. // #38
  102. D;JGT
  103. // #39
  104. @R13
  105. // #40
  106. M=0
  107. // #41
  108. @CONT_1
  109. // #42
  110. 0;JMP
  111. (PUT_TRUE_1)
  112. // #43
  113. @R13
  114. // #44
  115. M=-1
  116. (CONT_1)
  117. // #45
  118. @R13
  119. // #46
  120. D=M
  121. // #47
  122. @R13
  123. // #48
  124. M=0
  125. //^^ push_d_to_stack
  126. // #49
  127. @SP
  128. // #50
  129. A=M
  130. // #51
  131. M=D
  132. // #52
  133. @SP
  134. // #53
  135. M=M+1
  136. //vv push_d_to_stack
  137. //vv arith_cmp_op(JGT)
  138. //
  139. //// not
  140. //^^ arith_unary_op(!)
  141. //^^ pop_stack_to_d
  142. // #54
  143. @SP
  144. // #55
  145. M=M-1
  146. // #56
  147. A=M
  148. // #57
  149. D=M
  150. //vv pop_stack_to_d
  151. // #58
  152. D=!D
  153. //^^ push_d_to_stack
  154. // #59
  155. @SP
  156. // #60
  157. A=M
  158. // #61
  159. M=D
  160. // #62
  161. @SP
  162. // #63
  163. M=M+1
  164. //vv push_d_to_stack
  165. //vv arith_unary_op(!)
  166. //
  167. //// if-goto IF_TRUE0
  168. //^^ pop_stack_to_d
  169. // #64
  170. @SP
  171. // #65
  172. M=M-1
  173. // #66
  174. A=M
  175. // #67
  176. D=M
  177. //vv pop_stack_to_d
  178. // #68
  179. @Array.new$IF_TRUE0
  180. // #69
  181. D;JNE
  182. //
  183. //// goto IF_FALSE0
  184. // #70
  185. @Array.new$IF_FALSE0
  186. // #71
  187. 0;JMP
  188. //
  189. //// label IF_TRUE0
  190. (Array.new$IF_TRUE0)
  191. //
  192. //// push constant 2
  193. //^^ push_constant(2)
  194. // #72
  195. @2
  196. // #73
  197. D=A
  198. //^^ push_d_to_stack
  199. // #74
  200. @SP
  201. // #75
  202. A=M
  203. // #76
  204. M=D
  205. // #77
  206. @SP
  207. // #78
  208. M=M+1
  209. //vv push_d_to_stack
  210. //vv push_constant(2)
  211. //
  212. //// call Sys.error 1
  213. //^^ push_constant(RET_ADDR_2)
  214. // #79
  215. @RET_ADDR_2
  216. // #80
  217. D=A
  218. //^^ push_d_to_stack
  219. // #81
  220. @SP
  221. // #82
  222. A=M
  223. // #83
  224. M=D
  225. // #84
  226. @SP
  227. // #85
  228. M=M+1
  229. //vv push_d_to_stack
  230. //vv push_constant(RET_ADDR_2)
  231. //push return-address
  232. // #86
  233. @LCL
  234. // #87
  235. D=M
  236. //^^ push_d_to_stack
  237. // #88
  238. @SP
  239. // #89
  240. A=M
  241. // #90
  242. M=D
  243. // #91
  244. @SP
  245. // #92
  246. M=M+1
  247. //vv push_d_to_stack
  248. //push LCL
  249. // #93
  250. @ARG
  251. // #94
  252. D=M
  253. //^^ push_d_to_stack
  254. // #95
  255. @SP
  256. // #96
  257. A=M
  258. // #97
  259. M=D
  260. // #98
  261. @SP
  262. // #99
  263. M=M+1
  264. //vv push_d_to_stack
  265. //push ARG
  266. // #100
  267. @THIS
  268. // #101
  269. D=M
  270. //^^ push_d_to_stack
  271. // #102
  272. @SP
  273. // #103
  274. A=M
  275. // #104
  276. M=D
  277. // #105
  278. @SP
  279. // #106
  280. M=M+1
  281. //vv push_d_to_stack
  282. //push THIS
  283. // #107
  284. @THAT
  285. // #108
  286. D=M
  287. //^^ push_d_to_stack
  288. // #109
  289. @SP
  290. // #110
  291. A=M
  292. // #111
  293. M=D
  294. // #112
  295. @SP
  296. // #113
  297. M=M+1
  298. //vv push_d_to_stack
  299. //push THAT
  300. // #114
  301. @SP
  302. // #115
  303. D=M
  304. // #116
  305. @ARG
  306. // #117
  307. M=D
  308. // #118
  309. @6
  310. // #119
  311. D=A
  312. // #120
  313. @ARG
  314. // #121
  315. M=M-D // ARG = SP - args - 5
  316. // #122
  317. @SP
  318. // #123
  319. D=M
  320. // #124
  321. @LCL
  322. // #125
  323. M=D // LCL = SP
  324. // #126
  325. @Sys.error
  326. // #127
  327. 0;JMP
  328. (RET_ADDR_2)
  329. //
  330. //// pop temp 0
  331. //^^ pop_to_loc{5)
  332. //^^ pop_stack_to_d
  333. // #128
  334. @SP
  335. // #129
  336. M=M-1
  337. // #130
  338. A=M
  339. // #131
  340. D=M
  341. //vv pop_stack_to_d
  342. // #132
  343. @5
  344. // #133
  345. M=D
  346. //vv pop_to_loc{5)
  347. //
  348. //// label IF_FALSE0
  349. (Array.new$IF_FALSE0)
  350. //
  351. //// push argument 0
  352. //^^ push_from_ram(ARG, 0)
  353. // #134
  354. @ARG
  355. // #135
  356. D=M
  357. // #136
  358. @0
  359. // #137
  360. A=D+A
  361. // #138
  362. D=M
  363. //^^ push_d_to_stack
  364. // #139
  365. @SP
  366. // #140
  367. A=M
  368. // #141
  369. M=D
  370. // #142
  371. @SP
  372. // #143
  373. M=M+1
  374. //vv push_d_to_stack
  375. //vv push_from_ram(ARG, 0)
  376. //
  377. //// call Memory.alloc 1
  378. //^^ push_constant(RET_ADDR_3)
  379. // #144
  380. @RET_ADDR_3
  381. // #145
  382. D=A
  383. //^^ push_d_to_stack
  384. // #146
  385. @SP
  386. // #147
  387. A=M
  388. // #148
  389. M=D
  390. // #149
  391. @SP
  392. // #150
  393. M=M+1
  394. //vv push_d_to_stack
  395. //vv push_constant(RET_ADDR_3)
  396. //push return-address
  397. // #151
  398. @LCL
  399. // #152
  400. D=M
  401. //^^ push_d_to_stack
  402. // #153
  403. @SP
  404. // #154
  405. A=M
  406. // #155
  407. M=D
  408. // #156
  409. @SP
  410. // #157
  411. M=M+1
  412. //vv push_d_to_stack
  413. //push LCL
  414. // #158
  415. @ARG
  416. // #159
  417. D=M
  418. //^^ push_d_to_stack
  419. // #160
  420. @SP
  421. // #161
  422. A=M
  423. // #162
  424. M=D
  425. // #163
  426. @SP
  427. // #164
  428. M=M+1
  429. //vv push_d_to_stack
  430. //push ARG
  431. // #165
  432. @THIS
  433. // #166
  434. D=M
  435. //^^ push_d_to_stack
  436. // #167
  437. @SP
  438. // #168
  439. A=M
  440. // #169
  441. M=D
  442. // #170
  443. @SP
  444. // #171
  445. M=M+1
  446. //vv push_d_to_stack
  447. //push THIS
  448. // #172
  449. @THAT
  450. // #173
  451. D=M
  452. //^^ push_d_to_stack
  453. // #174
  454. @SP
  455. // #175
  456. A=M
  457. // #176
  458. M=D
  459. // #177
  460. @SP
  461. // #178
  462. M=M+1
  463. //vv push_d_to_stack
  464. //push THAT
  465. // #179
  466. @SP
  467. // #180
  468. D=M
  469. // #181
  470. @ARG
  471. // #182
  472. M=D
  473. // #183
  474. @6
  475. // #184
  476. D=A
  477. // #185
  478. @ARG
  479. // #186
  480. M=M-D // ARG = SP - args - 5
  481. // #187
  482. @SP
  483. // #188
  484. D=M
  485. // #189
  486. @LCL
  487. // #190
  488. M=D // LCL = SP
  489. // #191
  490. @Memory.alloc
  491. // #192
  492. 0;JMP
  493. (RET_ADDR_3)
  494. //
  495. //// return
  496. // #193
  497. @LCL
  498. // #194
  499. D=M
  500. // #195
  501. @R14
  502. // #196
  503. M=D //R14=LCL
  504. // #197
  505. @5
  506. // #198
  507. A=D-A
  508. // #199
  509. D=M
  510. // #200
  511. @R15
  512. // #201
  513. M=D //R15=*(LCL-5)
  514. //^^ pop_stack_to_d
  515. // #202
  516. @SP
  517. // #203
  518. M=M-1
  519. // #204
  520. A=M
  521. // #205
  522. D=M
  523. //vv pop_stack_to_d
  524. // #206
  525. @ARG
  526. // #207
  527. A=M
  528. // #208
  529. M=D //*ARG = pop()
  530. // #209
  531. @ARG
  532. // #210
  533. D=M
  534. // #211
  535. @SP
  536. // #212
  537. M=D+1 //SP=ARG+1
  538. // #213
  539. @R14
  540. // #214
  541. AM=M-1
  542. // #215
  543. D=M
  544. // #216
  545. @THAT
  546. // #217
  547. M=D //THAT = *(--R14)
  548. // #218
  549. @R14
  550. // #219
  551. AM=M-1
  552. // #220
  553. D=M
  554. // #221
  555. @THIS
  556. // #222
  557. M=D //THIS = *(--R14)
  558. // #223
  559. @R14
  560. // #224
  561. AM=M-1
  562. // #225
  563. D=M
  564. // #226
  565. @ARG
  566. // #227
  567. M=D //ARG = *(--R14)
  568. // #228
  569. @R14
  570. // #229
  571. AM=M-1
  572. // #230
  573. D=M
  574. // #231
  575. @LCL
  576. // #232
  577. M=D //LCL = *(--R14)
  578. // #233
  579. @R15
  580. // #234
  581. A=M
  582. // #235
  583. 0;JMP //goto *R15
  584. //
  585. //// function Array.dispose 0
  586. (Array.dispose)
  587. //
  588. //// push argument 0
  589. //^^ push_from_ram(ARG, 0)
  590. // #236
  591. @ARG
  592. // #237
  593. D=M
  594. // #238
  595. @0
  596. // #239
  597. A=D+A
  598. // #240
  599. D=M
  600. //^^ push_d_to_stack
  601. // #241
  602. @SP
  603. // #242
  604. A=M
  605. // #243
  606. M=D
  607. // #244
  608. @SP
  609. // #245
  610. M=M+1
  611. //vv push_d_to_stack
  612. //vv push_from_ram(ARG, 0)
  613. //
  614. //// pop pointer 0
  615. //^^ pop_to_loc{3)
  616. //^^ pop_stack_to_d
  617. // #246
  618. @SP
  619. // #247
  620. M=M-1
  621. // #248
  622. A=M
  623. // #249
  624. D=M
  625. //vv pop_stack_to_d
  626. // #250
  627. @3
  628. // #251
  629. M=D
  630. //vv pop_to_loc{3)
  631. //
  632. //// push pointer 0
  633. //^^ push_from_loc(3)
  634. // #252
  635. @3
  636. // #253
  637. D=M
  638. //^^ push_d_to_stack
  639. // #254
  640. @SP
  641. // #255
  642. A=M
  643. // #256
  644. M=D
  645. // #257
  646. @SP
  647. // #258
  648. M=M+1
  649. //vv push_d_to_stack
  650. //vv push_from_loc(3)
  651. //
  652. //// call Memory.deAlloc 1
  653. //^^ push_constant(RET_ADDR_4)
  654. // #259
  655. @RET_ADDR_4
  656. // #260
  657. D=A
  658. //^^ push_d_to_stack
  659. // #261
  660. @SP
  661. // #262
  662. A=M
  663. // #263
  664. M=D
  665. // #264
  666. @SP
  667. // #265
  668. M=M+1
  669. //vv push_d_to_stack
  670. //vv push_constant(RET_ADDR_4)
  671. //push return-address
  672. // #266
  673. @LCL
  674. // #267
  675. D=M
  676. //^^ push_d_to_stack
  677. // #268
  678. @SP
  679. // #269
  680. A=M
  681. // #270
  682. M=D
  683. // #271
  684. @SP
  685. // #272
  686. M=M+1
  687. //vv push_d_to_stack
  688. //push LCL
  689. // #273
  690. @ARG
  691. // #274
  692. D=M
  693. //^^ push_d_to_stack
  694. // #275
  695. @SP
  696. // #276
  697. A=M
  698. // #277
  699. M=D
  700. // #278
  701. @SP
  702. // #279
  703. M=M+1
  704. //vv push_d_to_stack
  705. //push ARG
  706. // #280
  707. @THIS
  708. // #281
  709. D=M
  710. //^^ push_d_to_stack
  711. // #282
  712. @SP
  713. // #283
  714. A=M
  715. // #284
  716. M=D
  717. // #285
  718. @SP
  719. // #286
  720. M=M+1
  721. //vv push_d_to_stack
  722. //push THIS
  723. // #287
  724. @THAT
  725. // #288
  726. D=M
  727. //^^ push_d_to_stack
  728. // #289
  729. @SP
  730. // #290
  731. A=M
  732. // #291
  733. M=D
  734. // #292
  735. @SP
  736. // #293
  737. M=M+1
  738. //vv push_d_to_stack
  739. //push THAT
  740. // #294
  741. @SP
  742. // #295
  743. D=M
  744. // #296
  745. @ARG
  746. // #297
  747. M=D
  748. // #298
  749. @6
  750. // #299
  751. D=A
  752. // #300
  753. @ARG
  754. // #301
  755. M=M-D // ARG = SP - args - 5
  756. // #302
  757. @SP
  758. // #303
  759. D=M
  760. // #304
  761. @LCL
  762. // #305
  763. M=D // LCL = SP
  764. // #306
  765. @Memory.deAlloc
  766. // #307
  767. 0;JMP
  768. (RET_ADDR_4)
  769. //
  770. //// pop temp 0
  771. //^^ pop_to_loc{5)
  772. //^^ pop_stack_to_d
  773. // #308
  774. @SP
  775. // #309
  776. M=M-1
  777. // #310
  778. A=M
  779. // #311
  780. D=M
  781. //vv pop_stack_to_d
  782. // #312
  783. @5
  784. // #313
  785. M=D
  786. //vv pop_to_loc{5)
  787. //
  788. //// push constant 0
  789. //^^ push_constant(0)
  790. // #314
  791. @0
  792. // #315
  793. D=A
  794. //^^ push_d_to_stack
  795. // #316
  796. @SP
  797. // #317
  798. A=M
  799. // #318
  800. M=D
  801. // #319
  802. @SP
  803. // #320
  804. M=M+1
  805. //vv push_d_to_stack
  806. //vv push_constant(0)
  807. //
  808. //// return
  809. // #321
  810. @LCL
  811. // #322
  812. D=M
  813. // #323
  814. @R14
  815. // #324
  816. M=D //R14=LCL
  817. // #325
  818. @5
  819. // #326
  820. A=D-A
  821. // #327
  822. D=M
  823. // #328
  824. @R15
  825. // #329
  826. M=D //R15=*(LCL-5)
  827. //^^ pop_stack_to_d
  828. // #330
  829. @SP
  830. // #331
  831. M=M-1
  832. // #332
  833. A=M
  834. // #333
  835. D=M
  836. //vv pop_stack_to_d
  837. // #334
  838. @ARG
  839. // #335
  840. A=M
  841. // #336
  842. M=D //*ARG = pop()
  843. // #337
  844. @ARG
  845. // #338
  846. D=M
  847. // #339
  848. @SP
  849. // #340
  850. M=D+1 //SP=ARG+1
  851. // #341
  852. @R14
  853. // #342
  854. AM=M-1
  855. // #343
  856. D=M
  857. // #344
  858. @THAT
  859. // #345
  860. M=D //THAT = *(--R14)
  861. // #346
  862. @R14
  863. // #347
  864. AM=M-1
  865. // #348
  866. D=M
  867. // #349
  868. @THIS
  869. // #350
  870. M=D //THIS = *(--R14)
  871. // #351
  872. @R14
  873. // #352
  874. AM=M-1
  875. // #353
  876. D=M
  877. // #354
  878. @ARG
  879. // #355
  880. M=D //ARG = *(--R14)
  881. // #356
  882. @R14
  883. // #357
  884. AM=M-1
  885. // #358
  886. D=M
  887. // #359
  888. @LCL
  889. // #360
  890. M=D //LCL = *(--R14)
  891. // #361
  892. @R15
  893. // #362
  894. A=M
  895. // #363
  896. 0;JMP //goto *R15
  897. //
  898. //// function Keyboard.init 0
  899. (Keyboard.init)
  900. //
  901. //// push constant 0
  902. //^^ push_constant(0)
  903. // #364
  904. @0
  905. // #365
  906. D=A
  907. //^^ push_d_to_stack
  908. // #366
  909. @SP
  910. // #367
  911. A=M
  912. // #368
  913. M=D
  914. // #369
  915. @SP
  916. // #370
  917. M=M+1
  918. //vv push_d_to_stack
  919. //vv push_constant(0)
  920. //
  921. //// return
  922. // #371
  923. @LCL
  924. // #372
  925. D=M
  926. // #373
  927. @R14
  928. // #374
  929. M=D //R14=LCL
  930. // #375
  931. @5
  932. // #376
  933. A=D-A
  934. // #377
  935. D=M
  936. // #378
  937. @R15
  938. // #379
  939. M=D //R15=*(LCL-5)
  940. //^^ pop_stack_to_d
  941. // #380
  942. @SP
  943. // #381
  944. M=M-1
  945. // #382
  946. A=M
  947. // #383
  948. D=M
  949. //vv pop_stack_to_d
  950. // #384
  951. @ARG
  952. // #385
  953. A=M
  954. // #386
  955. M=D //*ARG = pop()
  956. // #387
  957. @ARG
  958. // #388
  959. D=M
  960. // #389
  961. @SP
  962. // #390
  963. M=D+1 //SP=ARG+1
  964. // #391
  965. @R14
  966. // #392
  967. AM=M-1
  968. // #393
  969. D=M
  970. // #394
  971. @THAT
  972. // #395
  973. M=D //THAT = *(--R14)
  974. // #396
  975. @R14
  976. // #397
  977. AM=M-1
  978. // #398
  979. D=M
  980. // #399
  981. @THIS
  982. // #400
  983. M=D //THIS = *(--R14)
  984. // #401
  985. @R14
  986. // #402
  987. AM=M-1
  988. // #403
  989. D=M
  990. // #404
  991. @ARG
  992. // #405
  993. M=D //ARG = *(--R14)
  994. // #406
  995. @R14
  996. // #407
  997. AM=M-1
  998. // #408
  999. D=M
  1000. // #409
  1001. @LCL
  1002. // #410
  1003. M=D //LCL = *(--R14)
  1004. // #411
  1005. @R15
  1006. // #412
  1007. A=M
  1008. // #413
  1009. 0;JMP //goto *R15
  1010. //
  1011. //// function Keyboard.keyPressed 0
  1012. (Keyboard.keyPressed)
  1013. //
  1014. //// push constant 24576
  1015. //^^ push_constant(24576)
  1016. // #414
  1017. @24576
  1018. // #415
  1019. D=A
  1020. //^^ push_d_to_stack
  1021. // #416
  1022. @SP
  1023. // #417
  1024. A=M
  1025. // #418
  1026. M=D
  1027. // #419
  1028. @SP
  1029. // #420
  1030. M=M+1
  1031. //vv push_d_to_stack
  1032. //vv push_constant(24576)
  1033. //
  1034. //// call Memory.peek 1
  1035. //^^ push_constant(RET_ADDR_5)
  1036. // #421
  1037. @RET_ADDR_5
  1038. // #422
  1039. D=A
  1040. //^^ push_d_to_stack
  1041. // #423
  1042. @SP
  1043. // #424
  1044. A=M
  1045. // #425
  1046. M=D
  1047. // #426
  1048. @SP
  1049. // #427
  1050. M=M+1
  1051. //vv push_d_to_stack
  1052. //vv push_constant(RET_ADDR_5)
  1053. //push return-address
  1054. // #428
  1055. @LCL
  1056. // #429
  1057. D=M
  1058. //^^ push_d_to_stack
  1059. // #430
  1060. @SP
  1061. // #431
  1062. A=M
  1063. // #432
  1064. M=D
  1065. // #433
  1066. @SP
  1067. // #434
  1068. M=M+1
  1069. //vv push_d_to_stack
  1070. //push LCL
  1071. // #435
  1072. @ARG
  1073. // #436
  1074. D=M
  1075. //^^ push_d_to_stack
  1076. // #437
  1077. @SP
  1078. // #438
  1079. A=M
  1080. // #439
  1081. M=D
  1082. // #440
  1083. @SP
  1084. // #441
  1085. M=M+1
  1086. //vv push_d_to_stack
  1087. //push ARG
  1088. // #442
  1089. @THIS
  1090. // #443
  1091. D=M
  1092. //^^ push_d_to_stack
  1093. // #444
  1094. @SP
  1095. // #445
  1096. A=M
  1097. // #446
  1098. M=D
  1099. // #447
  1100. @SP
  1101. // #448
  1102. M=M+1
  1103. //vv push_d_to_stack
  1104. //push THIS
  1105. // #449
  1106. @THAT
  1107. // #450
  1108. D=M
  1109. //^^ push_d_to_stack
  1110. // #451
  1111. @SP
  1112. // #452
  1113. A=M
  1114. // #453
  1115. M=D
  1116. // #454
  1117. @SP
  1118. // #455
  1119. M=M+1
  1120. //vv push_d_to_stack
  1121. //push THAT
  1122. // #456
  1123. @SP
  1124. // #457
  1125. D=M
  1126. // #458
  1127. @ARG
  1128. // #459
  1129. M=D
  1130. // #460
  1131. @6
  1132. // #461
  1133. D=A
  1134. // #462
  1135. @ARG
  1136. // #463
  1137. M=M-D // ARG = SP - args - 5
  1138. // #464
  1139. @SP
  1140. // #465
  1141. D=M
  1142. // #466
  1143. @LCL
  1144. // #467
  1145. M=D // LCL = SP
  1146. // #468
  1147. @Memory.peek
  1148. // #469
  1149. 0;JMP
  1150. (RET_ADDR_5)
  1151. //
  1152. //// return
  1153. // #470
  1154. @LCL
  1155. // #471
  1156. D=M
  1157. // #472
  1158. @R14
  1159. // #473
  1160. M=D //R14=LCL
  1161. // #474
  1162. @5
  1163. // #475
  1164. A=D-A
  1165. // #476
  1166. D=M
  1167. // #477
  1168. @R15
  1169. // #478
  1170. M=D //R15=*(LCL-5)
  1171. //^^ pop_stack_to_d
  1172. // #479
  1173. @SP
  1174. // #480
  1175. M=M-1
  1176. // #481
  1177. A=M
  1178. // #482
  1179. D=M
  1180. //vv pop_stack_to_d
  1181. // #483
  1182. @ARG
  1183. // #484
  1184. A=M
  1185. // #485
  1186. M=D //*ARG = pop()
  1187. // #486
  1188. @ARG
  1189. // #487
  1190. D=M
  1191. // #488
  1192. @SP
  1193. // #489
  1194. M=D+1 //SP=ARG+1
  1195. // #490
  1196. @R14
  1197. // #491
  1198. AM=M-1
  1199. // #492
  1200. D=M
  1201. // #493
  1202. @THAT
  1203. // #494
  1204. M=D //THAT = *(--R14)
  1205. // #495
  1206. @R14
  1207. // #496
  1208. AM=M-1
  1209. // #497
  1210. D=M
  1211. // #498
  1212. @THIS
  1213. // #499
  1214. M=D //THIS = *(--R14)
  1215. // #500
  1216. @R14
  1217. // #501
  1218. AM=M-1
  1219. // #502
  1220. D=M
  1221. // #503
  1222. @ARG
  1223. // #504
  1224. M=D //ARG = *(--R14)
  1225. // #505
  1226. @R14
  1227. // #506
  1228. AM=M-1
  1229. // #507
  1230. D=M
  1231. // #508
  1232. @LCL
  1233. // #509
  1234. M=D //LCL = *(--R14)
  1235. // #510
  1236. @R15
  1237. // #511
  1238. A=M
  1239. // #512
  1240. 0;JMP //goto *R15
  1241. //
  1242. //// function Keyboard.readChar 2
  1243. (Keyboard.readChar)
  1244. // #513
  1245. D=0
  1246. //^^ push_d_to_stack
  1247. // #514
  1248. @SP
  1249. // #515
  1250. A=M
  1251. // #516
  1252. M=D
  1253. // #517
  1254. @SP
  1255. // #518
  1256. M=M+1
  1257. //vv push_d_to_stack
  1258. // #519
  1259. D=0
  1260. //^^ push_d_to_stack
  1261. // #520
  1262. @SP
  1263. // #521
  1264. A=M
  1265. // #522
  1266. M=D
  1267. // #523
  1268. @SP
  1269. // #524
  1270. M=M+1
  1271. //vv push_d_to_stack
  1272. //
  1273. //// call SquareGame.new 0
  1274. //^^ push_constant(RET_ADDR_26)
  1275. // #525
  1276. @RET_ADDR_26
  1277. // #526
  1278. D=A
  1279. //^^ push_d_to_stack
  1280. // #527
  1281. @SP
  1282. // #528
  1283. A=M
  1284. // #529
  1285. M=D
  1286. // #530
  1287. @SP
  1288. // #531
  1289. M=M+1
  1290. //vv push_d_to_stack
  1291. //vv push_constant(RET_ADDR_26)
  1292. //push return-address
  1293. // #532
  1294. @LCL
  1295. // #533
  1296. D=M
  1297. //^^ push_d_to_stack
  1298. // #534
  1299. @SP
  1300. // #535
  1301. A=M
  1302. // #536
  1303. M=D
  1304. // #537
  1305. @SP
  1306. // #538
  1307. M=M+1
  1308. //vv push_d_to_stack
  1309. //push LCL
  1310. // #539
  1311. @ARG
  1312. // #540
  1313. D=M
  1314. //^^ push_d_to_stack
  1315. // #541
  1316. @SP
  1317. // #542
  1318. A=M
  1319. // #543
  1320. M=D
  1321. // #544
  1322. @SP
  1323. // #545
  1324. M=M+1
  1325. //vv push_d_to_stack
  1326. //push ARG
  1327. // #546
  1328. @THIS
  1329. // #547
  1330. D=M
  1331. //^^ push_d_to_stack
  1332. // #548
  1333. @SP
  1334. // #549
  1335. A=M
  1336. // #550
  1337. M=D
  1338. // #551
  1339. @SP
  1340. // #552
  1341. M=M+1
  1342. //vv push_d_to_stack
  1343. //push THIS
  1344. // #553
  1345. @THAT
  1346. // #554
  1347. D=M
  1348. //^^ push_d_to_stack
  1349. // #555
  1350. @SP
  1351. // #556
  1352. A=M
  1353. // #557
  1354. M=D
  1355. // #558
  1356. @SP
  1357. // #559
  1358. M=M+1
  1359. //vv push_d_to_stack
  1360. //push THAT
  1361. // #560
  1362. @SP
  1363. // #561
  1364. D=M
  1365. // #562
  1366. @ARG
  1367. // #563
  1368. M=D
  1369. // #564
  1370. @5
  1371. // #565
  1372. D=A
  1373. // #566
  1374. @ARG
  1375. // #567
  1376. M=M-D // ARG = SP - args - 5
  1377. // #568
  1378. @SP
  1379. // #569
  1380. D=M
  1381. // #570
  1382. @LCL
  1383. // #571
  1384. M=D // LCL = SP
  1385. // #572
  1386. @SquareGame.new
  1387. // #573
  1388. 0;JMP
  1389. (RET_ADDR_26)
  1390. //
  1391. //// pop local 0
  1392. //^^ pop_to_ram(LCL, 0)
  1393. // #574
  1394. @LCL
  1395. // #575
  1396. D=M
  1397. // #576
  1398. @0
  1399. // #577
  1400. D=D+A
  1401. // #578
  1402. @R13
  1403. // #579
  1404. M=D
  1405. //^^ pop_stack_to_d
  1406. // #580
  1407. @SP
  1408. // #581
  1409. M=M-1
  1410. // #582
  1411. A=M
  1412. // #583
  1413. D=M
  1414. //vv pop_stack_to_d
  1415. // #584
  1416. @R13
  1417. // #585
  1418. A=M
  1419. // #586
  1420. M=D
  1421. // #587
  1422. @R13
  1423. // #588
  1424. M=0
  1425. //vv pop_to_ram(LCL, 0)
  1426. //
  1427. //// push local 0
  1428. //^^ push_from_ram(LCL, 0)
  1429. // #589
  1430. @LCL
  1431. // #590
  1432. D=M
  1433. // #591
  1434. @0
  1435. // #592
  1436. A=D+A
  1437. // #593
  1438. D=M
  1439. //^^ push_d_to_stack
  1440. // #594
  1441. @SP
  1442. // #595
  1443. A=M
  1444. // #596
  1445. M=D
  1446. // #597
  1447. @SP
  1448. // #598
  1449. M=M+1
  1450. //vv push_d_to_stack
  1451. //vv push_from_ram(LCL, 0)
  1452. //
  1453. //// call SquareGame.run 1
  1454. //^^ push_constant(RET_ADDR_27)
  1455. // #599
  1456. @RET_ADDR_27
  1457. // #600
  1458. D=A
  1459. //^^ push_d_to_stack
  1460. // #601
  1461. @SP
  1462. // #602
  1463. A=M
  1464. // #603
  1465. M=D
  1466. // #604
  1467. @SP
  1468. // #605
  1469. M=M+1
  1470. //vv push_d_to_stack
  1471. //vv push_constant(RET_ADDR_27)
  1472. //push return-address
  1473. // #606
  1474. @LCL
  1475. // #607
  1476. D=M
  1477. //^^ push_d_to_stack
  1478. // #608
  1479. @SP
  1480. // #609
  1481. A=M
  1482. // #610
  1483. M=D
  1484. // #611
  1485. @SP
  1486. // #612
  1487. M=M+1
  1488. //vv push_d_to_stack
  1489. //push LCL
  1490. // #613
  1491. @ARG
  1492. // #614
  1493. D=M
  1494. //^^ push_d_to_stack
  1495. // #615
  1496. @SP
  1497. // #616
  1498. A=M
  1499. // #617
  1500. M=D
  1501. // #618
  1502. @SP
  1503. // #619
  1504. M=M+1
  1505. //vv push_d_to_stack
  1506. //push ARG
  1507. // #620
  1508. @THIS
  1509. // #621
  1510. D=M
  1511. //^^ push_d_to_stack
  1512. // #622
  1513. @SP
  1514. // #623
  1515. A=M
  1516. // #624
  1517. M=D
  1518. // #625
  1519. @SP
  1520. // #626
  1521. M=M+1
  1522. //vv push_d_to_stack
  1523. //push THIS
  1524. // #627
  1525. @THAT
  1526. // #628
  1527. D=M
  1528. //^^ push_d_to_stack
  1529. // #629
  1530. @SP
  1531. // #630
  1532. A=M
  1533. // #631
  1534. M=D
  1535. // #632
  1536. @SP
  1537. // #633
  1538. M=M+1
  1539. //vv push_d_to_stack
  1540. //push THAT
  1541. // #634
  1542. @SP
  1543. // #635
  1544. D=M
  1545. // #636
  1546. @ARG
  1547. // #637
  1548. M=D
  1549. // #638
  1550. @6
  1551. // #639
  1552. D=A
  1553. // #640
  1554. @ARG
  1555. // #641
  1556. M=M-D // ARG = SP - args - 5
  1557. // #642
  1558. @SP
  1559. // #643
  1560. D=M
  1561. // #644
  1562. @LCL
  1563. // #645
  1564. M=D // LCL = SP
  1565. // #646
  1566. @SquareGame.run
  1567. // #647
  1568. 0;JMP
  1569. (RET_ADDR_27)
  1570. //
  1571. //// pop temp 0
  1572. //^^ pop_to_loc{5)
  1573. //^^ pop_stack_to_d
  1574. // #648
  1575. @SP
  1576. // #649
  1577. M=M-1
  1578. // #650
  1579. A=M
  1580. // #651
  1581. D=M
  1582. //vv pop_stack_to_d
  1583. // #652
  1584. @5
  1585. // #653
  1586. M=D
  1587. //vv pop_to_loc{5)
  1588. //
  1589. //// push local 0
  1590. //^^ push_from_ram(LCL, 0)
  1591. // #654
  1592. @LCL
  1593. // #655
  1594. D=M
  1595. // #656
  1596. @0
  1597. // #657
  1598. A=D+A
  1599. // #658
  1600. D=M
  1601. //^^ push_d_to_stack
  1602. // #659
  1603. @SP
  1604. // #660
  1605. A=M
  1606. // #661
  1607. M=D
  1608. // #662
  1609. @SP
  1610. // #663
  1611. M=M+1
  1612. //vv push_d_to_stack
  1613. //vv push_from_ram(LCL, 0)
  1614. //
  1615. //// call SquareGame.dispose 1
  1616. //^^ push_constant(RET_ADDR_28)
  1617. // #664
  1618. @RET_ADDR_28
  1619. // #665
  1620. D=A
  1621. //^^ push_d_to_stack
  1622. // #666
  1623. @SP
  1624. // #667
  1625. A=M
  1626. // #668
  1627. M=D
  1628. // #669
  1629. @SP
  1630. // #670
  1631. M=M+1
  1632. //vv push_d_to_stack
  1633. //vv push_constant(RET_ADDR_28)
  1634. //push return-address
  1635. // #671
  1636. @LCL
  1637. // #672
  1638. D=M
  1639. //^^ push_d_to_stack
  1640. // #673
  1641. @SP
  1642. // #674
  1643. A=M
  1644. // #675
  1645. M=D
  1646. // #676
  1647. @SP
  1648. // #677
  1649. M=M+1
  1650. //vv push_d_to_stack
  1651. //push LCL
  1652. // #678
  1653. @ARG
  1654. // #679
  1655. D=M
  1656. //^^ push_d_to_stack
  1657. // #680
  1658. @SP
  1659. // #681
  1660. A=M
  1661. // #682
  1662. M=D
  1663. // #683
  1664. @SP
  1665. // #684
  1666. M=M+1
  1667. //vv push_d_to_stack
  1668. //push ARG
  1669. // #685
  1670. @THIS
  1671. // #686
  1672. D=M
  1673. //^^ push_d_to_stack
  1674. // #687
  1675. @SP
  1676. // #688
  1677. A=M
  1678. // #689
  1679. M=D
  1680. // #690
  1681. @SP
  1682. // #691
  1683. M=M+1
  1684. //vv push_d_to_stack
  1685. //push THIS
  1686. // #692
  1687. @THAT
  1688. // #693
  1689. D=M
  1690. //^^ push_d_to_stack
  1691. // #694
  1692. @SP
  1693. // #695
  1694. A=M
  1695. // #696
  1696. M=D
  1697. // #697
  1698. @SP
  1699. // #698
  1700. M=M+1
  1701. //vv push_d_to_stack
  1702. //push THAT
  1703. // #699
  1704. @SP
  1705. // #700
  1706. D=M
  1707. // #701
  1708. @ARG
  1709. // #702
  1710. M=D
  1711. // #703
  1712. @6
  1713. // #704
  1714. D=A
  1715. // #705
  1716. @ARG
  1717. // #706
  1718. M=M-D // ARG = SP - args - 5
  1719. // #707
  1720. @SP
  1721. // #708
  1722. D=M
  1723. // #709
  1724. @LCL
  1725. // #710
  1726. M=D // LCL = SP
  1727. // #711
  1728. @SquareGame.dispose
  1729. // #712
  1730. 0;JMP
  1731. (RET_ADDR_28)
  1732. //
  1733. //// pop temp 0
  1734. //^^ pop_to_loc{5)
  1735. //^^ pop_stack_to_d
  1736. // #713
  1737. @SP
  1738. // #714
  1739. M=M-1
  1740. // #715
  1741. A=M
  1742. // #716
  1743. D=M
  1744. //vv pop_stack_to_d
  1745. // #717
  1746. @5
  1747. // #718
  1748. M=D
  1749. //vv pop_to_loc{5)
  1750. //
  1751. //// push constant 0
  1752. //^^ push_constant(0)
  1753. // #719
  1754. @0
  1755. // #720
  1756. D=A
  1757. //^^ push_d_to_stack
  1758. // #721
  1759. @SP
  1760. // #722
  1761. A=M
  1762. // #723
  1763. M=D
  1764. // #724
  1765. @SP
  1766. // #725
  1767. M=M+1
  1768. //vv push_d_to_stack
  1769. //vv push_constant(0)
  1770. //
  1771. //// return
  1772. // #726
  1773. @LCL
  1774. // #727
  1775. D=M
  1776. // #728
  1777. @R14
  1778. // #729
  1779. M=D //R14=LCL
  1780. // #730
  1781. @5
  1782. // #731
  1783. A=D-A
  1784. // #732
  1785. D=M
  1786. // #733
  1787. @R15
  1788. // #734
  1789. M=D //R15=*(LCL-5)
  1790. //^^ pop_stack_to_d
  1791. // #735
  1792. @SP
  1793. // #736
  1794. M=M-1
  1795. // #737
  1796. A=M
  1797. // #738
  1798. D=M
  1799. //vv pop_stack_to_d
  1800. // #739
  1801. @ARG
  1802. // #740
  1803. A=M
  1804. // #741
  1805. M=D //*ARG = pop()
  1806. // #742
  1807. @ARG
  1808. // #743
  1809. D=M
  1810. // #744
  1811. @SP
  1812. // #745
  1813. M=D+1 //SP=ARG+1
  1814. // #746
  1815. @R14
  1816. // #747
  1817. AM=M-1
  1818. // #748
  1819. D=M
  1820. // #749
  1821. @THAT
  1822. // #750
  1823. M=D //THAT = *(--R14)
  1824. // #751
  1825. @R14
  1826. // #752
  1827. AM=M-1
  1828. // #753
  1829. D=M
  1830. // #754
  1831. @THIS
  1832. // #755
  1833. M=D //THIS = *(--R14)
  1834. // #756
  1835. @R14
  1836. // #757
  1837. AM=M-1
  1838. // #758
  1839. D=M
  1840. // #759
  1841. @ARG
  1842. // #760
  1843. M=D //ARG = *(--R14)
  1844. // #761
  1845. @R14
  1846. // #762
  1847. AM=M-1
  1848. // #763
  1849. D=M
  1850. // #764
  1851. @LCL
  1852. // #765
  1853. M=D //LCL = *(--R14)
  1854. // #766
  1855. @R15
  1856. // #767
  1857. A=M
  1858. // #768
  1859. 0;JMP //goto *R15
  1860. //
  1861. //// function Math.init 1
  1862. (Math.init)
  1863. // #769
  1864. D=0
  1865. //^^ push_d_to_stack
  1866. // #770
  1867. @SP
  1868. // #771
  1869. A=M
  1870. // #772
  1871. M=D
  1872. // #773
  1873. @SP
  1874. // #774
  1875. M=M+1
  1876. //vv push_d_to_stack
  1877. //
  1878. //// push constant 16
  1879. //^^ push_constant(16)
  1880. // #775
  1881. @16
  1882. // #776
  1883. D=A
  1884. //^^ push_d_to_stack
  1885. // #777
  1886. @SP
  1887. // #778
  1888. A=M
  1889. // #779
  1890. M=D
  1891. // #780
  1892. @SP
  1893. // #781
  1894. M=M+1
  1895. //vv push_d_to_stack
  1896. //vv push_constant(16)
  1897. //
  1898. //// call Array.new 1
  1899. //^^ push_constant(RET_ADDR_29)
  1900. // #782
  1901. @RET_ADDR_29
  1902. // #783
  1903. D=A
  1904. //^^ push_d_to_stack
  1905. // #784
  1906. @SP
  1907. // #785
  1908. A=M
  1909. // #786
  1910. M=D
  1911. // #787
  1912. @SP
  1913. // #788
  1914. M=M+1
  1915. //vv push_d_to_stack
  1916. //vv push_constant(RET_ADDR_29)
  1917. //push return-address
  1918. // #789
  1919. @LCL
  1920. // #790
  1921. D=M
  1922. //^^ push_d_to_stack
  1923. // #791
  1924. @SP
  1925. // #792
  1926. A=M
  1927. // #793
  1928. M=D
  1929. // #794
  1930. @SP
  1931. // #795
  1932. M=M+1
  1933. //vv push_d_to_stack
  1934. //push LCL
  1935. // #796
  1936. @ARG
  1937. // #797
  1938. D=M
  1939. //^^ push_d_to_stack
  1940. // #798
  1941. @SP
  1942. // #799
  1943. A=M
  1944. // #800
  1945. M=D
  1946. // #801
  1947. @SP
  1948. // #802
  1949. M=M+1
  1950. //vv push_d_to_stack
  1951. //push ARG
  1952. // #803
  1953. @THIS
  1954. // #804
  1955. D=M
  1956. //^^ push_d_to_stack
  1957. // #805
  1958. @SP
  1959. // #806
  1960. A=M
  1961. // #807
  1962. M=D
  1963. // #808
  1964. @SP
  1965. // #809
  1966. M=M+1
  1967. //vv push_d_to_stack
  1968. //push THIS
  1969. // #810
  1970. @THAT
  1971. // #811
  1972. D=M
  1973. //^^ push_d_to_stack
  1974. // #812
  1975. @SP
  1976. // #813
  1977. A=M
  1978. // #814
  1979. M=D
  1980. // #815
  1981. @SP
  1982. // #816
  1983. M=M+1
  1984. //vv push_d_to_stack
  1985. //push THAT
  1986. // #817
  1987. @SP
  1988. // #818
  1989. D=M
  1990. // #819
  1991. @ARG
  1992. // #820
  1993. M=D
  1994. // #821
  1995. @6
  1996. // #822
  1997. D=A
  1998. // #823
  1999. @ARG
  2000. // #824
  2001. M=M-D // ARG = SP - args - 5
  2002. // #825
  2003. @SP
  2004. // #826
  2005. D=M
  2006. // #827
  2007. @LCL
  2008. // #828
  2009. M=D // LCL = SP
  2010. // #829
  2011. @Array.new
  2012. // #830
  2013. 0;JMP
  2014. (RET_ADDR_29)
  2015. //
  2016. //// pop static 1
  2017. //^^ pop_to_loc{Math.vm.1)
  2018. //^^ pop_stack_to_d
  2019. // #831
  2020. @SP
  2021. // #832
  2022. M=M-1
  2023. // #833
  2024. A=M
  2025. // #834
  2026. D=M
  2027. //vv pop_stack_to_d
  2028. // #835
  2029. @Math.vm.1
  2030. // #836
  2031. M=D
  2032. //vv pop_to_loc{Math.vm.1)
  2033. //
  2034. //// push constant 16
  2035. //^^ push_constant(16)
  2036. // #837
  2037. @16
  2038. // #838
  2039. D=A
  2040. //^^ push_d_to_stack
  2041. // #839
  2042. @SP
  2043. // #840
  2044. A=M
  2045. // #841
  2046. M=D
  2047. // #842
  2048. @SP
  2049. // #843
  2050. M=M+1
  2051. //vv push_d_to_stack
  2052. //vv push_constant(16)
  2053. //
  2054. //// call Array.new 1
  2055. //^^ push_constant(RET_ADDR_30)
  2056. // #844
  2057. @RET_ADDR_30
  2058. // #845
  2059. D=A
  2060. //^^ push_d_to_stack
  2061. // #846
  2062. @SP
  2063. // #847
  2064. A=M
  2065. // #848
  2066. M=D
  2067. // #849
  2068. @SP
  2069. // #850
  2070. M=M+1
  2071. //vv push_d_to_stack
  2072. //vv push_constant(RET_ADDR_30)
  2073. //push return-address
  2074. // #851
  2075. @LCL
  2076. // #852
  2077. D=M
  2078. //^^ push_d_to_stack
  2079. // #853
  2080. @SP
  2081. // #854
  2082. A=M
  2083. // #855
  2084. M=D
  2085. // #856
  2086. @SP
  2087. // #857
  2088. M=M+1
  2089. //vv push_d_to_stack
  2090. //push LCL
  2091. // #858
  2092. @ARG
  2093. // #859
  2094. D=M
  2095. //^^ push_d_to_stack
  2096. // #860
  2097. @SP
  2098. // #861
  2099. A=M
  2100. // #862
  2101. M=D
  2102. // #863
  2103. @SP
  2104. // #864
  2105. M=M+1
  2106. //vv push_d_to_stack
  2107. //push ARG
  2108. // #865
  2109. @THIS
  2110. // #866
  2111. D=M
  2112. //^^ push_d_to_stack
  2113. // #867
  2114. @SP
  2115. // #868
  2116. A=M
  2117. // #869
  2118. M=D
  2119. // #870
  2120. @SP
  2121. // #871
  2122. M=M+1
  2123. //vv push_d_to_stack
  2124. //push THIS
  2125. // #872
  2126. @THAT
  2127. // #873
  2128. D=M
  2129. //^^ push_d_to_stack
  2130. // #874
  2131. @SP
  2132. // #875
  2133. A=M
  2134. // #876
  2135. M=D
  2136. // #877
  2137. @SP
  2138. // #878
  2139. M=M+1
  2140. //vv push_d_to_stack
  2141. //push THAT
  2142. // #879
  2143. @SP
  2144. // #880
  2145. D=M
  2146. // #881
  2147. @ARG
  2148. // #882
  2149. M=D
  2150. // #883
  2151. @6
  2152. // #884
  2153. D=A
  2154. // #885
  2155. @ARG
  2156. // #886
  2157. M=M-D // ARG = SP - args - 5
  2158. // #887
  2159. @SP
  2160. // #888
  2161. D=M
  2162. // #889
  2163. @LCL
  2164. // #890
  2165. M=D // LCL = SP
  2166. // #891
  2167. @Array.new
  2168. // #892
  2169. 0;JMP
  2170. (RET_ADDR_30)
  2171. //
  2172. //// pop static 0
  2173. //^^ pop_to_loc{Math.vm.0)
  2174. //^^ pop_stack_to_d
  2175. // #893
  2176. @SP
  2177. // #894
  2178. M=M-1
  2179. // #895
  2180. A=M
  2181. // #896
  2182. D=M
  2183. //vv pop_stack_to_d
  2184. // #897
  2185. @Math.vm.0
  2186. // #898
  2187. M=D
  2188. //vv pop_to_loc{Math.vm.0)
  2189. //
  2190. //// push constant 0
  2191. //^^ push_constant(0)
  2192. // #899
  2193. @0
  2194. // #900
  2195. D=A
  2196. //^^ push_d_to_stack
  2197. // #901
  2198. @SP
  2199. // #902
  2200. A=M
  2201. // #903
  2202. M=D
  2203. // #904
  2204. @SP
  2205. // #905
  2206. M=M+1
  2207. //vv push_d_to_stack
  2208. //vv push_constant(0)
  2209. //
  2210. //// push static 0
  2211. //^^ push_from_loc(Math.vm.0)
  2212. // #906
  2213. @Math.vm.0
  2214. // #907
  2215. D=M
  2216. //^^ push_d_to_stack
  2217. // #908
  2218. @SP
  2219. // #909
  2220. A=M
  2221. // #910
  2222. M=D
  2223. // #911
  2224. @SP
  2225. // #912
  2226. M=M+1
  2227. //vv push_d_to_stack
  2228. //vv push_from_loc(Math.vm.0)
  2229. //
  2230. //// add
  2231. //^^ arith_binary_op(+)
  2232. //^^ pop_stack_to_d
  2233. // #913
  2234. @SP
  2235. // #914
  2236. M=M-1
  2237. // #915
  2238. A=M
  2239. // #916
  2240. D=M
  2241. //vv pop_stack_to_d
  2242. //^^ arith_d_with_stack_top(D+M)
  2243. // #917
  2244. @R13
  2245. // #918
  2246. M=D
  2247. //^^ pop_stack_to_d
  2248. // #919
  2249. @SP
  2250. // #920
  2251. M=M-1
  2252. // #921
  2253. A=M
  2254. // #922
  2255. D=M
  2256. //vv pop_stack_to_d
  2257. // #923
  2258. @R13
  2259. // #924
  2260. D=D+M
  2261. // #925
  2262. @R13
  2263. // #926
  2264. M=0
  2265. //vv arith_d_with_stack_top(D+M)
  2266. //^^ push_d_to_stack
  2267. // #927
  2268. @SP
  2269. // #928
  2270. A=M
  2271. // #929
  2272. M=D
  2273. // #930
  2274. @SP
  2275. // #931
  2276. M=M+1
  2277. //vv push_d_to_stack
  2278. //vv arith_binary_op(+)
  2279. //
  2280. //// push constant 1
  2281. //^^ push_constant(1)
  2282. // #932
  2283. @1
  2284. // #933
  2285. D=A
  2286. //^^ push_d_to_stack
  2287. // #934
  2288. @SP
  2289. // #935
  2290. A=M
  2291. // #936
  2292. M=D
  2293. // #937
  2294. @SP
  2295. // #938
  2296. M=M+1
  2297. //vv push_d_to_stack
  2298. //vv push_constant(1)
  2299. //
  2300. //// pop temp 0
  2301. //^^ pop_to_loc{5)
  2302. //^^ pop_stack_to_d
  2303. // #939
  2304. @SP
  2305. // #940
  2306. M=M-1
  2307. // #941
  2308. A=M
  2309. // #942
  2310. D=M
  2311. //vv pop_stack_to_d
  2312. // #943
  2313. @5
  2314. // #944
  2315. M=D
  2316. //vv pop_to_loc{5)
  2317. //
  2318. //// pop pointer 1
  2319. //^^ pop_to_loc{4)
  2320. //^^ pop_stack_to_d
  2321. // #945
  2322. @SP
  2323. // #946
  2324. M=M-1
  2325. // #947
  2326. A=M
  2327. // #948
  2328. D=M
  2329. //vv pop_stack_to_d
  2330. // #949
  2331. @4
  2332. // #950
  2333. M=D
  2334. //vv pop_to_loc{4)
  2335. //
  2336. //// push temp 0
  2337. //^^ push_from_loc(5)
  2338. // #951
  2339. @5
  2340. // #952
  2341. D=M
  2342. //^^ push_d_to_stack
  2343. // #953
  2344. @SP
  2345. // #954
  2346. A=M
  2347. // #955
  2348. M=D
  2349. // #956
  2350. @SP
  2351. // #957
  2352. M=M+1
  2353. //vv push_d_to_stack
  2354. //vv push_from_loc(5)
  2355. //
  2356. //// pop that 0
  2357. //^^ pop_to_ram(THAT, 0)
  2358. // #958
  2359. @THAT
  2360. // #959
  2361. D=M
  2362. // #960
  2363. @0
  2364. // #961
  2365. D=D+A
  2366. // #962
  2367. @R13
  2368. // #963
  2369. M=D
  2370. //^^ pop_stack_to_d
  2371. // #964
  2372. @SP
  2373. // #965
  2374. M=M-1
  2375. // #966
  2376. A=M
  2377. // #967
  2378. D=M
  2379. //vv pop_stack_to_d
  2380. // #968
  2381. @R13
  2382. // #969
  2383. A=M
  2384. // #970
  2385. M=D
  2386. // #971
  2387. @R13
  2388. // #972
  2389. M=0
  2390. //vv pop_to_ram(THAT, 0)
  2391. //
  2392. //// label WHILE_EXP0
  2393. (Math.init$WHILE_EXP0)
  2394. //
  2395. //// push local 0
  2396. //^^ push_from_ram(LCL, 0)
  2397. // #973
  2398. @LCL
  2399. // #974
  2400. D=M
  2401. // #975
  2402. @0
  2403. // #976
  2404. A=D+A
  2405. // #977
  2406. D=M
  2407. //^^ push_d_to_stack
  2408. // #978
  2409. @SP
  2410. // #979
  2411. A=M
  2412. // #980
  2413. M=D
  2414. // #981
  2415. @SP
  2416. // #982
  2417. M=M+1
  2418. //vv push_d_to_stack
  2419. //vv push_from_ram(LCL, 0)
  2420. //
  2421. //// push constant 15
  2422. //^^ push_constant(15)
  2423. // #983
  2424. @15
  2425. // #984
  2426. D=A
  2427. //^^ push_d_to_stack
  2428. // #985
  2429. @SP
  2430. // #986
  2431. A=M
  2432. // #987
  2433. M=D
  2434. // #988
  2435. @SP
  2436. // #989
  2437. M=M+1
  2438. //vv push_d_to_stack
  2439. //vv push_constant(15)
  2440. //
  2441. //// lt
  2442. //^^ arith_cmp_op(JLT)
  2443. //^^ pop_stack_to_d
  2444. // #990
  2445. @SP
  2446. // #991
  2447. M=M-1
  2448. // #992
  2449. A=M
  2450. // #993
  2451. D=M
  2452. //vv pop_stack_to_d
  2453. //^^ arith_d_with_stack_top(D-M)
  2454. // #994
  2455. @R13
  2456. // #995
  2457. M=D
  2458. //^^ pop_stack_to_d
  2459. // #996
  2460. @SP
  2461. // #997
  2462. M=M-1
  2463. // #998
  2464. A=M
  2465. // #999
  2466. D=M
  2467. //vv pop_stack_to_d
  2468. // #1000
  2469. @R13
  2470. // #1001
  2471. D=D-M
  2472. // #1002
  2473. @R13
  2474. // #1003
  2475. M=0
  2476. //vv arith_d_with_stack_top(D-M)
  2477. // #1004
  2478. @PUT_TRUE_31
  2479. // #1005
  2480. D;JLT
  2481. // #1006
  2482. @R13
  2483. // #1007
  2484. M=0
  2485. // #1008
  2486. @CONT_31
  2487. // #1009
  2488. 0;JMP
  2489. (PUT_TRUE_31)
  2490. // #1010
  2491. @R13
  2492. // #1011
  2493. M=-1
  2494. (CONT_31)
  2495. // #1012
  2496. @R13
  2497. // #1013
  2498. D=M
  2499. // #1014
  2500. @R13
  2501. // #1015
  2502. M=0
  2503. //^^ push_d_to_stack
  2504. // #1016
  2505. @SP
  2506. // #1017
  2507. A=M
  2508. // #1018
  2509. M=D
  2510. // #1019
  2511. @SP
  2512. // #1020
  2513. M=M+1
  2514. //vv push_d_to_stack
  2515. //vv arith_cmp_op(JLT)
  2516. //
  2517. //// not
  2518. //^^ arith_unary_op(!)
  2519. //^^ pop_stack_to_d
  2520. // #1021
  2521. @SP
  2522. // #1022
  2523. M=M-1
  2524. // #1023
  2525. A=M
  2526. // #1024
  2527. D=M
  2528. //vv pop_stack_to_d
  2529. // #1025
  2530. D=!D
  2531. //^^ push_d_to_stack
  2532. // #1026
  2533. @SP
  2534. // #1027
  2535. A=M
  2536. // #1028
  2537. M=D
  2538. // #1029
  2539. @SP
  2540. // #1030
  2541. M=M+1
  2542. //vv push_d_to_stack
  2543. //vv arith_unary_op(!)
  2544. //
  2545. //// if-goto WHILE_END0
  2546. //^^ pop_stack_to_d
  2547. // #1031
  2548. @SP
  2549. // #1032
  2550. M=M-1
  2551. // #1033
  2552. A=M
  2553. // #1034
  2554. D=M
  2555. //vv pop_stack_to_d
  2556. // #1035
  2557. @Math.init$WHILE_END0
  2558. // #1036
  2559. D;JNE
  2560. //
  2561. //// push local 0
  2562. //^^ push_from_ram(LCL, 0)
  2563. // #1037
  2564. @LCL
  2565. // #1038
  2566. D=M
  2567. // #1039
  2568. @0
  2569. // #1040
  2570. A=D+A
  2571. // #1041
  2572. D=M
  2573. //^^ push_d_to_stack
  2574. // #1042
  2575. @SP
  2576. // #1043
  2577. A=M
  2578. // #1044
  2579. M=D
  2580. // #1045
  2581. @SP
  2582. // #1046
  2583. M=M+1
  2584. //vv push_d_to_stack
  2585. //vv push_from_ram(LCL, 0)
  2586. //
  2587. //// push constant 1
  2588. //^^ push_constant(1)
  2589. // #1047
  2590. @1
  2591. // #1048
  2592. D=A
  2593. //^^ push_d_to_stack
  2594. // #1049
  2595. @SP
  2596. // #1050
  2597. A=M
  2598. // #1051
  2599. M=D
  2600. // #1052
  2601. @SP
  2602. // #1053
  2603. M=M+1
  2604. //vv push_d_to_stack
  2605. //vv push_constant(1)
  2606. //
  2607. //// add
  2608. //^^ arith_binary_op(+)
  2609. //^^ pop_stack_to_d
  2610. // #1054
  2611. @SP
  2612. // #1055
  2613. M=M-1
  2614. // #1056
  2615. A=M
  2616. // #1057
  2617. D=M
  2618. //vv pop_stack_to_d
  2619. //^^ arith_d_with_stack_top(D+M)
  2620. // #1058
  2621. @R13
  2622. // #1059
  2623. M=D
  2624. //^^ pop_stack_to_d
  2625. // #1060
  2626. @SP
  2627. // #1061
  2628. M=M-1
  2629. // #1062
  2630. A=M
  2631. // #1063
  2632. D=M
  2633. //vv pop_stack_to_d
  2634. // #1064
  2635. @R13
  2636. // #1065
  2637. D=D+M
  2638. // #1066
  2639. @R13
  2640. // #1067
  2641. M=0
  2642. //vv arith_d_with_stack_top(D+M)
  2643. //^^ push_d_to_stack
  2644. // #1068
  2645. @SP
  2646. // #1069
  2647. A=M
  2648. // #1070
  2649. M=D
  2650. // #1071
  2651. @SP
  2652. // #1072
  2653. M=M+1
  2654. //vv push_d_to_stack
  2655. //vv arith_binary_op(+)
  2656. //
  2657. //// pop local 0
  2658. //^^ pop_to_ram(LCL, 0)
  2659. // #1073
  2660. @LCL
  2661. // #1074
  2662. D=M
  2663. // #1075
  2664. @0
  2665. // #1076
  2666. D=D+A
  2667. // #1077
  2668. @R13
  2669. // #1078
  2670. M=D
  2671. //^^ pop_stack_to_d
  2672. // #1079
  2673. @SP
  2674. // #1080
  2675. M=M-1
  2676. // #1081
  2677. A=M
  2678. // #1082
  2679. D=M
  2680. //vv pop_stack_to_d
  2681. // #1083
  2682. @R13
  2683. // #1084
  2684. A=M
  2685. // #1085
  2686. M=D
  2687. // #1086
  2688. @R13
  2689. // #1087
  2690. M=0
  2691. //vv pop_to_ram(LCL, 0)
  2692. //
  2693. //// push local 0
  2694. //^^ push_from_ram(LCL, 0)
  2695. // #1088
  2696. @LCL
  2697. // #1089
  2698. D=M
  2699. // #1090
  2700. @0
  2701. // #1091
  2702. A=D+A
  2703. // #1092
  2704. D=M
  2705. //^^ push_d_to_stack
  2706. // #1093
  2707. @SP
  2708. // #1094
  2709. A=M
  2710. // #1095
  2711. M=D
  2712. // #1096
  2713. @SP
  2714. // #1097
  2715. M=M+1
  2716. //vv push_d_to_stack
  2717. //vv push_from_ram(LCL, 0)
  2718. //
  2719. //// push static 0
  2720. //^^ push_from_loc(Math.vm.0)
  2721. // #1098
  2722. @Math.vm.0
  2723. // #1099
  2724. D=M
  2725. //^^ push_d_to_stack
  2726. // #1100
  2727. @SP
  2728. // #1101
  2729. A=M
  2730. // #1102
  2731. M=D
  2732. // #1103
  2733. @SP
  2734. // #1104
  2735. M=M+1
  2736. //vv push_d_to_stack
  2737. //vv push_from_loc(Math.vm.0)
  2738. //
  2739. //// add
  2740. //^^ arith_binary_op(+)
  2741. //^^ pop_stack_to_d
  2742. // #1105
  2743. @SP
  2744. // #1106
  2745. M=M-1
  2746. // #1107
  2747. A=M
  2748. // #1108
  2749. D=M
  2750. //vv pop_stack_to_d
  2751. //^^ arith_d_with_stack_top(D+M)
  2752. // #1109
  2753. @R13
  2754. // #1110
  2755. M=D
  2756. //^^ pop_stack_to_d
  2757. // #1111
  2758. @SP
  2759. // #1112
  2760. M=M-1
  2761. // #1113
  2762. A=M
  2763. // #1114
  2764. D=M
  2765. //vv pop_stack_to_d
  2766. // #1115
  2767. @R13
  2768. // #1116
  2769. D=D+M
  2770. // #1117
  2771. @R13
  2772. // #1118
  2773. M=0
  2774. //vv arith_d_with_stack_top(D+M)
  2775. //^^ push_d_to_stack
  2776. // #1119
  2777. @SP
  2778. // #1120
  2779. A=M
  2780. // #1121
  2781. M=D
  2782. // #1122
  2783. @SP
  2784. // #1123
  2785. M=M+1
  2786. //vv push_d_to_stack
  2787. //vv arith_binary_op(+)
  2788. //
  2789. //// push local 0
  2790. //^^ push_from_ram(LCL, 0)
  2791. // #1124
  2792. @LCL
  2793. // #1125
  2794. D=M
  2795. // #1126
  2796. @0
  2797. // #1127
  2798. A=D+A
  2799. // #1128
  2800. D=M
  2801. //^^ push_d_to_stack
  2802. // #1129
  2803. @SP
  2804. // #1130
  2805. A=M
  2806. // #1131
  2807. M=D
  2808. // #1132
  2809. @SP
  2810. // #1133
  2811. M=M+1
  2812. //vv push_d_to_stack
  2813. //vv push_from_ram(LCL, 0)
  2814. //
  2815. //// push constant 1
  2816. //^^ push_constant(1)
  2817. // #1134
  2818. @1
  2819. // #1135
  2820. D=A
  2821. //^^ push_d_to_stack
  2822. // #1136
  2823. @SP
  2824. // #1137
  2825. A=M
  2826. // #1138
  2827. M=D
  2828. // #1139
  2829. @SP
  2830. // #1140
  2831. M=M+1
  2832. //vv push_d_to_stack
  2833. //vv push_constant(1)
  2834. //
  2835. //// sub
  2836. //^^ arith_binary_op(-)
  2837. //^^ pop_stack_to_d
  2838. // #1141
  2839. @SP
  2840. // #1142
  2841. M=M-1
  2842. // #1143
  2843. A=M
  2844. // #1144
  2845. D=M
  2846. //vv pop_stack_to_d
  2847. //^^ arith_d_with_stack_top(D-M)
  2848. // #1145
  2849. @R13
  2850. // #1146
  2851. M=D
  2852. //^^ pop_stack_to_d
  2853. // #1147
  2854. @SP
  2855. // #1148
  2856. M=M-1
  2857. // #1149
  2858. A=M
  2859. // #1150
  2860. D=M
  2861. //vv pop_stack_to_d
  2862. // #1151
  2863. @R13
  2864. // #1152
  2865. D=D-M
  2866. // #1153
  2867. @R13
  2868. // #1154
  2869. M=0
  2870. //vv arith_d_with_stack_top(D-M)
  2871. //^^ push_d_to_stack
  2872. // #1155
  2873. @SP
  2874. // #1156
  2875. A=M
  2876. // #1157
  2877. M=D
  2878. // #1158
  2879. @SP
  2880. // #1159
  2881. M=M+1
  2882. //vv push_d_to_stack
  2883. //vv arith_binary_op(-)
  2884. //
  2885. //// push static 0
  2886. //^^ push_from_loc(Math.vm.0)
  2887. // #1160
  2888. @Math.vm.0
  2889. // #1161
  2890. D=M
  2891. //^^ push_d_to_stack
  2892. // #1162
  2893. @SP
  2894. // #1163
  2895. A=M
  2896. // #1164
  2897. M=D
  2898. // #1165
  2899. @SP
  2900. // #1166
  2901. M=M+1
  2902. //vv push_d_to_stack
  2903. //vv push_from_loc(Math.vm.0)
  2904. //
  2905. //// add
  2906. //^^ arith_binary_op(+)
  2907. //^^ pop_stack_to_d
  2908. // #1167
  2909. @SP
  2910. // #1168
  2911. M=M-1
  2912. // #1169
  2913. A=M
  2914. // #1170
  2915. D=M
  2916. //vv pop_stack_to_d
  2917. //^^ arith_d_with_stack_top(D+M)
  2918. // #1171
  2919. @R13
  2920. // #1172
  2921. M=D
  2922. //^^ pop_stack_to_d
  2923. // #1173
  2924. @SP
  2925. // #1174
  2926. M=M-1
  2927. // #1175
  2928. A=M
  2929. // #1176
  2930. D=M
  2931. //vv pop_stack_to_d
  2932. // #1177
  2933. @R13
  2934. // #1178
  2935. D=D+M
  2936. // #1179
  2937. @R13
  2938. // #1180
  2939. M=0
  2940. //vv arith_d_with_stack_top(D+M)
  2941. //^^ push_d_to_stack
  2942. // #1181
  2943. @SP
  2944. // #1182
  2945. A=M
  2946. // #1183
  2947. M=D
  2948. // #1184
  2949. @SP
  2950. // #1185
  2951. M=M+1
  2952. //vv push_d_to_stack
  2953. //vv arith_binary_op(+)
  2954. //
  2955. //// pop pointer 1
  2956. //^^ pop_to_loc{4)
  2957. //^^ pop_stack_to_d
  2958. // #1186
  2959. @SP
  2960. // #1187
  2961. M=M-1
  2962. // #1188
  2963. A=M
  2964. // #1189
  2965. D=M
  2966. //vv pop_stack_to_d
  2967. // #1190
  2968. @4
  2969. // #1191
  2970. M=D
  2971. //vv pop_to_loc{4)
  2972. //
  2973. //// push that 0
  2974. //^^ push_from_ram(THAT, 0)
  2975. // #1192
  2976. @THAT
  2977. // #1193
  2978. D=M
  2979. // #1194
  2980. @0
  2981. // #1195
  2982. A=D+A
  2983. // #1196
  2984. D=M
  2985. //^^ push_d_to_stack
  2986. // #1197
  2987. @SP
  2988. // #1198
  2989. A=M
  2990. // #1199
  2991. M=D
  2992. // #1200
  2993. @SP
  2994. // #1201
  2995. M=M+1
  2996. //vv push_d_to_stack
  2997. //vv push_from_ram(THAT, 0)
  2998. //
  2999. //// push local 0
  3000. //^^ push_from_ram(LCL, 0)
  3001. // #1202
  3002. @LCL
  3003. // #1203
  3004. D=M
  3005. // #1204
  3006. @0
  3007. // #1205
  3008. A=D+A
  3009. // #1206
  3010. D=M
  3011. //^^ push_d_to_stack
  3012. // #1207
  3013. @SP
  3014. // #1208
  3015. A=M
  3016. // #1209
  3017. M=D
  3018. // #1210
  3019. @SP
  3020. // #1211
  3021. M=M+1
  3022. //vv push_d_to_stack
  3023. //vv push_from_ram(LCL, 0)
  3024. //
  3025. //// push constant 1
  3026. //^^ push_constant(1)
  3027. // #1212
  3028. @1
  3029. // #1213
  3030. D=A
  3031. //^^ push_d_to_stack
  3032. // #1214
  3033. @SP
  3034. // #1215
  3035. A=M
  3036. // #1216
  3037. M=D
  3038. // #1217
  3039. @SP
  3040. // #1218
  3041. M=M+1
  3042. //vv push_d_to_stack
  3043. //vv push_constant(1)
  3044. //
  3045. //// sub
  3046. //^^ arith_binary_op(-)
  3047. //^^ pop_stack_to_d
  3048. // #1219
  3049. @SP
  3050. // #1220
  3051. M=M-1
  3052. // #1221
  3053. A=M
  3054. // #1222
  3055. D=M
  3056. //vv pop_stack_to_d
  3057. //^^ arith_d_with_stack_top(D-M)
  3058. // #1223
  3059. @R13
  3060. // #1224
  3061. M=D
  3062. //^^ pop_stack_to_d
  3063. // #1225
  3064. @SP
  3065. // #1226
  3066. M=M-1
  3067. // #1227
  3068. A=M
  3069. // #1228
  3070. D=M
  3071. //vv pop_stack_to_d
  3072. // #1229
  3073. @R13
  3074. // #1230
  3075. D=D-M
  3076. // #1231
  3077. @R13
  3078. // #1232
  3079. M=0
  3080. //vv arith_d_with_stack_top(D-M)
  3081. //^^ push_d_to_stack
  3082. // #1233
  3083. @SP
  3084. // #1234
  3085. A=M
  3086. // #1235
  3087. M=D
  3088. // #1236
  3089. @SP
  3090. // #1237
  3091. M=M+1
  3092. //vv push_d_to_stack
  3093. //vv arith_binary_op(-)
  3094. //
  3095. //// push static 0
  3096. //^^ push_from_loc(Math.vm.0)
  3097. // #1238
  3098. @Math.vm.0
  3099. // #1239
  3100. D=M
  3101. //^^ push_d_to_stack
  3102. // #1240
  3103. @SP
  3104. // #1241
  3105. A=M
  3106. // #1242
  3107. M=D
  3108. // #1243
  3109. @SP
  3110. // #1244
  3111. M=M+1
  3112. //vv push_d_to_stack
  3113. //vv push_from_loc(Math.vm.0)
  3114. //
  3115. //// add
  3116. //^^ arith_binary_op(+)
  3117. //^^ pop_stack_to_d
  3118. // #1245
  3119. @SP
  3120. // #1246
  3121. M=M-1
  3122. // #1247
  3123. A=M
  3124. // #1248
  3125. D=M
  3126. //vv pop_stack_to_d
  3127. //^^ arith_d_with_stack_top(D+M)
  3128. // #1249
  3129. @R13
  3130. // #1250
  3131. M=D
  3132. //^^ pop_stack_to_d
  3133. // #1251
  3134. @SP
  3135. // #1252
  3136. M=M-1
  3137. // #1253
  3138. A=M
  3139. // #1254
  3140. D=M
  3141. //vv pop_stack_to_d
  3142. // #1255
  3143. @R13
  3144. // #1256
  3145. D=D+M
  3146. // #1257
  3147. @R13
  3148. // #1258
  3149. M=0
  3150. //vv arith_d_with_stack_top(D+M)
  3151. //^^ push_d_to_stack
  3152. // #1259
  3153. @SP
  3154. // #1260
  3155. A=M
  3156. // #1261
  3157. M=D
  3158. // #1262
  3159. @SP
  3160. // #1263
  3161. M=M+1
  3162. //vv push_d_to_stack
  3163. //vv arith_binary_op(+)
  3164. //
  3165. //// pop pointer 1
  3166. //^^ pop_to_loc{4)
  3167. //^^ pop_stack_to_d
  3168. // #1264
  3169. @SP
  3170. // #1265
  3171. M=M-1
  3172. // #1266
  3173. A=M
  3174. // #1267
  3175. D=M
  3176. //vv pop_stack_to_d
  3177. // #1268
  3178. @4
  3179. // #1269
  3180. M=D
  3181. //vv pop_to_loc{4)
  3182. //
  3183. //// push that 0
  3184. //^^ push_from_ram(THAT, 0)
  3185. // #1270
  3186. @THAT
  3187. // #1271
  3188. D=M
  3189. // #1272
  3190. @0
  3191. // #1273
  3192. A=D+A
  3193. // #1274
  3194. D=M
  3195. //^^ push_d_to_stack
  3196. // #1275
  3197. @SP
  3198. // #1276
  3199. A=M
  3200. // #1277
  3201. M=D
  3202. // #1278
  3203. @SP
  3204. // #1279
  3205. M=M+1
  3206. //vv push_d_to_stack
  3207. //vv push_from_ram(THAT, 0)
  3208. //
  3209. //// add
  3210. //^^ arith_binary_op(+)
  3211. //^^ pop_stack_to_d
  3212. // #1280
  3213. @SP
  3214. // #1281
  3215. M=M-1
  3216. // #1282
  3217. A=M
  3218. // #1283
  3219. D=M
  3220. //vv pop_stack_to_d
  3221. //^^ arith_d_with_stack_top(D+M)
  3222. // #1284
  3223. @R13
  3224. // #1285
  3225. M=D
  3226. //^^ pop_stack_to_d
  3227. // #1286
  3228. @SP
  3229. // #1287
  3230. M=M-1
  3231. // #1288
  3232. A=M
  3233. // #1289
  3234. D=M
  3235. //vv pop_stack_to_d
  3236. // #1290
  3237. @R13
  3238. // #1291
  3239. D=D+M
  3240. // #1292
  3241. @R13
  3242. // #1293
  3243. M=0
  3244. //vv arith_d_with_stack_top(D+M)
  3245. //^^ push_d_to_stack
  3246. // #1294
  3247. @SP
  3248. // #1295
  3249. A=M
  3250. // #1296
  3251. M=D
  3252. // #1297
  3253. @SP
  3254. // #1298
  3255. M=M+1
  3256. //vv push_d_to_stack
  3257. //vv arith_binary_op(+)
  3258. //
  3259. //// pop temp 0
  3260. //^^ pop_to_loc{5)
  3261. //^^ pop_stack_to_d
  3262. // #1299
  3263. @SP
  3264. // #1300
  3265. M=M-1
  3266. // #1301
  3267. A=M
  3268. // #1302
  3269. D=M
  3270. //vv pop_stack_to_d
  3271. // #1303
  3272. @5
  3273. // #1304
  3274. M=D
  3275. //vv pop_to_loc{5)
  3276. //
  3277. //// pop pointer 1
  3278. //^^ pop_to_loc{4)
  3279. //^^ pop_stack_to_d
  3280. // #1305
  3281. @SP
  3282. // #1306
  3283. M=M-1
  3284. // #1307
  3285. A=M
  3286. // #1308
  3287. D=M
  3288. //vv pop_stack_to_d
  3289. // #1309
  3290. @4
  3291. // #1310
  3292. M=D
  3293. //vv pop_to_loc{4)
  3294. //
  3295. //// push temp 0
  3296. //^^ push_from_loc(5)
  3297. // #1311
  3298. @5
  3299. // #1312
  3300. D=M
  3301. //^^ push_d_to_stack
  3302. // #1313
  3303. @SP
  3304. // #1314
  3305. A=M
  3306. // #1315
  3307. M=D
  3308. // #1316
  3309. @SP
  3310. // #1317
  3311. M=M+1
  3312. //vv push_d_to_stack
  3313. //vv push_from_loc(5)
  3314. //
  3315. //// pop that 0
  3316. //^^ pop_to_ram(THAT, 0)
  3317. // #1318
  3318. @THAT
  3319. // #1319
  3320. D=M
  3321. // #1320
  3322. @0
  3323. // #1321
  3324. D=D+A
  3325. // #1322
  3326. @R13
  3327. // #1323
  3328. M=D
  3329. //^^ pop_stack_to_d
  3330. // #1324
  3331. @SP
  3332. // #1325
  3333. M=M-1
  3334. // #1326
  3335. A=M
  3336. // #1327
  3337. D=M
  3338. //vv pop_stack_to_d
  3339. // #1328
  3340. @R13
  3341. // #1329
  3342. A=M
  3343. // #1330
  3344. M=D
  3345. // #1331
  3346. @R13
  3347. // #1332
  3348. M=0
  3349. //vv pop_to_ram(THAT, 0)
  3350. //
  3351. //// goto WHILE_EXP0
  3352. // #1333
  3353. @Math.init$WHILE_EXP0
  3354. // #1334
  3355. 0;JMP
  3356. //
  3357. //// label WHILE_END0
  3358. (Math.init$WHILE_END0)
  3359. //
  3360. //// push constant 0
  3361. //^^ push_constant(0)
  3362. // #1335
  3363. @0
  3364. // #1336
  3365. D=A
  3366. //^^ push_d_to_stack
  3367. // #1337
  3368. @SP
  3369. // #1338
  3370. A=M
  3371. // #1339
  3372. M=D
  3373. // #1340
  3374. @SP
  3375. // #1341
  3376. M=M+1
  3377. //vv push_d_to_stack
  3378. //vv push_constant(0)
  3379. //
  3380. //// return
  3381. // #1342
  3382. @LCL
  3383. // #1343
  3384. D=M
  3385. // #1344
  3386. @R14
  3387. // #1345
  3388. M=D //R14=LCL
  3389. // #1346
  3390. @5
  3391. // #1347
  3392. A=D-A
  3393. // #1348
  3394. D=M
  3395. // #1349
  3396. @R15
  3397. // #1350
  3398. M=D //R15=*(LCL-5)
  3399. //^^ pop_stack_to_d
  3400. // #1351
  3401. @SP
  3402. // #1352
  3403. M=M-1
  3404. // #1353
  3405. A=M
  3406. // #1354
  3407. D=M
  3408. //vv pop_stack_to_d
  3409. // #1355
  3410. @ARG
  3411. // #1356
  3412. A=M
  3413. // #1357
  3414. M=D //*ARG = pop()
  3415. // #1358
  3416. @ARG
  3417. // #1359
  3418. D=M
  3419. // #1360
  3420. @SP
  3421. // #1361
  3422. M=D+1 //SP=ARG+1
  3423. // #1362
  3424. @R14
  3425. // #1363
  3426. AM=M-1
  3427. // #1364
  3428. D=M
  3429. // #1365
  3430. @THAT
  3431. // #1366
  3432. M=D //THAT = *(--R14)
  3433. // #1367
  3434. @R14
  3435. // #1368
  3436. AM=M-1
  3437. // #1369
  3438. D=M
  3439. // #1370
  3440. @THIS
  3441. // #1371
  3442. M=D //THIS = *(--R14)
  3443. // #1372
  3444. @R14
  3445. // #1373
  3446. AM=M-1
  3447. // #1374
  3448. D=M
  3449. // #1375
  3450. @ARG
  3451. // #1376
  3452. M=D //ARG = *(--R14)
  3453. // #1377
  3454. @R14
  3455. // #1378
  3456. AM=M-1
  3457. // #1379
  3458. D=M
  3459. // #1380
  3460. @LCL
  3461. // #1381
  3462. M=D //LCL = *(--R14)
  3463. // #1382
  3464. @R15
  3465. // #1383
  3466. A=M
  3467. // #1384
  3468. 0;JMP //goto *R15
  3469. //
  3470. //// function Math.abs 0
  3471. (Math.abs)
  3472. //
  3473. //// push argument 0
  3474. //^^ push_from_ram(ARG, 0)
  3475. // #1385
  3476. @ARG
  3477. // #1386
  3478. D=M
  3479. // #1387
  3480. @0
  3481. // #1388
  3482. A=D+A
  3483. // #1389
  3484. D=M
  3485. //^^ push_d_to_stack
  3486. // #1390
  3487. @SP
  3488. // #1391
  3489. A=M
  3490. // #1392
  3491. M=D
  3492. // #1393
  3493. @SP
  3494. // #1394
  3495. M=M+1
  3496. //vv push_d_to_stack
  3497. //vv push_from_ram(ARG, 0)
  3498. //
  3499. //// push constant 0
  3500. //^^ push_constant(0)
  3501. // #1395
  3502. @0
  3503. // #1396
  3504. D=A
  3505. //^^ push_d_to_stack
  3506. // #1397
  3507. @SP
  3508. // #1398
  3509. A=M
  3510. // #1399
  3511. M=D
  3512. // #1400
  3513. @SP
  3514. // #1401
  3515. M=M+1
  3516. //vv push_d_to_stack
  3517. //vv push_constant(0)
  3518. //
  3519. //// lt
  3520. //^^ arith_cmp_op(JLT)
  3521. //^^ pop_stack_to_d
  3522. // #1402
  3523. @SP
  3524. // #1403
  3525. M=M-1
  3526. // #1404
  3527. A=M
  3528. // #1405
  3529. D=M
  3530. //vv pop_stack_to_d
  3531. //^^ arith_d_with_stack_top(D-M)
  3532. // #1406
  3533. @R13
  3534. // #1407
  3535. M=D
  3536. //^^ pop_stack_to_d
  3537. // #1408
  3538. @SP
  3539. // #1409
  3540. M=M-1
  3541. // #1410
  3542. A=M
  3543. // #1411
  3544. D=M
  3545. //vv pop_stack_to_d
  3546. // #1412
  3547. @R13
  3548. // #1413
  3549. D=D-M
  3550. // #1414
  3551. @R13
  3552. // #1415
  3553. M=0
  3554. //vv arith_d_with_stack_top(D-M)
  3555. // #1416
  3556. @PUT_TRUE_32
  3557. // #1417
  3558. D;JLT
  3559. // #1418
  3560. @R13
  3561. // #1419
  3562. M=0
  3563. // #1420
  3564. @CONT_32
  3565. // #1421
  3566. 0;JMP
  3567. (PUT_TRUE_32)
  3568. // #1422
  3569. @R13
  3570. // #1423
  3571. M=-1
  3572. (CONT_32)
  3573. // #1424
  3574. @R13
  3575. // #1425
  3576. D=M
  3577. // #1426
  3578. @R13
  3579. // #1427
  3580. M=0
  3581. //^^ push_d_to_stack
  3582. // #1428
  3583. @SP
  3584. // #1429
  3585. A=M
  3586. // #1430
  3587. M=D
  3588. // #1431
  3589. @SP
  3590. // #1432
  3591. M=M+1
  3592. //vv push_d_to_stack
  3593. //vv arith_cmp_op(JLT)
  3594. //
  3595. //// if-goto IF_TRUE0
  3596. //^^ pop_stack_to_d
  3597. // #1433
  3598. @SP
  3599. // #1434
  3600. M=M-1
  3601. // #1435
  3602. A=M
  3603. // #1436
  3604. D=M
  3605. //vv pop_stack_to_d
  3606. // #1437
  3607. @Math.abs$IF_TRUE0
  3608. // #1438
  3609. D;JNE
  3610. //
  3611. //// goto IF_FALSE0
  3612. // #1439
  3613. @Math.abs$IF_FALSE0
  3614. // #1440
  3615. 0;JMP
  3616. //
  3617. //// label IF_TRUE0
  3618. (Math.abs$IF_TRUE0)
  3619. //
  3620. //// push argument 0
  3621. //^^ push_from_ram(ARG, 0)
  3622. // #1441
  3623. @ARG
  3624. // #1442
  3625. D=M
  3626. // #1443
  3627. @0
  3628. // #1444
  3629. A=D+A
  3630. // #1445
  3631. D=M
  3632. //^^ push_d_to_stack
  3633. // #1446
  3634. @SP
  3635. // #1447
  3636. A=M
  3637. // #1448
  3638. M=D
  3639. // #1449
  3640. @SP
  3641. // #1450
  3642. M=M+1
  3643. //vv push_d_to_stack
  3644. //vv push_from_ram(ARG, 0)
  3645. //
  3646. //// neg
  3647. //^^ arith_unary_op(-)
  3648. //^^ pop_stack_to_d
  3649. // #1451
  3650. @SP
  3651. // #1452
  3652. M=M-1
  3653. // #1453
  3654. A=M
  3655. // #1454
  3656. D=M
  3657. //vv pop_stack_to_d
  3658. // #1455
  3659. D=-D
  3660. //^^ push_d_to_stack
  3661. // #1456
  3662. @SP
  3663. // #1457
  3664. A=M
  3665. // #1458
  3666. M=D
  3667. // #1459
  3668. @SP
  3669. // #1460
  3670. M=M+1
  3671. //vv push_d_to_stack
  3672. //vv arith_unary_op(-)
  3673. //
  3674. //// pop argument 0
  3675. //^^ pop_to_ram(ARG, 0)
  3676. // #1461
  3677. @ARG
  3678. // #1462
  3679. D=M
  3680. // #1463
  3681. @0
  3682. // #1464
  3683. D=D+A
  3684. // #1465
  3685. @R13
  3686. // #1466
  3687. M=D
  3688. //^^ pop_stack_to_d
  3689. // #1467
  3690. @SP
  3691. // #1468
  3692. M=M-1
  3693. // #1469
  3694. A=M
  3695. // #1470
  3696. D=M
  3697. //vv pop_stack_to_d
  3698. // #1471
  3699. @R13
  3700. // #1472
  3701. A=M
  3702. // #1473
  3703. M=D
  3704. // #1474
  3705. @R13
  3706. // #1475
  3707. M=0
  3708. //vv pop_to_ram(ARG, 0)
  3709. //
  3710. //// label IF_FALSE0
  3711. (Math.abs$IF_FALSE0)
  3712. //
  3713. //// push argument 0
  3714. //^^ push_from_ram(ARG, 0)
  3715. // #1476
  3716. @ARG
  3717. // #1477
  3718. D=M
  3719. // #1478
  3720. @0
  3721. // #1479
  3722. A=D+A
  3723. // #1480
  3724. D=M
  3725. //^^ push_d_to_stack
  3726. // #1481
  3727. @SP
  3728. // #1482
  3729. A=M
  3730. // #1483
  3731. M=D
  3732. // #1484
  3733. @SP
  3734. // #1485
  3735. M=M+1
  3736. //vv push_d_to_stack
  3737. //vv push_from_ram(ARG, 0)
  3738. //
  3739. //// return
  3740. // #1486
  3741. @LCL
  3742. // #1487
  3743. D=M
  3744. // #1488
  3745. @R14
  3746. // #1489
  3747. M=D //R14=LCL
  3748. // #1490
  3749. @5
  3750. // #1491
  3751. A=D-A
  3752. // #1492
  3753. D=M
  3754. // #1493
  3755. @R15
  3756. // #1494
  3757. M=D //R15=*(LCL-5)
  3758. //^^ pop_stack_to_d
  3759. // #1495
  3760. @SP
  3761. // #1496
  3762. M=M-1
  3763. // #1497
  3764. A=M
  3765. // #1498
  3766. D=M
  3767. //vv pop_stack_to_d
  3768. // #1499
  3769. @ARG
  3770. // #1500
  3771. A=M
  3772. // #1501
  3773. M=D //*ARG = pop()
  3774. // #1502
  3775. @ARG
  3776. // #1503
  3777. D=M
  3778. // #1504
  3779. @SP
  3780. // #1505
  3781. M=D+1 //SP=ARG+1
  3782. // #1506
  3783. @R14
  3784. // #1507
  3785. AM=M-1
  3786. // #1508
  3787. D=M
  3788. // #1509
  3789. @THAT
  3790. // #1510
  3791. M=D //THAT = *(--R14)
  3792. // #1511
  3793. @R14
  3794. // #1512
  3795. AM=M-1
  3796. // #1513
  3797. D=M
  3798. // #1514
  3799. @THIS
  3800. // #1515
  3801. M=D //THIS = *(--R14)
  3802. // #1516
  3803. @R14
  3804. // #1517
  3805. AM=M-1
  3806. // #1518
  3807. D=M
  3808. // #1519
  3809. @ARG
  3810. // #1520
  3811. M=D //ARG = *(--R14)
  3812. // #1521
  3813. @R14
  3814. // #1522
  3815. AM=M-1
  3816. // #1523
  3817. D=M
  3818. // #1524
  3819. @LCL
  3820. // #1525
  3821. M=D //LCL = *(--R14)
  3822. // #1526
  3823. @R15
  3824. // #1527
  3825. A=M
  3826. // #1528
  3827. 0;JMP //goto *R15
  3828. //
  3829. //// function Math.multiply 5
  3830. (Math.multiply)
  3831. // #1529
  3832. D=0
  3833. //^^ push_d_to_stack
  3834. // #1530
  3835. @SP
  3836. // #1531
  3837. A=M
  3838. // #1532
  3839. M=D
  3840. // #1533
  3841. @SP
  3842. // #1534
  3843. M=M+1
  3844. //vv push_d_to_stack
  3845. // #1535
  3846. D=0
  3847. //^^ push_d_to_stack
  3848. // #1536
  3849. @SP
  3850. // #1537
  3851. A=M
  3852. // #1538
  3853. M=D
  3854. // #1539
  3855. @SP
  3856. // #1540
  3857. M=M+1
  3858. //vv push_d_to_stack
  3859. // #1541
  3860. D=0
  3861. //^^ push_d_to_stack
  3862. // #1542
  3863. @SP
  3864. // #1543
  3865. A=M
  3866. // #1544
  3867. M=D
  3868. // #1545
  3869. @SP
  3870. // #1546
  3871. M=M+1
  3872. //vv push_d_to_stack
  3873. // #1547
  3874. D=0
  3875. //^^ push_d_to_stack
  3876. // #1548
  3877. @SP
  3878. // #1549
  3879. A=M
  3880. // #1550
  3881. M=D
  3882. // #1551
  3883. @SP
  3884. // #1552
  3885. M=M+1
  3886. //vv push_d_to_stack
  3887. // #1553
  3888. D=0
  3889. //^^ push_d_to_stack
  3890. // #1554
  3891. @SP
  3892. // #1555
  3893. A=M
  3894. // #1556
  3895. M=D
  3896. // #1557
  3897. @SP
  3898. // #1558
  3899. M=M+1
  3900. //vv push_d_to_stack
  3901. //
  3902. //// push argument 0
  3903. //^^ push_from_ram(ARG, 0)
  3904. // #1559
  3905. @ARG
  3906. // #1560
  3907. D=M
  3908. // #1561
  3909. @0
  3910. // #1562
  3911. A=D+A
  3912. // #1563
  3913. D=M
  3914. //^^ push_d_to_stack
  3915. // #1564
  3916. @SP
  3917. // #1565
  3918. A=M
  3919. // #1566
  3920. M=D
  3921. // #1567
  3922. @SP
  3923. // #1568
  3924. M=M+1
  3925. //vv push_d_to_stack
  3926. //vv push_from_ram(ARG, 0)
  3927. //
  3928. //// push constant 0
  3929. //^^ push_constant(0)
  3930. // #1569
  3931. @0
  3932. // #1570
  3933. D=A
  3934. //^^ push_d_to_stack
  3935. // #1571
  3936. @SP
  3937. // #1572
  3938. A=M
  3939. // #1573
  3940. M=D
  3941. // #1574
  3942. @SP
  3943. // #1575
  3944. M=M+1
  3945. //vv push_d_to_stack
  3946. //vv push_constant(0)
  3947. //
  3948. //// lt
  3949. //^^ arith_cmp_op(JLT)
  3950. //^^ pop_stack_to_d
  3951. // #1576
  3952. @SP
  3953. // #1577
  3954. M=M-1
  3955. // #1578
  3956. A=M
  3957. // #1579
  3958. D=M
  3959. //vv pop_stack_to_d
  3960. //^^ arith_d_with_stack_top(D-M)
  3961. // #1580
  3962. @R13
  3963. // #1581
  3964. M=D
  3965. //^^ pop_stack_to_d
  3966. // #1582
  3967. @SP
  3968. // #1583
  3969. M=M-1
  3970. // #1584
  3971. A=M
  3972. // #1585
  3973. D=M
  3974. //vv pop_stack_to_d
  3975. // #1586
  3976. @R13
  3977. // #1587
  3978. D=D-M
  3979. // #1588
  3980. @R13
  3981. // #1589
  3982. M=0
  3983. //vv arith_d_with_stack_top(D-M)
  3984. // #1590
  3985. @PUT_TRUE_33
  3986. // #1591
  3987. D;JLT
  3988. // #1592
  3989. @R13
  3990. // #1593
  3991. M=0
  3992. // #1594
  3993. @CONT_33
  3994. // #1595
  3995. 0;JMP
  3996. (PUT_TRUE_33)
  3997. // #1596
  3998. @R13
  3999. // #1597
  4000. M=-1
  4001. (CONT_33)
  4002. // #1598
  4003. @R13
  4004. // #1599
  4005. D=M
  4006. // #1600
  4007. @R13
  4008. // #1601
  4009. M=0
  4010. //^^ push_d_to_stack
  4011. // #1602
  4012. @SP
  4013. // #1603
  4014. A=M
  4015. // #1604
  4016. M=D
  4017. // #1605
  4018. @SP
  4019. // #1606
  4020. M=M+1
  4021. //vv push_d_to_stack
  4022. //vv arith_cmp_op(JLT)
  4023. //
  4024. //// push argument 1
  4025. //^^ push_from_ram(ARG, 1)
  4026. // #1607
  4027. @ARG
  4028. // #1608
  4029. D=M
  4030. // #1609
  4031. @1
  4032. // #1610
  4033. A=D+A
  4034. // #1611
  4035. D=M
  4036. //^^ push_d_to_stack
  4037. // #1612
  4038. @SP
  4039. // #1613
  4040. A=M
  4041. // #1614
  4042. M=D
  4043. // #1615
  4044. @SP
  4045. // #1616
  4046. M=M+1
  4047. //vv push_d_to_stack
  4048. //vv push_from_ram(ARG, 1)
  4049. //
  4050. //// push constant 0
  4051. //^^ push_constant(0)
  4052. // #1617
  4053. @0
  4054. // #1618
  4055. D=A
  4056. //^^ push_d_to_stack
  4057. // #1619
  4058. @SP
  4059. // #1620
  4060. A=M
  4061. // #1621
  4062. M=D
  4063. // #1622
  4064. @SP
  4065. // #1623
  4066. M=M+1
  4067. //vv push_d_to_stack
  4068. //vv push_constant(0)
  4069. //
  4070. //// gt
  4071. //^^ arith_cmp_op(JGT)
  4072. //^^ pop_stack_to_d
  4073. // #1624
  4074. @SP
  4075. // #1625
  4076. M=M-1
  4077. // #1626
  4078. A=M
  4079. // #1627
  4080. D=M
  4081. //vv pop_stack_to_d
  4082. //^^ arith_d_with_stack_top(D-M)
  4083. // #1628
  4084. @R13
  4085. // #1629
  4086. M=D
  4087. //^^ pop_stack_to_d
  4088. // #1630
  4089. @SP
  4090. // #1631
  4091. M=M-1
  4092. // #1632
  4093. A=M
  4094. // #1633
  4095. D=M
  4096. //vv pop_stack_to_d
  4097. // #1634
  4098. @R13
  4099. // #1635
  4100. D=D-M
  4101. // #1636
  4102. @R13
  4103. // #1637
  4104. M=0
  4105. //vv arith_d_with_stack_top(D-M)
  4106. // #1638
  4107. @PUT_TRUE_34
  4108. // #1639
  4109. D;JGT
  4110. // #1640
  4111. @R13
  4112. // #1641
  4113. M=0
  4114. // #1642
  4115. @CONT_34
  4116. // #1643
  4117. 0;JMP
  4118. (PUT_TRUE_34)
  4119. // #1644
  4120. @R13
  4121. // #1645
  4122. M=-1
  4123. (CONT_34)
  4124. // #1646
  4125. @R13
  4126. // #1647
  4127. D=M
  4128. // #1648
  4129. @R13
  4130. // #1649
  4131. M=0
  4132. //^^ push_d_to_stack
  4133. // #1650
  4134. @SP
  4135. // #1651
  4136. A=M
  4137. // #1652
  4138. M=D
  4139. // #1653
  4140. @SP
  4141. // #1654
  4142. M=M+1
  4143. //vv push_d_to_stack
  4144. //vv arith_cmp_op(JGT)
  4145. //
  4146. //// and
  4147. //^^ arith_binary_op(&)
  4148. //^^ pop_stack_to_d
  4149. // #1655
  4150. @SP
  4151. // #1656
  4152. M=M-1
  4153. // #1657
  4154. A=M
  4155. // #1658
  4156. D=M
  4157. //vv pop_stack_to_d
  4158. //^^ arith_d_with_stack_top(D&M)
  4159. // #1659
  4160. @R13
  4161. // #1660
  4162. M=D
  4163. //^^ pop_stack_to_d
  4164. // #1661
  4165. @SP
  4166. // #1662
  4167. M=M-1
  4168. // #1663
  4169. A=M
  4170. // #1664
  4171. D=M
  4172. //vv pop_stack_to_d
  4173. // #1665
  4174. @R13
  4175. // #1666
  4176. D=D&M
  4177. // #1667
  4178. @R13
  4179. // #1668
  4180. M=0
  4181. //vv arith_d_with_stack_top(D&M)
  4182. //^^ push_d_to_stack
  4183. // #1669
  4184. @SP
  4185. // #1670
  4186. A=M
  4187. // #1671
  4188. M=D
  4189. // #1672
  4190. @SP
  4191. // #1673
  4192. M=M+1
  4193. //vv push_d_to_stack
  4194. //vv arith_binary_op(&)
  4195. //
  4196. //// push argument 0
  4197. //^^ push_from_ram(ARG, 0)
  4198. // #1674
  4199. @ARG
  4200. // #1675
  4201. D=M
  4202. // #1676
  4203. @0
  4204. // #1677
  4205. A=D+A
  4206. // #1678
  4207. D=M
  4208. //^^ push_d_to_stack
  4209. // #1679
  4210. @SP
  4211. // #1680
  4212. A=M
  4213. // #1681
  4214. M=D
  4215. // #1682
  4216. @SP
  4217. // #1683
  4218. M=M+1
  4219. //vv push_d_to_stack
  4220. //vv push_from_ram(ARG, 0)
  4221. //
  4222. //// push constant 0
  4223. //^^ push_constant(0)
  4224. // #1684
  4225. @0
  4226. // #1685
  4227. D=A
  4228. //^^ push_d_to_stack
  4229. // #1686
  4230. @SP
  4231. // #1687
  4232. A=M
  4233. // #1688
  4234. M=D
  4235. // #1689
  4236. @SP
  4237. // #1690
  4238. M=M+1
  4239. //vv push_d_to_stack
  4240. //vv push_constant(0)
  4241. //
  4242. //// gt
  4243. //^^ arith_cmp_op(JGT)
  4244. //^^ pop_stack_to_d
  4245. // #1691
  4246. @SP
  4247. // #1692
  4248. M=M-1
  4249. // #1693
  4250. A=M
  4251. // #1694
  4252. D=M
  4253. //vv pop_stack_to_d
  4254. //^^ arith_d_with_stack_top(D-M)
  4255. // #1695
  4256. @R13
  4257. // #1696
  4258. M=D
  4259. //^^ pop_stack_to_d
  4260. // #1697
  4261. @SP
  4262. // #1698
  4263. M=M-1
  4264. // #1699
  4265. A=M
  4266. // #1700
  4267. D=M
  4268. //vv pop_stack_to_d
  4269. // #1701
  4270. @R13
  4271. // #1702
  4272. D=D-M
  4273. // #1703
  4274. @R13
  4275. // #1704
  4276. M=0
  4277. //vv arith_d_with_stack_top(D-M)
  4278. // #1705
  4279. @PUT_TRUE_35
  4280. // #1706
  4281. D;JGT
  4282. // #1707
  4283. @R13
  4284. // #1708
  4285. M=0
  4286. // #1709
  4287. @CONT_35
  4288. // #1710
  4289. 0;JMP
  4290. (PUT_TRUE_35)
  4291. // #1711
  4292. @R13
  4293. // #1712
  4294. M=-1
  4295. (CONT_35)
  4296. // #1713
  4297. @R13
  4298. // #1714
  4299. D=M
  4300. // #1715
  4301. @R13
  4302. // #1716
  4303. M=0
  4304. //^^ push_d_to_stack
  4305. // #1717
  4306. @SP
  4307. // #1718
  4308. A=M
  4309. // #1719
  4310. M=D
  4311. // #1720
  4312. @SP
  4313. // #1721
  4314. M=M+1
  4315. //vv push_d_to_stack
  4316. //vv arith_cmp_op(JGT)
  4317. //
  4318. //// push argument 1
  4319. //^^ push_from_ram(ARG, 1)
  4320. // #1722
  4321. @ARG
  4322. // #1723
  4323. D=M
  4324. // #1724
  4325. @1
  4326. // #1725
  4327. A=D+A
  4328. // #1726
  4329. D=M
  4330. //^^ push_d_to_stack
  4331. // #1727
  4332. @SP
  4333. // #1728
  4334. A=M
  4335. // #1729
  4336. M=D
  4337. // #1730
  4338. @SP
  4339. // #1731
  4340. M=M+1
  4341. //vv push_d_to_stack
  4342. //vv push_from_ram(ARG, 1)
  4343. //
  4344. //// push constant 0
  4345. //^^ push_constant(0)
  4346. // #1732
  4347. @0
  4348. // #1733
  4349. D=A
  4350. //^^ push_d_to_stack
  4351. // #1734
  4352. @SP
  4353. // #1735
  4354. A=M
  4355. // #1736
  4356. M=D
  4357. // #1737
  4358. @SP
  4359. // #1738
  4360. M=M+1
  4361. //vv push_d_to_stack
  4362. //vv push_constant(0)
  4363. //
  4364. //// lt
  4365. //^^ arith_cmp_op(JLT)
  4366. //^^ pop_stack_to_d
  4367. // #1739
  4368. @SP
  4369. // #1740
  4370. M=M-1
  4371. // #1741
  4372. A=M
  4373. // #1742
  4374. D=M
  4375. //vv pop_stack_to_d
  4376. //^^ arith_d_with_stack_top(D-M)
  4377. // #1743
  4378. @R13
  4379. // #1744
  4380. M=D
  4381. //^^ pop_stack_to_d
  4382. // #1745
  4383. @SP
  4384. // #1746
  4385. M=M-1
  4386. // #1747
  4387. A=M
  4388. // #1748
  4389. D=M
  4390. //vv pop_stack_to_d
  4391. // #1749
  4392. @R13
  4393. // #1750
  4394. D=D-M
  4395. // #1751
  4396. @R13
  4397. // #1752
  4398. M=0
  4399. //vv arith_d_with_stack_top(D-M)
  4400. // #1753
  4401. @PUT_TRUE_36
  4402. // #1754
  4403. D;JLT
  4404. // #1755
  4405. @R13
  4406. // #1756
  4407. M=0
  4408. // #1757
  4409. @CONT_36
  4410. // #1758
  4411. 0;JMP
  4412. (PUT_TRUE_36)
  4413. // #1759
  4414. @R13
  4415. // #1760
  4416. M=-1
  4417. (CONT_36)
  4418. // #1761
  4419. @R13
  4420. // #1762
  4421. D=M
  4422. // #1763
  4423. @R13
  4424. // #1764
  4425. M=0
  4426. //^^ push_d_to_stack
  4427. // #1765
  4428. @SP
  4429. // #1766
  4430. A=M
  4431. // #1767
  4432. M=D
  4433. // #1768
  4434. @SP
  4435. // #1769
  4436. M=M+1
  4437. //vv push_d_to_stack
  4438. //vv arith_cmp_op(JLT)
  4439. //
  4440. //// and
  4441. //^^ arith_binary_op(&)
  4442. //^^ pop_stack_to_d
  4443. // #1770
  4444. @SP
  4445. // #1771
  4446. M=M-1
  4447. // #1772
  4448. A=M
  4449. // #1773
  4450. D=M
  4451. //vv pop_stack_to_d
  4452. //^^ arith_d_with_stack_top(D&M)
  4453. // #1774
  4454. @R13
  4455. // #1775
  4456. M=D
  4457. //^^ pop_stack_to_d
  4458. // #1776
  4459. @SP
  4460. // #1777
  4461. M=M-1
  4462. // #1778
  4463. A=M
  4464. // #1779
  4465. D=M
  4466. //vv pop_stack_to_d
  4467. // #1780
  4468. @R13
  4469. // #1781
  4470. D=D&M
  4471. // #1782
  4472. @R13
  4473. // #1783
  4474. M=0
  4475. //vv arith_d_with_stack_top(D&M)
  4476. //^^ push_d_to_stack
  4477. // #1784
  4478. @SP
  4479. // #1785
  4480. A=M
  4481. // #1786
  4482. M=D
  4483. // #1787
  4484. @SP
  4485. // #1788
  4486. M=M+1
  4487. //vv push_d_to_stack
  4488. //vv arith_binary_op(&)
  4489. //
  4490. //// or
  4491. //^^ arith_binary_op(|)
  4492. //^^ pop_stack_to_d
  4493. // #1789
  4494. @SP
  4495. // #1790
  4496. M=M-1
  4497. // #1791
  4498. A=M
  4499. // #1792
  4500. D=M
  4501. //vv pop_stack_to_d
  4502. //^^ arith_d_with_stack_top(D|M)
  4503. // #1793
  4504. @R13
  4505. // #1794
  4506. M=D
  4507. //^^ pop_stack_to_d
  4508. // #1795
  4509. @SP
  4510. // #1796
  4511. M=M-1
  4512. // #1797
  4513. A=M
  4514. // #1798
  4515. D=M
  4516. //vv pop_stack_to_d
  4517. // #1799
  4518. @R13
  4519. // #1800
  4520. D=D|M
  4521. // #1801
  4522. @R13
  4523. // #1802
  4524. M=0
  4525. //vv arith_d_with_stack_top(D|M)
  4526. //^^ push_d_to_stack
  4527. // #1803
  4528. @SP
  4529. // #1804
  4530. A=M
  4531. // #1805
  4532. M=D
  4533. // #1806
  4534. @SP
  4535. // #1807
  4536. M=M+1
  4537. //vv push_d_to_stack
  4538. //vv arith_binary_op(|)
  4539. //
  4540. //// pop local 4
  4541. //^^ pop_to_ram(LCL, 4)
  4542. // #1808
  4543. @LCL
  4544. // #1809
  4545. D=M
  4546. // #1810
  4547. @4
  4548. // #1811
  4549. D=D+A
  4550. // #1812
  4551. @R13
  4552. // #1813
  4553. M=D
  4554. //^^ pop_stack_to_d
  4555. // #1814
  4556. @SP
  4557. // #1815
  4558. M=M-1
  4559. // #1816
  4560. A=M
  4561. // #1817
  4562. D=M
  4563. //vv pop_stack_to_d
  4564. // #1818
  4565. @R13
  4566. // #1819
  4567. A=M
  4568. // #1820
  4569. M=D
  4570. // #1821
  4571. @R13
  4572. // #1822
  4573. M=0
  4574. //vv pop_to_ram(LCL, 4)
  4575. //
  4576. //// push argument 0
  4577. //^^ push_from_ram(ARG, 0)
  4578. // #1823
  4579. @ARG
  4580. // #1824
  4581. D=M
  4582. // #1825
  4583. @0
  4584. // #1826
  4585. A=D+A
  4586. // #1827
  4587. D=M
  4588. //^^ push_d_to_stack
  4589. // #1828
  4590. @SP
  4591. // #1829
  4592. A=M
  4593. // #1830
  4594. M=D
  4595. // #1831
  4596. @SP
  4597. // #1832
  4598. M=M+1
  4599. //vv push_d_to_stack
  4600. //vv push_from_ram(ARG, 0)
  4601. //
  4602. //// call Math.abs 1
  4603. //^^ push_constant(RET_ADDR_37)
  4604. // #1833
  4605. @RET_ADDR_37
  4606. // #1834
  4607. D=A
  4608. //^^ push_d_to_stack
  4609. // #1835
  4610. @SP
  4611. // #1836
  4612. A=M
  4613. // #1837
  4614. M=D
  4615. // #1838
  4616. @SP
  4617. // #1839
  4618. M=M+1
  4619. //vv push_d_to_stack
  4620. //vv push_constant(RET_ADDR_37)
  4621. //push return-address
  4622. // #1840
  4623. @LCL
  4624. // #1841
  4625. D=M
  4626. //^^ push_d_to_stack
  4627. // #1842
  4628. @SP
  4629. // #1843
  4630. A=M
  4631. // #1844
  4632. M=D
  4633. // #1845
  4634. @SP
  4635. // #1846
  4636. M=M+1
  4637. //vv push_d_to_stack
  4638. //push LCL
  4639. // #1847
  4640. @ARG
  4641. // #1848
  4642. D=M
  4643. //^^ push_d_to_stack
  4644. // #1849
  4645. @SP
  4646. // #1850
  4647. A=M
  4648. // #1851
  4649. M=D
  4650. // #1852
  4651. @SP
  4652. // #1853
  4653. M=M+1
  4654. //vv push_d_to_stack
  4655. //push ARG
  4656. // #1854
  4657. @THIS
  4658. // #1855
  4659. D=M
  4660. //^^ push_d_to_stack
  4661. // #1856
  4662. @SP
  4663. // #1857
  4664. A=M
  4665. // #1858
  4666. M=D
  4667. // #1859
  4668. @SP
  4669. // #1860
  4670. M=M+1
  4671. //vv push_d_to_stack
  4672. //push THIS
  4673. // #1861
  4674. @THAT
  4675. // #1862
  4676. D=M
  4677. //^^ push_d_to_stack
  4678. // #1863
  4679. @SP
  4680. // #1864
  4681. A=M
  4682. // #1865
  4683. M=D
  4684. // #1866
  4685. @SP
  4686. // #1867
  4687. M=M+1
  4688. //vv push_d_to_stack
  4689. //push THAT
  4690. // #1868
  4691. @SP
  4692. // #1869
  4693. D=M
  4694. // #1870
  4695. @ARG
  4696. // #1871
  4697. M=D
  4698. // #1872
  4699. @6
  4700. // #1873
  4701. D=A
  4702. // #1874
  4703. @ARG
  4704. // #1875
  4705. M=M-D // ARG = SP - args - 5
  4706. // #1876
  4707. @SP
  4708. // #1877
  4709. D=M
  4710. // #1878
  4711. @LCL
  4712. // #1879
  4713. M=D // LCL = SP
  4714. // #1880
  4715. @Math.abs
  4716. // #1881
  4717. 0;JMP
  4718. (RET_ADDR_37)
  4719. //
  4720. //// pop argument 0
  4721. //^^ pop_to_ram(ARG, 0)
  4722. // #1882
  4723. @ARG
  4724. // #1883
  4725. D=M
  4726. // #1884
  4727. @0
  4728. // #1885
  4729. D=D+A
  4730. // #1886
  4731. @R13
  4732. // #1887
  4733. M=D
  4734. //^^ pop_stack_to_d
  4735. // #1888
  4736. @SP
  4737. // #1889
  4738. M=M-1
  4739. // #1890
  4740. A=M
  4741. // #1891
  4742. D=M
  4743. //vv pop_stack_to_d
  4744. // #1892
  4745. @R13
  4746. // #1893
  4747. A=M
  4748. // #1894
  4749. M=D
  4750. // #1895
  4751. @R13
  4752. // #1896
  4753. M=0
  4754. //vv pop_to_ram(ARG, 0)
  4755. //
  4756. //// push argument 1
  4757. //^^ push_from_ram(ARG, 1)
  4758. // #1897
  4759. @ARG
  4760. // #1898
  4761. D=M
  4762. // #1899
  4763. @1
  4764. // #1900
  4765. A=D+A
  4766. // #1901
  4767. D=M
  4768. //^^ push_d_to_stack
  4769. // #1902
  4770. @SP
  4771. // #1903
  4772. A=M
  4773. // #1904
  4774. M=D
  4775. // #1905
  4776. @SP
  4777. // #1906
  4778. M=M+1
  4779. //vv push_d_to_stack
  4780. //vv push_from_ram(ARG, 1)
  4781. //
  4782. //// call Math.abs 1
  4783. //^^ push_constant(RET_ADDR_38)
  4784. // #1907
  4785. @RET_ADDR_38
  4786. // #1908
  4787. D=A
  4788. //^^ push_d_to_stack
  4789. // #1909
  4790. @SP
  4791. // #1910
  4792. A=M
  4793. // #1911
  4794. M=D
  4795. // #1912
  4796. @SP
  4797. // #1913
  4798. M=M+1
  4799. //vv push_d_to_stack
  4800. //vv push_constant(RET_ADDR_38)
  4801. //push return-address
  4802. // #1914
  4803. @LCL
  4804. // #1915
  4805. D=M
  4806. //^^ push_d_to_stack
  4807. // #1916
  4808. @SP
  4809. // #1917
  4810. A=M
  4811. // #1918
  4812. M=D
  4813. // #1919
  4814. @SP
  4815. // #1920
  4816. M=M+1
  4817. //vv push_d_to_stack
  4818. //push LCL
  4819. // #1921
  4820. @ARG
  4821. // #1922
  4822. D=M
  4823. //^^ push_d_to_stack
  4824. // #1923
  4825. @SP
  4826. // #1924
  4827. A=M
  4828. // #1925
  4829. M=D
  4830. // #1926
  4831. @SP
  4832. // #1927
  4833. M=M+1
  4834. //vv push_d_to_stack
  4835. //push ARG
  4836. // #1928
  4837. @THIS
  4838. // #1929
  4839. D=M
  4840. //^^ push_d_to_stack
  4841. // #1930
  4842. @SP
  4843. // #1931
  4844. A=M
  4845. // #1932
  4846. M=D
  4847. // #1933
  4848. @SP
  4849. // #1934
  4850. M=M+1
  4851. //vv push_d_to_stack
  4852. //push THIS
  4853. // #1935
  4854. @THAT
  4855. // #1936
  4856. D=M
  4857. //^^ push_d_to_stack
  4858. // #1937
  4859. @SP
  4860. // #1938
  4861. A=M
  4862. // #1939
  4863. M=D
  4864. // #1940
  4865. @SP
  4866. // #1941
  4867. M=M+1
  4868. //vv push_d_to_stack
  4869. //push THAT
  4870. // #1942
  4871. @SP
  4872. // #1943
  4873. D=M
  4874. // #1944
  4875. @ARG
  4876. // #1945
  4877. M=D
  4878. // #1946
  4879. @6
  4880. // #1947
  4881. D=A
  4882. // #1948
  4883. @ARG
  4884. // #1949
  4885. M=M-D // ARG = SP - args - 5
  4886. // #1950
  4887. @SP
  4888. // #1951
  4889. D=M
  4890. // #1952
  4891. @LCL
  4892. // #1953
  4893. M=D // LCL = SP
  4894. // #1954
  4895. @Math.abs
  4896. // #1955
  4897. 0;JMP
  4898. (RET_ADDR_38)
  4899. //
  4900. //// pop argument 1
  4901. //^^ pop_to_ram(ARG, 1)
  4902. // #1956
  4903. @ARG
  4904. // #1957
  4905. D=M
  4906. // #1958
  4907. @1
  4908. // #1959
  4909. D=D+A
  4910. // #1960
  4911. @R13
  4912. // #1961
  4913. M=D
  4914. //^^ pop_stack_to_d
  4915. // #1962
  4916. @SP
  4917. // #1963
  4918. M=M-1
  4919. // #1964
  4920. A=M
  4921. // #1965
  4922. D=M
  4923. //vv pop_stack_to_d
  4924. // #1966
  4925. @R13
  4926. // #1967
  4927. A=M
  4928. // #1968
  4929. M=D
  4930. // #1969
  4931. @R13
  4932. // #1970
  4933. M=0
  4934. //vv pop_to_ram(ARG, 1)
  4935. //
  4936. //// push argument 0
  4937. //^^ push_from_ram(ARG, 0)
  4938. // #1971
  4939. @ARG
  4940. // #1972
  4941. D=M
  4942. // #1973
  4943. @0
  4944. // #1974
  4945. A=D+A
  4946. // #1975
  4947. D=M
  4948. //^^ push_d_to_stack
  4949. // #1976
  4950. @SP
  4951. // #1977
  4952. A=M
  4953. // #1978
  4954. M=D
  4955. // #1979
  4956. @SP
  4957. // #1980
  4958. M=M+1
  4959. //vv push_d_to_stack
  4960. //vv push_from_ram(ARG, 0)
  4961. //
  4962. //// push argument 1
  4963. //^^ push_from_ram(ARG, 1)
  4964. // #1981
  4965. @ARG
  4966. // #1982
  4967. D=M
  4968. // #1983
  4969. @1
  4970. // #1984
  4971. A=D+A
  4972. // #1985
  4973. D=M
  4974. //^^ push_d_to_stack
  4975. // #1986
  4976. @SP
  4977. // #1987
  4978. A=M
  4979. // #1988
  4980. M=D
  4981. // #1989
  4982. @SP
  4983. // #1990
  4984. M=M+1
  4985. //vv push_d_to_stack
  4986. //vv push_from_ram(ARG, 1)
  4987. //
  4988. //// lt
  4989. //^^ arith_cmp_op(JLT)
  4990. //^^ pop_stack_to_d
  4991. // #1991
  4992. @SP
  4993. // #1992
  4994. M=M-1
  4995. // #1993
  4996. A=M
  4997. // #1994
  4998. D=M
  4999. //vv pop_stack_to_d
  5000. //^^ arith_d_with_stack_top(D-M)
  5001. // #1995
  5002. @R13
  5003. // #1996
  5004. M=D
  5005. //^^ pop_stack_to_d
  5006. // #1997
  5007. @SP
  5008. // #1998
  5009. M=M-1
  5010. // #1999
  5011. A=M
  5012. // #2000
  5013. D=M
  5014. //vv pop_stack_to_d
  5015. // #2001
  5016. @R13
  5017. // #2002
  5018. D=D-M
  5019. // #2003
  5020. @R13
  5021. // #2004
  5022. M=0
  5023. //vv arith_d_with_stack_top(D-M)
  5024. // #2005
  5025. @PUT_TRUE_39
  5026. // #2006
  5027. D;JLT
  5028. // #2007
  5029. @R13
  5030. // #2008
  5031. M=0
  5032. // #2009
  5033. @CONT_39
  5034. // #2010
  5035. 0;JMP
  5036. (PUT_TRUE_39)
  5037. // #2011
  5038. @R13
  5039. // #2012
  5040. M=-1
  5041. (CONT_39)
  5042. // #2013
  5043. @R13
  5044. // #2014
  5045. D=M
  5046. // #2015
  5047. @R13
  5048. // #2016
  5049. M=0
  5050. //^^ push_d_to_stack
  5051. // #2017
  5052. @SP
  5053. // #2018
  5054. A=M
  5055. // #2019
  5056. M=D
  5057. // #2020
  5058. @SP
  5059. // #2021
  5060. M=M+1
  5061. //vv push_d_to_stack
  5062. //vv arith_cmp_op(JLT)
  5063. //
  5064. //// if-goto IF_TRUE0
  5065. //^^ pop_stack_to_d
  5066. // #2022
  5067. @SP
  5068. // #2023
  5069. M=M-1
  5070. // #2024
  5071. A=M
  5072. // #2025
  5073. D=M
  5074. //vv pop_stack_to_d
  5075. // #2026
  5076. @Math.multiply$IF_TRUE0
  5077. // #2027
  5078. D;JNE
  5079. //
  5080. //// goto IF_FALSE0
  5081. // #2028
  5082. @Math.multiply$IF_FALSE0
  5083. // #2029
  5084. 0;JMP
  5085. //
  5086. //// label IF_TRUE0
  5087. (Math.multiply$IF_TRUE0)
  5088. //
  5089. //// push argument 0
  5090. //^^ push_from_ram(ARG, 0)
  5091. // #2030
  5092. @ARG
  5093. // #2031
  5094. D=M
  5095. // #2032
  5096. @0
  5097. // #2033
  5098. A=D+A
  5099. // #2034
  5100. D=M
  5101. //^^ push_d_to_stack
  5102. // #2035
  5103. @SP
  5104. // #2036
  5105. A=M
  5106. // #2037
  5107. M=D
  5108. // #2038
  5109. @SP
  5110. // #2039
  5111. M=M+1
  5112. //vv push_d_to_stack
  5113. //vv push_from_ram(ARG, 0)
  5114. //
  5115. //// pop local 1
  5116. //^^ pop_to_ram(LCL, 1)
  5117. // #2040
  5118. @LCL
  5119. // #2041
  5120. D=M
  5121. // #2042
  5122. @1
  5123. // #2043
  5124. D=D+A
  5125. // #2044
  5126. @R13
  5127. // #2045
  5128. M=D
  5129. //^^ pop_stack_to_d
  5130. // #2046
  5131. @SP
  5132. // #2047
  5133. M=M-1
  5134. // #2048
  5135. A=M
  5136. // #2049
  5137. D=M
  5138. //vv pop_stack_to_d
  5139. // #2050
  5140. @R13
  5141. // #2051
  5142. A=M
  5143. // #2052
  5144. M=D
  5145. // #2053
  5146. @R13
  5147. // #2054
  5148. M=0
  5149. //vv pop_to_ram(LCL, 1)
  5150. //
  5151. //// push argument 1
  5152. //^^ push_from_ram(ARG, 1)
  5153. // #2055
  5154. @ARG
  5155. // #2056
  5156. D=M
  5157. // #2057
  5158. @1
  5159. // #2058
  5160. A=D+A
  5161. // #2059
  5162. D=M
  5163. //^^ push_d_to_stack
  5164. // #2060
  5165. @SP
  5166. // #2061
  5167. A=M
  5168. // #2062
  5169. M=D
  5170. // #2063
  5171. @SP
  5172. // #2064
  5173. M=M+1
  5174. //vv push_d_to_stack
  5175. //vv push_from_ram(ARG, 1)
  5176. //
  5177. //// pop argument 0
  5178. //^^ pop_to_ram(ARG, 0)
  5179. // #2065
  5180. @ARG
  5181. // #2066
  5182. D=M
  5183. // #2067
  5184. @0
  5185. // #2068
  5186. D=D+A
  5187. // #2069
  5188. @R13
  5189. // #2070
  5190. M=D
  5191. //^^ pop_stack_to_d
  5192. // #2071
  5193. @SP
  5194. // #2072
  5195. M=M-1
  5196. // #2073
  5197. A=M
  5198. // #2074
  5199. D=M
  5200. //vv pop_stack_to_d
  5201. // #2075
  5202. @R13
  5203. // #2076
  5204. A=M
  5205. // #2077
  5206. M=D
  5207. // #2078
  5208. @R13
  5209. // #2079
  5210. M=0
  5211. //vv pop_to_ram(ARG, 0)
  5212. //
  5213. //// push local 1
  5214. //^^ push_from_ram(LCL, 1)
  5215. // #2080
  5216. @LCL
  5217. // #2081
  5218. D=M
  5219. // #2082
  5220. @1
  5221. // #2083
  5222. A=D+A
  5223. // #2084
  5224. D=M
  5225. //^^ push_d_to_stack
  5226. // #2085
  5227. @SP
  5228. // #2086
  5229. A=M
  5230. // #2087
  5231. M=D
  5232. // #2088
  5233. @SP
  5234. // #2089
  5235. M=M+1
  5236. //vv push_d_to_stack
  5237. //vv push_from_ram(LCL, 1)
  5238. //
  5239. //// pop argument 1
  5240. //^^ pop_to_ram(ARG, 1)
  5241. // #2090
  5242. @ARG
  5243. // #2091
  5244. D=M
  5245. // #2092
  5246. @1
  5247. // #2093
  5248. D=D+A
  5249. // #2094
  5250. @R13
  5251. // #2095
  5252. M=D
  5253. //^^ pop_stack_to_d
  5254. // #2096
  5255. @SP
  5256. // #2097
  5257. M=M-1
  5258. // #2098
  5259. A=M
  5260. // #2099
  5261. D=M
  5262. //vv pop_stack_to_d
  5263. // #2100
  5264. @R13
  5265. // #2101
  5266. A=M
  5267. // #2102
  5268. M=D
  5269. // #2103
  5270. @R13
  5271. // #2104
  5272. M=0
  5273. //vv pop_to_ram(ARG, 1)
  5274. //
  5275. //// label IF_FALSE0
  5276. (Math.multiply$IF_FALSE0)
  5277. //
  5278. //// label WHILE_EXP0
  5279. (Math.multiply$WHILE_EXP0)
  5280. //
  5281. //// push local 2
  5282. //^^ push_from_ram(LCL, 2)
  5283. // #2105
  5284. @LCL
  5285. // #2106
  5286. D=M
  5287. // #2107
  5288. @2
  5289. // #2108
  5290. A=D+A
  5291. // #2109
  5292. D=M
  5293. //^^ push_d_to_stack
  5294. // #2110
  5295. @SP
  5296. // #2111
  5297. A=M
  5298. // #2112
  5299. M=D
  5300. // #2113
  5301. @SP
  5302. // #2114
  5303. M=M+1
  5304. //vv push_d_to_stack
  5305. //vv push_from_ram(LCL, 2)
  5306. //
  5307. //// push argument 1
  5308. //^^ push_from_ram(ARG, 1)
  5309. // #2115
  5310. @ARG
  5311. // #2116
  5312. D=M
  5313. // #2117
  5314. @1
  5315. // #2118
  5316. A=D+A
  5317. // #2119
  5318. D=M
  5319. //^^ push_d_to_stack
  5320. // #2120
  5321. @SP
  5322. // #2121
  5323. A=M
  5324. // #2122
  5325. M=D
  5326. // #2123
  5327. @SP
  5328. // #2124
  5329. M=M+1
  5330. //vv push_d_to_stack
  5331. //vv push_from_ram(ARG, 1)
  5332. //
  5333. //// lt
  5334. //^^ arith_cmp_op(JLT)
  5335. //^^ pop_stack_to_d
  5336. // #2125
  5337. @SP
  5338. // #2126
  5339. M=M-1
  5340. // #2127
  5341. A=M
  5342. // #2128
  5343. D=M
  5344. //vv pop_stack_to_d
  5345. //^^ arith_d_with_stack_top(D-M)
  5346. // #2129
  5347. @R13
  5348. // #2130
  5349. M=D
  5350. //^^ pop_stack_to_d
  5351. // #2131
  5352. @SP
  5353. // #2132
  5354. M=M-1
  5355. // #2133
  5356. A=M
  5357. // #2134
  5358. D=M
  5359. //vv pop_stack_to_d
  5360. // #2135
  5361. @R13
  5362. // #2136
  5363. D=D-M
  5364. // #21…

Large files files are truncated, but you can click here to view the full file