API tools faq
paste
Advertisement
Guest User

Untitled

a guest
Dec 8th, 2019
105
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
text 33.57 KB | None | 0 0
raw download clone embed print report
  1. data
  2. # syscall constants
  3. PRINT_STRING = 4
  4. PRINT_CHAR = 11
  5. PRINT_INT = 1
  6.  
  7. # memory-mapped I/O
  8. VELOCITY = 0xffff0010
  9. ANGLE = 0xffff0014
  10. ANGLE_CONTROL = 0xffff0018
  11.  
  12. BOT_X = 0xffff0020
  13. BOT_Y = 0xffff0024
  14.  
  15. TIMER = 0xffff001c
  16. ARENA_MAP = 0xffff00dc
  17.  
  18. REQUEST_PUZZLE = 0xffff00d0 ## Puzzle
  19. SUBMIT_SOLUTION = 0xffff00d4 ## Puzzle
  20.  
  21. BONK_INT_MASK = 0x1000
  22. BONK_ACK = 0xffff0060
  23.  
  24. TIMER_INT_MASK = 0x8000
  25. TIMER_ACK = 0xffff006c
  26.  
  27. REQUEST_PUZZLE_INT_MASK = 0x800 ## Puzzle
  28. REQUEST_PUZZLE_ACK = 0xffff00d8 ## Puzzle
  29. ENABLE_PAINT_BRUSH = 0xffff00f0
  30. GET_PAINT_BUCKETS = 0xffff00e4
  31. ### Puzzle request puzzle until you get interrrupt saying that they finished creating the puzzle, solve puzzle,
  32. GRIDSIZE = 8
  33.  
  34. MAP_SIZE = 30
  35. NEXT_X: .word -1
  36. NEXT_Y: .word -1
  37. POWERUP_X: .word -1
  38. POWERUP_Y: .word -1
  39. PREV_X: .word -1
  40. PREV_Y: .word -1
  41. PREV_X1: .word -1
  42. PREV_Y1: .word -1
  43. PREV_X2: .word -1
  44. PREV_Y2: .word -1
  45.  
  46.  
  47. PREV_X3: .word -1
  48. PREV_Y3: .word -1
  49.  
  50.  
  51.  
  52.  
  53.  
  54. VISITED: .space 2700
  55. SIZE: .word 0
  56.  
  57.  
  58. MAP: .half 0:1800
  59. POWERUP_MAP: .space 1800
  60. newline: .asciiz "\n"
  61. NUM_POWERUPS: .word 0
  62. FLAG_VAR: .word 1
  63. puzzle: .half 0:164
  64. heap: .half 0:50000
  65. .text
  66. main:
  67. # Construct interrupt mask
  68. li $t1, 0
  69. sw $t1, FLAG_VAR($zero)
  70. li $t4, 0
  71. #or $t4, $t4, BONK_INT_MASK # request bonk
  72. or $t4, $t4, REQUEST_PUZZLE_INT_MASK # puzzle interrupt bit
  73. or $t4, $t4, TIMER_INT_MASK
  74. or $t4, $t4, 1 # global enable
  75. mtc0 $t4, $12
  76. li $t0, 0
  77. check_paint:
  78. lw $v0, TIMER
  79. add $v0, $v0, 0
  80. sw $v0, TIMER
  81. add $t0, $t0, 1
  82. blt $t0, 40, check_paint
  83.  
  84. long_do_while:
  85. lw $t0, GET_PAINT_BUCKETS
  86. blt $t0, 200, long_do_while
  87.  
  88. li $t1, 1
  89. sw $t0, ENABLE_PAINT_BRUSH
  90. keep_moving:
  91. li $t1, 0
  92. sw $t1, 0xffff00f4($zero)
  93. sw $t1, 0xffff00ec($zero)
  94.  
  95. jal closest_powerup
  96. lw $s2, NUM_POWERUPS
  97. add $s2 $s2, 1
  98. sw $s2, NUM_POWERUPS
  99. sw $zero, SIZE
  100.  
  101. closest_path:
  102.  
  103. lw $a0, BOT_X($zero)
  104. lw $a1, BOT_Y($zero)
  105.  
  106. jal nextPath
  107.  
  108. sw $a0, PREV_X($zero)
  109. sw $a1, PREV_Y($zero)
  110.  
  111. jal updateVisited
  112.  
  113. move $a0, $v0
  114. jal moveDir
  115.  
  116. lw $a0, BOT_X($zero)
  117. lw $a1, BOT_Y($zero)
  118. jal reachedDestination
  119. move $t1, $v0
  120.  
  121. beq $t1, $zero, closest_path
  122.  
  123. j keep_moving
  124.  
  125. closest_powerup:
  126. sub $sp, $sp, 24
  127. sw $ra, 0($sp)
  128. sw $s0, 4($sp)
  129. sw $s1, 8($sp)
  130. sw $s2, 12($sp)
  131. sw $a0, 16($sp)
  132. sw $a1, 20($sp)
  133.  
  134. lw $s2, NUM_POWERUPS
  135. la $s0, POWERUP_MAP($zero)
  136. sw $s0, 0xffff00e0($zero)
  137. mul $s2, $s2, 12
  138. add $s2, $s2, 16
  139. add $s2, $s2, $s0
  140. lh $s1, 16($s0) # get power_up_x
  141.  
  142. mul $s1, $s1, 10
  143. add $s2, $s2, 2
  144. lh $s2, 18($s0) # get power_up_y
  145. mul $s2, $s2, 10
  146. add $s1, $s1, 5
  147. add $s2, $s2, 5
  148. sh $s1, POWERUP_X($zero)
  149. sh $s2, POWERUP_Y($zero)
  150.  
  151.  
  152. lw $ra, 0($sp)
  153. lw $s0, 4($sp)
  154. lw $s1, 8($sp)
  155. lw $s2, 12($sp)
  156. lw $a0, 16($sp)
  157. lw $a1, 20($sp)
  158.  
  159. add $sp, $sp, 24
  160. jr $ra
  161.  
  162. euclidean_dist:
  163.  
  164. sub $sp, $sp, 12
  165. sw $ra, 0($sp)
  166. sw $a0, 4($sp)
  167. sw $a1, 8($sp)
  168.  
  169.  
  170. mul $a0, $a0, $a0 # x^2
  171. mul $a1, $a1, $a1 # y^2
  172. add $v0, $a0, $a1 # x^2 + y^2
  173. mtc1 $v0, $f0
  174. cvt.s.w $f0, $f0 # float(x^2 + y^2)
  175. sqrt.s $f0, $f0 # sqrt(x^2 + y^2)
  176. cvt.w.s $f0, $f0 # int(sqrt(...))
  177. mfc1 $v0, $f0
  178.  
  179. lw $ra, 0($sp)
  180. lw $a0, 4($sp)
  181. lw $a1, 8($sp)
  182. add $sp, $sp, 12
  183. jr $ra
  184.  
  185. updateVisited:
  186. sub $sp, $sp, 28
  187. sw $ra, 0($sp)
  188. sw $s0, 4($sp)
  189. sw $s1, 8($sp)
  190. sw $s2, 12($sp)
  191. sw $s3, 16($sp)
  192. sw $a0, 20($sp)
  193. sw $a1, 24($sp)
  194.  
  195. lw $s0, SIZE
  196. la $s1, VISITED
  197. mul $s0, $s0, 8
  198. add $s1, $s0, $s1
  199. sw $a0, 0($s1)
  200. sw $a1, 4($s1)
  201. lw $s0, SIZE
  202. add $s0, $s0, 1
  203. sw $s0, SIZE
  204.  
  205. lw $ra, 0($sp)
  206. lw $s0, 4($sp)
  207. lw $s1, 8($sp)
  208. lw $s2, 12($sp)
  209. lw $s3, 16($sp)
  210. lw $a0, 20($sp)
  211. lw $a1, 24($sp)
  212.  
  213. add $sp, $sp, 28
  214. jr $ra
  215.  
  216. isVisited:
  217. sub $sp, $sp, 28
  218. sw $ra, 0($sp)
  219. sw $s0, 4($sp)
  220. sw $s1, 8($sp)
  221. sw $s2, 12($sp)
  222. sw $s3, 16($sp)
  223. sw $a0, 20($sp)
  224. sw $a1, 24($sp)
  225.  
  226. li $s0, 0
  227. lw $s1, SIZE
  228. la $s2, VISITED
  229. isVisited_loop:
  230. bge $s0, $s1, isVisited_end_false
  231. mul $s3, $s0, 8
  232. add $s3, $s2, $s3
  233. lw $s4, 0($s3)
  234. bne $a0, $s4, isVisited_add
  235. lw $s4, 4($s3)
  236. bne $a1, $s4, isVisited_add
  237. j isVisited_end_true
  238. isVisited_add:
  239. add $s0, $s0, 1
  240. j isVisited_loop
  241. isVisited_end_false:
  242. li $v0, 0
  243. j isVisited_end
  244. isVisited_end_true:
  245. li $v0, 1
  246. isVisited_end:
  247. lw $ra, 0($sp)
  248. lw $s0, 4($sp)
  249. lw $s1, 8($sp)
  250. lw $s2, 12($sp)
  251. lw $s3, 16($sp)
  252. lw $a0, 20($sp)
  253. lw $a1, 24($sp)
  254.  
  255. add $sp, $sp, 28
  256. jr $ra
  257.  
  258.  
  259. costFunction:
  260. sub $sp, $sp, 28
  261. sw $ra, 0($sp)
  262. sw $s0, 4($sp)
  263. sw $s1, 8($sp)
  264. sw $s2, 12($sp)
  265. sw $s3, 16($sp)
  266. sw $a0, 20($sp)
  267. sw $a1, 24($sp)
  268.  
  269. move $s0, $a0 # destination_x
  270. move $s1, $a1 # destination_y
  271.  
  272. # MADE FIX HERE
  273. lh $s2, POWERUP_X($zero) # BOT_X
  274. lh $s3, POWERUP_Y($zero) # BOT_Y
  275.  
  276. sub $s2, $s0, $s2 # destination_x - BOT_X
  277. sub $s3, $s1, $s3 # destination_y - BOT_Y
  278.  
  279.  
  280. move $a0, $s2
  281. move $a1, $s3
  282. jal euclidean_dist
  283.  
  284. lw $ra, 0($sp)
  285. lw $s0, 4($sp)
  286. lw $s1, 8($sp)
  287. lw $s2, 12($sp)
  288. lw $s3, 16($sp)
  289. lw $a0, 20($sp)
  290. lw $a1, 24($sp)
  291. add $sp, $sp, 28
  292. jr $ra
  293.  
  294.  
  295. reachedDestination:
  296. sub $sp, $sp, 12
  297. sw $ra, 0($sp)
  298. sw $a0, 4($sp)
  299. sw $a1, 8($sp)
  300.  
  301. jal costFunction
  302. bgt $v0, 0, not_reached
  303. li $v0, 1
  304. j return_reached_destination
  305.  
  306. not_reached:
  307. li $v0, 0
  308.  
  309. return_reached_destination:
  310.  
  311. lw $ra, 0($sp)
  312. lw $a0, 0($sp)
  313. lw $a1, 0($sp)
  314. add $sp, $sp, 12
  315. jr $ra
  316.  
  317. nextPath:
  318. sub $sp, $sp, 32
  319. sw $ra, 0($sp)
  320. sw $s0, 4($sp)
  321. sw $s1, 8($sp)
  322. sw $s2, 12($sp)
  323. sw $s3, 16($sp)
  324. sw $t1, 20($sp)
  325. sw $a0, 24($sp)
  326. sw $a1, 28($sp)
  327.  
  328. move $s0, $a0
  329. move $s1, $a1
  330. li $s2, 10000 # storing min = 10000
  331. li $s3, 0 # angle
  332. CHECK_RIGHT:
  333. add $t1, $s0, 10 # bot_x + 10
  334. move $a0, $t1 # arg 1: bot_x + 10
  335. move $a1, $s1 # arg 2: bot_y
  336.  
  337. jal isValid
  338.  
  339. beq $v0, $zero, CHECK_LEFT
  340. jal costFunction
  341. bgt $v0, $s2, CHECK_LEFT
  342.  
  343. sw $a0, NEXT_X
  344. sw $a1, NEXT_Y
  345. move $s2, $v0
  346. li $s3, 0
  347. CHECK_LEFT:
  348. sub $t1, $s0, 10 # bot_x - 10
  349. move $a0, $t1 # arg 1: bot_x - 10
  350. move $a1, $s1 # arg 2: bot_y
  351.  
  352. jal isValid
  353.  
  354. beq $v0, $zero, CHECK_UP
  355. jal costFunction
  356. bgt $v0, $s2, CHECK_UP
  357. sw $a0, NEXT_X
  358. sw $a1, NEXT_Y
  359.  
  360. move $s2, $v0
  361. li $s3, 180
  362. CHECK_UP:
  363. sub $t1, $s1, 10 # bot_y + 10
  364. move $a1, $t1 # arg 1: bot_y + 10
  365. move $a0, $s0 # arg 2: bot_x
  366. jal isValid
  367. beq $v0, $zero, CHECK_BOTTOM
  368. jal costFunction
  369. bgt $v0, $s2, CHECK_BOTTOM
  370. sw $a0, NEXT_X
  371. sw $a1, NEXT_Y
  372.  
  373. move $s2, $v0
  374. li $s3, 270
  375. CHECK_BOTTOM:
  376. add $t1, $s1, 10 # bot_y - 10
  377. move $a1, $t1 # arg 1: bot_y - 10
  378. move $a0, $s0 # arg 2: bot_x
  379. jal isValid
  380. beq $v0, 0, return_angle
  381. jal costFunction
  382. bgt $v0, $s2, return_angle
  383. sw $a0, NEXT_X
  384. sw $a1, NEXT_Y
  385.  
  386. move $s2, $v0
  387. li $s3, 90
  388. return_angle:
  389. move $v0, $s3 # returning the angle
  390.  
  391. lw $ra, 0($sp)
  392. lw $s0, 4($sp)
  393. lw $s1, 8($sp)
  394. lw $s2, 12($sp)
  395. lw $s3, 16($sp)
  396. lw $t1, 20($sp)
  397. lw $a0, 24($sp)
  398. lw $a1, 28($sp)
  399. add $sp, $sp, 32
  400. jr $ra
  401.  
  402. moveDir:
  403. # a0 = int dir #a1, $a2
  404. sub $sp, $sp, 12
  405. sw $ra, 0($sp)
  406. sw $s0, 4($sp)
  407. sw $s1, 8($sp)
  408. li $s1, 10
  409. sw $s1, VELOCITY($zero)
  410. sw $a0, ANGLE
  411. li $s1, 1
  412. sw $s1, ANGLE_CONTROL
  413.  
  414.  
  415. while_loop_move:
  416.  
  417. lw $s0, NEXT_X
  418. lw $s1, BOT_X
  419. bne $s0, $s1, speed
  420.  
  421. lw $s0, NEXT_Y
  422. lw $s1, BOT_Y
  423. bne $s0, $s1, speed
  424. j we_done
  425. speed:
  426. li $a0, 10
  427. sw $a0, VELOCITY
  428. j while_loop_move
  429. we_done:
  430. sw $zero, VELOCITY($zero)
  431. lw $ra, 0($sp)
  432. lw $s0, 4($sp)
  433. lw $s1, 8($sp)
  434. add $sp, $sp, 12
  435. jr $ra
  436.  
  437. isValid:
  438. # a0 = x, a1 = y
  439. sub $sp, $sp, 44
  440. sw $ra, 0($sp)
  441. sw $s0, 4($sp)
  442. sw $s1, 8($sp)
  443. sw $s2, 12($sp)
  444. sw $s3, 16($sp)
  445. sw $s4, 20($sp)
  446. sw $s5, 24($sp)
  447. sw $s6, 28($sp)
  448. sw $s7, 32($sp)
  449. sw $a0, 36($sp)
  450. sw $a1, 40($sp)
  451. li $s7, MAP_SIZE
  452. mul $s7, $s7, 10
  453. move $s0, $a0
  454. move $s1, $a1
  455. bge $s0, $s7, valid_false
  456. ble $s0, $zero, valid_false
  457. bge $s1, $s7, valid_false
  458. ble $s1, $zero, valid_false
  459. div $s7, $s7, 10
  460. div $s2, $s0, 10
  461. div $s3, $s1, 10
  462. mul $s4, $s7, $s3
  463. add $s4, $s4, $s2
  464. mul $s4, $s4, 2
  465. add $s4, $s4, 1
  466. la $s5, MAP
  467. sw $s5, ARENA_MAP
  468. add $s7, $s5, $s4
  469. lb $s5, 0($s7)
  470. li $s6, 2
  471. beq $s6, $s5, valid_false
  472. move $a0, $s0
  473. move $a1, $s1
  474. jal isVisited
  475. beq $zero, $v0, valid_true
  476. j valid_false
  477.  
  478. valid_true:
  479. li $v0, 1
  480. j valid_end
  481. valid_false:
  482. li $v0, 0
  483. j valid_end
  484. valid_end:
  485.  
  486. lw $ra, 0($sp)
  487. lw $s0, 4($sp)
  488. lw $s1, 8($sp)
  489. lw $s2, 12($sp)
  490. lw $s3, 16($sp)
  491. lw $s4, 20($sp)
  492. lw $s5, 24($sp)
  493. lw $s6, 28($sp)
  494. lw $s7, 32($sp)
  495. lw $a0, 36($sp)
  496. lw $a1, 40($sp)
  497. add $sp, $sp, 44
  498.  
  499. jr $ra
  500.  
  501.  
  502.  
  503. .kdata
  504. chunkIH: .space 32
  505. non_intrpt_str: .asciiz "Non-interrupt exception\n"
  506. unhandled_str: .asciiz "Unhandled interrupt type\n"
  507. .ktext 0x80000180
  508. interrupt_handler:
  509. .set noat
  510. move $k1, $at # Save $at
  511. .set at
  512. la $k0, chunkIH
  513. sw $a0, 0($k0) # Get some free registers
  514. sw $v0, 4($k0) # by storing them to a global variable
  515. sw $t0, 8($k0)
  516. sw $t1, 12($k0)
  517. sw $t2, 16($k0)
  518. sw $t3, 20($k0)
  519. sw $t4, 24($k0)
  520. sw $t5, 28($k0)
  521.  
  522. mfc0 $k0, $13 # Get Cause register
  523. srl $a0, $k0, 2
  524. and $a0, $a0, 0xf # ExcCode field
  525. bne $a0, 0, non_intrpt
  526.  
  527.  
  528.  
  529. interrupt_dispatch: # Interrupt:
  530. mfc0 $k0, $13 # Get Cause register, again
  531. beq $k0, 0, done # handled all outstanding interrupts
  532.  
  533. and $a0, $k0, BONK_INT_MASK # is there a bonk interrupt?
  534. bne $a0, 0, bonk_interrupt
  535.  
  536. and $a0, $k0, TIMER_INT_MASK # is there a timer interrupt?
  537. bne $a0, 0, timer_interrupt
  538.  
  539. and $a0, $k0, REQUEST_PUZZLE_INT_MASK
  540. bne $a0, 0, request_puzzle_interrupt
  541.  
  542. li $v0, PRINT_STRING # Unhandled interrupt types
  543. la $a0, unhandled_str
  544. syscall
  545. j done
  546.  
  547. bonk_interrupt:
  548. sw $0, BONK_ACK
  549. li $t8, 10
  550. sw $t8, VELOCITY
  551. j interrupt_dispatch # see if other interrupts are waiting
  552.  
  553. request_puzzle_interrupt:
  554. sw $0, REQUEST_PUZZLE_ACK
  555. li $t0, 1
  556. sw $t0, FLAG_VAR($zero)
  557.  
  558. la $a0, puzzle
  559. la $a1, heap
  560. jal copy_board
  561.  
  562. la $a0, heap
  563. move $a1, $zero
  564. move $a2, $zero
  565. la $a3, puzzle
  566. jal solve
  567. la $t1, puzzle
  568. sw $t1, SUBMIT_SOLUTION($zero)
  569.  
  570. j interrupt_dispatch
  571.  
  572. timer_interrupt:
  573. sw $0, TIMER_ACK
  574. la $t0, puzzle
  575. sw $t0, REQUEST_PUZZLE
  576. #Fill in your code here
  577. j interrupt_dispatch # see if other interrupts are waiting
  578.  
  579. non_intrpt: # was some non-interrupt
  580. li $v0, PRINT_STRING
  581. la $a0, non_intrpt_str
  582. syscall # print out an error message
  583. # fall through to done
  584.  
  585. done:
  586. la $k0, chunkIH
  587. lw $a0, 0($k0) # Restore saved registers
  588. lw $v0, 4($k0)
  589. lw $t0, 8($k0)
  590. lw $t1, 12($k0)
  591. lw $t2, 16($k0)
  592. lw $t3, 20($k0)
  593. lw $t4, 24($k0)
  594. lw $t5, 28($k0)
  595. .set noat
  596. move $at, $k1 # Restore $at
  597. .set at
  598. eret
  599.  
  600. solve:
  601. sub $sp, $sp, 36
  602. sw $ra, 0($sp)
  603. sw $s0, 4($sp)
  604. sw $s1, 8($sp)
  605. sw $s2, 12($sp)
  606. sw $s3, 16($sp)
  607. sw $s4, 20($sp)
  608. sw $s5, 24($sp)
  609. sw $s6, 28($sp)
  610. sw $s7, 32($sp)
  611. li $s7, GRIDSIZE
  612. move $s0, $a1 # row
  613. move $s1, $a2 # col
  614.  
  615. move $s2, $a0 # current_board
  616. move $s3, $a3 # puzzle
  617.  
  618. bge $s0, $s7, solve_done_check # row >= GRIDSIZE
  619. bge $s1, $s7, solve_done_check # col >= GRIDSIZE
  620. j solve_not_done
  621. solve_done_check:
  622. move $a0, $s2 # current_board
  623. move $a1, $s3 # puzzle
  624. jal board_done
  625.  
  626. beq $v0, $0, solve_done_false # if (done)
  627. move $s7, $v0 # save done
  628. move $a0, $s2 # current_board
  629. move $a1, $s3 # puzzle // same as puzzle->board
  630. jal copy_board
  631.  
  632. move $v0, $s7 # $v0: done
  633.  
  634. j solve_done
  635.  
  636. solve_not_done:
  637.  
  638. move $a0, $s2 # current_board
  639. jal increment_heap
  640. move $s2, $v0 # update current_board
  641.  
  642. li $v0, 0 # changed = false
  643. solve_start_do:
  644.  
  645. move $a0, $s2
  646.  
  647.  
  648. jal rule1 # changed = rule1(current_board);
  649. move $s6, $v0 # done
  650.  
  651. move $a0, $s2 # current_board
  652. # jal rule2
  653.  
  654. or $v0, $v0, $s6 # changed |= rule2(current_board);
  655.  
  656. bne $v0, $0, solve_start_do # while (changed)
  657.  
  658. move $a0, $s2 # current_board
  659. move $a1, $s3 # puzzle
  660. jal board_done
  661.  
  662. beq $v0, $0, solve_board_not_done_after_dowhile # if (done)
  663. move $s7, $v0 # save done
  664. move $a0, $s2 # current_board
  665. move $a1, $s3 # puzzle // same as puzzle->board
  666. jal copy_board
  667.  
  668. move $v0, $s7 # $v0: done
  669. j solve_done
  670.  
  671. solve_board_not_done_after_dowhile:
  672.  
  673.  
  674. mul $t0, $s0, $s7 # row*GRIDSIZE
  675. add $t0, $t0, $s1 # row*GRIDSIZE + col
  676. mul $t0, $t0, 2 # sizeof(unsigned short) * (row*GRIDSIZE + col)
  677. add $s4, $t0, $s2 # &current_board[row*GRIDSIZE + col]
  678. lhu $s6, 0($s4) # possibles = current_board[row*GRIDSIZE + col]
  679.  
  680. li $s5, 0 # char number = 0
  681. solve_start_guess:
  682. bge $s5, $s7, solve_start_guess_end # number < GRIDSIZE
  683. li $t0, 1
  684. sll $t1, $t0, $s5 # (1 << number)
  685. and $t0, $t1, $s6 # (1 << number) & possibles
  686. beq $t0, $0, solve_start_guess_else
  687. sh $t1, 0($s4) # current_board[row*GRIDSIZE + col] = 1 << number;
  688.  
  689. move $a0, $s2 # current_board
  690. move $a1, $s0 # next_row = row
  691. sub $t0, $s7, 1 # GRIDSIZE-1
  692. bne $s1, $t0, solve_start_guess_same_row # col < GRIDSIZE // col==GRIDSIZE-1
  693. addi $a1, $a1, 1 # row + 1
  694. solve_start_guess_same_row:
  695. move $a2, $s1 # col
  696. addu $a2, $a2, 1 # col + 1
  697. divu $a2, $s7
  698. mfhi $a2 # (col + 1) % GRIDSIZE
  699. move $a3, $s3 # puzzle
  700. jal solve # solve(current_board, next_row, (col + 1) % GRIDSIZE, puzzle)
  701.  
  702. bne $v0, $0, solve_done_true # if done {return true}
  703. sh $s6, 0($s4) # current_board[row*GRIDSIZE + col] = possibles;
  704. solve_start_guess_else:
  705. addi $s5, $s5, 1
  706. j solve_start_guess
  707.  
  708. solve_done_false:
  709. solve_start_guess_end:
  710. li $v0, 0 # done = false
  711.  
  712. solve_done:
  713. lw $ra, 0($sp)
  714. lw $s0, 4($sp)
  715. lw $s1, 8($sp)
  716. lw $s2, 12($sp)
  717. lw $s3, 16($sp)
  718. lw $s4, 20($sp)
  719. lw $s5, 24($sp)
  720. lw $s6, 28($sp)
  721. lw $s7, 32($sp)
  722. add $sp, $sp, 36
  723. jr $ra
  724.  
  725. solve_done_true:
  726. li $v0, 1
  727. j solve_done
  728.  
  729. # // bool rule1(unsigned short* board) {
  730. # // bool changed = false;
  731. # // for (int y = 0 ; y < GRIDSIZE ; y++) {
  732. # // for (int x = 0 ; x < GRIDSIZE ; x++) {
  733. # // unsigned value = board[y*GRIDSIZE + x];
  734. # // if (has_single_bit_set(value)) {
  735. # // for (int k = 0 ; k < GRIDSIZE ; k++) {
  736. # // // eliminate from row
  737. # // if (k != x) {
  738. # // if (board[y*GRIDSIZE + k] & value) {
  739. # // board[y*GRIDSIZE + k] &= ~value;
  740. # // changed = true;
  741. # // }
  742. # // }
  743. # // // eliminate from column
  744. # // if (k != y) {
  745. # // if (board[k*GRIDSIZE + x] & value) {
  746. # // board[k*GRIDSIZE + x] &= ~value;
  747. # // changed = true;
  748. # // }
  749. # // }
  750. # // }
  751. # // }
  752. # // }
  753. # // }
  754. # // return changed;
  755. # // }
  756. #a0: board
  757. rule1:
  758. sub $sp, $sp, 36
  759. sw $ra, 0($sp)
  760. sw $s0, 4($sp)
  761. sw $s1, 8($sp)
  762. sw $s2, 12($sp)
  763. sw $s3, 16($sp)
  764. sw $s4, 20($sp)
  765. sw $s5, 24($sp)
  766. sw $s6, 28($sp)
  767. sw $s7, 32($sp)
  768. li $s0, GRIDSIZE # $s0: GRIDSIZE = 4
  769. move $s1, $a0 # $s1: board
  770. li $s2, 0 # $s2: changed = false
  771. li $s3, 0 # $s3: y = 0
  772. r1_for_y_start:
  773. bge $s3, $s0, r1_for_y_end # for: y < GRIDSIZE
  774. li $s4, 0 # $s4: x = 0
  775. r1_for_x_start:
  776. bge $s4, $s0, r1_for_x_end # for: x < GRIDSIZE
  777. mul $a0, $s3, $s0 # $a0: y*GRIDSIZE
  778. add $a0, $a0, $s4 # $a0: y*GRIDSIZE + x
  779. sll $a0, $a0, 1 # $a0: 2*(y*GRIDSIZE + x)
  780. add $a0, $a0, $s1 # $a0: &board[y*GRIDSIZE+x]
  781. lhu $a0, 0($a0) # $a0: value = board[y*GRIDSIZE+x]
  782. move $s6, $a0 # $s6: value
  783. jal has_single_bit_set
  784. beq $v0, 0, r1_for_x_inc # if(has_single_bit_set(value))
  785. li $s5, 0 # $s5: k = 0
  786. r1_for_k_start:
  787. bge $s5, $s0, r1_for_k_end # for: k < GRIDSIZE
  788. beq $s5, $s4, r1_if_kx_end # if (k != x)
  789. mul $t0, $s3, $s0 # $t0: y*GRIDSIZE
  790. add $t0, $t0, $s5 # $t0: y*GRIDSIZE + k
  791. sll $t0, $t0, 1 # $t0: 2*(y*GRIDSIZE + k)
  792. add $t0, $t0, $s1 # $t0: &board[y*GRIDSIZE+k]
  793. lhu $t1, 0($t0) # $t1: board[y*GRIDSIZE + k]
  794. and $t2, $t1, $s6 # $t2: board[y*GRIDSIZE + k] & value
  795. beq $t2, 0, r1_if_kx_end # if (board[y*GRIDSIZE + k] & value)
  796. not $t3, $s6 # $t3: ~value
  797. and $t1, $t1, $t3 # $t1: board[y*GRIDSIZE + k] & ~value
  798. sh $t1, 0($t0) # board[y*GRIDSIZE + k] &= ~value
  799. li $s2, 1 # changed = true
  800. r1_if_kx_end:
  801. beq $s5, $s3, r1_if_ky_end # if (k != y)
  802. mul $t0, $s5, $s0 # $t0: k*GRIDSIZE
  803. add $t0, $t0, $s4 # $t0: k*GRIDSIZE + x
  804. sll $t0, $t0, 1 # $t0: 2*(k*GRIDSIZE + x)
  805. add $t0, $t0, $s1 # $t0: &board[k*GRIDSIZE+x]
  806. lhu $t1, 0($t0) # $t1: board[k*GRIDSIZE + x]
  807. and $t2, $t1, $s6 # $t2: board[k*GRIDSIZE + x] & value
  808. beq $t2, 0, r1_if_ky_end # if (board[k*GRIDSIZE + x] & value)
  809. not $t3, $s6 # $t3: ~value
  810. and $t1, $t1, $t3 # $t1: board[k*GRIDSIZE + x] & ~value
  811. sh $t1, 0($t0) # board[k*GRIDSIZE + x] &= ~value
  812. li $s2, 1 # changed = true
  813. r1_if_ky_end:
  814. add $s5, $s5, 1 # for: k++
  815. j r1_for_k_start
  816. r1_for_k_end:
  817. r1_for_x_inc:
  818. add $s4, $s4, 1 # for: x++
  819. j r1_for_x_start
  820. r1_for_x_end:
  821. r1_for_y_inc:
  822. add $s3, $s3, 1 # for: y++
  823. j r1_for_y_start
  824. r1_for_y_end:
  825. move $v0, $s2 # return changed
  826. r1_return:
  827. lw $ra, 0($sp)
  828. lw $s0, 4($sp)
  829. lw $s1, 8($sp)
  830. lw $s2, 12($sp)
  831. lw $s3, 16($sp)
  832. lw $s4, 20($sp)
  833. lw $s5, 24($sp)
  834. lw $s6, 28($sp)
  835. lw $s7, 32($sp)
  836. add $sp, $sp, 36
  837. jr $ra
  838.  
  839. # rule2 #####################################################
  840. #
  841. # argument $a0: pointer to current board
  842. rule2:
  843. sub $sp, $sp, 4 #Store ra onto stack and initialize GRIDSIZE
  844. sw $ra, 0($sp)
  845. li $t0, GRIDSIZE # GRIDSIZE
  846. li $t1, 1
  847. sll $t1, $t1, $t0
  848. subu $t1, $t1, 1 #int ALL_VALUES = (1 << GRIDSIZE) - 1;
  849. li $v0, 0 #bool changed = false
  850. li $t2, 0 #i = 0
  851. rule2iloopstart:
  852. bge $t2, $t0, rule2iloopend
  853. li $t3, 0 #j = 0
  854. rule2jloopstart:
  855. bge $t3, $t0, rule2jloopend
  856.  
  857. mul $t4, $t2, $t0
  858. add $t4, $t4, $t3
  859. mul $t4, $t4, 2 #sizeof(unsigned short)*(i*GRIDSIZE + j)
  860. add $t4, $a0, $t4 #address of board[i*GRIDSIZE+j]
  861. lhu $t4, 0($t4) #board[i*GRIDSIZE + j]
  862.  
  863. sub $sp, $sp, 24 # Allocate stack
  864. sw $a0, 0($sp)
  865. sw $t0, 4($sp)
  866. sw $t1, 8($sp)
  867. sw $t2, 12($sp)
  868. sw $t3, 16($sp)
  869. sw $v0, 20($sp) #Store all necessary variables on stack
  870. move $a0, $t4
  871. jal has_single_bit_set
  872. lw $a0, 0($sp)
  873. lw $t0, 4($sp)
  874. lw $t1, 8($sp)
  875. lw $t2, 12($sp)
  876. lw $t3, 16($sp)
  877. move $t4, $v0 # Save $v0 into $t4
  878. lw $v0, 20($sp) # Restore variables
  879. add $sp, $sp, 24 # Deallocate stack
  880.  
  881. bne $t4, $0, rule2continuestatement #if (has_single_bit_set(value)) continue;
  882.  
  883. li $t5, 0 #isum = 0
  884. li $t6, 0 #jsum = 0
  885. li $t4, 0 #k = 0, t2 = i, t3 = j, t4 = k
  886. rule2kloopstart:
  887. bge $t4, $t0, rule2kloopend
  888. beq $t4, $t3, rule2kequalsj
  889. mul $t7, $t2, $t0 #i*GRIDSIZE
  890. add $t7, $t7, $t4 #i*GRIDSIZE+k
  891. mul $t7, $t7, 2
  892. add $t7, $a0, $t7 #&board[i*GRIDSIZE + k]
  893. lhu $t7, 0($t7)
  894. or $t6, $t6, $t7 #jsum |= board[i*GRIDSIZE + k];
  895. rule2kequalsj:
  896. beq $t4, $t2, rule2kequalsi
  897. mul $t7, $t4, $t0 #k*GRIDSIZE
  898. add $t7, $t7, $t3 #k*GRIDSIZE+j
  899. mul $t7, $t7, 2
  900. add $t7, $a0, $t7 #&board[k*GRIDSIZE + j]
  901. lhu $t7, 0($t7)
  902. or $t5, $t5, $t7 #isum |= board[k*GRIDSIZE + j];
  903. rule2kequalsi:
  904. add $t4, $t4, 1
  905. j rule2kloopstart
  906. rule2kloopend:
  907. beq $t1, $t6, rule2allvalequalsjsum
  908. not $t6, $t6 # ~jsum
  909. and $t6, $t1, $t6 #ALL_VALUES & ~jsum
  910. mul $t7, $t0, $t2 # i*GRIDSIZE
  911. add $t7, $t7, $t3 #[i*GRIDSIZE+j]
  912. mul $t7, $t7, 2 #(i*GRIDSIZE+j)*sizeof(unsigned short)
  913. add $t7, $a0, $t7
  914. sh $t6, 0($t7) #board[i*GRIDSIZE + j] = ALL_VALUES & ~jsum;
  915. li $v0, 1
  916. j rule2continuestatement
  917. rule2allvalequalsjsum:
  918. beq $t1, $t5, rule2continuestatement
  919. not $t5, $t5 # ~isum
  920. and $t5, $t1, $t5 #ALL_VALUES & ~isum;
  921. mul $t7, $t0, $t2 # i*GRIDSIZE
  922. add $t7, $t7, $t3 #[i*GRIDSIZE+j]
  923. mul $t7, $t7, 2 #(i*GRIDSIZE+j)*sizeof(unsigned short)
  924. add $t7, $a0, $t7
  925. sh $t5, 0($t7) #board[i*GRIDSIZE + j] = ALL_VALUES & ~isum;
  926. li $v0, 1
  927. rule2continuestatement:
  928. add $t3, $t3, 1
  929. j rule2jloopstart #continue; iterates to next index of jloop
  930. rule2jloopend:
  931. add $t2, $t2, 1
  932. j rule2iloopstart
  933. rule2iloopend:
  934.  
  935. lw $ra, 0($sp)
  936. add $sp, $sp, 4
  937. jr $ra
  938.  
  939.  
  940. # board done ##################################################
  941. #
  942. # argument $a0: pointer to current board to check
  943. # argument $a1: pointer to puzzle struct
  944. board_done:
  945. sub $sp, $sp, 36
  946. sw $ra, 0($sp)
  947. sw $s0, 4($sp)
  948. sw $s1, 8($sp)
  949. sw $s2, 12($sp)
  950. sw $s3, 16($sp)
  951. sw $s4, 20($sp)
  952. sw $s5, 24($sp)
  953. sw $s6, 28($sp)
  954. sw $s7, 32($sp)
  955.  
  956. move $s0, $a0 # s0 = current_board
  957. move $s1, $a1 # s1 = puzzle
  958. li $s2, GRIDSIZE # s2 = GRIDSIZE
  959. li $t0, 1
  960. sll $t0, $t0, $s2 # 1 << GRIDSIZE
  961. sub $s3, $t0, 1 # s3 = ALL_VALUES = (1 << GRIDSIZE) - 1
  962.  
  963. li $s4, 0 # s4 = i = 0
  964. bd_i1_loop_start:
  965. bge $s4, $s2, bd_i1_loop_end # !(i < GRIDSIZE)
  966. bd_i1_loop_body:
  967. li $s5, 0 # s5 = acc = 0
  968. li $s6, 0 # s6 = j = 0
  969. bd_j1_loop_start:
  970. bge $s6, $s2, bd_j1_loop_end # !(j < GRIDSIZE)
  971. bd_j1_loop_body:
  972. mul $t0, $s4, $s2 # i*GRIDSIZE
  973. add $t0, $t0, $s6 # i*GRIDSIZE + j
  974. mul $t0, $t0, 2 # sizeof(unsigned short)*(i*GRIDSIZE + j)
  975. add $t0, $s0, $t0 # &current_board[i*GRIDSIZE + j]
  976. lhu $s7, 0($t0) # s7 = value = current_board[i*GRIDSIZE + j]
  977.  
  978. move $a0, $s7
  979. jal has_single_bit_set
  980. beq $v0, $0, bd_j1_loop_increment # if (!hsbs(value)) continue
  981. xor $s5, $s5, $s7
  982.  
  983. bd_j1_loop_increment:
  984. add $s6, $s6, 1 # ++ j
  985. j bd_j1_loop_start
  986. bd_j1_loop_end:
  987. bne $s5, $s3, bd_return_false # if (acc != ALL_VALUES) return false
  988.  
  989. li $s5, 0 # s5 = acc = 0
  990. li $s6, 0 # s6 = j = 0
  991. bd_j2_loop_start:
  992. bge $s6, $s2, bd_j2_loop_end # !(j < GRIDSIZE)
  993. bd_j2_loop_body:
  994. mul $t0, $s6, $s2 # j*GRIDSIZE
  995. add $t0, $t0, $s4 # j*GRIDSIZE + i
  996. mul $t0, $t0, 2
  997. add $t0, $s0, $t0 # &current_board[j*GRIDSIZE + i]
  998. lhu $s7, 0($t0) # s7 = value = current_board[j*GRIDSIZE + i]
  999.  
  1000. move $a0, $s7
  1001. jal has_single_bit_set
  1002. beq $v0, $0, bd_j2_loop_increment # if (!hsbs(value)) continue
  1003. xor $s5, $s5, $s7
  1004.  
  1005. bd_j2_loop_increment:
  1006. add $s6, $s6, 1 # ++ j
  1007. j bd_j2_loop_start
  1008. bd_j2_loop_end:
  1009. bne $s5, $s3, bd_return_false # if (acc != ALL_VALUES) return false
  1010.  
  1011. bd_i1_loop_increment:
  1012. add $s4, $s4, 1 # ++ i
  1013. j bd_i1_loop_start
  1014. bd_i1_loop_end:
  1015. li $s4, 0 # s4 = i = 0
  1016. bd_i2_loop_start:
  1017. bge $s4, $s2, bd_i2_loop_end # !(i < GRIDSIZE)
  1018. bd_i2_loop_body:
  1019. li $t0, 2 # sizeof(short)
  1020. mul $t0, $t0, $s2
  1021. mul $t0, $t0, $s2 # sizeof(unsigned short board[GRIDSIZE*GRIDSIZE])
  1022. add $s3, $s1, $t0 # s3 = &(puzzle->constraints)
  1023.  
  1024. add $t0, $s4, 1 # i+1
  1025. add $t1, $s2, 2 # GRIDSIZE+2
  1026. mul $t0, $t0, $t1 # (i+1)*(GRIDSIZE+2)
  1027. mul $t0, $t0, 2
  1028. add $t0, $t0, $s3 # &puzzle->constraints[(i+1)*(GRIDSIZE+2) + 0]
  1029. lhu $t9, 0($t0) # t9 = left_constraint = puzzle->constraints[(i+1)*(GRIDSIZE+2) + 0]
  1030. li $s5, 0 # s5 = count = 0
  1031. li $s6, 0 # s6 = last = 0
  1032.  
  1033. li $s7, 0 # s7 = j = 0
  1034. bd_j3_loop_start:
  1035. bge $s7, $s2, bd_j3_loop_end # !(j < GRIDSIZE)
  1036. bd_j3_loop_body:
  1037. mul $t0, $s4, $s2 # i*GRIDSIZE
  1038. add $t0, $t0, $s7 # i*GRIDSIZE + j
  1039. mul $t0, $t0, 2
  1040. add $t0, $s0, $t0 # &current_board[i*GRIDSIZE + j]
  1041. lhu $t0, 0($t0) # t0 = current = current_board[i*GRIDSIZE + j]
  1042. ble $t0, $s6, bd_j3_loop_increment # !(current > last)
  1043. add $s5, $s5, 1 # count += 1
  1044. move $s6, $t0 # last = current
  1045. bd_j3_loop_increment:
  1046. add $s7, $s7, 1 # ++ j
  1047. j bd_j3_loop_start
  1048. bd_j3_loop_end:
  1049. bne $s5, $t9, bd_return_false # if (count != left_constraint) return false
  1050.  
  1051. add $t0, $s4, 1 # i+1
  1052. add $t1, $s2, 2 # GRIDSIZE+2
  1053. mul $t0, $t0, $t1 # (i+1)*(GRIDSIZE+2)
  1054. add $t0, $t0, $s2 # (i+1)*(GRIDSIZE+2) + GRIDSIZE
  1055. add $t0, $t0, 1 # (i+1)*(GRIDSIZE+2) + GRIDSIZE + 1
  1056. mul $t0, $t0, 2
  1057. add $t0, $t0, $s3 # &puzzle->constraints[(i+1)*(GRIDSIZE+2) + GRIDSIZE + 1]
  1058. lhu $t9, 0($t0) # t9 = right_constraint = puzzle->constraints[(i+1)*(GRIDSIZE+2) + GRIDSIZE + 1]
  1059. li $s5, 0 # s5 = count = 0
  1060. li $s6, 0 # s6 = last = 0
  1061.  
  1062. sub $s7, $s2, 1 # s7 = j = GRIDSIZE - 1
  1063. bd_j4_loop_start:
  1064. blt $s7, $0, bd_j4_loop_end # !(j >= 0)
  1065. bd_j4_loop_body:
  1066. mul $t0, $s4, $s2 # i*GRIDSIZE
  1067. add $t0, $t0, $s7 # i*GRIDSIZE + j
  1068. mul $t0, $t0, 2
  1069. add $t0, $s0, $t0 # &current_board[i*GRIDSIZE + j]
  1070. lhu $t0, 0($t0) # t0 = current = current_board[i*GRIDSIZE + j]
  1071. ble $t0, $s6, bd_j4_loop_increment # !(current > last)
  1072. add $s5, $s5, 1 # count += 1
  1073. move $s6, $t0 # last = current
  1074. bd_j4_loop_increment:
  1075. sub $s7, $s7, 1 # -- j
  1076. j bd_j4_loop_start
  1077. bd_j4_loop_end:
  1078. bne $s5, $t9, bd_return_false # if (count != right_constraint) return false
  1079. add $t0, $s4, 1 # i+1
  1080. mul $t0, $t0, 2
  1081. add $t0, $t0, $s3 # &puzzle->constraints[i + 1]
  1082. lhu $t9, 0($t0) # t9 = top_constraint = puzzle->constraints[i + 1]
  1083. li $s5, 0 # s5 = count = 0
  1084. li $s6, 0 # s6 = last = 0
  1085.  
  1086. li $s7, 0 # s7 = j = 0
  1087. bd_j5_loop_start:
  1088. bge $s7, $s2, bd_j5_loop_end # !(j < GRIDSIZE)
  1089. bd_j5_loop_body:
  1090. mul $t0, $s7, $s2 # j*GRIDSIZE
  1091. add $t0, $t0, $s4 # j*GRIDSIZE + i
  1092. mul $t0, $t0, 2
  1093. add $t0, $s0, $t0 # &current_board[j*GRIDSIZE + i]
  1094. lhu $t0, 0($t0) # t0 = current = current_board[j*GRIDSIZE + i]
  1095. ble $t0, $s6, bd_j5_loop_increment # !(current > last)
  1096. add $s5, $s5, 1 # count += 1
  1097. move $s6, $t0 # last = current
  1098. bd_j5_loop_increment:
  1099. add $s7, $s7, 1 # ++ j
  1100. j bd_j5_loop_start
  1101. bd_j5_loop_end:
  1102. bne $s5, $t9, bd_return_false # if (count != top_constraint) return false
  1103.  
  1104. add $t0, $s2, 1 # GRIDSIZE+1
  1105. add $t1, $s2, 2 # GRIDSIZE+2
  1106. mul $t0, $t0, $t1 # (GRIDSIZE+1)*(GRIDSIZE+2)
  1107. add $t0, $t0, $s4 # (GRIDSIZE+1)*(GRIDSIZE+2) + i
  1108. add $t0, $t0, 1 # (GRIDSIZE+1)*(GRIDSIZE+2) + i + 1
  1109. mul $t0, $t0, 2
  1110. add $t0, $t0, $s3 # &puzzle->constraints[(GRIDSIZE+1)*(GRIDSIZE+2) + i + 1]
  1111. lhu $t9, 0($t0) # t9 = bottom_constraint = puzzle->constraints[(GRIDSIZE+1)*(GRIDSIZE+2) + i + 1]
  1112. li $s5, 0 # s5 = count = 0
  1113. li $s6, 0 # s6 = last = 0
  1114.  
  1115. sub $s7, $s2, 1 # s7 = j = GRIDSIZE - 1
  1116. bd_j6_loop_start:
  1117. blt $s7, $0, bd_j6_loop_end # !(j >= 0)
  1118. bd_j6_loop_body:
  1119. mul $t0, $s7, $s2 # j*GRIDSIZE
  1120. add $t0, $t0, $s4 # j*GRIDSIZE + i
  1121. mul $t0, $t0, 2
  1122. add $t0, $s0, $t0 # &current_board[j*GRIDSIZE + i]
  1123. lhu $t0, 0($t0) # t0 = current = current_board[j*GRIDSIZE + i]
  1124. ble $t0, $s6, bd_j6_loop_increment # !(current > last)
  1125. add $s5, $s5, 1 # count += 1
  1126. move $s6, $t0 # last = current
  1127. bd_j6_loop_increment:
  1128. sub $s7, $s7, 1 # -- j
  1129. j bd_j6_loop_start
  1130. bd_j6_loop_end:
  1131. bne $s5, $t9, bd_return_false # if (count != bottom_constraint) return false
  1132. bd_i2_loop_increment:
  1133. add $s4, $s4, 1
  1134. j bd_i2_loop_start
  1135. bd_i2_loop_end:
  1136. li $v0, 1 # return true
  1137. j bd_return
  1138. bd_return_false:
  1139. li $v0, 0 # return false
  1140. bd_return:
  1141. lw $ra, 0($sp)
  1142. lw $s0, 4($sp)
  1143. lw $s1, 8($sp)
  1144. lw $s2, 12($sp)
  1145. lw $s3, 16($sp)
  1146. lw $s4, 20($sp)
  1147. lw $s5, 24($sp)
  1148. lw $s6, 28($sp)
  1149. lw $s7, 32($sp)
  1150. add $sp, $sp, 36
  1151. jr $ra
  1152.  
  1153. # has single bit set ###########################################
  1154. #
  1155. # argument $a0: bit mask
  1156. has_single_bit_set:
  1157. beq $a0, $0, has_single_bit_set_iszero
  1158. sub $v0, $a0, 1 # $v0: b-1
  1159. and $v0, $a0, $v0 # $v0: b & (b-1)
  1160. not $v0, $v0 # $v0: !(b & (b-1))
  1161. # if $v0 is zero, return zero
  1162. bne $v0, -1, has_single_bit_set_iszero
  1163. li $v0, 1
  1164. j has_single_bit_set_done
  1165. has_single_bit_set_iszero:
  1166. li $v0, 0
  1167. has_single_bit_set_done:
  1168. jr $ra
  1169.  
  1170.  
  1171.  
  1172. # increment heap ###############################################
  1173. #
  1174. # argument $a0: pointer to current board to check
  1175. increment_heap:
  1176. sub $sp, $sp, 4
  1177. sw $ra, 0($sp) # save $ra on stack
  1178.  
  1179. li $t0, GRIDSIZE
  1180. mul $t0, $t0, $t0 # GRIDSIZE * GRIDSIZE
  1181. mul $a1, $t0, 2
  1182. add $a1, $a0, $a1 # new_board = old_board + GRIDSIZE*GRIDSIZE
  1183.  
  1184. jal copy_board
  1185.  
  1186. move $v0, $v0 # // output the output of copy_board
  1187. lw $ra, 0($sp)
  1188. add $sp, $sp, 4
  1189. jr $ra
  1190.  
  1191.  
  1192. # copy board ###################################################
  1193. #
  1194. # argument $a0: pointer to old board
  1195. # argument $a1: pointer to new board
  1196. copy_board:
  1197. li $t0, GRIDSIZE
  1198. mul $t0, $t0, $t0 # GRIDSIZE * GRIDSIZE
  1199. li $t1, 0 # i = 0
  1200. ih_loop:
  1201. bge $t1, $t0, ih_done # i < GRIDSIZE*GRIDSIZE
  1202.  
  1203. mul $t2, $t1, 2 # i * sizeof(unsigned short)
  1204. add $t3, $a0, $t2 # &old_board[i]
  1205. lw $t3, 0($t3) # old_board[i]
  1206.  
  1207. add $t4, $a1, $t2 # &new_board[i]
  1208. sw $t3, 0($t4) # new_board[i] = old_board[i]
  1209.  
  1210. addi $t1, $t1, 2 # i++
  1211. j ih_loop
  1212. ih_done:
  1213. move $v0, $a1
  1214. jr $ra
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!