Advertisement
Guest User

Untitled

a guest
May 29th, 2016
69
0
Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
text 48.13 KB | None | 0 0
  1. jmp("begin")
  2. label("func_g_ptr_addr()") //1
  3. push(ebp)
  4. mov(ebp,esp)
  5. mov(eax,1024)
  6. push(eax)
  7. mov(eax,64)
  8. add(eax,7)
  9. mov(ebx,eax)
  10. pop(eax)
  11. mul(eax,ebx)
  12. mov(edx,ptr[ebp+2])
  13. mov(ptr[edx+0],eax)
  14. jmp("func_g_ptr_addr()::ret")
  15. label("func_g_ptr_addr()::ret") //14
  16. mov(esp,ebp)
  17. pop(ebp)
  18. ret()
  19. label("func_alloc(int)") //18
  20. push(ebp)
  21. mov(ebp,esp)
  22. dec(esp)
  23. dec(esp)
  24. pushlea(ptr[ebp-2])
  25. call("func_g_ptr_addr()")
  26. add(esp,1)
  27. mov(eax,ptr[ebp-2])
  28. mov(ptr[ebp-1],eax)
  29. inc(esp)
  30. dec(esp)
  31. dec(esp)
  32. pushlea(ptr[ebp-3])
  33. push(ptr[ebp-1])
  34. call("func_get_int(int)")
  35. add(esp,2)
  36. mov(eax,ptr[ebp-3])
  37. mov(ptr[ebp-2],eax)
  38. inc(esp)
  39. not(eax,ptr[ebp-2])
  40. jz("if_1000::end",eax)
  41. dec(esp)
  42. mov(eax,1024)
  43. mul(eax,128)
  44. mov(ptr[ebp-3],eax)
  45. mov(ebx,ptr[ebp-3])
  46. mov(ptr[ebp-2],ebx)
  47. inc(esp)
  48. jmp("if_1000::end")
  49. label("if_1000::end") //48
  50. dec(esp)
  51. dec(esp)
  52. mov(eax,ptr[ebp-2])
  53. add(eax,ptr[ebp+2])
  54. mov(ptr[ebp-3],eax)
  55. pushlea(ptr[ebp-4])
  56. push(ptr[ebp-1])
  57. push(ptr[ebp-3])
  58. call("func_set_int(int,int)")
  59. add(esp,3)
  60. inc(esp)
  61. inc(esp)
  62. mov(edx,ptr[ebp+3])
  63. push(ptr[ebp-2])
  64. pop(ptr[edx+0])
  65. jmp("func_alloc(int)::ret")
  66. inc(esp)
  67. inc(esp)
  68. label("func_alloc(int)::ret") //67
  69. mov(esp,ebp)
  70. pop(ebp)
  71. ret()
  72. label("func_vec2i::mag()") //71
  73. push(ebp)
  74. mov(ebp,esp)
  75. dec(esp)
  76. mov(ptr[ebp-1],ecx)
  77. dec(esp)
  78. pushlea(ptr[ebp-2])
  79. push(ptr[ecx+0])
  80. push(ptr[ecx+1])
  81. call("func_hypot(int,int)")
  82. mov(ecx,ptr[ebp-1])
  83. add(esp,3)
  84. mov(edx,ptr[ebp+2])
  85. push(ptr[ebp-2])
  86. pop(ptr[edx+0])
  87. jmp("func_vec2i::mag()::ret")
  88. inc(esp)
  89. inc(esp)
  90. label("func_vec2i::mag()::ret") //89
  91. mov(esp,ebp)
  92. pop(ebp)
  93. ret()
  94. label("func_vec2i::`ctor()") //93
  95. push(ebp)
  96. mov(ebp,esp)
  97. dec(esp)
  98. mov(ptr[ebp-1],ecx)
  99. mov(ptr[ecx+0],0)
  100. mov(ptr[ecx+1],0)
  101. inc(esp)
  102. label("func_vec2i::`ctor()::ret") //101
  103. mov(esp,ebp)
  104. pop(ebp)
  105. ret()
  106. label("func_vec2i(int,int)") //105
  107. push(ebp)
  108. mov(ebp,esp)
  109. sub(esp,2)
  110. lea(ecx,ptr[ebp-2])
  111. call("func_vec2i::`ctor()")
  112. mov(ebx,ptr[ebp+3])
  113. mov(ptr[ebp-2],ebx)
  114. mov(ebx,ptr[ebp+2])
  115. mov(ptr[ebp-1],ebx)
  116. mov(edx,ptr[ebp+4])
  117. push(ptr[ebp-1])
  118. push(ptr[ebp-2])
  119. pop(ptr[edx+0])
  120. pop(ptr[edx+1])
  121. jmp("func_vec2i(int,int)::ret")
  122. add(esp,2)
  123. label("func_vec2i(int,int)::ret") //122
  124. mov(esp,ebp)
  125. pop(ebp)
  126. ret()
  127. label("func_add(int,int)") //126
  128. push(ebp)
  129. mov(ebp,esp)
  130. dec(esp)
  131. pushlea(ptr[ebp-1])
  132. push(ptr[ebp+3])
  133. push(ptr[ebp+2])
  134. call("func_set_int(int,int)")
  135. add(esp,3)
  136. mov(edx,ptr[ebp+4])
  137. push(ptr[ebp-1])
  138. pop(ptr[edx+0])
  139. jmp("func_add(int,int)::ret")
  140. inc(esp)
  141. label("func_add(int,int)::ret") //140
  142. mov(esp,ebp)
  143. pop(ebp)
  144. ret()
  145. label("func_hypot(vec2i)") //144
  146. push(ebp)
  147. mov(ebp,esp)
  148. dec(esp)
  149. pushlea(ptr[ebp-1])
  150. push(ptr[ebp+2])
  151. push(ptr[ebp+3])
  152. call("func_hypot(int,int)")
  153. add(esp,3)
  154. mov(edx,ptr[ebp+4])
  155. push(ptr[ebp-1])
  156. pop(ptr[edx+0])
  157. jmp("func_hypot(vec2i)::ret")
  158. inc(esp)
  159. label("func_hypot(vec2i)::ret") //158
  160. mov(esp,ebp)
  161. pop(ebp)
  162. ret()
  163. label("func_sub(vec2i,vec2i)") //162
  164. push(ebp)
  165. mov(ebp,esp)
  166. dec(esp)
  167. dec(esp)
  168. sub(esp,2)
  169. mov(eax,ptr[ebp+4])
  170. sub(eax,ptr[ebp+2])
  171. mov(ptr[ebp-1],eax)
  172. mov(eax,ptr[ebp+5])
  173. sub(eax,ptr[ebp+3])
  174. mov(ptr[ebp-2],eax)
  175. pushlea(ptr[ebp-4])
  176. push(ptr[ebp-1])
  177. push(ptr[ebp-2])
  178. call("func_vec2i(int,int)")
  179. add(esp,3)
  180. mov(edx,ptr[ebp+6])
  181. push(ptr[ebp-3])
  182. push(ptr[ebp-4])
  183. pop(ptr[edx+0])
  184. pop(ptr[edx+1])
  185. jmp("func_sub(vec2i,vec2i)::ret")
  186. add(esp,2)
  187. inc(esp)
  188. inc(esp)
  189. label("func_sub(vec2i,vec2i)::ret") //188
  190. mov(esp,ebp)
  191. pop(ebp)
  192. ret()
  193. label("func_add(vec2i,vec2i)") //192
  194. push(ebp)
  195. mov(ebp,esp)
  196. dec(esp)
  197. dec(esp)
  198. sub(esp,2)
  199. mov(eax,ptr[ebp+4])
  200. add(eax,ptr[ebp+2])
  201. mov(ptr[ebp-1],eax)
  202. mov(eax,ptr[ebp+5])
  203. add(eax,ptr[ebp+3])
  204. mov(ptr[ebp-2],eax)
  205. pushlea(ptr[ebp-4])
  206. push(ptr[ebp-1])
  207. push(ptr[ebp-2])
  208. call("func_vec2i(int,int)")
  209. add(esp,3)
  210. mov(edx,ptr[ebp+6])
  211. push(ptr[ebp-3])
  212. push(ptr[ebp-4])
  213. pop(ptr[edx+0])
  214. pop(ptr[edx+1])
  215. jmp("func_add(vec2i,vec2i)::ret")
  216. add(esp,2)
  217. inc(esp)
  218. inc(esp)
  219. label("func_add(vec2i,vec2i)::ret") //218
  220. mov(esp,ebp)
  221. pop(ebp)
  222. ret()
  223. label("func_mul(vec2i,int)") //222
  224. push(ebp)
  225. mov(ebp,esp)
  226. dec(esp)
  227. dec(esp)
  228. sub(esp,2)
  229. mov(eax,ptr[ebp+3])
  230. mul(eax,ptr[ebp+2])
  231. mov(ptr[ebp-1],eax)
  232. mov(eax,ptr[ebp+4])
  233. mul(eax,ptr[ebp+2])
  234. mov(ptr[ebp-2],eax)
  235. pushlea(ptr[ebp-4])
  236. push(ptr[ebp-1])
  237. push(ptr[ebp-2])
  238. call("func_vec2i(int,int)")
  239. add(esp,3)
  240. mov(edx,ptr[ebp+5])
  241. push(ptr[ebp-3])
  242. push(ptr[ebp-4])
  243. pop(ptr[edx+0])
  244. pop(ptr[edx+1])
  245. jmp("func_mul(vec2i,int)::ret")
  246. add(esp,2)
  247. inc(esp)
  248. inc(esp)
  249. label("func_mul(vec2i,int)::ret") //248
  250. mov(esp,ebp)
  251. pop(ebp)
  252. ret()
  253. label("func_div(vec2i,int)") //252
  254. push(ebp)
  255. mov(ebp,esp)
  256. dec(esp)
  257. dec(esp)
  258. sub(esp,2)
  259. mov(eax,ptr[ebp+3])
  260. div(eax,ptr[ebp+2])
  261. mov(ptr[ebp-1],eax)
  262. mov(eax,ptr[ebp+4])
  263. div(eax,ptr[ebp+2])
  264. mov(ptr[ebp-2],eax)
  265. pushlea(ptr[ebp-4])
  266. push(ptr[ebp-1])
  267. push(ptr[ebp-2])
  268. call("func_vec2i(int,int)")
  269. add(esp,3)
  270. mov(edx,ptr[ebp+5])
  271. push(ptr[ebp-3])
  272. push(ptr[ebp-4])
  273. pop(ptr[edx+0])
  274. pop(ptr[edx+1])
  275. jmp("func_div(vec2i,int)::ret")
  276. add(esp,2)
  277. inc(esp)
  278. inc(esp)
  279. label("func_div(vec2i,int)::ret") //278
  280. mov(esp,ebp)
  281. pop(ebp)
  282. ret()
  283. label("func_get_int(int)") //282
  284. push(ebp)
  285. mov(ebp,esp)
  286. dec(esp)
  287. mov(ptr[ebp-1],0)
  288. mov(eax,ptr[ebp+2])
  289. mov(ptr[ebp-1],ptr[eax])
  290. mov(edx,ptr[ebp+3])
  291. push(ptr[ebp-1])
  292. pop(ptr[edx+0])
  293. jmp("func_get_int(int)::ret")
  294. inc(esp)
  295. label("func_get_int(int)::ret") //294
  296. mov(esp,ebp)
  297. pop(ebp)
  298. ret()
  299. label("func_set_int(int,int)") //298
  300. push(ebp)
  301. mov(ebp,esp)
  302. push(ebx)
  303. mov(eax,ptr[ebp+3])
  304. mov(ebx,ptr[ebp+2])
  305. mov(ptr[eax],ebx)
  306. pop(ebx)
  307. mov(eax,ptr[ebp+3])
  308. add(eax,1)
  309. mov(edx,ptr[ebp+4])
  310. mov(ptr[edx+0],eax)
  311. jmp("func_set_int(int,int)::ret")
  312. label("func_set_int(int,int)::ret") //311
  313. mov(esp,ebp)
  314. pop(ebp)
  315. ret()
  316. label("func_setebx(int)") //315
  317. push(ebp)
  318. mov(ebp,esp)
  319. mov(ebx,ptr[ebp+2])
  320. mov(edx,ptr[ebp+3])
  321. mov(ptr[edx+0],0)
  322. jmp("func_setebx(int)::ret")
  323. label("func_setebx(int)::ret") //322
  324. mov(esp,ebp)
  325. pop(ebp)
  326. ret()
  327. label("func_hypot(int,int)") //326
  328. push(ebp)
  329. mov(ebp,esp)
  330. dec(esp)
  331. mov(ptr[ebp-1],0)
  332. mov(eax,ptr[ebp+3])
  333. mov(ebx,ptr[ebp+2])
  334. hypot(eax,ebx)
  335. mov(ptr[ebp-1],eax)
  336. mov(edx,ptr[ebp+4])
  337. push(ptr[ebp-1])
  338. pop(ptr[edx+0])
  339. jmp("func_hypot(int,int)::ret")
  340. inc(esp)
  341. label("func_hypot(int,int)::ret") //340
  342. mov(esp,ebp)
  343. pop(ebp)
  344. ret()
  345. label("func_QapAssert(int)") //344
  346. push(ebp)
  347. mov(ebp,esp)
  348. not(eax,ptr[ebp+2])
  349. jz("if_1001::end",eax)
  350. label("Run-time error!") //349
  351. mov(err,-1)
  352. jmp("if_1001::end")
  353. label("if_1001::end") //352
  354. label("func_QapAssert(int)::ret") //353
  355. mov(esp,ebp)
  356. pop(ebp)
  357. ret()
  358. label("func_min(int,int)") //357
  359. push(ebp)
  360. mov(ebp,esp)
  361. mov(eax,ptr[ebp+3])
  362. less(eax,ptr[ebp+2])
  363. jz("if_1002::end",eax)
  364. mov(edx,ptr[ebp+4])
  365. push(ptr[ebp+3])
  366. pop(ptr[edx+0])
  367. jmp("func_min(int,int)::ret")
  368. jmp("if_1002::end")
  369. label("if_1002::end") //368
  370. mov(edx,ptr[ebp+4])
  371. push(ptr[ebp+2])
  372. pop(ptr[edx+0])
  373. jmp("func_min(int,int)::ret")
  374. label("func_min(int,int)::ret") //373
  375. mov(esp,ebp)
  376. pop(ebp)
  377. ret()
  378. label("func_max(int,int)") //377
  379. push(ebp)
  380. mov(ebp,esp)
  381. mov(eax,ptr[ebp+3])
  382. more(eax,ptr[ebp+2])
  383. jz("if_1003::end",eax)
  384. mov(edx,ptr[ebp+4])
  385. push(ptr[ebp+3])
  386. pop(ptr[edx+0])
  387. jmp("func_max(int,int)::ret")
  388. jmp("if_1003::end")
  389. label("if_1003::end") //388
  390. mov(edx,ptr[ebp+4])
  391. push(ptr[ebp+2])
  392. pop(ptr[edx+0])
  393. jmp("func_max(int,int)::ret")
  394. label("func_max(int,int)::ret") //393
  395. mov(esp,ebp)
  396. pop(ebp)
  397. ret()
  398. label("func_clamp(int,int,int)") //397
  399. push(ebp)
  400. mov(ebp,esp)
  401. dec(esp)
  402. dec(esp)
  403. pushlea(ptr[ebp-1])
  404. push(ptr[ebp+4])
  405. push(ptr[ebp+2])
  406. call("func_max(int,int)")
  407. add(esp,3)
  408. pushlea(ptr[ebp-2])
  409. push(ptr[ebp-1])
  410. push(ptr[ebp+3])
  411. call("func_min(int,int)")
  412. add(esp,3)
  413. mov(edx,ptr[ebp+5])
  414. push(ptr[ebp-2])
  415. pop(ptr[edx+0])
  416. jmp("func_clamp(int,int,int)::ret")
  417. inc(esp)
  418. inc(esp)
  419. label("func_clamp(int,int,int)::ret") //418
  420. mov(esp,ebp)
  421. pop(ebp)
  422. ret()
  423. label("func_qap_vertex::`ctor()") //422
  424. push(ebp)
  425. mov(ebp,esp)
  426. dec(esp)
  427. mov(ptr[ebp-1],ecx)
  428. mov(ptr[ecx+0],0)
  429. lea(ecx,ptr[ecx+1])
  430. call("func_vec2i::`ctor()")
  431. mov(ecx,ptr[ebp-1])
  432. inc(esp)
  433. label("func_qap_vertex::`ctor()::ret") //432
  434. mov(esp,ebp)
  435. pop(ebp)
  436. ret()
  437. label("func_qap_vertex(int,vec2i)") //436
  438. push(ebp)
  439. mov(ebp,esp)
  440. sub(esp,3)
  441. lea(ecx,ptr[ebp-3])
  442. call("func_qap_vertex::`ctor()")
  443. mov(ebx,ptr[ebp+4])
  444. mov(ptr[ebp-3],ebx)
  445. push(ptr[ebp+3])
  446. push(ptr[ebp+2])
  447. pop(ptr[ebp-2])
  448. pop(ptr[ebp-1])
  449. mov(edx,ptr[ebp+5])
  450. push(ptr[ebp-1])
  451. push(ptr[ebp-2])
  452. push(ptr[ebp-3])
  453. pop(ptr[edx+0])
  454. pop(ptr[edx+1])
  455. pop(ptr[edx+2])
  456. jmp("func_qap_vertex(int,vec2i)::ret")
  457. add(esp,3)
  458. label("func_qap_vertex(int,vec2i)::ret") //457
  459. mov(esp,ebp)
  460. pop(ebp)
  461. ret()
  462. label("func_vector_qap_vertex::sys_add(int)") //461
  463. push(ebp)
  464. mov(ebp,esp)
  465. dec(esp)
  466. mov(ptr[ebp-1],ecx)
  467. dec(esp)
  468. pushlea(ptr[ebp-2])
  469. push(ptr[ecx+0])
  470. push(ptr[ebp+2])
  471. call("func_set_int(int,int)")
  472. mov(ecx,ptr[ebp-1])
  473. add(esp,3)
  474. mov(ebx,ptr[ebp-2])
  475. mov(ptr[ecx+0],ebx)
  476. inc(esp)
  477. mov(edx,ptr[ebp+3])
  478. push(ptr[ecx+0])
  479. pop(ptr[edx+0])
  480. jmp("func_vector_qap_vertex::sys_add(int)::ret")
  481. inc(esp)
  482. label("func_vector_qap_vertex::sys_add(int)::ret") //481
  483. mov(esp,ebp)
  484. pop(ebp)
  485. ret()
  486. label("func_vector_qap_vertex::sys_add(vec2i)") //485
  487. push(ebp)
  488. mov(ebp,esp)
  489. dec(esp)
  490. mov(ptr[ebp-1],ecx)
  491. dec(esp)
  492. pushlea(ptr[ebp-2])
  493. push(ptr[ebp+2])
  494. mov(ecx,ptr[ebp-1])
  495. call("func_vector_qap_vertex::sys_add(int)")
  496. mov(ecx,ptr[ebp-1])
  497. add(esp,2)
  498. inc(esp)
  499. dec(esp)
  500. pushlea(ptr[ebp-2])
  501. push(ptr[ebp+3])
  502. mov(ecx,ptr[ebp-1])
  503. call("func_vector_qap_vertex::sys_add(int)")
  504. mov(ecx,ptr[ebp-1])
  505. add(esp,2)
  506. inc(esp)
  507. mov(edx,ptr[ebp+4])
  508. push(ptr[ecx+0])
  509. pop(ptr[edx+0])
  510. jmp("func_vector_qap_vertex::sys_add(vec2i)::ret")
  511. inc(esp)
  512. label("func_vector_qap_vertex::sys_add(vec2i)::ret") //511
  513. mov(esp,ebp)
  514. pop(ebp)
  515. ret()
  516. label("func_vector_qap_vertex::add(int,vec2i)") //515
  517. push(ebp)
  518. mov(ebp,esp)
  519. dec(esp)
  520. mov(ptr[ebp-1],ecx)
  521. dec(esp)
  522. pushlea(ptr[ebp-2])
  523. push(ptr[ebp+4])
  524. mov(ecx,ptr[ebp-1])
  525. call("func_vector_qap_vertex::sys_add(int)")
  526. mov(ecx,ptr[ebp-1])
  527. add(esp,2)
  528. inc(esp)
  529. dec(esp)
  530. pushlea(ptr[ebp-2])
  531. push(ptr[ebp+3])
  532. push(ptr[ebp+2])
  533. mov(ecx,ptr[ebp-1])
  534. call("func_vector_qap_vertex::sys_add(vec2i)")
  535. mov(ecx,ptr[ebp-1])
  536. add(esp,3)
  537. inc(esp)
  538. inc(ptr[ecx+1])
  539. mov(edx,ptr[ebp+5])
  540. push(ptr[ecx+0])
  541. pop(ptr[edx+0])
  542. jmp("func_vector_qap_vertex::add(int,vec2i)::ret")
  543. inc(esp)
  544. label("func_vector_qap_vertex::add(int,vec2i)::ret") //543
  545. mov(esp,ebp)
  546. pop(ebp)
  547. ret()
  548. label("func_vector_qap_vertex::add(qap_vertex)") //547
  549. push(ebp)
  550. mov(ebp,esp)
  551. dec(esp)
  552. mov(ptr[ebp-1],ecx)
  553. dec(esp)
  554. pushlea(ptr[ebp-2])
  555. push(ptr[ebp+2])
  556. mov(ecx,ptr[ebp-1])
  557. call("func_vector_qap_vertex::sys_add(int)")
  558. mov(ecx,ptr[ebp-1])
  559. add(esp,2)
  560. inc(esp)
  561. dec(esp)
  562. pushlea(ptr[ebp-2])
  563. push(ptr[ebp+4])
  564. push(ptr[ebp+3])
  565. mov(ecx,ptr[ebp-1])
  566. call("func_vector_qap_vertex::sys_add(vec2i)")
  567. mov(ecx,ptr[ebp-1])
  568. add(esp,3)
  569. inc(esp)
  570. inc(ptr[ecx+1])
  571. mov(edx,ptr[ebp+5])
  572. push(ptr[ecx+0])
  573. pop(ptr[edx+0])
  574. jmp("func_vector_qap_vertex::add(qap_vertex)::ret")
  575. inc(esp)
  576. label("func_vector_qap_vertex::add(qap_vertex)::ret") //575
  577. mov(esp,ebp)
  578. pop(ebp)
  579. ret()
  580. label("func_vector_qap_vertex::get_vec2i(int)") //579
  581. push(ebp)
  582. mov(ebp,esp)
  583. dec(esp)
  584. mov(ptr[ebp-1],ecx)
  585. dec(esp)
  586. dec(esp)
  587. dec(esp)
  588. sub(esp,2)
  589. pushlea(ptr[ebp-2])
  590. push(ptr[ebp+2])
  591. call("func_get_int(int)")
  592. mov(ecx,ptr[ebp-1])
  593. add(esp,2)
  594. mov(eax,ptr[ebp+2])
  595. add(eax,1)
  596. mov(ptr[ebp-3],eax)
  597. pushlea(ptr[ebp-4])
  598. push(ptr[ebp-3])
  599. call("func_get_int(int)")
  600. mov(ecx,ptr[ebp-1])
  601. add(esp,2)
  602. pushlea(ptr[ebp-6])
  603. push(ptr[ebp-2])
  604. push(ptr[ebp-4])
  605. call("func_vec2i(int,int)")
  606. mov(ecx,ptr[ebp-1])
  607. add(esp,3)
  608. mov(edx,ptr[ebp+3])
  609. push(ptr[ebp-5])
  610. push(ptr[ebp-6])
  611. pop(ptr[edx+0])
  612. pop(ptr[edx+1])
  613. jmp("func_vector_qap_vertex::get_vec2i(int)::ret")
  614. add(esp,2)
  615. inc(esp)
  616. inc(esp)
  617. inc(esp)
  618. inc(esp)
  619. label("func_vector_qap_vertex::get_vec2i(int)::ret") //618
  620. mov(esp,ebp)
  621. pop(ebp)
  622. ret()
  623. label("func_vector_qap_vertex::get(int)") //622
  624. push(ebp)
  625. mov(ebp,esp)
  626. dec(esp)
  627. mov(ptr[ebp-1],ecx)
  628. dec(esp)
  629. dec(esp)
  630. sub(esp,2)
  631. sub(esp,3)
  632. pushlea(ptr[ebp-2])
  633. push(ptr[ebp+2])
  634. call("func_get_int(int)")
  635. mov(ecx,ptr[ebp-1])
  636. add(esp,2)
  637. mov(eax,ptr[ebp+2])
  638. add(eax,1)
  639. mov(ptr[ebp-3],eax)
  640. pushlea(ptr[ebp-5])
  641. push(ptr[ebp-3])
  642. mov(ecx,ptr[ebp-1])
  643. call("func_vector_qap_vertex::get_vec2i(int)")
  644. mov(ecx,ptr[ebp-1])
  645. add(esp,2)
  646. pushlea(ptr[ebp-8])
  647. push(ptr[ebp-2])
  648. push(ptr[ebp-4])
  649. push(ptr[ebp-5])
  650. call("func_qap_vertex(int,vec2i)")
  651. mov(ecx,ptr[ebp-1])
  652. add(esp,4)
  653. mov(edx,ptr[ebp+3])
  654. push(ptr[ebp-6])
  655. push(ptr[ebp-7])
  656. push(ptr[ebp-8])
  657. pop(ptr[edx+0])
  658. pop(ptr[edx+1])
  659. pop(ptr[edx+2])
  660. jmp("func_vector_qap_vertex::get(int)::ret")
  661. add(esp,3)
  662. add(esp,2)
  663. inc(esp)
  664. inc(esp)
  665. inc(esp)
  666. label("func_vector_qap_vertex::get(int)::ret") //665
  667. mov(esp,ebp)
  668. pop(ebp)
  669. ret()
  670. label("func_vector_qap_vertex::at(int)") //669
  671. push(ebp)
  672. mov(ebp,esp)
  673. dec(esp)
  674. mov(ptr[ebp-1],ecx)
  675. dec(esp)
  676. sub(esp,3)
  677. mov(eax,ptr[ecx+0])
  678. push(eax)
  679. mov(eax,ptr[ebp+2])
  680. sub(eax,ptr[ecx+1])
  681. mov(eax,eax)
  682. mul(eax,3)
  683. mov(ebx,eax)
  684. pop(eax)
  685. add(eax,ebx)
  686. mov(ptr[ebp-2],eax)
  687. pushlea(ptr[ebp-5])
  688. push(ptr[ebp-2])
  689. mov(ecx,ptr[ebp-1])
  690. call("func_vector_qap_vertex::get(int)")
  691. mov(ecx,ptr[ebp-1])
  692. add(esp,2)
  693. mov(edx,ptr[ebp+3])
  694. push(ptr[ebp-3])
  695. push(ptr[ebp-4])
  696. push(ptr[ebp-5])
  697. pop(ptr[edx+0])
  698. pop(ptr[edx+1])
  699. pop(ptr[edx+2])
  700. jmp("func_vector_qap_vertex::at(int)::ret")
  701. add(esp,3)
  702. inc(esp)
  703. inc(esp)
  704. label("func_vector_qap_vertex::at(int)::ret") //703
  705. mov(esp,ebp)
  706. pop(ebp)
  707. ret()
  708. label("func_vector_qap_vertex::`ctor()") //707
  709. push(ebp)
  710. mov(ebp,esp)
  711. dec(esp)
  712. mov(ptr[ebp-1],ecx)
  713. mov(ptr[ecx+0],0)
  714. mov(ptr[ecx+1],0)
  715. inc(esp)
  716. label("func_vector_qap_vertex::`ctor()::ret") //715
  717. mov(esp,ebp)
  718. pop(ebp)
  719. ret()
  720. label("func_vector_int::add(int)") //719
  721. push(ebp)
  722. mov(ebp,esp)
  723. dec(esp)
  724. mov(ptr[ebp-1],ecx)
  725. dec(esp)
  726. pushlea(ptr[ebp-2])
  727. push(ptr[ecx+0])
  728. push(ptr[ebp+2])
  729. call("func_set_int(int,int)")
  730. mov(ecx,ptr[ebp-1])
  731. add(esp,3)
  732. mov(ebx,ptr[ebp-2])
  733. mov(ptr[ecx+0],ebx)
  734. inc(esp)
  735. inc(ptr[ecx+1])
  736. mov(edx,ptr[ebp+3])
  737. push(ptr[ecx+0])
  738. pop(ptr[edx+0])
  739. jmp("func_vector_int::add(int)::ret")
  740. inc(esp)
  741. label("func_vector_int::add(int)::ret") //740
  742. mov(esp,ebp)
  743. pop(ebp)
  744. ret()
  745. label("func_vector_int::get(int)") //744
  746. push(ebp)
  747. mov(ebp,esp)
  748. dec(esp)
  749. mov(ptr[ebp-1],ecx)
  750. dec(esp)
  751. pushlea(ptr[ebp-2])
  752. push(ptr[ebp+2])
  753. call("func_get_int(int)")
  754. mov(ecx,ptr[ebp-1])
  755. add(esp,2)
  756. mov(edx,ptr[ebp+3])
  757. push(ptr[ebp-2])
  758. pop(ptr[edx+0])
  759. jmp("func_vector_int::get(int)::ret")
  760. inc(esp)
  761. inc(esp)
  762. label("func_vector_int::get(int)::ret") //761
  763. mov(esp,ebp)
  764. pop(ebp)
  765. ret()
  766. label("func_vector_int::at(int)") //765
  767. push(ebp)
  768. mov(ebp,esp)
  769. dec(esp)
  770. mov(ptr[ebp-1],ecx)
  771. dec(esp)
  772. dec(esp)
  773. mov(eax,ptr[ecx+0])
  774. add(eax,ptr[ebp+2])
  775. sub(eax,ptr[ecx+1])
  776. mov(ptr[ebp-2],eax)
  777. pushlea(ptr[ebp-3])
  778. push(ptr[ebp-2])
  779. mov(ecx,ptr[ebp-1])
  780. call("func_vector_int::get(int)")
  781. mov(ecx,ptr[ebp-1])
  782. add(esp,2)
  783. mov(edx,ptr[ebp+3])
  784. push(ptr[ebp-3])
  785. pop(ptr[edx+0])
  786. jmp("func_vector_int::at(int)::ret")
  787. inc(esp)
  788. inc(esp)
  789. inc(esp)
  790. label("func_vector_int::at(int)::ret") //789
  791. mov(esp,ebp)
  792. pop(ebp)
  793. ret()
  794. label("func_vector_int::front()") //793
  795. push(ebp)
  796. mov(ebp,esp)
  797. dec(esp)
  798. mov(ptr[ebp-1],ecx)
  799. dec(esp)
  800. dec(esp)
  801. mov(eax,ptr[ecx+1])
  802. more(eax,0)
  803. mov(ptr[ebp-2],eax)
  804. pushlea(ptr[ebp-3])
  805. push(ptr[ebp-2])
  806. call("func_QapAssert(int)")
  807. mov(ecx,ptr[ebp-1])
  808. add(esp,2)
  809. inc(esp)
  810. inc(esp)
  811. dec(esp)
  812. pushlea(ptr[ebp-2])
  813. push(0)
  814. mov(ecx,ptr[ebp-1])
  815. call("func_vector_int::at(int)")
  816. mov(ecx,ptr[ebp-1])
  817. add(esp,2)
  818. mov(edx,ptr[ebp+2])
  819. push(ptr[ebp-2])
  820. pop(ptr[edx+0])
  821. jmp("func_vector_int::front()::ret")
  822. inc(esp)
  823. inc(esp)
  824. label("func_vector_int::front()::ret") //823
  825. mov(esp,ebp)
  826. pop(ebp)
  827. ret()
  828. label("func_vector_int::back()") //827
  829. push(ebp)
  830. mov(ebp,esp)
  831. dec(esp)
  832. mov(ptr[ebp-1],ecx)
  833. dec(esp)
  834. dec(esp)
  835. mov(eax,ptr[ecx+1])
  836. more(eax,0)
  837. mov(ptr[ebp-2],eax)
  838. pushlea(ptr[ebp-3])
  839. push(ptr[ebp-2])
  840. call("func_QapAssert(int)")
  841. mov(ecx,ptr[ebp-1])
  842. add(esp,2)
  843. inc(esp)
  844. inc(esp)
  845. dec(esp)
  846. dec(esp)
  847. mov(eax,ptr[ecx+1])
  848. sub(eax,1)
  849. mov(ptr[ebp-2],eax)
  850. pushlea(ptr[ebp-3])
  851. push(ptr[ebp-2])
  852. mov(ecx,ptr[ebp-1])
  853. call("func_vector_int::at(int)")
  854. mov(ecx,ptr[ebp-1])
  855. add(esp,2)
  856. mov(edx,ptr[ebp+2])
  857. push(ptr[ebp-3])
  858. pop(ptr[edx+0])
  859. jmp("func_vector_int::back()::ret")
  860. inc(esp)
  861. inc(esp)
  862. inc(esp)
  863. label("func_vector_int::back()::ret") //862
  864. mov(esp,ebp)
  865. pop(ebp)
  866. ret()
  867. label("func_vector_int::`ctor()") //866
  868. push(ebp)
  869. mov(ebp,esp)
  870. dec(esp)
  871. mov(ptr[ebp-1],ecx)
  872. mov(ptr[ecx+0],0)
  873. mov(ptr[ecx+1],0)
  874. inc(esp)
  875. label("func_vector_int::`ctor()::ret") //874
  876. mov(esp,ebp)
  877. pop(ebp)
  878. ret()
  879. label("func_t_out_dev::AddTris(int,int,int)") //878
  880. push(ebp)
  881. mov(ebp,esp)
  882. dec(esp)
  883. mov(ptr[ebp-1],ecx)
  884. dec(esp)
  885. pushlea(ptr[ebp-2])
  886. push(ptr[ebp+4])
  887. lea(ecx,ptr[ecx+2])
  888. call("func_vector_int::add(int)")
  889. mov(ecx,ptr[ebp-1])
  890. add(esp,2)
  891. inc(esp)
  892. dec(esp)
  893. pushlea(ptr[ebp-2])
  894. push(ptr[ebp+3])
  895. lea(ecx,ptr[ecx+2])
  896. call("func_vector_int::add(int)")
  897. mov(ecx,ptr[ebp-1])
  898. add(esp,2)
  899. inc(esp)
  900. dec(esp)
  901. pushlea(ptr[ebp-2])
  902. push(ptr[ebp+2])
  903. lea(ecx,ptr[ecx+2])
  904. call("func_vector_int::add(int)")
  905. mov(ecx,ptr[ebp-1])
  906. add(esp,2)
  907. inc(esp)
  908. mov(edx,ptr[ebp+5])
  909. mov(ptr[edx+0],0)
  910. jmp("func_t_out_dev::AddTris(int,int,int)::ret")
  911. inc(esp)
  912. label("func_t_out_dev::AddTris(int,int,int)::ret") //911
  913. mov(esp,ebp)
  914. pop(ebp)
  915. ret()
  916. label("func_t_out_dev::AddVertex(qap_vertex)") //915
  917. push(ebp)
  918. mov(ebp,esp)
  919. dec(esp)
  920. mov(ptr[ebp-1],ecx)
  921. dec(esp)
  922. pushlea(ptr[ebp-2])
  923. push(ptr[ebp+4])
  924. push(ptr[ebp+3])
  925. push(ptr[ebp+2])
  926. lea(ecx,ptr[ecx+0])
  927. call("func_vector_qap_vertex::add(qap_vertex)")
  928. mov(ecx,ptr[ebp-1])
  929. add(esp,4)
  930. inc(esp)
  931. mov(edx,ptr[ebp+5])
  932. mov(ptr[edx+0],0)
  933. jmp("func_t_out_dev::AddVertex(qap_vertex)::ret")
  934. inc(esp)
  935. label("func_t_out_dev::AddVertex(qap_vertex)::ret") //934
  936. mov(esp,ebp)
  937. pop(ebp)
  938. ret()
  939. label("func_t_out_dev::AddVertex(int,int)") //938
  940. push(ebp)
  941. mov(ebp,esp)
  942. dec(esp)
  943. mov(ptr[ebp-1],ecx)
  944. sub(esp,2)
  945. dec(esp)
  946. pushlea(ptr[ebp-3])
  947. push(ptr[ebp+3])
  948. push(ptr[ebp+2])
  949. call("func_vec2i(int,int)")
  950. mov(ecx,ptr[ebp-1])
  951. add(esp,3)
  952. pushlea(ptr[ebp-4])
  953. push(ptr[ecx+4])
  954. push(ptr[ebp-2])
  955. push(ptr[ebp-3])
  956. lea(ecx,ptr[ecx+0])
  957. call("func_vector_qap_vertex::add(int,vec2i)")
  958. mov(ecx,ptr[ebp-1])
  959. add(esp,4)
  960. inc(esp)
  961. add(esp,2)
  962. mov(edx,ptr[ebp+4])
  963. mov(ptr[edx+0],0)
  964. jmp("func_t_out_dev::AddVertex(int,int)::ret")
  965. inc(esp)
  966. label("func_t_out_dev::AddVertex(int,int)::ret") //965
  967. mov(esp,ebp)
  968. pop(ebp)
  969. ret()
  970. label("func_t_out_dev::AddVertex(vec2i)") //969
  971. push(ebp)
  972. mov(ebp,esp)
  973. dec(esp)
  974. mov(ptr[ebp-1],ecx)
  975. dec(esp)
  976. pushlea(ptr[ebp-2])
  977. push(ptr[ecx+4])
  978. push(ptr[ebp+3])
  979. push(ptr[ebp+2])
  980. lea(ecx,ptr[ecx+0])
  981. call("func_vector_qap_vertex::add(int,vec2i)")
  982. mov(ecx,ptr[ebp-1])
  983. add(esp,4)
  984. inc(esp)
  985. mov(edx,ptr[ebp+4])
  986. mov(ptr[edx+0],0)
  987. jmp("func_t_out_dev::AddVertex(vec2i)::ret")
  988. inc(esp)
  989. label("func_t_out_dev::AddVertex(vec2i)::ret") //988
  990. mov(esp,ebp)
  991. pop(ebp)
  992. ret()
  993. label("func_t_out_dev::AddVertexAndRetVID(vec2i)") //992
  994. push(ebp)
  995. mov(ebp,esp)
  996. dec(esp)
  997. mov(ptr[ebp-1],ecx)
  998. dec(esp)
  999. pushlea(ptr[ebp-2])
  1000. push(ptr[ecx+4])
  1001. push(ptr[ebp+3])
  1002. push(ptr[ebp+2])
  1003. lea(ecx,ptr[ecx+0])
  1004. call("func_vector_qap_vertex::add(int,vec2i)")
  1005. mov(ecx,ptr[ebp-1])
  1006. add(esp,4)
  1007. inc(esp)
  1008. mov(eax,ptr[ecx+1])
  1009. sub(eax,1)
  1010. mov(edx,ptr[ebp+4])
  1011. mov(ptr[edx+0],eax)
  1012. jmp("func_t_out_dev::AddVertexAndRetVID(vec2i)::ret")
  1013. inc(esp)
  1014. label("func_t_out_dev::AddVertexAndRetVID(vec2i)::ret") //1013
  1015. mov(esp,ebp)
  1016. pop(ebp)
  1017. ret()
  1018. label("func_t_out_dev::add(t_out_dev)") //1017
  1019. push(ebp)
  1020. mov(ebp,esp)
  1021. dec(esp)
  1022. mov(ptr[ebp-1],ecx)
  1023. dec(esp)
  1024. dec(esp)
  1025. mov(eax,0)
  1026. push(eax)
  1027. mov(eax,ptr[ebp+5])
  1028. mod(eax,3)
  1029. mov(ebx,eax)
  1030. pop(eax)
  1031. eq(eax,ebx)
  1032. mov(ptr[ebp-2],eax)
  1033. pushlea(ptr[ebp-3])
  1034. push(ptr[ebp-2])
  1035. call("func_QapAssert(int)")
  1036. mov(ecx,ptr[ebp-1])
  1037. add(esp,2)
  1038. inc(esp)
  1039. inc(esp)
  1040. dec(esp)
  1041. mov(eax,ptr[ecx+1])
  1042. mov(ptr[ebp-2],eax)
  1043. dec(esp)
  1044. mov(ptr[ebp-3],0)
  1045. jmp("for_8000::condition")
  1046. label("for_8000::continue") //1045
  1047. inc(ptr[ebp-3])
  1048. label("for_8000::condition") //1047
  1049. mov(eax,ptr[ebp-3])
  1050. less(eax,ptr[ebp+3])
  1051. jz("for_8000::break",eax)
  1052. sub(esp,3)
  1053. dec(esp)
  1054. pushlea(ptr[ebp-6])
  1055. push(ptr[ebp-3])
  1056. lea(ecx,ptr[ebp+2])
  1057. call("func_vector_qap_vertex::at(int)")
  1058. mov(ecx,ptr[ebp-1])
  1059. add(esp,2)
  1060. pushlea(ptr[ebp-7])
  1061. push(ptr[ebp-4])
  1062. push(ptr[ebp-5])
  1063. push(ptr[ebp-6])
  1064. lea(ecx,ptr[ecx+0])
  1065. call("func_vector_qap_vertex::add(qap_vertex)")
  1066. mov(ecx,ptr[ebp-1])
  1067. add(esp,4)
  1068. inc(esp)
  1069. add(esp,3)
  1070. jmp("for_8000::continue")
  1071. label("for_8000::break") //1070
  1072. inc(esp)
  1073. dec(esp)
  1074. mov(ptr[ebp-3],0)
  1075. jmp("for_8001::condition")
  1076. label("for_8001::continue") //1075
  1077. inc(ptr[ebp-3])
  1078. label("for_8001::condition") //1077
  1079. mov(eax,ptr[ebp-3])
  1080. less(eax,ptr[ebp+5])
  1081. jz("for_8001::break",eax)
  1082. dec(esp)
  1083. dec(esp)
  1084. dec(esp)
  1085. mov(eax,ptr[ebp-2])
  1086. pushlea(ptr[ebp-4])
  1087. push(ptr[ebp-3])
  1088. lea(ecx,ptr[ebp+4])
  1089. call("func_vector_int::at(int)")
  1090. mov(ecx,ptr[ebp-1])
  1091. add(esp,2)
  1092. add(eax,ptr[ebp-4])
  1093. mov(ptr[ebp-5],eax)
  1094. pushlea(ptr[ebp-6])
  1095. push(ptr[ebp-5])
  1096. lea(ecx,ptr[ecx+2])
  1097. call("func_vector_int::add(int)")
  1098. mov(ecx,ptr[ebp-1])
  1099. add(esp,2)
  1100. inc(esp)
  1101. inc(esp)
  1102. inc(esp)
  1103. jmp("for_8001::continue")
  1104. label("for_8001::break") //1103
  1105. inc(esp)
  1106. mov(edx,ptr[ebp+7])
  1107. mov(ptr[edx+0],0)
  1108. jmp("func_t_out_dev::add(t_out_dev)::ret")
  1109. inc(esp)
  1110. inc(esp)
  1111. label("func_t_out_dev::add(t_out_dev)::ret") //1110
  1112. mov(esp,ebp)
  1113. pop(ebp)
  1114. ret()
  1115. label("func_t_out_dev::add_with_offset(t_out_dev,vec2i)") //1114
  1116. push(ebp)
  1117. mov(ebp,esp)
  1118. dec(esp)
  1119. mov(ptr[ebp-1],ecx)
  1120. dec(esp)
  1121. mov(eax,ptr[ecx+1])
  1122. mov(ptr[ebp-2],eax)
  1123. dec(esp)
  1124. dec(esp)
  1125. mov(eax,ptr[ebp-2])
  1126. push(eax)
  1127. mov(eax,1024)
  1128. mul(eax,16)
  1129. mov(ebx,eax)
  1130. pop(eax)
  1131. less(eax,ebx)
  1132. mov(ptr[ebp-3],eax)
  1133. pushlea(ptr[ebp-4])
  1134. push(ptr[ebp-3])
  1135. call("func_QapAssert(int)")
  1136. mov(ecx,ptr[ebp-1])
  1137. add(esp,2)
  1138. inc(esp)
  1139. inc(esp)
  1140. dec(esp)
  1141. mov(ptr[ebp-3],0)
  1142. jmp("for_8002::condition")
  1143. label("for_8002::continue") //1142
  1144. inc(ptr[ebp-3])
  1145. label("for_8002::condition") //1144
  1146. mov(eax,ptr[ebp-3])
  1147. less(eax,ptr[ebp+5])
  1148. jz("for_8002::break",eax)
  1149. sub(esp,3)
  1150. sub(esp,3)
  1151. pushlea(ptr[ebp-9])
  1152. push(ptr[ebp-3])
  1153. lea(ecx,ptr[ebp+4])
  1154. call("func_vector_qap_vertex::at(int)")
  1155. mov(ecx,ptr[ebp-1])
  1156. add(esp,2)
  1157. push(ptr[ebp-7])
  1158. push(ptr[ebp-8])
  1159. push(ptr[ebp-9])
  1160. pop(ptr[ebp-6])
  1161. pop(ptr[ebp-5])
  1162. pop(ptr[ebp-4])
  1163. add(esp,3)
  1164. sub(esp,2)
  1165. pushlea(ptr[ebp-8])
  1166. push(ptr[ebp-4])
  1167. push(ptr[ebp-5])
  1168. push(ptr[ebp+3])
  1169. push(ptr[ebp+2])
  1170. mov(ecx,ptr[ebp-1])
  1171. call("func_add(vec2i,vec2i)")
  1172. mov(ecx,ptr[ebp-1])
  1173. add(esp,5)
  1174. push(ptr[ebp-7])
  1175. push(ptr[ebp-8])
  1176. pop(ptr[ebp-5])
  1177. pop(ptr[ebp-4])
  1178. add(esp,2)
  1179. dec(esp)
  1180. pushlea(ptr[ebp-7])
  1181. push(ptr[ebp-4])
  1182. push(ptr[ebp-5])
  1183. push(ptr[ebp-6])
  1184. mov(ecx,ptr[ebp-1])
  1185. call("func_t_out_dev::AddVertex(qap_vertex)")
  1186. mov(ecx,ptr[ebp-1])
  1187. add(esp,4)
  1188. inc(esp)
  1189. add(esp,3)
  1190. jmp("for_8002::continue")
  1191. label("for_8002::break") //1190
  1192. inc(esp)
  1193. dec(esp)
  1194. dec(esp)
  1195. mov(eax,0)
  1196. push(eax)
  1197. mov(eax,ptr[ebp+7])
  1198. mod(eax,3)
  1199. mov(ebx,eax)
  1200. pop(eax)
  1201. eq(eax,ebx)
  1202. mov(ptr[ebp-3],eax)
  1203. pushlea(ptr[ebp-4])
  1204. push(ptr[ebp-3])
  1205. call("func_QapAssert(int)")
  1206. mov(ecx,ptr[ebp-1])
  1207. add(esp,2)
  1208. inc(esp)
  1209. inc(esp)
  1210. dec(esp)
  1211. mov(ptr[ebp-3],0)
  1212. jmp("for_8003::condition")
  1213. label("for_8003::continue") //1212
  1214. inc(ptr[ebp-3])
  1215. label("for_8003::condition") //1214
  1216. mov(eax,ptr[ebp-3])
  1217. less(eax,ptr[ebp+7])
  1218. jz("for_8003::break",eax)
  1219. dec(esp)
  1220. dec(esp)
  1221. dec(esp)
  1222. mov(eax,ptr[ebp-2])// begin of mistakle
  1223. pushlea(ptr[ebp-4])
  1224. push(ptr[ebp-3])
  1225. lea(ecx,ptr[ebp+6])
  1226. call("func_vector_int::at(int)")// eax modified inside this function
  1227. mov(ecx,ptr[ebp-1])
  1228. add(esp,2)
  1229. add(eax,ptr[ebp-4])//end of mistakle
  1230. mov(ptr[ebp-5],eax)
  1231. pushlea(ptr[ebp-6])
  1232. push(ptr[ebp-5])
  1233. lea(ecx,ptr[ecx+2])
  1234. call("func_vector_int::add(int)")
  1235. mov(ecx,ptr[ebp-1])
  1236. add(esp,2)
  1237. inc(esp)
  1238. inc(esp)
  1239. inc(esp)
  1240. jmp("for_8003::continue")
  1241. label("for_8003::break") //1240
  1242. inc(esp)
  1243. mov(edx,ptr[ebp+9])
  1244. mov(ptr[edx+0],0)
  1245. jmp("func_t_out_dev::add_with_offset(t_out_dev,vec2i)::ret")
  1246. inc(esp)
  1247. inc(esp)
  1248. label("func_t_out_dev::add_with_offset(t_out_dev,vec2i)::ret") //1247
  1249. mov(esp,ebp)
  1250. pop(ebp)
  1251. ret()
  1252. label("func_t_out_dev::GenGeomQuad(int,int,int,int)") //1251
  1253. push(ebp)
  1254. mov(ebp,esp)
  1255. dec(esp)
  1256. mov(ptr[ebp-1],ecx)
  1257. sub(esp,5)
  1258. sub(esp,5)
  1259. pushlea(ptr[ebp-11])
  1260. push(1)
  1261. call("func_new_geom(int)")
  1262. mov(ecx,ptr[ebp-1])
  1263. add(esp,2)
  1264. push(ptr[ebp-7])
  1265. push(ptr[ebp-8])
  1266. push(ptr[ebp-9])
  1267. push(ptr[ebp-10])
  1268. push(ptr[ebp-11])
  1269. pop(ptr[ebp-6])
  1270. pop(ptr[ebp-5])
  1271. pop(ptr[ebp-4])
  1272. pop(ptr[ebp-3])
  1273. pop(ptr[ebp-2])
  1274. add(esp,5)
  1275. mov(ebx,ptr[ecx+4])
  1276. mov(ptr[ebp-2],ebx)
  1277. dec(esp)
  1278. mov(eax,ptr[ebp+3])
  1279. div(eax,2)
  1280. mov(ptr[ebp-7],eax)
  1281. dec(esp)
  1282. mov(eax,ptr[ebp+2])
  1283. div(eax,2)
  1284. mov(ptr[ebp-8],eax)
  1285. dec(esp)
  1286. dec(esp)
  1287. dec(esp)
  1288. mov(eax,ptr[ebp+5])
  1289. sub(eax,ptr[ebp-7])
  1290. mov(ptr[ebp-9],eax)
  1291. mov(eax,ptr[ebp+4])
  1292. sub(eax,ptr[ebp-8])
  1293. mov(ptr[ebp-10],eax)
  1294. pushlea(ptr[ebp-11])
  1295. push(ptr[ebp-9])
  1296. push(ptr[ebp-10])
  1297. lea(ecx,ptr[ebp-6])
  1298. call("func_t_out_dev::AddVertex(int,int)")
  1299. mov(ecx,ptr[ebp-1])
  1300. add(esp,3)
  1301. inc(esp)
  1302. inc(esp)
  1303. inc(esp)
  1304. dec(esp)
  1305. dec(esp)
  1306. dec(esp)
  1307. mov(eax,ptr[ebp+5])
  1308. add(eax,ptr[ebp-7])
  1309. mov(ptr[ebp-9],eax)
  1310. mov(eax,ptr[ebp+4])
  1311. sub(eax,ptr[ebp-8])
  1312. mov(ptr[ebp-10],eax)
  1313. pushlea(ptr[ebp-11])
  1314. push(ptr[ebp-9])
  1315. push(ptr[ebp-10])
  1316. lea(ecx,ptr[ebp-6])
  1317. call("func_t_out_dev::AddVertex(int,int)")
  1318. mov(ecx,ptr[ebp-1])
  1319. add(esp,3)
  1320. inc(esp)
  1321. inc(esp)
  1322. inc(esp)
  1323. dec(esp)
  1324. dec(esp)
  1325. dec(esp)
  1326. mov(eax,ptr[ebp+5])
  1327. add(eax,ptr[ebp-7])
  1328. mov(ptr[ebp-9],eax)
  1329. mov(eax,ptr[ebp+4])
  1330. add(eax,ptr[ebp-8])
  1331. mov(ptr[ebp-10],eax)
  1332. pushlea(ptr[ebp-11])
  1333. push(ptr[ebp-9])
  1334. push(ptr[ebp-10])
  1335. lea(ecx,ptr[ebp-6])
  1336. call("func_t_out_dev::AddVertex(int,int)")
  1337. mov(ecx,ptr[ebp-1])
  1338. add(esp,3)
  1339. inc(esp)
  1340. inc(esp)
  1341. inc(esp)
  1342. dec(esp)
  1343. dec(esp)
  1344. dec(esp)
  1345. mov(eax,ptr[ebp+5])
  1346. sub(eax,ptr[ebp-7])
  1347. mov(ptr[ebp-9],eax)
  1348. mov(eax,ptr[ebp+4])
  1349. add(eax,ptr[ebp-8])
  1350. mov(ptr[ebp-10],eax)
  1351. pushlea(ptr[ebp-11])
  1352. push(ptr[ebp-9])
  1353. push(ptr[ebp-10])
  1354. lea(ecx,ptr[ebp-6])
  1355. call("func_t_out_dev::AddVertex(int,int)")
  1356. mov(ecx,ptr[ebp-1])
  1357. add(esp,3)
  1358. inc(esp)
  1359. inc(esp)
  1360. inc(esp)
  1361. dec(esp)
  1362. pushlea(ptr[ebp-9])
  1363. push(1)
  1364. push(0)
  1365. push(3)
  1366. lea(ecx,ptr[ebp-6])
  1367. call("func_t_out_dev::AddTris(int,int,int)")
  1368. mov(ecx,ptr[ebp-1])
  1369. add(esp,4)
  1370. inc(esp)
  1371. dec(esp)
  1372. pushlea(ptr[ebp-9])
  1373. push(3)
  1374. push(2)
  1375. push(1)
  1376. lea(ecx,ptr[ebp-6])
  1377. call("func_t_out_dev::AddTris(int,int,int)")
  1378. mov(ecx,ptr[ebp-1])
  1379. add(esp,4)
  1380. inc(esp)
  1381. mov(edx,ptr[ebp+6])
  1382. push(ptr[ebp-2])
  1383. push(ptr[ebp-3])
  1384. push(ptr[ebp-4])
  1385. push(ptr[ebp-5])
  1386. push(ptr[ebp-6])
  1387. pop(ptr[edx+0])
  1388. pop(ptr[edx+1])
  1389. pop(ptr[edx+2])
  1390. pop(ptr[edx+3])
  1391. pop(ptr[edx+4])
  1392. jmp("func_t_out_dev::GenGeomQuad(int,int,int,int)::ret")
  1393. inc(esp)
  1394. inc(esp)
  1395. add(esp,5)
  1396. inc(esp)
  1397. label("func_t_out_dev::GenGeomQuad(int,int,int,int)::ret") //1396
  1398. mov(esp,ebp)
  1399. pop(ebp)
  1400. ret()
  1401. label("func_t_out_dev::`ctor()") //1400
  1402. push(ebp)
  1403. mov(ebp,esp)
  1404. dec(esp)
  1405. mov(ptr[ebp-1],ecx)
  1406. lea(ecx,ptr[ecx+0])
  1407. call("func_vector_qap_vertex::`ctor()")
  1408. mov(ecx,ptr[ebp-1])
  1409. lea(ecx,ptr[ecx+2])
  1410. call("func_vector_int::`ctor()")
  1411. mov(ecx,ptr[ebp-1])
  1412. mov(ptr[ecx+4],0)
  1413. inc(esp)
  1414. label("func_t_out_dev::`ctor()::ret") //1413
  1415. mov(esp,ebp)
  1416. pop(ebp)
  1417. ret()
  1418. label("func_new_geom(int)") //1417
  1419. push(ebp)
  1420. mov(ebp,esp)
  1421. sub(esp,5)
  1422. lea(ecx,ptr[ebp-5])
  1423. call("func_t_out_dev::`ctor()")
  1424. dec(esp)
  1425. dec(esp)
  1426. mov(eax,3)
  1427. mul(eax,4)
  1428. mul(eax,ptr[ebp+2])
  1429. mov(ptr[ebp-6],eax)
  1430. pushlea(ptr[ebp-7])
  1431. push(ptr[ebp-6])
  1432. call("func_alloc(int)")
  1433. add(esp,2)
  1434. mov(ebx,ptr[ebp-7])
  1435. mov(ptr[ebp-5],ebx)
  1436. inc(esp)
  1437. inc(esp)
  1438. mov(ptr[ebp-4],0)
  1439. dec(esp)
  1440. dec(esp)
  1441. mov(eax,1)
  1442. mul(eax,6)
  1443. mul(eax,ptr[ebp+2])
  1444. mov(ptr[ebp-6],eax)
  1445. pushlea(ptr[ebp-7])
  1446. push(ptr[ebp-6])
  1447. call("func_alloc(int)")
  1448. add(esp,2)
  1449. mov(ebx,ptr[ebp-7])
  1450. mov(ptr[ebp-3],ebx)
  1451. inc(esp)
  1452. inc(esp)
  1453. mov(ptr[ebp-2],0)
  1454. mov(edx,ptr[ebp+3])
  1455. push(ptr[ebp-1])
  1456. push(ptr[ebp-2])
  1457. push(ptr[ebp-3])
  1458. push(ptr[ebp-4])
  1459. push(ptr[ebp-5])
  1460. pop(ptr[edx+0])
  1461. pop(ptr[edx+1])
  1462. pop(ptr[edx+2])
  1463. pop(ptr[edx+3])
  1464. pop(ptr[edx+4])
  1465. jmp("func_new_geom(int)::ret")
  1466. add(esp,5)
  1467. label("func_new_geom(int)::ret") //1466
  1468. mov(esp,ebp)
  1469. pop(ebp)
  1470. ret()
  1471. label("func_t_input::`ctor()") //1470
  1472. push(ebp)
  1473. mov(ebp,esp)
  1474. dec(esp)
  1475. mov(ptr[ebp-1],ecx)
  1476. lea(ecx,ptr[ecx+0])
  1477. call("func_vec2i::`ctor()")
  1478. mov(ecx,ptr[ebp-1])
  1479. mov(ptr[ecx+2],0)
  1480. lea(ecx,ptr[ecx+3])
  1481. call("func_vector_int::`ctor()")
  1482. mov(ecx,ptr[ebp-1])
  1483. lea(ecx,ptr[ecx+5])
  1484. call("func_vector_int::`ctor()")
  1485. mov(ecx,ptr[ebp-1])
  1486. inc(esp)
  1487. label("func_t_input::`ctor()::ret") //1486
  1488. mov(esp,ebp)
  1489. pop(ebp)
  1490. ret()
  1491. label("func_t_dev::read_int()") //1490
  1492. push(ebp)
  1493. mov(ebp,esp)
  1494. dec(esp)
  1495. mov(ptr[ebp-1],ecx)
  1496. dec(esp)
  1497. dec(esp)
  1498. pushlea(ptr[ebp-3])
  1499. push(ptr[ecx+0])
  1500. call("func_get_int(int)")
  1501. mov(ecx,ptr[ebp-1])
  1502. add(esp,2)
  1503. mov(eax,ptr[ebp-3])
  1504. mov(ptr[ebp-2],eax)
  1505. inc(esp)
  1506. inc(ptr[ecx+0])
  1507. mov(edx,ptr[ebp+2])
  1508. push(ptr[ebp-2])
  1509. pop(ptr[edx+0])
  1510. jmp("func_t_dev::read_int()::ret")
  1511. inc(esp)
  1512. inc(esp)
  1513. label("func_t_dev::read_int()::ret") //1512
  1514. mov(esp,ebp)
  1515. pop(ebp)
  1516. ret()
  1517. label("func_t_dev::read_vec2i()") //1516
  1518. push(ebp)
  1519. mov(ebp,esp)
  1520. dec(esp)
  1521. mov(ptr[ebp-1],ecx)
  1522. dec(esp)
  1523. dec(esp)
  1524. sub(esp,2)
  1525. pushlea(ptr[ebp-2])
  1526. mov(ecx,ptr[ebp-1])
  1527. call("func_t_dev::read_int()")
  1528. mov(ecx,ptr[ebp-1])
  1529. add(esp,1)
  1530. pushlea(ptr[ebp-3])
  1531. mov(ecx,ptr[ebp-1])
  1532. call("func_t_dev::read_int()")
  1533. mov(ecx,ptr[ebp-1])
  1534. add(esp,1)
  1535. pushlea(ptr[ebp-5])
  1536. push(ptr[ebp-2])
  1537. push(ptr[ebp-3])
  1538. call("func_vec2i(int,int)")
  1539. mov(ecx,ptr[ebp-1])
  1540. add(esp,3)
  1541. mov(edx,ptr[ebp+2])
  1542. push(ptr[ebp-4])
  1543. push(ptr[ebp-5])
  1544. pop(ptr[edx+0])
  1545. pop(ptr[edx+1])
  1546. jmp("func_t_dev::read_vec2i()::ret")
  1547. add(esp,2)
  1548. inc(esp)
  1549. inc(esp)
  1550. inc(esp)
  1551. label("func_t_dev::read_vec2i()::ret") //1550
  1552. mov(esp,ebp)
  1553. pop(ebp)
  1554. ret()
  1555. label("func_t_dev::read_vector_int()") //1554
  1556. push(ebp)
  1557. mov(ebp,esp)
  1558. dec(esp)
  1559. mov(ptr[ebp-1],ecx)
  1560. sub(esp,2)
  1561. lea(ecx,ptr[ebp-3])
  1562. call("func_vector_int::`ctor()")
  1563. mov(ecx,ptr[ebp-1])
  1564. dec(esp)
  1565. pushlea(ptr[ebp-4])
  1566. mov(ecx,ptr[ebp-1])
  1567. call("func_t_dev::read_int()")
  1568. mov(ecx,ptr[ebp-1])
  1569. add(esp,1)
  1570. mov(ebx,ptr[ebp-4])
  1571. mov(ptr[ebp-2],ebx)
  1572. inc(esp)
  1573. mov(ebx,ptr[ebp-2])
  1574. add(ptr[ecx+0],ebx)
  1575. mov(ebx,ptr[ecx+0])
  1576. mov(ptr[ebp-3],ebx)
  1577. mov(edx,ptr[ebp+2])
  1578. push(ptr[ebp-2])
  1579. push(ptr[ebp-3])
  1580. pop(ptr[edx+0])
  1581. pop(ptr[edx+1])
  1582. jmp("func_t_dev::read_vector_int()::ret")
  1583. add(esp,2)
  1584. inc(esp)
  1585. label("func_t_dev::read_vector_int()::ret") //1584
  1586. mov(esp,ebp)
  1587. pop(ebp)
  1588. ret()
  1589. label("func_t_dev::write(int)") //1588
  1590. push(ebp)
  1591. mov(ebp,esp)
  1592. dec(esp)
  1593. mov(ptr[ebp-1],ecx)
  1594. dec(esp)
  1595. pushlea(ptr[ebp-2])
  1596. push(ptr[ecx+0])
  1597. push(ptr[ebp+2])
  1598. call("func_set_int(int,int)")
  1599. mov(ecx,ptr[ebp-1])
  1600. add(esp,3)
  1601. mov(ebx,ptr[ebp-2])
  1602. mov(ptr[ecx+0],ebx)
  1603. inc(esp)
  1604. mov(edx,ptr[ebp+3])
  1605. push(ptr[ecx+0])
  1606. pop(ptr[edx+0])
  1607. jmp("func_t_dev::write(int)::ret")
  1608. inc(esp)
  1609. label("func_t_dev::write(int)::ret") //1608
  1610. mov(esp,ebp)
  1611. pop(ebp)
  1612. ret()
  1613. label("func_t_dev::write(int,int,int)") //1612
  1614. push(ebp)
  1615. mov(ebp,esp)
  1616. dec(esp)
  1617. mov(ptr[ebp-1],ecx)
  1618. dec(esp)
  1619. pushlea(ptr[ebp-2])
  1620. push(ptr[ebp+4])
  1621. mov(ecx,ptr[ebp-1])
  1622. call("func_t_dev::write(int)")
  1623. mov(ecx,ptr[ebp-1])
  1624. add(esp,2)
  1625. inc(esp)
  1626. dec(esp)
  1627. pushlea(ptr[ebp-2])
  1628. push(ptr[ebp+3])
  1629. mov(ecx,ptr[ebp-1])
  1630. call("func_t_dev::write(int)")
  1631. mov(ecx,ptr[ebp-1])
  1632. add(esp,2)
  1633. inc(esp)
  1634. dec(esp)
  1635. pushlea(ptr[ebp-2])
  1636. push(ptr[ebp+2])
  1637. mov(ecx,ptr[ebp-1])
  1638. call("func_t_dev::write(int)")
  1639. mov(ecx,ptr[ebp-1])
  1640. add(esp,2)
  1641. inc(esp)
  1642. mov(edx,ptr[ebp+5])
  1643. push(ptr[ecx+0])
  1644. pop(ptr[edx+0])
  1645. jmp("func_t_dev::write(int,int,int)::ret")
  1646. inc(esp)
  1647. label("func_t_dev::write(int,int,int)::ret") //1646
  1648. mov(esp,ebp)
  1649. pop(ebp)
  1650. ret()
  1651. label("func_t_dev::write(vec2i)") //1650
  1652. push(ebp)
  1653. mov(ebp,esp)
  1654. dec(esp)
  1655. mov(ptr[ebp-1],ecx)
  1656. dec(esp)
  1657. pushlea(ptr[ebp-2])
  1658. push(ptr[ebp+2])
  1659. mov(ecx,ptr[ebp-1])
  1660. call("func_t_dev::write(int)")
  1661. mov(ecx,ptr[ebp-1])
  1662. add(esp,2)
  1663. inc(esp)
  1664. dec(esp)
  1665. pushlea(ptr[ebp-2])
  1666. push(ptr[ebp+3])
  1667. mov(ecx,ptr[ebp-1])
  1668. call("func_t_dev::write(int)")
  1669. mov(ecx,ptr[ebp-1])
  1670. add(esp,2)
  1671. inc(esp)
  1672. mov(edx,ptr[ebp+4])
  1673. push(ptr[ecx+0])
  1674. pop(ptr[edx+0])
  1675. jmp("func_t_dev::write(vec2i)::ret")
  1676. inc(esp)
  1677. label("func_t_dev::write(vec2i)::ret") //1676
  1678. mov(esp,ebp)
  1679. pop(ebp)
  1680. ret()
  1681. label("func_t_dev::write(int,vec2i)") //1680
  1682. push(ebp)
  1683. mov(ebp,esp)
  1684. dec(esp)
  1685. mov(ptr[ebp-1],ecx)
  1686. dec(esp)
  1687. pushlea(ptr[ebp-2])
  1688. push(ptr[ebp+4])
  1689. mov(ecx,ptr[ebp-1])
  1690. call("func_t_dev::write(int)")
  1691. mov(ecx,ptr[ebp-1])
  1692. add(esp,2)
  1693. inc(esp)
  1694. dec(esp)
  1695. pushlea(ptr[ebp-2])
  1696. push(ptr[ebp+2])
  1697. mov(ecx,ptr[ebp-1])
  1698. call("func_t_dev::write(int)")
  1699. mov(ecx,ptr[ebp-1])
  1700. add(esp,2)
  1701. inc(esp)
  1702. dec(esp)
  1703. pushlea(ptr[ebp-2])
  1704. push(ptr[ebp+3])
  1705. mov(ecx,ptr[ebp-1])
  1706. call("func_t_dev::write(int)")
  1707. mov(ecx,ptr[ebp-1])
  1708. add(esp,2)
  1709. inc(esp)
  1710. mov(edx,ptr[ebp+5])
  1711. push(ptr[ecx+0])
  1712. pop(ptr[edx+0])
  1713. jmp("func_t_dev::write(int,vec2i)::ret")
  1714. inc(esp)
  1715. label("func_t_dev::write(int,vec2i)::ret") //1714
  1716. mov(esp,ebp)
  1717. pop(ebp)
  1718. ret()
  1719. label("func_t_dev::write(qap_vertex)") //1718
  1720. push(ebp)
  1721. mov(ebp,esp)
  1722. dec(esp)
  1723. mov(ptr[ebp-1],ecx)
  1724. dec(esp)
  1725. pushlea(ptr[ebp-2])
  1726. push(ptr[ebp+2])
  1727. mov(ecx,ptr[ebp-1])
  1728. call("func_t_dev::write(int)")
  1729. mov(ecx,ptr[ebp-1])
  1730. add(esp,2)
  1731. inc(esp)
  1732. dec(esp)
  1733. pushlea(ptr[ebp-2])
  1734. push(ptr[ebp+4])
  1735. push(ptr[ebp+3])
  1736. mov(ecx,ptr[ebp-1])
  1737. call("func_t_dev::write(vec2i)")
  1738. mov(ecx,ptr[ebp-1])
  1739. add(esp,3)
  1740. inc(esp)
  1741. mov(edx,ptr[ebp+5])
  1742. push(ptr[ecx+0])
  1743. pop(ptr[edx+0])
  1744. jmp("func_t_dev::write(qap_vertex)::ret")
  1745. inc(esp)
  1746. label("func_t_dev::write(qap_vertex)::ret") //1745
  1747. mov(esp,ebp)
  1748. pop(ebp)
  1749. ret()
  1750. label("func_t_dev::write(t_out_dev)") //1749
  1751. push(ebp)
  1752. mov(ebp,esp)
  1753. dec(esp)
  1754. mov(ptr[ebp-1],ecx)
  1755. dec(esp)
  1756. pushlea(ptr[ebp-2])
  1757. push(ptr[ebp+3])
  1758. mov(ecx,ptr[ebp-1])
  1759. call("func_t_dev::write(int)")
  1760. mov(ecx,ptr[ebp-1])
  1761. add(esp,2)
  1762. inc(esp)
  1763. dec(esp)
  1764. mov(ptr[ebp-2],0)
  1765. jmp("for_8004::condition")
  1766. label("for_8004::continue") //1765
  1767. inc(ptr[ebp-2])
  1768. label("for_8004::condition") //1767
  1769. mov(eax,ptr[ebp-2])
  1770. less(eax,ptr[ebp+3])
  1771. jz("for_8004::break",eax)
  1772. sub(esp,3)
  1773. dec(esp)
  1774. pushlea(ptr[ebp-5])
  1775. push(ptr[ebp-2])
  1776. lea(ecx,ptr[ebp+2])
  1777. call("func_vector_qap_vertex::at(int)")
  1778. mov(ecx,ptr[ebp-1])
  1779. add(esp,2)
  1780. pushlea(ptr[ebp-6])
  1781. push(ptr[ebp-3])
  1782. push(ptr[ebp-4])
  1783. push(ptr[ebp-5])
  1784. mov(ecx,ptr[ebp-1])
  1785. call("func_t_dev::write(qap_vertex)")
  1786. mov(ecx,ptr[ebp-1])
  1787. add(esp,4)
  1788. inc(esp)
  1789. add(esp,3)
  1790. jmp("for_8004::continue")
  1791. label("for_8004::break") //1790
  1792. inc(esp)
  1793. dec(esp)
  1794. pushlea(ptr[ebp-2])
  1795. push(ptr[ebp+5])
  1796. mov(ecx,ptr[ebp-1])
  1797. call("func_t_dev::write(int)")
  1798. mov(ecx,ptr[ebp-1])
  1799. add(esp,2)
  1800. inc(esp)
  1801. dec(esp)
  1802. mov(ptr[ebp-2],0)
  1803. jmp("for_8005::condition")
  1804. label("for_8005::continue") //1803
  1805. inc(ptr[ebp-2])
  1806. label("for_8005::condition") //1805
  1807. mov(eax,ptr[ebp-2])
  1808. less(eax,ptr[ebp+5])
  1809. jz("for_8005::break",eax)
  1810. dec(esp)
  1811. dec(esp)
  1812. pushlea(ptr[ebp-3])
  1813. push(ptr[ebp-2])
  1814. lea(ecx,ptr[ebp+4])
  1815. call("func_vector_int::at(int)")
  1816. mov(ecx,ptr[ebp-1])
  1817. add(esp,2)
  1818. pushlea(ptr[ebp-4])
  1819. push(ptr[ebp-3])
  1820. mov(ecx,ptr[ebp-1])
  1821. call("func_t_dev::write(int)")
  1822. mov(ecx,ptr[ebp-1])
  1823. add(esp,2)
  1824. inc(esp)
  1825. inc(esp)
  1826. jmp("for_8005::continue")
  1827. label("for_8005::break") //1826
  1828. inc(esp)
  1829. inc(esp)
  1830. label("func_t_dev::write(t_out_dev)::ret") //1829
  1831. mov(esp,ebp)
  1832. pop(ebp)
  1833. ret()
  1834. label("func_t_dev::write_def(vec2i)") //1833
  1835. push(ebp)
  1836. mov(ebp,esp)
  1837. dec(esp)
  1838. mov(ptr[ebp-1],ecx)
  1839. dec(esp)
  1840. pushlea(ptr[ebp-2])
  1841. push(6)
  1842. mov(ecx,ptr[ebp-1])
  1843. call("func_t_dev::write(int)")
  1844. mov(ecx,ptr[ebp-1])
  1845. add(esp,2)
  1846. inc(esp)
  1847. dec(esp)
  1848. mov(eax,255)
  1849. push(eax)
  1850. mov(eax,8)
  1851. mul(eax,3)
  1852. mov(ebx,eax)
  1853. pop(eax)
  1854. shl(eax,ebx)
  1855. mov(ptr[ebp-2],eax)
  1856. dec(esp)
  1857. inv(eax,1)
  1858. mov(ptr[ebp-3],eax)
  1859. dec(esp)
  1860. mov(eax,ptr[ebp-2])
  1861. push(eax)
  1862. mov(eax,255)
  1863. push(eax)
  1864. mov(eax,8)
  1865. mul(eax,2)
  1866. mov(ebx,eax)
  1867. pop(eax)
  1868. shl(eax,ebx)
  1869. mov(ebx,eax)
  1870. pop(eax)
  1871. add(eax,ebx)
  1872. mov(ptr[ebp-4],eax)
  1873. dec(esp)
  1874. mov(eax,ptr[ebp-2])
  1875. push(eax)
  1876. mov(eax,255)
  1877. push(eax)
  1878. mov(eax,8)
  1879. mul(eax,1)
  1880. mov(ebx,eax)
  1881. pop(eax)
  1882. shl(eax,ebx)
  1883. mov(ebx,eax)
  1884. pop(eax)
  1885. add(eax,ebx)
  1886. mov(ptr[ebp-5],eax)
  1887. dec(esp)
  1888. mov(eax,ptr[ebp-2])
  1889. push(eax)
  1890. mov(eax,255)
  1891. push(eax)
  1892. mov(eax,8)
  1893. mul(eax,0)
  1894. mov(ebx,eax)
  1895. pop(eax)
  1896. shl(eax,ebx)
  1897. mov(ebx,eax)
  1898. pop(eax)
  1899. add(eax,ebx)
  1900. mov(ptr[ebp-6],eax)
  1901. dec(esp)
  1902. mov(eax,ptr[ebp-2])
  1903. mov(ptr[ebp-7],eax)
  1904. dec(esp)
  1905. sub(esp,2)
  1906. sub(esp,2)
  1907. dec(esp)
  1908. inv(eax,30)
  1909. mov(ptr[ebp-8],eax)
  1910. pushlea(ptr[ebp-10])
  1911. push(ptr[ebp-8])
  1912. push(0)
  1913. call("func_vec2i(int,int)")
  1914. mov(ecx,ptr[ebp-1])
  1915. add(esp,3)
  1916. pushlea(ptr[ebp-12])
  1917. push(ptr[ebp+3])
  1918. push(ptr[ebp+2])
  1919. push(ptr[ebp-9])
  1920. push(ptr[ebp-10])
  1921. call("func_add(vec2i,vec2i)")
  1922. mov(ecx,ptr[ebp-1])
  1923. add(esp,5)
  1924. pushlea(ptr[ebp-13])
  1925. push(ptr[ebp-7])
  1926. push(ptr[ebp-11])
  1927. push(ptr[ebp-12])
  1928. mov(ecx,ptr[ebp-1])
  1929. call("func_t_dev::write(int,vec2i)")
  1930. mov(ecx,ptr[ebp-1])
  1931. add(esp,4)
  1932. inc(esp)
  1933. add(esp,2)
  1934. add(esp,2)
  1935. inc(esp)
  1936. sub(esp,2)
  1937. sub(esp,2)
  1938. dec(esp)
  1939. pushlea(ptr[ebp-9])
  1940. push(0)
  1941. push(30)
  1942. call("func_vec2i(int,int)")
  1943. mov(ecx,ptr[ebp-1])
  1944. add(esp,3)
  1945. pushlea(ptr[ebp-11])
  1946. push(ptr[ebp+3])
  1947. push(ptr[ebp+2])
  1948. push(ptr[ebp-8])
  1949. push(ptr[ebp-9])
  1950. call("func_add(vec2i,vec2i)")
  1951. mov(ecx,ptr[ebp-1])
  1952. add(esp,5)
  1953. pushlea(ptr[ebp-12])
  1954. push(ptr[ebp-7])
  1955. push(ptr[ebp-10])
  1956. push(ptr[ebp-11])
  1957. mov(ecx,ptr[ebp-1])
  1958. call("func_t_dev::write(int,vec2i)")
  1959. mov(ecx,ptr[ebp-1])
  1960. add(esp,4)
  1961. inc(esp)
  1962. add(esp,2)
  1963. add(esp,2)
  1964. sub(esp,2)
  1965. sub(esp,2)
  1966. dec(esp)
  1967. pushlea(ptr[ebp-9])
  1968. push(30)
  1969. push(0)
  1970. call("func_vec2i(int,int)")
  1971. mov(ecx,ptr[ebp-1])
  1972. add(esp,3)
  1973. pushlea(ptr[ebp-11])
  1974. push(ptr[ebp+3])
  1975. push(ptr[ebp+2])
  1976. push(ptr[ebp-8])
  1977. push(ptr[ebp-9])
  1978. call("func_add(vec2i,vec2i)")
  1979. mov(ecx,ptr[ebp-1])
  1980. add(esp,5)
  1981. pushlea(ptr[ebp-12])
  1982. push(ptr[ebp-7])
  1983. push(ptr[ebp-10])
  1984. push(ptr[ebp-11])
  1985. mov(ecx,ptr[ebp-1])
  1986. call("func_t_dev::write(int,vec2i)")
  1987. mov(ecx,ptr[ebp-1])
  1988. add(esp,4)
  1989. inc(esp)
  1990. add(esp,2)
  1991. add(esp,2)
  1992. sub(esp,2)
  1993. push(ptr[ebp+3])
  1994. push(ptr[ebp+2])
  1995. pop(ptr[ebp-9])
  1996. pop(ptr[ebp-8])
  1997. add(ptr[ebp-9],60)
  1998. dec(esp)
  1999. sub(esp,2)
  2000. sub(esp,2)
  2001. dec(esp)
  2002. inv(eax,30)
  2003. mov(ptr[ebp-10],eax)
  2004. pushlea(ptr[ebp-12])
  2005. push(ptr[ebp-10])
  2006. push(0)
  2007. call("func_vec2i(int,int)")
  2008. mov(ecx,ptr[ebp-1])
  2009. add(esp,3)
  2010. pushlea(ptr[ebp-14])
  2011. push(ptr[ebp-8])
  2012. push(ptr[ebp-9])
  2013. push(ptr[ebp-11])
  2014. push(ptr[ebp-12])
  2015. call("func_add(vec2i,vec2i)")
  2016. mov(ecx,ptr[ebp-1])
  2017. add(esp,5)
  2018. pushlea(ptr[ebp-15])
  2019. push(ptr[ebp-7])
  2020. push(ptr[ebp-13])
  2021. push(ptr[ebp-14])
  2022. mov(ecx,ptr[ebp-1])
  2023. call("func_t_dev::write(int,vec2i)")
  2024. mov(ecx,ptr[ebp-1])
  2025. add(esp,4)
  2026. inc(esp)
  2027. add(esp,2)
  2028. add(esp,2)
  2029. inc(esp)
  2030. sub(esp,2)
  2031. sub(esp,2)
  2032. dec(esp)
  2033. pushlea(ptr[ebp-11])
  2034. push(0)
  2035. push(30)
  2036. call("func_vec2i(int,int)")
  2037. mov(ecx,ptr[ebp-1])
  2038. add(esp,3)
  2039. pushlea(ptr[ebp-13])
  2040. push(ptr[ebp-8])
  2041. push(ptr[ebp-9])
  2042. push(ptr[ebp-10])
  2043. push(ptr[ebp-11])
  2044. call("func_add(vec2i,vec2i)")
  2045. mov(ecx,ptr[ebp-1])
  2046. add(esp,5)
  2047. pushlea(ptr[ebp-14])
  2048. push(ptr[ebp-7])
  2049. push(ptr[ebp-12])
  2050. push(ptr[ebp-13])
  2051. mov(ecx,ptr[ebp-1])
  2052. call("func_t_dev::write(int,vec2i)")
  2053. mov(ecx,ptr[ebp-1])
  2054. add(esp,4)
  2055. inc(esp)
  2056. add(esp,2)
  2057. add(esp,2)
  2058. sub(esp,2)
  2059. sub(esp,2)
  2060. dec(esp)
  2061. pushlea(ptr[ebp-11])
  2062. push(30)
  2063. push(0)
  2064. call("func_vec2i(int,int)")
  2065. mov(ecx,ptr[ebp-1])
  2066. add(esp,3)
  2067. pushlea(ptr[ebp-13])
  2068. push(ptr[ebp-8])
  2069. push(ptr[ebp-9])
  2070. push(ptr[ebp-10])
  2071. push(ptr[ebp-11])
  2072. call("func_add(vec2i,vec2i)")
  2073. mov(ecx,ptr[ebp-1])
  2074. add(esp,5)
  2075. pushlea(ptr[ebp-14])
  2076. push(ptr[ebp-5])
  2077. push(ptr[ebp-12])
  2078. push(ptr[ebp-13])
  2079. mov(ecx,ptr[ebp-1])
  2080. call("func_t_dev::write(int,vec2i)")
  2081. mov(ecx,ptr[ebp-1])
  2082. add(esp,4)
  2083. inc(esp)
  2084. add(esp,2)
  2085. add(esp,2)
  2086. dec(esp)
  2087. mov(eax,2)
  2088. mul(eax,3)
  2089. mov(ptr[ebp-10],eax)
  2090. dec(esp)
  2091. pushlea(ptr[ebp-11])
  2092. push(ptr[ebp-10])
  2093. mov(ecx,ptr[ebp-1])
  2094. call("func_t_dev::write(int)")
  2095. mov(ecx,ptr[ebp-1])
  2096. add(esp,2)
  2097. inc(esp)
  2098. dec(esp)
  2099. mov(ptr[ebp-11],0)
  2100. jmp("for_8006::condition")
  2101. label("for_8006::continue") //2100
  2102. inc(ptr[ebp-11])
  2103. label("for_8006::condition") //2102
  2104. mov(eax,ptr[ebp-11])
  2105. less(eax,ptr[ebp-10])
  2106. jz("for_8006::break",eax)
  2107. dec(esp)
  2108. pushlea(ptr[ebp-12])
  2109. push(ptr[ebp-11])
  2110. mov(ecx,ptr[ebp-1])
  2111. call("func_t_dev::write(int)")
  2112. mov(ecx,ptr[ebp-1])
  2113. add(esp,2)
  2114. inc(esp)
  2115. jmp("for_8006::continue")
  2116. label("for_8006::break") //2115
  2117. inc(esp)
  2118. inc(esp)
  2119. add(esp,2)
  2120. inc(esp)
  2121. inc(esp)
  2122. inc(esp)
  2123. inc(esp)
  2124. inc(esp)
  2125. inc(esp)
  2126. inc(esp)
  2127. label("func_t_dev::write_def(vec2i)::ret") //2126
  2128. mov(esp,ebp)
  2129. pop(ebp)
  2130. ret()
  2131. label("func_t_dev::`ctor()") //2130
  2132. push(ebp)
  2133. mov(ebp,esp)
  2134. dec(esp)
  2135. mov(ptr[ebp-1],ecx)
  2136. mov(ptr[ecx+0],0)
  2137. inc(esp)
  2138. label("func_t_dev::`ctor()::ret") //2137
  2139. mov(esp,ebp)
  2140. pop(ebp)
  2141. ret()
  2142. label("func_t_mem::`ctor()") //2141
  2143. push(ebp)
  2144. mov(ebp,esp)
  2145. dec(esp)
  2146. mov(ptr[ebp-1],ecx)
  2147. mov(ptr[ecx+0],0)
  2148. mov(ptr[ecx+1],0)
  2149. inc(esp)
  2150. label("func_t_mem::`ctor()::ret") //2149
  2151. mov(esp,ebp)
  2152. pop(ebp)
  2153. ret()
  2154. label("func_cr_test(t_input)") //2153
  2155. push(ebp)
  2156. mov(ebp,esp)
  2157. dec(esp)
  2158. mov(eax,1024)
  2159. push(eax)
  2160. mov(eax,64)
  2161. add(eax,8)
  2162. mov(ebx,eax)
  2163. pop(eax)
  2164. mul(eax,ebx)
  2165. mov(ptr[ebp-1],eax)
  2166. dec(esp)
  2167. lea(ecx,ptr[ebp-2])
  2168. call("func_t_dev::`ctor()")
  2169. mov(ebx,ptr[ebp-1])
  2170. mov(ptr[ebp-2],ebx)
  2171. sub(esp,2)
  2172. push(ptr[ebp+3])
  2173. push(ptr[ebp+2])
  2174. pop(ptr[ebp-4])
  2175. pop(ptr[ebp-3])
  2176. sub(esp,5)
  2177. sub(esp,5)
  2178. pushlea(ptr[ebp-14])
  2179. push(16)
  2180. call("func_new_geom(int)")
  2181. add(esp,2)
  2182. push(ptr[ebp-10])
  2183. push(ptr[ebp-11])
  2184. push(ptr[ebp-12])
  2185. push(ptr[ebp-13])
  2186. push(ptr[ebp-14])
  2187. pop(ptr[ebp-9])
  2188. pop(ptr[ebp-8])
  2189. pop(ptr[ebp-7])
  2190. pop(ptr[ebp-6])
  2191. pop(ptr[ebp-5])
  2192. add(esp,5)
  2193. push(eax)
  2194. mov(eax,255)
  2195. shl(eax,24)
  2196. mov(eax,eax)
  2197. push(eax)
  2198. mov(eax,128)
  2199. shl(eax,8)
  2200. mov(ebx,eax)
  2201. pop(eax)
  2202. add(eax,ebx)
  2203. mov(ebx,eax)
  2204. pop(eax)
  2205. mov(ptr[ebp-5],ebx)
  2206. jz("if_1004::else",1)
  2207. sub(esp,5)
  2208. sub(esp,5)
  2209. pushlea(ptr[ebp-19])
  2210. push(ptr[ebp-4])
  2211. push(ptr[ebp-3])
  2212. push(30)
  2213. push(30)
  2214. lea(ecx,ptr[ebp-9])
  2215. call("func_t_out_dev::GenGeomQuad(int,int,int,int)")
  2216. add(esp,5)
  2217. push(ptr[ebp-15])
  2218. push(ptr[ebp-16])
  2219. push(ptr[ebp-17])
  2220. push(ptr[ebp-18])
  2221. push(ptr[ebp-19])
  2222. pop(ptr[ebp-14])
  2223. pop(ptr[ebp-13])
  2224. pop(ptr[ebp-12])
  2225. pop(ptr[ebp-11])
  2226. pop(ptr[ebp-10])
  2227. add(esp,5)
  2228. push(eax)
  2229. mov(eax,255)
  2230. shl(eax,24)
  2231. mov(eax,eax)
  2232. push(eax)
  2233. mov(eax,128)
  2234. shl(eax,8)
  2235. mov(ebx,eax)
  2236. pop(eax)
  2237. add(eax,ebx)
  2238. push(eax)
  2239. mov(eax,255)
  2240. shl(eax,16)
  2241. mov(ebx,eax)
  2242. pop(eax)
  2243. add(eax,ebx)
  2244. mov(ebx,eax)
  2245. pop(eax)
  2246. mov(ptr[ebp-5],ebx)
  2247. sub(esp,5)
  2248. dec(esp)
  2249. sub(esp,5)
  2250. mov(eax,ptr[ebp-3])
  2251. sub(eax,64)
  2252. mov(ptr[ebp-20],eax)
  2253. pushlea(ptr[ebp-25])
  2254. push(ptr[ebp-4])
  2255. push(ptr[ebp-20])
  2256. push(100)
  2257. push(10)
  2258. lea(ecx,ptr[ebp-9])
  2259. call("func_t_out_dev::GenGeomQuad(int,int,int,int)")
  2260. add(esp,5)
  2261. push(ptr[ebp-21])
  2262. push(ptr[ebp-22])
  2263. push(ptr[ebp-23])
  2264. push(ptr[ebp-24])
  2265. push(ptr[ebp-25])
  2266. pop(ptr[ebp-19])
  2267. pop(ptr[ebp-18])
  2268. pop(ptr[ebp-17])
  2269. pop(ptr[ebp-16])
  2270. pop(ptr[ebp-15])
  2271. add(esp,5)
  2272. inc(esp)
  2273. sub(esp,5)
  2274. dec(esp)
  2275. sub(esp,5)
  2276. mov(eax,200)
  2277. add(eax,ptr[ebp-4])
  2278. mov(ptr[ebp-25],eax)
  2279. pushlea(ptr[ebp-30])
  2280. push(ptr[ebp-25])
  2281. push(ptr[ebp-3])
  2282. push(10)
  2283. push(60)
  2284. lea(ecx,ptr[ebp-9])
  2285. call("func_t_out_dev::GenGeomQuad(int,int,int,int)")
  2286. add(esp,5)
  2287. push(ptr[ebp-26])
  2288. push(ptr[ebp-27])
  2289. push(ptr[ebp-28])
  2290. push(ptr[ebp-29])
  2291. push(ptr[ebp-30])
  2292. pop(ptr[ebp-24])
  2293. pop(ptr[ebp-23])
  2294. pop(ptr[ebp-22])
  2295. pop(ptr[ebp-21])
  2296. pop(ptr[ebp-20])
  2297. add(esp,5)
  2298. inc(esp)
  2299. dec(esp)
  2300. dec(esp)
  2301. dec(esp)
  2302. pushlea(ptr[ebp-25])
  2303. lea(ecx,ptr[ebp-12])
  2304. call("func_vector_int::back()")
  2305. add(esp,1)
  2306. mov(eax,ptr[ebp-25])
  2307. less(eax,1024)
  2308. mov(ptr[ebp-26],eax)
  2309. pushlea(ptr[ebp-27])
  2310. push(ptr[ebp-26])
  2311. call("func_QapAssert(int)")
  2312. add(esp,2)
  2313. inc(esp)
  2314. inc(esp)
  2315. inc(esp)
  2316. dec(esp)
  2317. dec(esp)
  2318. dec(esp)
  2319. pushlea(ptr[ebp-25])
  2320. lea(ecx,ptr[ebp-17])
  2321. call("func_vector_int::back()")
  2322. add(esp,1)
  2323. mov(eax,ptr[ebp-25])
  2324. less(eax,1024)
  2325. mov(ptr[ebp-26],eax)
  2326. pushlea(ptr[ebp-27])
  2327. push(ptr[ebp-26])
  2328. call("func_QapAssert(int)")
  2329. add(esp,2)
  2330. inc(esp)
  2331. inc(esp)
  2332. inc(esp)
  2333. dec(esp)
  2334. dec(esp)
  2335. dec(esp)
  2336. pushlea(ptr[ebp-25])
  2337. lea(ecx,ptr[ebp-22])
  2338. call("func_vector_int::back()")
  2339. add(esp,1)
  2340. mov(eax,ptr[ebp-25])
  2341. less(eax,1024)
  2342. mov(ptr[ebp-26],eax)
  2343. pushlea(ptr[ebp-27])
  2344. push(ptr[ebp-26])
  2345. call("func_QapAssert(int)")
  2346. add(esp,2)
  2347. inc(esp)
  2348. inc(esp)
  2349. inc(esp)
  2350. sub(esp,2)
  2351. sub(esp,2)
  2352. pushlea(ptr[ebp-28])
  2353. push(0)
  2354. push(0)
  2355. call("func_vec2i(int,int)")
  2356. add(esp,3)
  2357. push(ptr[ebp-27])
  2358. push(ptr[ebp-28])
  2359. pop(ptr[ebp-26])
  2360. pop(ptr[ebp-25])
  2361. add(esp,2)
  2362. dec(esp)
  2363. pushlea(ptr[ebp-27])
  2364. push(ptr[ebp-10])
  2365. push(ptr[ebp-11])
  2366. push(ptr[ebp-12])
  2367. push(ptr[ebp-13])
  2368. push(ptr[ebp-14])
  2369. push(ptr[ebp-25])
  2370. push(ptr[ebp-26])
  2371. lea(ecx,ptr[ebp-9])
  2372. call("func_t_out_dev::add_with_offset(t_out_dev,vec2i)")
  2373. add(esp,8)
  2374. inc(esp)
  2375. dec(esp)
  2376. dec(esp)
  2377. dec(esp)
  2378. pushlea(ptr[ebp-27])
  2379. lea(ecx,ptr[ebp-7])
  2380. call("func_vector_int::back()")
  2381. add(esp,1)
  2382. mov(eax,ptr[ebp-27])
  2383. less(eax,1024)
  2384. mov(ptr[ebp-28],eax)
  2385. pushlea(ptr[ebp-29])
  2386. push(ptr[ebp-28])
  2387. call("func_QapAssert(int)")
  2388. add(esp,2)
  2389. inc(esp)
  2390. inc(esp)
  2391. inc(esp)
  2392. dec(esp)
  2393. pushlea(ptr[ebp-27])
  2394. push(ptr[ebp-15])
  2395. push(ptr[ebp-16])
  2396. push(ptr[ebp-17])
  2397. push(ptr[ebp-18])
  2398. push(ptr[ebp-19])
  2399. push(ptr[ebp-25])
  2400. push(ptr[ebp-26])
  2401. lea(ecx,ptr[ebp-9])
  2402. call("func_t_out_dev::add_with_offset(t_out_dev,vec2i)")
  2403. add(esp,8)
  2404. inc(esp)
  2405. dec(esp)
  2406. dec(esp)
  2407. dec(esp)
  2408. pushlea(ptr[ebp-27])
  2409. lea(ecx,ptr[ebp-7])
  2410. call("func_vector_int::back()")
  2411. add(esp,1)
  2412. mov(eax,ptr[ebp-27])
  2413. less(eax,1024)
  2414. mov(ptr[ebp-28],eax)
  2415. pushlea(ptr[ebp-29])
  2416. push(ptr[ebp-28])
  2417. call("func_QapAssert(int)")
  2418. add(esp,2)
  2419. inc(esp)
  2420. inc(esp)
  2421. inc(esp)
  2422. dec(esp)
  2423. pushlea(ptr[ebp-27])
  2424. push(ptr[ebp-20])
  2425. push(ptr[ebp-21])
  2426. push(ptr[ebp-22])
  2427. push(ptr[ebp-23])
  2428. push(ptr[ebp-24])
  2429. push(ptr[ebp-25])
  2430. push(ptr[ebp-26])
  2431. lea(ecx,ptr[ebp-9])
  2432. call("func_t_out_dev::add_with_offset(t_out_dev,vec2i)")
  2433. add(esp,8)
  2434. inc(esp)
  2435. dec(esp)
  2436. dec(esp)
  2437. dec(esp)
  2438. pushlea(ptr[ebp-27])
  2439. lea(ecx,ptr[ebp-7])
  2440. call("func_vector_int::back()")
  2441. add(esp,1)
  2442. mov(eax,ptr[ebp-27])
  2443. less(eax,1024)
  2444. mov(ptr[ebp-28],eax)
  2445. pushlea(ptr[ebp-29])
  2446. push(ptr[ebp-28])
  2447. call("func_QapAssert(int)")
  2448. add(esp,2)
  2449. inc(esp)
  2450. inc(esp)
  2451. inc(esp)
  2452. dec(esp)
  2453. pushlea(ptr[ebp-27])
  2454. push(ptr[ebp-5])
  2455. push(ptr[ebp-6])
  2456. push(ptr[ebp-7])
  2457. push(ptr[ebp-8])
  2458. push(ptr[ebp-9])
  2459. lea(ecx,ptr[ebp-2])
  2460. call("func_t_dev::write(t_out_dev)")
  2461. add(esp,6)
  2462. inc(esp)
  2463. add(esp,2)
  2464. add(esp,5)
  2465. add(esp,5)
  2466. add(esp,5)
  2467. jmp("if_1004::end")
  2468. label("if_1004::else") //2467
  2469. sub(esp,5)
  2470. pushlea(ptr[ebp-14])
  2471. push(ptr[ebp-4])
  2472. push(ptr[ebp-3])
  2473. push(30)
  2474. push(30)
  2475. lea(ecx,ptr[ebp-9])
  2476. call("func_t_out_dev::GenGeomQuad(int,int,int,int)")
  2477. add(esp,5)
  2478. push(ptr[ebp-10])
  2479. push(ptr[ebp-11])
  2480. push(ptr[ebp-12])
  2481. push(ptr[ebp-13])
  2482. push(ptr[ebp-14])
  2483. pop(ptr[ebp-9])
  2484. pop(ptr[ebp-8])
  2485. pop(ptr[ebp-7])
  2486. pop(ptr[ebp-6])
  2487. pop(ptr[ebp-5])
  2488. add(esp,5)
  2489. dec(esp)
  2490. pushlea(ptr[ebp-10])
  2491. push(ptr[ebp-5])
  2492. push(ptr[ebp-6])
  2493. push(ptr[ebp-7])
  2494. push(ptr[ebp-8])
  2495. push(ptr[ebp-9])
  2496. lea(ecx,ptr[ebp-2])
  2497. call("func_t_dev::write(t_out_dev)")
  2498. add(esp,6)
  2499. inc(esp)
  2500. label("if_1004::end") //2499
  2501. sub(esp,2)
  2502. lea(ecx,ptr[ebp-11])
  2503. call("func_t_mem::`ctor()")
  2504. mov(ebx,ptr[ebp-1])
  2505. mov(ptr[ebp-11],ebx)
  2506. push(eax)
  2507. mov(eax,ptr[ebp-2])
  2508. sub(eax,ptr[ebp-11])
  2509. mov(ebx,eax)
  2510. pop(eax)
  2511. mov(ptr[ebp-10],ebx)
  2512. mov(edx,ptr[ebp+9])
  2513. push(ptr[ebp-10])
  2514. push(ptr[ebp-11])
  2515. pop(ptr[edx+0])
  2516. pop(ptr[edx+1])
  2517. jmp("func_cr_test(t_input)::ret")
  2518. add(esp,2)
  2519. add(esp,5)
  2520. add(esp,2)
  2521. inc(esp)
  2522. inc(esp)
  2523. label("func_cr_test(t_input)::ret") //2522
  2524. mov(esp,ebp)
  2525. pop(ebp)
  2526. ret()
  2527. label("func_main(int)") //2526
  2528. push(ebp)
  2529. mov(ebp,esp)
  2530. dec(esp)
  2531. dec(esp)
  2532. pushlea(ptr[ebp-1])
  2533. call("func_g_ptr_addr()")
  2534. add(esp,1)
  2535. pushlea(ptr[ebp-2])
  2536. push(ptr[ebp-1])
  2537. push(0)
  2538. call("func_set_int(int,int)")
  2539. add(esp,3)
  2540. inc(esp)
  2541. inc(esp)
  2542. sub(esp,7)
  2543. lea(ecx,ptr[ebp-7])
  2544. call("func_t_input::`ctor()")
  2545. dec(esp)
  2546. lea(ecx,ptr[ebp-8])
  2547. call("func_t_dev::`ctor()")
  2548. mov(ebx,ptr[ebp+2])
  2549. mov(ptr[ebp-8],ebx)
  2550. sub(esp,2)
  2551. pushlea(ptr[ebp-10])
  2552. lea(ecx,ptr[ebp-8])
  2553. call("func_t_dev::read_vec2i()")
  2554. add(esp,1)
  2555. push(ptr[ebp-9])
  2556. push(ptr[ebp-10])
  2557. pop(ptr[ebp-7])
  2558. pop(ptr[ebp-6])
  2559. add(esp,2)
  2560. dec(esp)
  2561. pushlea(ptr[ebp-9])
  2562. lea(ecx,ptr[ebp-8])
  2563. call("func_t_dev::read_int()")
  2564. add(esp,1)
  2565. mov(ebx,ptr[ebp-9])
  2566. mov(ptr[ebp-5],ebx)
  2567. inc(esp)
  2568. sub(esp,2)
  2569. pushlea(ptr[ebp-10])
  2570. lea(ecx,ptr[ebp-8])
  2571. call("func_t_dev::read_vector_int()")
  2572. add(esp,1)
  2573. push(ptr[ebp-9])
  2574. push(ptr[ebp-10])
  2575. pop(ptr[ebp-4])
  2576. pop(ptr[ebp-3])
  2577. add(esp,2)
  2578. sub(esp,2)
  2579. pushlea(ptr[ebp-10])
  2580. lea(ecx,ptr[ebp-8])
  2581. call("func_t_dev::read_vector_int()")
  2582. add(esp,1)
  2583. push(ptr[ebp-9])
  2584. push(ptr[ebp-10])
  2585. pop(ptr[ebp-2])
  2586. pop(ptr[ebp-1])
  2587. add(esp,2)
  2588. sub(esp,2)
  2589. sub(esp,2)
  2590. pushlea(ptr[ebp-12])
  2591. push(ptr[ebp-1])
  2592. push(ptr[ebp-2])
  2593. push(ptr[ebp-3])
  2594. push(ptr[ebp-4])
  2595. push(ptr[ebp-5])
  2596. push(ptr[ebp-6])
  2597. push(ptr[ebp-7])
  2598. call("func_cr_test(t_input)")
  2599. add(esp,8)
  2600. push(ptr[ebp-11])
  2601. push(ptr[ebp-12])
  2602. pop(ptr[ebp-10])
  2603. pop(ptr[ebp-9])
  2604. add(esp,2)
  2605. dec(esp)
  2606. pushlea(ptr[ebp-11])
  2607. push(ptr[ebp-9])
  2608. call("func_setebx(int)")
  2609. add(esp,2)
  2610. inc(esp)
  2611. mov(ecx,1)
  2612. mov(edx,ptr[ebp+3])
  2613. push(ptr[ebp-10])
  2614. pop(ptr[edx+0])
  2615. jmp("func_main(int)::ret")
  2616. add(esp,2)
  2617. inc(esp)
  2618. add(esp,7)
  2619. label("func_main(int)::ret") //2618
  2620. mov(esp,ebp)
  2621. pop(ebp)
  2622. ret()
  2623. label("begin") //2622
  2624. dec(esp)
  2625. pushlea(ptr[ebp-1])
  2626. push(ecx)
  2627. call("func_main(int)")
  2628. add(esp,2)
  2629. mov(eax,ptr[ebp-1])
  2630. inc(esp)
  2631. mov(err,1)
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement