home *** CD-ROM | disk | FTP | other *** search
/ Amiga ACS 1998 #4 / amigaacscoverdisc1998-041998.iso / utilities / shareware / dev / ppcsmalleiffel / source.lha / bin_c / compile_to_jvm10.c < prev    next >
Encoding:
C/C++ Source or Header  |  1998-01-16  |  30.9 KB  |  1,044 lines
  1. /*
  2. -- ANSI C code generated by :
  3. -- SmallEiffel The GNU Eiffel Compiler -- Release (- 0.82)      --
  4. -- Copyright (C), 1994-98 - LORIA - UHP - CRIN - INRIA - FRANCE --
  5. -- Dominique COLNET and Suzanne COLLIN -    colnet@loria.fr     --
  6. --                 http://www.loria.fr/SmallEiffel              --
  7. */
  8. #include "compile_to_jvm.h"
  9. /*No:ARRAY[BOOLEAN].clear_all*/
  10. /*No:ARRAY[BOOLEAN].set_all_with*/
  11. void r353force(T353* C,int a1,int a2){
  12. /*IF*/if (((((T353*)C))->_upper/*8*/)<(a2)) {
  13. r353resize(C,(((T353*)C))->_lower/*12*/,a2);
  14. }
  15.  else if ((a2)<((((T353*)C))->_lower/*12*/)) {
  16. r353resize(C,a2,(((T353*)C))->_upper/*8*/);
  17. }
  18. /*FI*//*[IRF3.6put*/{T353* C1=C;
  19. int b1=a1;
  20. int b2=a2;
  21. ((((T353*)C1))->_storage/*0*/)[(b2)-((((T353*)C1))->_lower/*12*/)]=(b1);
  22. }/*]*/
  23. }
  24. void r353make(T353* C,int a1,int a2){
  25. int _needed=0;
  26. C->_lower=a1;
  27. C->_upper=a2;
  28. _needed=((a2)-(a1))+(1);
  29. /*IF*/if ((_needed)>(0)) {
  30. /*IF*/if (((((T353*)C))->_capacity/*4*/)<(_needed)) {
  31. /*IF*/if (((((T353*)C))->_capacity/*4*/)==(0)) {
  32. C->_storage=calloc(_needed,sizeof(int));
  33. }
  34. else {
  35. C->_storage=calloc(_needed,sizeof(int));
  36. }
  37. /*FI*/C->_capacity=_needed;
  38. }
  39. else {
  40. /*[IRF3.6clear_all*/{T353* C1=C;
  41. int __value=0;
  42. /*[IRF3.6set_all_with*/{T353* C2=C1;
  43. int c1=__value;
  44. r593set_all_with((((T353*)C2))->_storage/*0*/,c1,((((T353*)C2))->_upper/*8*/)-((((T353*)C2))->_lower/*12*/));
  45. }/*]*/
  46. }/*]*/
  47. }
  48. /*FI*/}
  49. /*FI*/}
  50. int r353item(T353* C,int a1){
  51. int R=0;
  52. R=((((T353*)C))->_storage/*0*/)[(a1)-((((T353*)C))->_lower/*12*/)];
  53. return R;
  54. }
  55. void r353resize(T353* C,int a1,int a2){
  56. int _mem=0;
  57. int _up=0;
  58. int _i=0;
  59. T0* _other=NULL;
  60. {T353*n=malloc(sizeof(*n));
  61. *n=M353;
  62. r353make(n,a1,a2);
  63. _other=(T0*)n;
  64. }
  65. _i=r2max((((T353*)C))->_lower/*12*/,(((T353*)((T353*)_other)))->_lower/*12*/);
  66. _up=r2min((((T353*)C))->_upper/*8*/,(((T353*)((T353*)_other)))->_upper/*8*/);
  67. while (!((_i)>(_up))) {
  68. /*[IRF3.6put*/{T353* C1=((T353*)_other);
  69. int b1=r353item(C,_i);
  70. int b2=_i;
  71. ((((T353*)C1))->_storage/*0*/)[(b2)-((((T353*)C1))->_lower/*12*/)]=(b1);
  72. }/*]*/
  73. _i=(_i)+(1);
  74. }
  75. *((T353*)(C))=*((T353*)(_other));
  76. }
  77. /*No:ARRAY[BOOLEAN].storage*/
  78. /*No:ARRAY[BOOLEAN].capacity*/
  79. /*No:ARRAY[BOOLEAN].lower*/
  80. /*No:ARRAY[BOOLEAN].put*/
  81. /*No:ARRAY[BOOLEAN].upper*/
  82. int r353valid_index(T353* C,int a1){
  83. int R=0;
  84. R=(((((T353*)C))->_lower/*12*/)<=(a1))&&((a1)<=((((T353*)C))->_upper/*8*/));
  85. return R;
  86. }
  87. void r353set_slice_with(T353* C,int a1,int a2,int a3){
  88. int _i=0;
  89. _i=a2;
  90. while (!((_i)>(a3))) {
  91. /*[IRF3.6put*/{T353* C1=C;
  92. int b1=a1;
  93. int b2=_i;
  94. ((((T353*)C1))->_storage/*0*/)[(b2)-((((T353*)C1))->_lower/*12*/)]=(b1);
  95. }/*]*/
  96. _i=(_i)+(1);
  97. }
  98. }
  99. /*No:FIXED_ARRAY[MANIFEST_STRING].clear_all*/
  100. /*No:FIXED_ARRAY[MANIFEST_STRING].set_all_with*/
  101. int r269empty(T269* C){
  102. int R=0;
  103. R=(/*(IRF4.6count*/((((T269*)C))->_upper/*12*/)+(1)/*)*/)==(0);
  104. return R;
  105. }
  106. void r269make(T269* C,int a1){
  107. /*IF*/if ((a1)==(0)) {
  108. C->_upper=-(1);
  109. }
  110.  else if (((((T269*)C))->_capacity/*8*/)==(0)) {
  111. C->_storage=calloc(a1,sizeof(T0*));
  112. C->_capacity=a1;
  113. C->_upper=(a1)-(1);
  114. }
  115.  else if (((((T269*)C))->_capacity/*8*/)<(a1)) {
  116. C->_storage=calloc(a1,sizeof(T0*));
  117. C->_capacity=a1;
  118. C->_upper=(a1)-(1);
  119. }
  120. else {
  121. C->_upper=(a1)-(1);
  122. /*[IRF3.6clear_all*/{T269* C1=C;
  123. T0* __value=NULL;
  124. /*[IRF3.6set_all_with*/{T269* C2=C1;
  125. T0* c1=__value;
  126. r729set_all_with((((T269*)C2))->_storage/*4*/,c1,(((T269*)C2))->_upper/*12*/);
  127. }/*]*/
  128. }/*]*/
  129. }
  130. /*FI*/}
  131. int r269fast_has(T269* C,T0* a1){
  132. int R=0;
  133. /*IF*/if ((/*(IRF4.6count*/((((T269*)C))->_upper/*12*/)+(1)/*)*/)>(0)) {
  134. R=(r269fast_index_of(C,a1))<=((((T269*)C))->_upper/*12*/);
  135. }
  136. /*FI*/return R;
  137. }
  138. /*No:FIXED_ARRAY[MANIFEST_STRING].item*/
  139. void r269resize(T269* C,int a1){
  140. T0* _elt_default=NULL;
  141. int _i=0;
  142. int _new_capacity=0;
  143. /*IF*/if ((a1)<=(/*(IRF4.6count*/((((T269*)C))->_upper/*12*/)+(1)/*)*/)) {
  144. C->_upper=(a1)-(1);
  145. }
  146. else {
  147. _new_capacity=a1;
  148. /*IF*/if (((((T269*)C))->_capacity/*8*/)<(_new_capacity)) {
  149. /*IF*/if (((((T269*)C))->_capacity/*8*/)==(0)) {
  150. C->_storage=calloc(_new_capacity,sizeof(T0*));
  151. }
  152. else {
  153. C->_storage=r729realloc((((T269*)C))->_storage/*4*/,(((T269*)C))->_capacity/*8*/,_new_capacity);
  154. }
  155. /*FI*/C->_capacity=_new_capacity;
  156. }
  157. /*FI*/_new_capacity=(((T269*)C))->_upper/*12*/;
  158. C->_upper=(a1)-(1);
  159. _i=(((T269*)C))->_upper/*12*/;
  160. while (!((_i)==(_new_capacity))) {
  161. /*[IRF3.5put*/((((T269*)C))->_storage/*4*/)[_i]=(_elt_default);
  162. /*]*/
  163. _i=(_i)-(1);
  164. }
  165. }
  166. /*FI*/}
  167. /*No:FIXED_ARRAY[MANIFEST_STRING].storage*/
  168. /*No:FIXED_ARRAY[MANIFEST_STRING].capacity*/
  169. void r269with_capacity(T269* C,int a1){
  170. /*IF*/if (((((T269*)C))->_capacity/*8*/)<(a1)) {
  171. C->_storage=calloc(a1,sizeof(T0*));
  172. C->_capacity=a1;
  173. }
  174. /*FI*/C->_upper=-(1);
  175. }
  176. int r269fast_index_of(T269* C,T0* a1){
  177. int R=0;
  178. R=r729fast_index_of((((T269*)C))->_storage/*4*/,a1,(((T269*)C))->_upper/*12*/);
  179. return R;
  180. }
  181. /*No:FIXED_ARRAY[MANIFEST_STRING].put*/
  182. /*No:FIXED_ARRAY[MANIFEST_STRING].upper*/
  183. void r269add_last(T269* C,T0* a1){
  184. int _new_capacity=0;
  185. /*IF*/if ((((((T269*)C))->_upper/*12*/)+(1))<=(((((T269*)C))->_capacity/*8*/)-(1))) {
  186. C->_upper=((((T269*)C))->_upper/*12*/)+(1);
  187. }
  188.  else if (((((T269*)C))->_capacity/*8*/)==(0)) {
  189. C->_storage=calloc(2,sizeof(T0*));
  190. C->_capacity=2;
  191. C->_upper=0;
  192. }
  193. else {
  194. _new_capacity=(2)*((((T269*)C))->_capacity/*8*/);
  195. C->_storage=r729realloc((((T269*)C))->_storage/*4*/,(((T269*)C))->_capacity/*8*/,_new_capacity);
  196. C->_capacity=_new_capacity;
  197. C->_upper=((((T269*)C))->_upper/*12*/)+(1);
  198. }
  199. /*FI*//*[IRF3.5put*/((((T269*)C))->_storage/*4*/)[(((T269*)C))->_upper/*12*/]=(a1);
  200. /*]*/
  201. }
  202. /*No:FIXED_ARRAY[MANIFEST_STRING].count*/
  203. /*No:FIXED_ARRAY[RUN_CLASS].storage*/
  204. /*No:FIXED_ARRAY[RUN_CLASS].capacity*/
  205. void r187with_capacity(T187* C,int a1){
  206. /*IF*/if (((((T187*)C))->_capacity/*4*/)<(a1)) {
  207. C->_storage=calloc(a1,sizeof(T0*));
  208. C->_capacity=a1;
  209. }
  210. /*FI*/C->_upper=-(1);
  211. }
  212. int r187fast_index_of(T187* C,T0* a1){
  213. int R=0;
  214. R=r659fast_index_of((((T187*)C))->_storage/*0*/,a1,(((T187*)C))->_upper/*8*/);
  215. return R;
  216. }
  217. /*No:FIXED_ARRAY[RUN_CLASS].put*/
  218. /*No:FIXED_ARRAY[RUN_CLASS].upper*/
  219. void r187add_last(T187* C,T0* a1){
  220. int _new_capacity=0;
  221. /*IF*/if ((((((T187*)C))->_upper/*8*/)+(1))<=(((((T187*)C))->_capacity/*4*/)-(1))) {
  222. C->_upper=((((T187*)C))->_upper/*8*/)+(1);
  223. }
  224.  else if (((((T187*)C))->_capacity/*4*/)==(0)) {
  225. C->_storage=calloc(2,sizeof(T0*));
  226. C->_capacity=2;
  227. C->_upper=0;
  228. }
  229. else {
  230. _new_capacity=(2)*((((T187*)C))->_capacity/*4*/);
  231. C->_storage=r659realloc((((T187*)C))->_storage/*0*/,(((T187*)C))->_capacity/*4*/,_new_capacity);
  232. C->_capacity=_new_capacity;
  233. C->_upper=((((T187*)C))->_upper/*8*/)+(1);
  234. }
  235. /*FI*//*[IRF3.5put*/((((T187*)C))->_storage/*0*/)[(((T187*)C))->_upper/*8*/]=(a1);
  236. /*]*/
  237. }
  238. T0* r419item(T419* C,int a1){
  239. T0* R=NULL;
  240. R=((((T419*)C))->_storage/*0*/)[(a1)-((((T419*)C))->_lower/*12*/)];
  241. return R;
  242. }
  243. /*No:ARRAY[INSTRUCTION].storage*/
  244. T0* r419twin(T419* C){
  245. T0* R=NULL;
  246. R=malloc(sizeof(*C));
  247. *((T419*)R)=M419;
  248. r419copy(((T419*)R),((T0*)C));
  249. return R;
  250. }
  251. /*No:ARRAY[INSTRUCTION].capacity*/
  252. void r419copy(T419* C,T0* a1){
  253. int _needed_capacity=0;
  254. C->_lower=(((T419*)((T419*)a1)))->_lower/*12*/;
  255. C->_upper=(((T419*)((T419*)a1)))->_upper/*8*/;
  256. _needed_capacity=(((((T419*)C))->_upper/*8*/)-((((T419*)C))->_lower/*12*/))+(1);
  257. /*IF*/if (((((T419*)C))->_capacity/*4*/)<(_needed_capacity)) {
  258. C->_capacity=_needed_capacity;
  259. C->_storage=calloc((((T419*)C))->_capacity/*4*/,sizeof(T0*));
  260. }
  261. /*FI*//*IF*/if ((_needed_capacity)>(0)) {
  262. r705copy_from((((T419*)C))->_storage/*0*/,(((T419*)((T419*)a1)))->_storage/*0*/,(_needed_capacity)-(1));
  263. }
  264. /*FI*/}
  265. /*No:ARRAY[INSTRUCTION].lower*/
  266. /*No:ARRAY[INSTRUCTION].put*/
  267. /*No:ARRAY[INSTRUCTION].upper*/
  268. int r419count(T419* C){
  269. int R=0;
  270. R=(((((T419*)C))->_upper/*8*/)-((((T419*)C))->_lower/*12*/))+(1);
  271. return R;
  272. }
  273. void r419add_last(T419* C,T0* a1){
  274. int _new_capacity=0;
  275. /*IF*/if (((((T419*)C))->_capacity/*4*/)<((r419count(C))+(1))) {
  276. /*IF*/if (((((T419*)C))->_capacity/*4*/)==(0)) {
  277. C->_capacity=16;
  278. C->_storage=calloc((((T419*)C))->_capacity/*4*/,sizeof(T0*));
  279. }
  280. else {
  281. _new_capacity=(2)*((((T419*)C))->_capacity/*4*/);
  282. C->_storage=r705realloc((((T419*)C))->_storage/*0*/,(((T419*)C))->_capacity/*4*/,_new_capacity);
  283. C->_capacity=_new_capacity;
  284. }
  285. /*FI*/}
  286. /*FI*/C->_upper=((((T419*)C))->_upper/*8*/)+(1);
  287. /*[IRF3.6put*/{T419* C1=C;
  288. T0* b1=a1;
  289. int b2=(((T419*)C))->_upper/*8*/;
  290. ((((T419*)C1))->_storage/*0*/)[(b2)-((((T419*)C1))->_lower/*12*/)]=(b1);
  291. }/*]*/
  292. }
  293. T0* r419first(T419* C){
  294. T0* R=NULL;
  295. R=r419item(C,(((T419*)C))->_lower/*12*/);
  296. return R;
  297. }
  298. T0* r901item(T901* C,int a1){
  299. T0* R=NULL;
  300. R=((((T901*)C))->_storage/*0*/)[(a1)-((((T901*)C))->_lower/*12*/)];
  301. return R;
  302. }
  303. /*No:ARRAY[CLASS_NAME].storage*/
  304. T0* r901twin(T901* C){
  305. T0* R=NULL;
  306. R=malloc(sizeof(*C));
  307. *((T901*)R)=M901;
  308. r901copy(((T901*)R),((T0*)C));
  309. return R;
  310. }
  311. /*No:ARRAY[CLASS_NAME].capacity*/
  312. void r901copy(T901* C,T0* a1){
  313. int _needed_capacity=0;
  314. C->_lower=(((T901*)((T901*)a1)))->_lower/*12*/;
  315. C->_upper=(((T901*)((T901*)a1)))->_upper/*8*/;
  316. _needed_capacity=(((((T901*)C))->_upper/*8*/)-((((T901*)C))->_lower/*12*/))+(1);
  317. /*IF*/if (((((T901*)C))->_capacity/*4*/)<(_needed_capacity)) {
  318. C->_capacity=_needed_capacity;
  319. C->_storage=calloc((((T901*)C))->_capacity/*4*/,sizeof(T0*));
  320. }
  321. /*FI*//*IF*/if ((_needed_capacity)>(0)) {
  322. r221copy_from((((T901*)C))->_storage/*0*/,(((T901*)((T901*)a1)))->_storage/*0*/,(_needed_capacity)-(1));
  323. }
  324. /*FI*/}
  325. /*No:ARRAY[CLASS_NAME].lower*/
  326. /*No:ARRAY[CLASS_NAME].put*/
  327. /*No:ARRAY[CLASS_NAME].upper*/
  328. int r901count(T901* C){
  329. int R=0;
  330. R=(((((T901*)C))->_upper/*8*/)-((((T901*)C))->_lower/*12*/))+(1);
  331. return R;
  332. }
  333. void r901add_last(T901* C,T0* a1){
  334. int _new_capacity=0;
  335. /*IF*/if (((((T901*)C))->_capacity/*4*/)<((r901count(C))+(1))) {
  336. /*IF*/if (((((T901*)C))->_capacity/*4*/)==(0)) {
  337. C->_capacity=16;
  338. C->_storage=calloc((((T901*)C))->_capacity/*4*/,sizeof(T0*));
  339. }
  340. else {
  341. _new_capacity=(2)*((((T901*)C))->_capacity/*4*/);
  342. C->_storage=r221realloc((((T901*)C))->_storage/*0*/,(((T901*)C))->_capacity/*4*/,_new_capacity);
  343. C->_capacity=_new_capacity;
  344. }
  345. /*FI*/}
  346. /*FI*/C->_upper=((((T901*)C))->_upper/*8*/)+(1);
  347. /*[IRF3.6put*/{T901* C1=C;
  348. T0* b1=a1;
  349. int b2=(((T901*)C))->_upper/*8*/;
  350. ((((T901*)C1))->_storage/*0*/)[(b2)-((((T901*)C1))->_lower/*12*/)]=(b1);
  351. }/*]*/
  352. }
  353. /*No:FIXED_ARRAY[STRING].clear_all*/
  354. /*No:FIXED_ARRAY[STRING].set_all_with*/
  355. void r927make(T927* C,int a1){
  356. /*IF*/if ((a1)==(0)) {
  357. C->_upper=-(1);
  358. }
  359.  else if (((((T927*)C))->_capacity/*4*/)==(0)) {
  360. C->_storage=calloc(a1,sizeof(T0*));
  361. C->_capacity=a1;
  362. C->_upper=(a1)-(1);
  363. }
  364.  else if (((((T927*)C))->_capacity/*4*/)<(a1)) {
  365. C->_storage=calloc(a1,sizeof(T0*));
  366. C->_capacity=a1;
  367. C->_upper=(a1)-(1);
  368. }
  369. else {
  370. C->_upper=(a1)-(1);
  371. /*[IRF3.6clear_all*/{T927* C1=C;
  372. T0* __value=NULL;
  373. /*[IRF3.6set_all_with*/{T927* C2=C1;
  374. T0* c1=__value;
  375. r400set_all_with((((T927*)C2))->_storage/*0*/,c1,(((T927*)C2))->_upper/*8*/);
  376. }/*]*/
  377. }/*]*/
  378. }
  379. /*FI*/}
  380. int r927fast_has(T927* C,T0* a1){
  381. int R=0;
  382. /*IF*/if ((/*(IRF4.6count*/((((T927*)C))->_upper/*8*/)+(1)/*)*/)>(0)) {
  383. R=(r927fast_index_of(C,a1))<=((((T927*)C))->_upper/*8*/);
  384. }
  385. /*FI*/return R;
  386. }
  387. /*No:FIXED_ARRAY[STRING].item*/
  388. /*No:FIXED_ARRAY[STRING].storage*/
  389. /*No:FIXED_ARRAY[STRING].capacity*/
  390. void r927with_capacity(T927* C,int a1){
  391. /*IF*/if (((((T927*)C))->_capacity/*4*/)<(a1)) {
  392. C->_storage=calloc(a1,sizeof(T0*));
  393. C->_capacity=a1;
  394. }
  395. /*FI*/C->_upper=-(1);
  396. }
  397. int r927fast_index_of(T927* C,T0* a1){
  398. int R=0;
  399. R=r400fast_index_of((((T927*)C))->_storage/*0*/,a1,(((T927*)C))->_upper/*8*/);
  400. return R;
  401. }
  402. /*No:FIXED_ARRAY[STRING].put*/
  403. /*No:FIXED_ARRAY[STRING].upper*/
  404. /*No:FIXED_ARRAY[STRING].count*/
  405. void r927add_last(T927* C,T0* a1){
  406. int _new_capacity=0;
  407. /*IF*/if ((((((T927*)C))->_upper/*8*/)+(1))<=(((((T927*)C))->_capacity/*4*/)-(1))) {
  408. C->_upper=((((T927*)C))->_upper/*8*/)+(1);
  409. }
  410.  else if (((((T927*)C))->_capacity/*4*/)==(0)) {
  411. C->_storage=calloc(2,sizeof(T0*));
  412. C->_capacity=2;
  413. C->_upper=0;
  414. }
  415. else {
  416. _new_capacity=(2)*((((T927*)C))->_capacity/*4*/);
  417. C->_storage=r400realloc((((T927*)C))->_storage/*0*/,(((T927*)C))->_capacity/*4*/,_new_capacity);
  418. C->_capacity=_new_capacity;
  419. C->_upper=((((T927*)C))->_upper/*8*/)+(1);
  420. }
  421. /*FI*//*[IRF3.5put*/((((T927*)C))->_storage/*0*/)[(((T927*)C))->_upper/*8*/]=(a1);
  422. /*]*/
  423. }
  424. /*No:ARRAY[RUN_CLASS].clear_all*/
  425. /*No:ARRAY[RUN_CLASS].set_all_with*/
  426. int r396empty(T396* C){
  427. int R=0;
  428. R=(r396count(C))==(0);
  429. return R;
  430. }
  431. void r396make(T396* C,int a1,int a2){
  432. int _needed=0;
  433. C->_lower=a1;
  434. C->_upper=a2;
  435. _needed=((a2)-(a1))+(1);
  436. /*IF*/if ((_needed)>(0)) {
  437. /*IF*/if (((((T396*)C))->_capacity/*4*/)<(_needed)) {
  438. /*IF*/if (((((T396*)C))->_capacity/*4*/)==(0)) {
  439. C->_storage=calloc(_needed,sizeof(T0*));
  440. }
  441. else {
  442. C->_storage=calloc(_needed,sizeof(T0*));
  443. }
  444. /*FI*/C->_capacity=_needed;
  445. }
  446. else {
  447. /*[IRF3.6clear_all*/{T396* C1=C;
  448. T0* __value=NULL;
  449. /*[IRF3.6set_all_with*/{T396* C2=C1;
  450. T0* c1=__value;
  451. r659set_all_with((((T396*)C2))->_storage/*0*/,c1,((((T396*)C2))->_upper/*8*/)-((((T396*)C2))->_lower/*12*/));
  452. }/*]*/
  453. }/*]*/
  454. }
  455. /*FI*/}
  456. /*FI*/}
  457. int r396fast_has(T396* C,T0* a1){
  458. int R=0;
  459. /*IF*/if ((r396count(C))>(0)) {
  460. R=(r396fast_index_of(C,a1))<=((((T396*)C))->_upper/*8*/);
  461. }
  462. /*FI*/return R;
  463. }
  464. T0* r396item(T396* C,int a1){
  465. T0* R=NULL;
  466. R=((((T396*)C))->_storage/*0*/)[(a1)-((((T396*)C))->_lower/*12*/)];
  467. return R;
  468. }
  469. void r396resize(T396* C,int a1,int a2){
  470. int _mem=0;
  471. int _up=0;
  472. int _i=0;
  473. T0* _other=NULL;
  474. {T396*n=malloc(sizeof(*n));
  475. *n=M396;
  476. r396make(n,a1,a2);
  477. _other=(T0*)n;
  478. }
  479. _i=r2max((((T396*)C))->_lower/*12*/,(((T396*)((T396*)_other)))->_lower/*12*/);
  480. _up=r2min((((T396*)C))->_upper/*8*/,(((T396*)((T396*)_other)))->_upper/*8*/);
  481. while (!((_i)>(_up))) {
  482. /*[IRF3.6put*/{T396* C1=((T396*)_other);
  483. T0* b1=r396item(C,_i);
  484. int b2=_i;
  485. ((((T396*)C1))->_storage/*0*/)[(b2)-((((T396*)C1))->_lower/*12*/)]=(b1);
  486. }/*]*/
  487. _i=(_i)+(1);
  488. }
  489. *((T396*)(C))=*((T396*)(_other));
  490. }
  491. /*No:ARRAY[RUN_CLASS].storage*/
  492. /*No:ARRAY[RUN_CLASS].capacity*/
  493. void r396copy(T396* C,T0* a1){
  494. int _needed_capacity=0;
  495. C->_lower=(((T396*)((T396*)a1)))->_lower/*12*/;
  496. C->_upper=(((T396*)((T396*)a1)))->_upper/*8*/;
  497. _needed_capacity=(((((T396*)C))->_upper/*8*/)-((((T396*)C))->_lower/*12*/))+(1);
  498. /*IF*/if (((((T396*)C))->_capacity/*4*/)<(_needed_capacity)) {
  499. C->_capacity=_needed_capacity;
  500. C->_storage=calloc((((T396*)C))->_capacity/*4*/,sizeof(T0*));
  501. }
  502. /*FI*//*IF*/if ((_needed_capacity)>(0)) {
  503. r659copy_from((((T396*)C))->_storage/*0*/,(((T396*)((T396*)a1)))->_storage/*0*/,(_needed_capacity)-(1));
  504. }
  505. /*FI*/}
  506. /*No:ARRAY[RUN_CLASS].lower*/
  507. void r396with_capacity(T396* C,int a1,int a2){
  508. /*IF*/if (((((T396*)C))->_capacity/*4*/)<(a1)) {
  509. C->_storage=calloc(a1,sizeof(T0*));
  510. C->_capacity=a1;
  511. }
  512. /*FI*/C->_lower=a2;
  513. C->_upper=(a2)-(1);
  514. }
  515. int r396fast_index_of(T396* C,T0* a1){
  516. int R=0;
  517. R=((((T396*)C))->_lower/*12*/)+(r659fast_index_of((((T396*)C))->_storage/*0*/,a1,((((T396*)C))->_upper/*8*/)-((((T396*)C))->_lower/*12*/)));
  518. return R;
  519. }
  520. /*No:ARRAY[RUN_CLASS].put*/
  521. /*No:ARRAY[RUN_CLASS].upper*/
  522. void r396add_last(T396* C,T0* a1){
  523. int _new_capacity=0;
  524. /*IF*/if (((((T396*)C))->_capacity/*4*/)<((r396count(C))+(1))) {
  525. /*IF*/if (((((T396*)C))->_capacity/*4*/)==(0)) {
  526. C->_capacity=16;
  527. C->_storage=calloc((((T396*)C))->_capacity/*4*/,sizeof(T0*));
  528. }
  529. else {
  530. _new_capacity=(2)*((((T396*)C))->_capacity/*4*/);
  531. C->_storage=r659realloc((((T396*)C))->_storage/*0*/,(((T396*)C))->_capacity/*4*/,_new_capacity);
  532. C->_capacity=_new_capacity;
  533. }
  534. /*FI*/}
  535. /*FI*/C->_upper=((((T396*)C))->_upper/*8*/)+(1);
  536. /*[IRF3.6put*/{T396* C1=C;
  537. T0* b1=a1;
  538. int b2=(((T396*)C))->_upper/*8*/;
  539. ((((T396*)C1))->_storage/*0*/)[(b2)-((((T396*)C1))->_lower/*12*/)]=(b1);
  540. }/*]*/
  541. }
  542. int r396count(T396* C){
  543. int R=0;
  544. R=(((((T396*)C))->_upper/*8*/)-((((T396*)C))->_lower/*12*/))+(1);
  545. return R;
  546. }
  547. T0* r396first(T396* C){
  548. T0* R=NULL;
  549. R=r396item(C,(((T396*)C))->_lower/*12*/);
  550. return R;
  551. }
  552. /*No:FIXED_ARRAY[EFFECTIVE_ARG_LIST].clear_all*/
  553. /*No:FIXED_ARRAY[EFFECTIVE_ARG_LIST].set_all_with*/
  554. void r374make(T374* C,int a1){
  555. /*IF*/if ((a1)==(0)) {
  556. C->_upper=-(1);
  557. }
  558.  else if (((((T374*)C))->_capacity/*4*/)==(0)) {
  559. C->_storage=calloc(a1,sizeof(T0*));
  560. C->_capacity=a1;
  561. C->_upper=(a1)-(1);
  562. }
  563.  else if (((((T374*)C))->_capacity/*4*/)<(a1)) {
  564. C->_storage=calloc(a1,sizeof(T0*));
  565. C->_capacity=a1;
  566. C->_upper=(a1)-(1);
  567. }
  568. else {
  569. C->_upper=(a1)-(1);
  570. /*[IRF3.6clear_all*/{T374* C1=C;
  571. T0* __value=NULL;
  572. /*[IRF3.6set_all_with*/{T374* C2=C1;
  573. T0* c1=__value;
  574. r857set_all_with((((T374*)C2))->_storage/*0*/,c1,(((T374*)C2))->_upper/*8*/);
  575. }/*]*/
  576. }/*]*/
  577. }
  578. /*FI*/}
  579. void r374resize(T374* C,int a1){
  580. T0* _elt_default=NULL;
  581. int _i=0;
  582. int _new_capacity=0;
  583. /*IF*/if ((a1)<=(/*(IRF4.6count*/((((T374*)C))->_upper/*8*/)+(1)/*)*/)) {
  584. C->_upper=(a1)-(1);
  585. }
  586. else {
  587. _new_capacity=a1;
  588. /*IF*/if (((((T374*)C))->_capacity/*4*/)<(_new_capacity)) {
  589. /*IF*/if (((((T374*)C))->_capacity/*4*/)==(0)) {
  590. C->_storage=calloc(_new_capacity,sizeof(T0*));
  591. }
  592. else {
  593. C->_storage=r857realloc((((T374*)C))->_storage/*0*/,(((T374*)C))->_capacity/*4*/,_new_capacity);
  594. }
  595. /*FI*/C->_capacity=_new_capacity;
  596. }
  597. /*FI*/_new_capacity=(((T374*)C))->_upper/*8*/;
  598. C->_upper=(a1)-(1);
  599. _i=(((T374*)C))->_upper/*8*/;
  600. while (!((_i)==(_new_capacity))) {
  601. /*[IRF3.5put*/((((T374*)C))->_storage/*0*/)[_i]=(_elt_default);
  602. /*]*/
  603. _i=(_i)-(1);
  604. }
  605. }
  606. /*FI*/}
  607. /*No:FIXED_ARRAY[EFFECTIVE_ARG_LIST].storage*/
  608. /*No:FIXED_ARRAY[EFFECTIVE_ARG_LIST].capacity*/
  609. /*No:FIXED_ARRAY[EFFECTIVE_ARG_LIST].put*/
  610. /*No:FIXED_ARRAY[EFFECTIVE_ARG_LIST].upper*/
  611. /*No:FIXED_ARRAY[EFFECTIVE_ARG_LIST].count*/
  612. T0* r794at(T794* C,T0* a1){
  613. T0* R=NULL;
  614. int _foo=0;
  615. _foo=r794has(C,a1);
  616. R=r52item(((T52*)((((T794*)C))->_store/*4*/)),(((T794*)C))->_has_mem/*24*/);
  617. return R;
  618. }
  619. void r794expand(T794* C){
  620. int _old_size=0;
  621. int _i=0;
  622. C->_item_mem=0;
  623. _old_size=r52count(((T52*)((((T794*)C))->_store/*4*/)));
  624. r429resize(((T429*)((((T794*)C))->_chain/*12*/)),1,(2)*(_old_size));
  625. r52resize(((T52*)((((T794*)C))->_keys/*0*/)),1,(2)*(_old_size));
  626. r52resize(((T52*)((((T794*)C))->_store/*4*/)),1,(2)*(_old_size));
  627. _i=(_old_size)+(1);
  628. while (!((_i)==(r429count(((T429*)((((T794*)C))->_chain/*12*/)))))) {
  629. /*[IRF3.6put*/{T429* C1=((T429*)((((T794*)C))->_chain/*12*/));
  630. int b1=(_i)+(1);
  631. int b2=_i;
  632. ((((T429*)C1))->_storage/*0*/)[(b2)-((((T429*)C1))->_lower/*12*/)]=(b1);
  633. }/*]*/
  634. _i=(_i)+(1);
  635. }
  636. /*[IRF3.6put*/{T429* C1=((T429*)((((T794*)C))->_chain/*12*/));
  637. int b1=(((T794*)C))->_free/*16*/;
  638. int b2=_i;
  639. ((((T429*)C1))->_storage/*0*/)[(b2)-((((T429*)C1))->_lower/*12*/)]=(b1);
  640. }/*]*/
  641. C->_free=(_old_size)+(1);
  642. }
  643. T0*oBC672tmp_buckets=NULL;
  644. /*No:DICTIONARY[STRING,STRING].free*/
  645. void r794make(T794* C){
  646. C->_modulus=(2)*(32);
  647. {T226*n=malloc(sizeof(*n));
  648. *n=M226;
  649. r226make(n,(((T794*)C))->_modulus/*20*/);
  650. C->_buckets=(T0*)n;
  651. }
  652. {T429*n=malloc(sizeof(*n));
  653. *n=M429;
  654. r429make(n,1,32);
  655. C->_chain=(T0*)n;
  656. }
  657. {T52*n=malloc(sizeof(*n));
  658. *n=M52;
  659. r52make(n,1,32);
  660. C->_store=(T0*)n;
  661. }
  662. {T52*n=malloc(sizeof(*n));
  663. *n=M52;
  664. r52make(n,1,32);
  665. C->_keys=(T0*)n;
  666. }
  667. r794initialize(C);
  668. }
  669. void r794resize(T794* C,int a1){
  670. int _p=0;
  671. int _n=0;
  672. int _i=0;
  673. int _hash=0;
  674. r226copy(((T226*)(oBC672tmp_buckets)),(((T794*)C))->_buckets/*8*/);
  675. r226make(((T226*)((((T794*)C))->_buckets/*8*/)),a1);
  676. _i=0;
  677. while (!((_i)>=((((T794*)C))->_modulus/*20*/))) {
  678. _n=/*(IRF4.6item*/((((T226*)((T226*)(oBC672tmp_buckets))))->_storage/*0*/)[_i]/*)*/;
  679. while (!((_n)==(0))) {
  680. _p=r429item(((T429*)((((T794*)C))->_chain/*12*/)),_n);
  681. _hash=(r7hash_code(((T7*)(r52item(((T52*)((((T794*)C))->_keys/*0*/)),_n)))))%(a1);
  682. /*[IRF3.6put*/{T429* C1=((T429*)((((T794*)C))->_chain/*12*/));
  683. int b1=/*(IRF4.6item*/((((T226*)((T226*)((((T794*)C))->_buckets/*8*/))))->_storage/*0*/)[_hash]/*)*/;
  684. int b2=_n;
  685. ((((T429*)C1))->_storage/*0*/)[(b2)-((((T429*)C1))->_lower/*12*/)]=(b1);
  686. }/*]*/
  687. /*[IRF3.5put*/((((T226*)((T226*)((((T794*)C))->_buckets/*8*/))))->_storage/*0*/)[_hash]=(_n);
  688. /*]*/
  689. _n=_p;
  690. }
  691. _i=(_i)+(1);
  692. }
  693. C->_modulus=a1;
  694. C->_item_mem=0;
  695. }
  696. /*No:DICTIONARY[STRING,STRING].item_mem*/
  697. /*No:DICTIONARY[STRING,STRING].chain*/
  698. /*No:DICTIONARY[STRING,STRING].keys*/
  699. /*No:DICTIONARY[STRING,STRING].buckets*/
  700. int r794has(T794* C,T0* a1){
  701. int R=0;
  702. /*IF*/if ((((((T794*)C))->_has_mem/*24*/)==(0))||(!(r7is_equal(((T7*)a1),r52item(((T52*)((((T794*)C))->_keys/*0*/)),(((T794*)C))->_has_mem/*24*/))))) {
  703. C->_has_mem=/*(IRF4.6item*/((((T226*)((T226*)((((T794*)C))->_buckets/*8*/))))->_storage/*0*/)[(r7hash_code(((T7*)a1)))%((((T794*)C))->_modulus/*20*/)]/*)*/;
  704. while (!((((((T794*)C))->_has_mem/*24*/)==(0))||(r7is_equal(((T7*)a1),r52item(((T52*)((((T794*)C))->_keys/*0*/)),(((T794*)C))->_has_mem/*24*/))))) {
  705. C->_has_mem=r429item(((T429*)((((T794*)C))->_chain/*12*/)),(((T794*)C))->_has_mem/*24*/);
  706. }
  707. }
  708. /*FI*/R=((((T794*)C))->_has_mem/*24*/)!=(0);
  709. return R;
  710. }
  711. /*No:DICTIONARY[STRING,STRING].Min_size*/
  712. /*No:DICTIONARY[STRING,STRING].store*/
  713. void r794with_capacity(T794* C,int a1){
  714. int _i=0;
  715. _i=32;
  716. while (!((_i)>=(a1))) {
  717. _i=(2)*(_i);
  718. }
  719. C->_modulus=(2)*(_i);
  720. {T226*n=malloc(sizeof(*n));
  721. *n=M226;
  722. r226make(n,(((T794*)C))->_modulus/*20*/);
  723. C->_buckets=(T0*)n;
  724. }
  725. {T429*n=malloc(sizeof(*n));
  726. *n=M429;
  727. r429make(n,1,_i);
  728. C->_chain=(T0*)n;
  729. }
  730. {T52*n=malloc(sizeof(*n));
  731. *n=M52;
  732. r52make(n,1,_i);
  733. C->_store=(T0*)n;
  734. }
  735. {T52*n=malloc(sizeof(*n));
  736. *n=M52;
  737. r52make(n,1,_i);
  738. C->_keys=(T0*)n;
  739. }
  740. r794initialize(C);
  741. }
  742. void r794put(T794* C,T0* a1,T0* a2){
  743. int _hash=0;
  744. _hash=(r7hash_code(((T7*)a2)))%((((T794*)C))->_modulus/*20*/);
  745. /*IF*/if ((((((T794*)C))->_has_mem/*24*/)==(0))||(!(r7is_equal(((T7*)a2),r52item(((T52*)((((T794*)C))->_keys/*0*/)),(((T794*)C))->_has_mem/*24*/))))) {
  746. C->_has_mem=/*(IRF4.6item*/((((T226*)((T226*)((((T794*)C))->_buckets/*8*/))))->_storage/*0*/)[_hash]/*)*/;
  747. while (!((((((T794*)C))->_has_mem/*24*/)==(0))||(r7is_equal(((T7*)a2),r52item(((T52*)((((T794*)C))->_keys/*0*/)),(((T794*)C))->_has_mem/*24*/))))) {
  748. C->_has_mem=r429item(((T429*)((((T794*)C))->_chain/*12*/)),(((T794*)C))->_has_mem/*24*/);
  749. }
  750. /*IF*/if (((((T794*)C))->_has_mem/*24*/)==(0)) {
  751. /*IF*/if (((((T794*)C))->_count/*32*/)>=(r52count(((T52*)((((T794*)C))->_store/*4*/))))) {
  752. r794expand(C);
  753. }
  754. /*FI*//*[IRF3.6put*/{T52* C1=((T52*)((((T794*)C))->_keys/*0*/));
  755. T0* b1=a2;
  756. int b2=(((T794*)C))->_free/*16*/;
  757. ((((T52*)C1))->_storage/*0*/)[(b2)-((((T52*)C1))->_lower/*12*/)]=(b1);
  758. }/*]*/
  759. /*[IRF3.6put*/{T52* C1=((T52*)((((T794*)C))->_store/*4*/));
  760. T0* b1=a1;
  761. int b2=(((T794*)C))->_free/*16*/;
  762. ((((T52*)C1))->_storage/*0*/)[(b2)-((((T52*)C1))->_lower/*12*/)]=(b1);
  763. }/*]*/
  764. C->_has_mem=(((T794*)C))->_free/*16*/;
  765. C->_free=r429item(((T429*)((((T794*)C))->_chain/*12*/)),(((T794*)C))->_free/*16*/);
  766. /*[IRF3.6put*/{T429* C1=((T429*)((((T794*)C))->_chain/*12*/));
  767. int b1=/*(IRF4.6item*/((((T226*)((T226*)((((T794*)C))->_buckets/*8*/))))->_storage/*0*/)[_hash]/*)*/;
  768. int b2=(((T794*)C))->_has_mem/*24*/;
  769. ((((T429*)C1))->_storage/*0*/)[(b2)-((((T429*)C1))->_lower/*12*/)]=(b1);
  770. }/*]*/
  771. /*[IRF3.5put*/((((T226*)((T226*)((((T794*)C))->_buckets/*8*/))))->_storage/*0*/)[_hash]=((((T794*)C))->_has_mem/*24*/);
  772. /*]*/
  773. C->_count=((((T794*)C))->_count/*32*/)+(1);
  774. /*IF*/if (((((T794*)C))->_count/*32*/)>(((((T794*)C))->_modulus/*20*/)*(2))) {
  775. r794resize(C,(2)*((((T794*)C))->_modulus/*20*/));
  776. }
  777. /*FI*/}
  778. /*FI*/}
  779. else {
  780. /*[IRF3.6put*/{T52* C1=((T52*)((((T794*)C))->_store/*4*/));
  781. T0* b1=a1;
  782. int b2=(((T794*)C))->_has_mem/*24*/;
  783. ((((T52*)C1))->_storage/*0*/)[(b2)-((((T52*)C1))->_lower/*12*/)]=(b1);
  784. }/*]*/
  785. }
  786. /*FI*/C->_item_mem=0;
  787. }
  788. /*No:DICTIONARY[STRING,STRING].modulus*/
  789. /*No:DICTIONARY[STRING,STRING].count*/
  790. /*No:DICTIONARY[STRING,STRING].has_mem*/
  791. void r794initialize(T794* C){
  792. int _i=0;
  793. C->_count=0;
  794. C->_free=1;
  795. C->_has_mem=0;
  796. C->_item_mem=0;
  797. _i=1;
  798. while (!((_i)==(r429count(((T429*)((((T794*)C))->_chain/*12*/)))))) {
  799. /*[IRF3.6put*/{T429* C1=((T429*)((((T794*)C))->_chain/*12*/));
  800. int b1=(_i)+(1);
  801. int b2=_i;
  802. ((((T429*)C1))->_storage/*0*/)[(b2)-((((T429*)C1))->_lower/*12*/)]=(b1);
  803. }/*]*/
  804. _i=(_i)+(1);
  805. }
  806. /*[IRF3.6put*/{T429* C1=((T429*)((((T794*)C))->_chain/*12*/));
  807. int b1=0;
  808. int b2=_i;
  809. ((((T429*)C1))->_storage/*0*/)[(b2)-((((T429*)C1))->_lower/*12*/)]=(b1);
  810. }/*]*/
  811. _i=0;
  812. while (!((_i)>=((((T794*)C))->_modulus/*20*/))) {
  813. /*[IRF3.5put*/((((T226*)((T226*)((((T794*)C))->_buckets/*8*/))))->_storage/*0*/)[_i]=(0);
  814. /*]*/
  815. _i=(_i)+(1);
  816. }
  817. }
  818. T0* r338at(T338* C,T0* a1){
  819. T0* R=NULL;
  820. int _foo=0;
  821. _foo=r338has(C,a1);
  822. R=r943item(((T943*)((((T338*)C))->_store/*4*/)),(((T338*)C))->_has_mem/*24*/);
  823. return R;
  824. }
  825. void r338expand(T338* C){
  826. int _old_size=0;
  827. int _i=0;
  828. C->_item_mem=0;
  829. _old_size=r943count(((T943*)((((T338*)C))->_store/*4*/)));
  830. r429resize(((T429*)((((T338*)C))->_chain/*12*/)),1,(2)*(_old_size));
  831. r52resize(((T52*)((((T338*)C))->_keys/*0*/)),1,(2)*(_old_size));
  832. r943resize(((T943*)((((T338*)C))->_store/*4*/)),1,(2)*(_old_size));
  833. _i=(_old_size)+(1);
  834. while (!((_i)==(r429count(((T429*)((((T338*)C))->_chain/*12*/)))))) {
  835. /*[IRF3.6put*/{T429* C1=((T429*)((((T338*)C))->_chain/*12*/));
  836. int b1=(_i)+(1);
  837. int b2=_i;
  838. ((((T429*)C1))->_storage/*0*/)[(b2)-((((T429*)C1))->_lower/*12*/)]=(b1);
  839. }/*]*/
  840. _i=(_i)+(1);
  841. }
  842. /*[IRF3.6put*/{T429* C1=((T429*)((((T338*)C))->_chain/*12*/));
  843. int b1=(((T338*)C))->_free/*16*/;
  844. int b2=_i;
  845. ((((T429*)C1))->_storage/*0*/)[(b2)-((((T429*)C1))->_lower/*12*/)]=(b1);
  846. }/*]*/
  847. C->_free=(_old_size)+(1);
  848. }
  849. /*No:DICTIONARY[DICTIONARY[RUN_FEATURE,STRING],STRING].empty*/
  850. /*No:DICTIONARY[DICTIONARY[RUN_FEATURE,STRING],STRING].free*/
  851. void r338make(T338* C){
  852. C->_modulus=(2)*(32);
  853. {T226*n=malloc(sizeof(*n));
  854. *n=M226;
  855. r226make(n,(((T338*)C))->_modulus/*20*/);
  856. C->_buckets=(T0*)n;
  857. }
  858. {T429*n=malloc(sizeof(*n));
  859. *n=M429;
  860. r429make(n,1,32);
  861. C->_chain=(T0*)n;
  862. }
  863. {T943*n=malloc(sizeof(*n));
  864. *n=M943;
  865. r943make(n,1,32);
  866. C->_store=(T0*)n;
  867. }
  868. {T52*n=malloc(sizeof(*n));
  869. *n=M52;
  870. r52make(n,1,32);
  871. C->_keys=(T0*)n;
  872. }
  873. r338initialize(C);
  874. }
  875. T0* r338item(T338* C,int a1){
  876. T0* R=NULL;
  877. /*IF*/if (((((T338*)C))->_item_mem/*28*/)==(0)) {
  878. r338first(C);
  879. while (!((a1)==((((T338*)C))->_item_mem/*28*/))) {
  880. r338forth(C);
  881. }
  882. R=r943item(((T943*)((((T338*)C))->_store/*4*/)),(((T338*)C))->_item_mem_j/*32*/);
  883. }
  884.  else if (((((T338*)C))->_item_mem/*28*/)<=(a1)) {
  885. while (!((a1)==((((T338*)C))->_item_mem/*28*/))) {
  886. r338forth(C);
  887. }
  888. R=r943item(((T943*)((((T338*)C))->_store/*4*/)),(((T338*)C))->_item_mem_j/*32*/);
  889. }
  890. else {
  891. C->_item_mem=0;
  892. R=r338item(C,a1);
  893. }
  894. /*FI*/return R;
  895. }
  896. /*No:DICTIONARY[DICTIONARY[RUN_FEATURE,STRING],STRING].item_mem_i*/
  897. void r338resize(T338* C,int a1){
  898. int _p=0;
  899. int _n=0;
  900. int _i=0;
  901. int _hash=0;
  902. r226copy(((T226*)(oBC672tmp_buckets)),(((T338*)C))->_buckets/*8*/);
  903. r226make(((T226*)((((T338*)C))->_buckets/*8*/)),a1);
  904. _i=0;
  905. while (!((_i)>=((((T338*)C))->_modulus/*20*/))) {
  906. _n=/*(IRF4.6item*/((((T226*)((T226*)(oBC672tmp_buckets))))->_storage/*0*/)[_i]/*)*/;
  907. while (!((_n)==(0))) {
  908. _p=r429item(((T429*)((((T338*)C))->_chain/*12*/)),_n);
  909. _hash=(r7hash_code(((T7*)(r52item(((T52*)((((T338*)C))->_keys/*0*/)),_n)))))%(a1);
  910. /*[IRF3.6put*/{T429* C1=((T429*)((((T338*)C))->_chain/*12*/));
  911. int b1=/*(IRF4.6item*/((((T226*)((T226*)((((T338*)C))->_buckets/*8*/))))->_storage/*0*/)[_hash]/*)*/;
  912. int b2=_n;
  913. ((((T429*)C1))->_storage/*0*/)[(b2)-((((T429*)C1))->_lower/*12*/)]=(b1);
  914. }/*]*/
  915. /*[IRF3.5put*/((((T226*)((T226*)((((T338*)C))->_buckets/*8*/))))->_storage/*0*/)[_hash]=(_n);
  916. /*]*/
  917. _n=_p;
  918. }
  919. _i=(_i)+(1);
  920. }
  921. C->_modulus=a1;
  922. C->_item_mem=0;
  923. }
  924. /*No:DICTIONARY[DICTIONARY[RUN_FEATURE,STRING],STRING].item_mem_j*/
  925. /*No:DICTIONARY[DICTIONARY[RUN_FEATURE,STRING],STRING].item_mem*/
  926. /*No:DICTIONARY[DICTIONARY[RUN_FEATURE,STRING],STRING].chain*/
  927. /*No:DICTIONARY[DICTIONARY[RUN_FEATURE,STRING],STRING].keys*/
  928. /*No:DICTIONARY[DICTIONARY[RUN_FEATURE,STRING],STRING].buckets*/
  929. int r338has(T338* C,T0* a1){
  930. int R=0;
  931. /*IF*/if ((((((T338*)C))->_has_mem/*24*/)==(0))||(!(r7is_equal(((T7*)a1),r52item(((T52*)((((T338*)C))->_keys/*0*/)),(((T338*)C))->_has_mem/*24*/))))) {
  932. C->_has_mem=/*(IRF4.6item*/((((T226*)((T226*)((((T338*)C))->_buckets/*8*/))))->_storage/*0*/)[(r7hash_code(((T7*)a1)))%((((T338*)C))->_modulus/*20*/)]/*)*/;
  933. while (!((((((T338*)C))->_has_mem/*24*/)==(0))||(r7is_equal(((T7*)a1),r52item(((T52*)((((T338*)C))->_keys/*0*/)),(((T338*)C))->_has_mem/*24*/))))) {
  934. C->_has_mem=r429item(((T429*)((((T338*)C))->_chain/*12*/)),(((T338*)C))->_has_mem/*24*/);
  935. }
  936. }
  937. /*FI*/R=((((T338*)C))->_has_mem/*24*/)!=(0);
  938. return R;
  939. }
  940. /*No:DICTIONARY[DICTIONARY[RUN_FEATURE,STRING],STRING].Min_size*/
  941. void r338forth(T338* C){
  942. int _i=0;
  943. /*IF*/if ((r429item(((T429*)((((T338*)C))->_chain/*12*/)),(((T338*)C))->_item_mem_j/*32*/))!=(0)) {
  944. C->_item_mem_j=r429item(((T429*)((((T338*)C))->_chain/*12*/)),(((T338*)C))->_item_mem_j/*32*/);
  945. }
  946. else {
  947. _i=((((T338*)C))->_item_mem_i/*36*/)+(1);
  948. while (!((/*(IRF4.6item*/((((T226*)((T226*)((((T338*)C))->_buckets/*8*/))))->_storage/*0*/)[_i]/*)*/)!=(0))) {
  949. _i=(_i)+(1);
  950. }
  951. C->_item_mem_i=_i;
  952. C->_item_mem_j=/*(IRF4.6item*/((((T226*)((T226*)((((T338*)C))->_buckets/*8*/))))->_storage/*0*/)[_i]/*)*/;
  953. }
  954. /*FI*/C->_item_mem=((((T338*)C))->_item_mem/*28*/)+(1);
  955. }
  956. /*No:DICTIONARY[DICTIONARY[RUN_FEATURE,STRING],STRING].store*/
  957. void r338put(T338* C,T0* a1,T0* a2){
  958. int _hash=0;
  959. _hash=(r7hash_code(((T7*)a2)))%((((T338*)C))->_modulus/*20*/);
  960. /*IF*/if ((((((T338*)C))->_has_mem/*24*/)==(0))||(!(r7is_equal(((T7*)a2),r52item(((T52*)((((T338*)C))->_keys/*0*/)),(((T338*)C))->_has_mem/*24*/))))) {
  961. C->_has_mem=/*(IRF4.6item*/((((T226*)((T226*)((((T338*)C))->_buckets/*8*/))))->_storage/*0*/)[_hash]/*)*/;
  962. while (!((((((T338*)C))->_has_mem/*24*/)==(0))||(r7is_equal(((T7*)a2),r52item(((T52*)((((T338*)C))->_keys/*0*/)),(((T338*)C))->_has_mem/*24*/))))) {
  963. C->_has_mem=r429item(((T429*)((((T338*)C))->_chain/*12*/)),(((T338*)C))->_has_mem/*24*/);
  964. }
  965. /*IF*/if (((((T338*)C))->_has_mem/*24*/)==(0)) {
  966. /*IF*/if (((((T338*)C))->_count/*40*/)>=(r943count(((T943*)((((T338*)C))->_store/*4*/))))) {
  967. r338expand(C);
  968. }
  969. /*FI*//*[IRF3.6put*/{T52* C1=((T52*)((((T338*)C))->_keys/*0*/));
  970. T0* b1=a2;
  971. int b2=(((T338*)C))->_free/*16*/;
  972. ((((T52*)C1))->_storage/*0*/)[(b2)-((((T52*)C1))->_lower/*12*/)]=(b1);
  973. }/*]*/
  974. /*[IRF3.6put*/{T943* C1=((T943*)((((T338*)C))->_store/*4*/));
  975. T0* b1=a1;
  976. int b2=(((T338*)C))->_free/*16*/;
  977. ((((T943*)C1))->_storage/*0*/)[(b2)-((((T943*)C1))->_lower/*12*/)]=(b1);
  978. }/*]*/
  979. C->_has_mem=(((T338*)C))->_free/*16*/;
  980. C->_free=r429item(((T429*)((((T338*)C))->_chain/*12*/)),(((T338*)C))->_free/*16*/);
  981. /*[IRF3.6put*/{T429* C1=((T429*)((((T338*)C))->_chain/*12*/));
  982. int b1=/*(IRF4.6item*/((((T226*)((T226*)((((T338*)C))->_buckets/*8*/))))->_storage/*0*/)[_hash]/*)*/;
  983. int b2=(((T338*)C))->_has_mem/*24*/;
  984. ((((T429*)C1))->_storage/*0*/)[(b2)-((((T429*)C1))->_lower/*12*/)]=(b1);
  985. }/*]*/
  986. /*[IRF3.5put*/((((T226*)((T226*)((((T338*)C))->_buckets/*8*/))))->_storage/*0*/)[_hash]=((((T338*)C))->_has_mem/*24*/);
  987. /*]*/
  988. C->_count=((((T338*)C))->_count/*40*/)+(1);
  989. /*IF*/if (((((T338*)C))->_count/*40*/)>(((((T338*)C))->_modulus/*20*/)*(2))) {
  990. r338resize(C,(2)*((((T338*)C))->_modulus/*20*/));
  991. }
  992. /*FI*/}
  993. /*FI*/}
  994. else {
  995. /*[IRF3.6put*/{T943* C1=((T943*)((((T338*)C))->_store/*4*/));
  996. T0* b1=a1;
  997. int b2=(((T338*)C))->_has_mem/*24*/;
  998. ((((T943*)C1))->_storage/*0*/)[(b2)-((((T943*)C1))->_lower/*12*/)]=(b1);
  999. }/*]*/
  1000. }
  1001. /*FI*/C->_item_mem=0;
  1002. }
  1003. /*No:DICTIONARY[DICTIONARY[RUN_FEATURE,STRING],STRING].modulus*/
  1004. /*No:DICTIONARY[DICTIONARY[RUN_FEATURE,STRING],STRING].count*/
  1005. /*No:DICTIONARY[DICTIONARY[RUN_FEATURE,STRING],STRING].has_mem*/
  1006. void r338first(T338* C){
  1007. int _i=0;
  1008. _i=0;
  1009. while (!((/*(IRF4.6item*/((((T226*)((T226*)((((T338*)C))->_buckets/*8*/))))->_storage/*0*/)[_i]/*)*/)!=(0))) {
  1010. _i=(_i)+(1);
  1011. }
  1012. C->_item_mem_i=_i;
  1013. C->_item_mem_j=/*(IRF4.6item*/((((T226*)((T226*)((((T338*)C))->_buckets/*8*/))))->_storage/*0*/)[_i]/*)*/;
  1014. C->_item_mem=1;
  1015. }
  1016. void r338initialize(T338* C){
  1017. int _i=0;
  1018. C->_count=0;
  1019. C->_free=1;
  1020. C->_has_mem=0;
  1021. C->_item_mem=0;
  1022. _i=1;
  1023. while (!((_i)==(r429count(((T429*)((((T338*)C))->_chain/*12*/)))))) {
  1024. /*[IRF3.6put*/{T429* C1=((T429*)((((T338*)C))->_chain/*12*/));
  1025. int b1=(_i)+(1);
  1026. int b2=_i;
  1027. ((((T429*)C1))->_storage/*0*/)[(b2)-((((T429*)C1))->_lower/*12*/)]=(b1);
  1028. }/*]*/
  1029. _i=(_i)+(1);
  1030. }
  1031. /*[IRF3.6put*/{T429* C1=((T429*)((((T338*)C))->_chain/*12*/));
  1032. int b1=0;
  1033. int b2=_i;
  1034. ((((T429*)C1))->_storage/*0*/)[(b2)-((((T429*)C1))->_lower/*12*/)]=(b1);
  1035. }/*]*/
  1036. _i=0;
  1037. while (!((_i)>=((((T338*)C))->_modulus/*20*/))) {
  1038. /*[IRF3.5put*/((((T226*)((T226*)((((T338*)C))->_buckets/*8*/))))->_storage/*0*/)[_i]=(0);
  1039. /*]*/
  1040. _i=(_i)+(1);
  1041. }
  1042. }
  1043.  
  1044.