• R/O
  • SSH
  • HTTPS

jpl: Commit


Commit MetaInfo

Revision412 (tree)
Time2019-01-19 10:45:44
Authorjakobthomsen

Log Message

test swap

Change Summary

Incremental Difference

--- trunk/pragmatic/memory_tests/mem_test_output.txt (revision 411)
+++ trunk/pragmatic/memory_tests/mem_test_output.txt (revision 412)
@@ -9,6 +9,7 @@
99 Hello!
1010 12345
1111 END MATCH-TEST
12+Hello world swapped world Hello
1213 ["./mem_tests.bin", "dummy", "args"]
1314 ...["This"]
1415 0
--- trunk/pragmatic/memory_tests/mem_tests.c (revision 411)
+++ trunk/pragmatic/memory_tests/mem_tests.c (revision 412)
@@ -681,6 +681,16 @@
681681 let _ = PrintU(streams.out, nr(12345));
682682 PutStrLn(streams.out, "END MATCH-TEST");
683683
684+ {
685+ let mut string a = "Hello";
686+ let mut string b = "world";
687+ PutStr(streams.out, a); Put(streams.out, ' '); PutStr(streams.out, b);
688+ PutStr(streams.out, " swapped ");
689+ swap<string>(a, b);
690+ PutStr(streams.out, a); Put(streams.out, ' '); PutStr(streams.out, b);
691+ PutStrLn(streams.out, "");
692+ };
693+
684694 Print<stack<string>>(streams.out, cmdargs);
685695 PutStrLn(streams.out, "");
686696
--- trunk/pragmatic/memory_tests/mem_tests.txt (revision 411)
+++ trunk/pragmatic/memory_tests/mem_tests.txt (revision 412)
@@ -9,6 +9,7 @@
99 Hello!
1010 12345
1111 END MATCH-TEST
12+Hello world swapped world Hello
1213 ["./mem_tests.bin", "dummy", "args"]
1314 ...["This"]
1415 0
--- trunk/pragmatic/memory_tests/mem_tests_compiled.c (revision 411)
+++ trunk/pragmatic/memory_tests/mem_tests_compiled.c (revision 412)
@@ -5102,129 +5102,170 @@
51025102 string$dest(&_12);
51035103 }
51045104 {
5105- const struct StreamOut *_12 = &(*streams).out;
5106- Print$stack(0 /* _11 */, &*_12, &_cmdargs, sizeof(struct string), (void (*)(void *, const struct StreamOut *, const void *))Print$string);
5105+ struct string _a; memset(&_a, 0, sizeof(struct string));
5106+ init$fromliteral(&_a, "Hello", 5);
5107+ struct string _b; memset(&_b, 0, sizeof(struct string));
5108+ init$fromliteral(&_b, "world", 5);
5109+ {
5110+ const struct StreamOut *_13 = &(*streams).out;
5111+ PutStr(0 /* _12 */, &*_13, &_a);
5112+ }
5113+ {
5114+ const struct StreamOut *_14 = &(*streams).out;
5115+ uint8_t _15; memset(&_15, 0, sizeof(uint8_t));
5116+ _15 = 32;
5117+ Put(0 /* _13 */, &*_14, &_15);
5118+ _IGNORE_(_15);
5119+ }
5120+ {
5121+ const struct StreamOut *_15 = &(*streams).out;
5122+ PutStr(0 /* _14 */, &*_15, &_b);
5123+ }
5124+ {
5125+ const struct StreamOut *_16 = &(*streams).out;
5126+ struct string _17; memset(&_17, 0, sizeof(struct string));
5127+ init$fromliteral(&_17, " swapped ", 9);
5128+ PutStr(0 /* _15 */, &*_16, &_17);
5129+ string$dest(&_17);
5130+ }
5131+ {
5132+ swap(0 /* _16 */, &_a, &_b, sizeof(struct string));
5133+ }
5134+ {
5135+ const struct StreamOut *_18 = &(*streams).out;
5136+ PutStr(0 /* _17 */, &*_18, &_a);
5137+ }
5138+ {
5139+ const struct StreamOut *_19 = &(*streams).out;
5140+ uint8_t _20; memset(&_20, 0, sizeof(uint8_t));
5141+ _20 = 32;
5142+ Put(0 /* _18 */, &*_19, &_20);
5143+ _IGNORE_(_20);
5144+ }
5145+ {
5146+ const struct StreamOut *_20 = &(*streams).out;
5147+ PutStr(0 /* _19 */, &*_20, &_b);
5148+ }
5149+ {
5150+ const struct StreamOut *_21 = &(*streams).out;
5151+ struct string _22; memset(&_22, 0, sizeof(struct string));
5152+ init$fromliteral(&_22, "", 0);
5153+ PutStrLn(0 /* _20 */, &*_21, &_22);
5154+ string$dest(&_22);
5155+ }
5156+ string$dest(&_b);
5157+ string$dest(&_a);
51075158 }
51085159 {
51095160 const struct StreamOut *_13 = &(*streams).out;
5110- struct string _14; memset(&_14, 0, sizeof(struct string));
5111- init$fromliteral(&_14, "", 0);
5112- PutStrLn(0 /* _12 */, &*_13, &_14);
5113- string$dest(&_14);
5161+ Print$stack(0 /* _12 */, &*_13, &_cmdargs, sizeof(struct string), (void (*)(void *, const struct StreamOut *, const void *))Print$string);
51145162 }
5115- struct stack/*string*/ _orig; memset(&_orig, 0, sizeof(struct stack/*string*/));
51165163 {
5117- struct string _14; memset(&_14, 0, sizeof(struct string));
5118- init$fromliteral(&_14, "This", 4);
5119- push(0 /* _13 */, &_orig, &_14, sizeof(struct string), (void (*)(void *))string$dest, (void (*)(void *, const void *))string$copy, 687);
5120- string$dest(&_14);
5164+ const struct StreamOut *_14 = &(*streams).out;
5165+ struct string _15; memset(&_15, 0, sizeof(struct string));
5166+ init$fromliteral(&_15, "", 0);
5167+ PutStrLn(0 /* _13 */, &*_14, &_15);
5168+ string$dest(&_15);
51215169 }
5170+ struct stack/*string*/ _orig; memset(&_orig, 0, sizeof(struct stack/*string*/));
51225171 {
51235172 struct string _15; memset(&_15, 0, sizeof(struct string));
5124- init$fromliteral(&_15, "is", 2);
5125- push(0 /* _14 */, &_orig, &_15, sizeof(struct string), (void (*)(void *))string$dest, (void (*)(void *, const void *))string$copy, 688);
5173+ init$fromliteral(&_15, "This", 4);
5174+ push(0 /* _14 */, &_orig, &_15, sizeof(struct string), (void (*)(void *))string$dest, (void (*)(void *, const void *))string$copy, 697);
51265175 string$dest(&_15);
51275176 }
51285177 {
51295178 struct string _16; memset(&_16, 0, sizeof(struct string));
5130- init$fromliteral(&_16, "not", 3);
5131- push(0 /* _15 */, &_orig, &_16, sizeof(struct string), (void (*)(void *))string$dest, (void (*)(void *, const void *))string$copy, 689);
5179+ init$fromliteral(&_16, "is", 2);
5180+ push(0 /* _15 */, &_orig, &_16, sizeof(struct string), (void (*)(void *))string$dest, (void (*)(void *, const void *))string$copy, 698);
51325181 string$dest(&_16);
51335182 }
51345183 {
51355184 struct string _17; memset(&_17, 0, sizeof(struct string));
5136- init$fromliteral(&_17, "reduced", 7);
5137- push(0 /* _16 */, &_orig, &_17, sizeof(struct string), (void (*)(void *))string$dest, (void (*)(void *, const void *))string$copy, 690);
5185+ init$fromliteral(&_17, "not", 3);
5186+ push(0 /* _16 */, &_orig, &_17, sizeof(struct string), (void (*)(void *))string$dest, (void (*)(void *, const void *))string$copy, 699);
51385187 string$dest(&_17);
51395188 }
51405189 {
5141- const struct StreamOut *_18 = &(*streams).out;
5142- struct stack/*string*/ _19; memset(&_19, 0, sizeof(struct stack/*string*/));
5143- {
5144- TestIgnoringStackElementsAndReturnOfReduced(&_19, &*streams, &_orig);
5145- }
5146- Print$stack(0 /* _17 */, &*_18, &_19, sizeof(struct string), (void (*)(void *, const struct StreamOut *, const void *))Print$string);
5147- free$(&_19, sizeof(struct string), (void (*)(void *))string$dest);
5190+ struct string _18; memset(&_18, 0, sizeof(struct string));
5191+ init$fromliteral(&_18, "reduced", 7);
5192+ push(0 /* _17 */, &_orig, &_18, sizeof(struct string), (void (*)(void *))string$dest, (void (*)(void *, const void *))string$copy, 700);
5193+ string$dest(&_18);
51485194 }
51495195 {
51505196 const struct StreamOut *_19 = &(*streams).out;
5151- struct string _20; memset(&_20, 0, sizeof(struct string));
5152- init$fromliteral(&_20, "", 0);
5153- PutStrLn(0 /* _18 */, &*_19, &_20);
5154- string$dest(&_20);
5197+ struct stack/*string*/ _20; memset(&_20, 0, sizeof(struct stack/*string*/));
5198+ {
5199+ TestIgnoringStackElementsAndReturnOfReduced(&_20, &*streams, &_orig);
5200+ }
5201+ Print$stack(0 /* _18 */, &*_19, &_20, sizeof(struct string), (void (*)(void *, const struct StreamOut *, const void *))Print$string);
5202+ free$(&_20, sizeof(struct string), (void (*)(void *))string$dest);
51555203 }
51565204 {
51575205 const struct StreamOut *_20 = &(*streams).out;
5158- uint64_t _21; memset(&_21, 0, sizeof(uint64_t));
5159- {
5160- clear(&_21, &_orig);
5161- }
5162- Print$u64(0 /* _19 */, &*_20, &_21);
5163- _IGNORE_(_21);
5206+ struct string _21; memset(&_21, 0, sizeof(struct string));
5207+ init$fromliteral(&_21, "", 0);
5208+ PutStrLn(0 /* _19 */, &*_20, &_21);
5209+ string$dest(&_21);
51645210 }
51655211 {
51665212 const struct StreamOut *_21 = &(*streams).out;
5167- struct string _22; memset(&_22, 0, sizeof(struct string));
5168- init$fromliteral(&_22, "", 0);
5169- PutStrLn(0 /* _20 */, &*_21, &_22);
5170- string$dest(&_22);
5213+ uint64_t _22; memset(&_22, 0, sizeof(uint64_t));
5214+ {
5215+ clear(&_22, &_orig);
5216+ }
5217+ Print$u64(0 /* _20 */, &*_21, &_22);
5218+ _IGNORE_(_22);
51715219 }
51725220 {
51735221 const struct StreamOut *_22 = &(*streams).out;
5174- Print$stack(0 /* _21 */, &*_22, &_orig, sizeof(struct string), (void (*)(void *, const struct StreamOut *, const void *))Print$string);
5222+ struct string _23; memset(&_23, 0, sizeof(struct string));
5223+ init$fromliteral(&_23, "", 0);
5224+ PutStrLn(0 /* _21 */, &*_22, &_23);
5225+ string$dest(&_23);
51755226 }
51765227 {
51775228 const struct StreamOut *_23 = &(*streams).out;
5178- struct string _24; memset(&_24, 0, sizeof(struct string));
5179- init$fromliteral(&_24, "", 0);
5180- PutStrLn(0 /* _22 */, &*_23, &_24);
5181- string$dest(&_24);
5229+ Print$stack(0 /* _22 */, &*_23, &_orig, sizeof(struct string), (void (*)(void *, const struct StreamOut *, const void *))Print$string);
51825230 }
51835231 {
5184- TestIterateStream(0 /* _23 */, &*streams);
5232+ const struct StreamOut *_24 = &(*streams).out;
5233+ struct string _25; memset(&_25, 0, sizeof(struct string));
5234+ init$fromliteral(&_25, "", 0);
5235+ PutStrLn(0 /* _23 */, &*_24, &_25);
5236+ string$dest(&_25);
51855237 }
51865238 {
5187- const struct StreamOut *_25 = &(*streams).out;
5188- TestNestedLoop(0 /* _24 */, &*_25);
5239+ TestIterateStream(0 /* _24 */, &*streams);
51895240 }
51905241 {
5191- TestStack$(0 /* _25 */, &*streams);
5242+ const struct StreamOut *_26 = &(*streams).out;
5243+ TestNestedLoop(0 /* _25 */, &*_26);
51925244 }
51935245 {
5194- const struct StreamOut *_27 = &(*streams).out;
5195- struct string _28; memset(&_28, 0, sizeof(struct string));
5196- init$fromliteral(&_28, "Test compare", 12);
5197- PutStrLn(0 /* _26 */, &*_27, &_28);
5198- string$dest(&_28);
5246+ TestStack$(0 /* _26 */, &*streams);
51995247 }
52005248 {
5249+ const struct StreamOut *_28 = &(*streams).out;
5250+ struct string _29; memset(&_29, 0, sizeof(struct string));
5251+ init$fromliteral(&_29, "Test compare", 12);
5252+ PutStrLn(0 /* _27 */, &*_28, &_29);
5253+ string$dest(&_29);
5254+ }
5255+ {
52015256 struct stack/*string2$*/ _data; memset(&_data, 0, sizeof(struct stack/*string2$*/));
52025257 {
5203- struct string2$ _29; memset(&_29, 0, sizeof(struct string2$));
5204- {
5205- struct string _30; memset(&_30, 0, sizeof(struct string));
5206- init$fromliteral(&_30, "abc", 3);
5207- struct string _31; memset(&_31, 0, sizeof(struct string));
5208- init$fromliteral(&_31, "abc", 3);
5209- string2$(&_29, &_30, &_31);
5210- string$dest(&_31);
5211- string$dest(&_30);
5212- }
5213- push(0 /* _28 */, &_data, &_29, sizeof(struct string2$), (void (*)(void *))string2$$dest, (void (*)(void *, const void *))string2$$copy, 709);
5214- string2$$dest(&_29);
5215- }
5216- {
52175258 struct string2$ _30; memset(&_30, 0, sizeof(struct string2$));
52185259 {
52195260 struct string _31; memset(&_31, 0, sizeof(struct string));
52205261 init$fromliteral(&_31, "abc", 3);
52215262 struct string _32; memset(&_32, 0, sizeof(struct string));
5222- init$fromliteral(&_32, "abcba", 5);
5263+ init$fromliteral(&_32, "abc", 3);
52235264 string2$(&_30, &_31, &_32);
52245265 string$dest(&_32);
52255266 string$dest(&_31);
52265267 }
5227- push(0 /* _29 */, &_data, &_30, sizeof(struct string2$), (void (*)(void *))string2$$dest, (void (*)(void *, const void *))string2$$copy, 710);
5268+ push(0 /* _29 */, &_data, &_30, sizeof(struct string2$), (void (*)(void *))string2$$dest, (void (*)(void *, const void *))string2$$copy, 719);
52285269 string2$$dest(&_30);
52295270 }
52305271 {
@@ -5231,14 +5272,14 @@
52315272 struct string2$ _31; memset(&_31, 0, sizeof(struct string2$));
52325273 {
52335274 struct string _32; memset(&_32, 0, sizeof(struct string));
5234- init$fromliteral(&_32, "abcba", 5);
5275+ init$fromliteral(&_32, "abc", 3);
52355276 struct string _33; memset(&_33, 0, sizeof(struct string));
5236- init$fromliteral(&_33, "abc", 3);
5277+ init$fromliteral(&_33, "abcba", 5);
52375278 string2$(&_31, &_32, &_33);
52385279 string$dest(&_33);
52395280 string$dest(&_32);
52405281 }
5241- push(0 /* _30 */, &_data, &_31, sizeof(struct string2$), (void (*)(void *))string2$$dest, (void (*)(void *, const void *))string2$$copy, 711);
5282+ push(0 /* _30 */, &_data, &_31, sizeof(struct string2$), (void (*)(void *))string2$$dest, (void (*)(void *, const void *))string2$$copy, 720);
52425283 string2$$dest(&_31);
52435284 }
52445285 {
@@ -5245,14 +5286,14 @@
52455286 struct string2$ _32; memset(&_32, 0, sizeof(struct string2$));
52465287 {
52475288 struct string _33; memset(&_33, 0, sizeof(struct string));
5248- init$fromliteral(&_33, "2abc1", 5);
5289+ init$fromliteral(&_33, "abcba", 5);
52495290 struct string _34; memset(&_34, 0, sizeof(struct string));
5250- init$fromliteral(&_34, "1abc2", 5);
5291+ init$fromliteral(&_34, "abc", 3);
52515292 string2$(&_32, &_33, &_34);
52525293 string$dest(&_34);
52535294 string$dest(&_33);
52545295 }
5255- push(0 /* _31 */, &_data, &_32, sizeof(struct string2$), (void (*)(void *))string2$$dest, (void (*)(void *, const void *))string2$$copy, 712);
5296+ push(0 /* _31 */, &_data, &_32, sizeof(struct string2$), (void (*)(void *))string2$$dest, (void (*)(void *, const void *))string2$$copy, 721);
52565297 string2$$dest(&_32);
52575298 }
52585299 {
@@ -5259,14 +5300,14 @@
52595300 struct string2$ _33; memset(&_33, 0, sizeof(struct string2$));
52605301 {
52615302 struct string _34; memset(&_34, 0, sizeof(struct string));
5262- init$fromliteral(&_34, "1abc2", 5);
5303+ init$fromliteral(&_34, "2abc1", 5);
52635304 struct string _35; memset(&_35, 0, sizeof(struct string));
5264- init$fromliteral(&_35, "2abc1", 5);
5305+ init$fromliteral(&_35, "1abc2", 5);
52655306 string2$(&_33, &_34, &_35);
52665307 string$dest(&_35);
52675308 string$dest(&_34);
52685309 }
5269- push(0 /* _32 */, &_data, &_33, sizeof(struct string2$), (void (*)(void *))string2$$dest, (void (*)(void *, const void *))string2$$copy, 713);
5310+ push(0 /* _32 */, &_data, &_33, sizeof(struct string2$), (void (*)(void *))string2$$dest, (void (*)(void *, const void *))string2$$copy, 722);
52705311 string2$$dest(&_33);
52715312 }
52725313 {
@@ -5273,14 +5314,14 @@
52735314 struct string2$ _34; memset(&_34, 0, sizeof(struct string2$));
52745315 {
52755316 struct string _35; memset(&_35, 0, sizeof(struct string));
5276- init$fromliteral(&_35, "abc1", 4);
5317+ init$fromliteral(&_35, "1abc2", 5);
52775318 struct string _36; memset(&_36, 0, sizeof(struct string));
5278- init$fromliteral(&_36, "abc2", 4);
5319+ init$fromliteral(&_36, "2abc1", 5);
52795320 string2$(&_34, &_35, &_36);
52805321 string$dest(&_36);
52815322 string$dest(&_35);
52825323 }
5283- push(0 /* _33 */, &_data, &_34, sizeof(struct string2$), (void (*)(void *))string2$$dest, (void (*)(void *, const void *))string2$$copy, 714);
5324+ push(0 /* _33 */, &_data, &_34, sizeof(struct string2$), (void (*)(void *))string2$$dest, (void (*)(void *, const void *))string2$$copy, 723);
52845325 string2$$dest(&_34);
52855326 }
52865327 {
@@ -5287,14 +5328,14 @@
52875328 struct string2$ _35; memset(&_35, 0, sizeof(struct string2$));
52885329 {
52895330 struct string _36; memset(&_36, 0, sizeof(struct string));
5290- init$fromliteral(&_36, "abc2", 4);
5331+ init$fromliteral(&_36, "abc1", 4);
52915332 struct string _37; memset(&_37, 0, sizeof(struct string));
5292- init$fromliteral(&_37, "abc1", 4);
5333+ init$fromliteral(&_37, "abc2", 4);
52935334 string2$(&_35, &_36, &_37);
52945335 string$dest(&_37);
52955336 string$dest(&_36);
52965337 }
5297- push(0 /* _34 */, &_data, &_35, sizeof(struct string2$), (void (*)(void *))string2$$dest, (void (*)(void *, const void *))string2$$copy, 715);
5338+ push(0 /* _34 */, &_data, &_35, sizeof(struct string2$), (void (*)(void *))string2$$dest, (void (*)(void *, const void *))string2$$copy, 724);
52985339 string2$$dest(&_35);
52995340 }
53005341 {
@@ -5301,14 +5342,14 @@
53015342 struct string2$ _36; memset(&_36, 0, sizeof(struct string2$));
53025343 {
53035344 struct string _37; memset(&_37, 0, sizeof(struct string));
5304- init$fromliteral(&_37, "1abc", 4);
5345+ init$fromliteral(&_37, "abc2", 4);
53055346 struct string _38; memset(&_38, 0, sizeof(struct string));
5306- init$fromliteral(&_38, "2abc", 4);
5347+ init$fromliteral(&_38, "abc1", 4);
53075348 string2$(&_36, &_37, &_38);
53085349 string$dest(&_38);
53095350 string$dest(&_37);
53105351 }
5311- push(0 /* _35 */, &_data, &_36, sizeof(struct string2$), (void (*)(void *))string2$$dest, (void (*)(void *, const void *))string2$$copy, 716);
5352+ push(0 /* _35 */, &_data, &_36, sizeof(struct string2$), (void (*)(void *))string2$$dest, (void (*)(void *, const void *))string2$$copy, 725);
53125353 string2$$dest(&_36);
53135354 }
53145355 {
@@ -5315,14 +5356,14 @@
53155356 struct string2$ _37; memset(&_37, 0, sizeof(struct string2$));
53165357 {
53175358 struct string _38; memset(&_38, 0, sizeof(struct string));
5318- init$fromliteral(&_38, "2abc", 4);
5359+ init$fromliteral(&_38, "1abc", 4);
53195360 struct string _39; memset(&_39, 0, sizeof(struct string));
5320- init$fromliteral(&_39, "1abc", 4);
5361+ init$fromliteral(&_39, "2abc", 4);
53215362 string2$(&_37, &_38, &_39);
53225363 string$dest(&_39);
53235364 string$dest(&_38);
53245365 }
5325- push(0 /* _36 */, &_data, &_37, sizeof(struct string2$), (void (*)(void *))string2$$dest, (void (*)(void *, const void *))string2$$copy, 717);
5366+ push(0 /* _36 */, &_data, &_37, sizeof(struct string2$), (void (*)(void *))string2$$dest, (void (*)(void *, const void *))string2$$copy, 726);
53265367 string2$$dest(&_37);
53275368 }
53285369 {
@@ -5329,48 +5370,62 @@
53295370 struct string2$ _38; memset(&_38, 0, sizeof(struct string2$));
53305371 {
53315372 struct string _39; memset(&_39, 0, sizeof(struct string));
5332- init$fromliteral(&_39, "bbcc", 4);
5373+ init$fromliteral(&_39, "2abc", 4);
53335374 struct string _40; memset(&_40, 0, sizeof(struct string));
5334- init$fromliteral(&_40, "abcd", 4);
5375+ init$fromliteral(&_40, "1abc", 4);
53355376 string2$(&_38, &_39, &_40);
53365377 string$dest(&_40);
53375378 string$dest(&_39);
53385379 }
5339- push(0 /* _37 */, &_data, &_38, sizeof(struct string2$), (void (*)(void *))string2$$dest, (void (*)(void *, const void *))string2$$copy, 718);
5380+ push(0 /* _37 */, &_data, &_38, sizeof(struct string2$), (void (*)(void *))string2$$dest, (void (*)(void *, const void *))string2$$copy, 727);
53405381 string2$$dest(&_38);
53415382 }
53425383 {
5343- const struct StreamOut *_39 = &(*streams).out;
5344- struct string _40; memset(&_40, 0, sizeof(struct string));
5345- init$fromliteral(&_40, "for-test 0: ", 12);
5346- PutStrLn(0 /* _38 */, &*_39, &_40);
5347- string$dest(&_40);
5384+ struct string2$ _39; memset(&_39, 0, sizeof(struct string2$));
5385+ {
5386+ struct string _40; memset(&_40, 0, sizeof(struct string));
5387+ init$fromliteral(&_40, "bbcc", 4);
5388+ struct string _41; memset(&_41, 0, sizeof(struct string));
5389+ init$fromliteral(&_41, "abcd", 4);
5390+ string2$(&_39, &_40, &_41);
5391+ string$dest(&_41);
5392+ string$dest(&_40);
5393+ }
5394+ push(0 /* _38 */, &_data, &_39, sizeof(struct string2$), (void (*)(void *))string2$$dest, (void (*)(void *, const void *))string2$$copy, 728);
5395+ string2$$dest(&_39);
53485396 }
5349- const struct stack/*string2$*/ *_39 = &(_data);
5350- for(uint64_t _40 = 0; _40 < (*_39).fill; ++_40)
53515397 {
5352- struct string2$ *elem = &((struct string2$ *)((*_39).data))[_40];
5398+ const struct StreamOut *_40 = &(*streams).out;
5399+ struct string _41; memset(&_41, 0, sizeof(struct string));
5400+ init$fromliteral(&_41, "for-test 0: ", 12);
5401+ PutStrLn(0 /* _39 */, &*_40, &_41);
5402+ string$dest(&_41);
5403+ }
5404+ const struct stack/*string2$*/ *_40 = &(_data);
5405+ for(uint64_t _41 = 0; _41 < (*_40).fill; ++_41)
5406+ {
5407+ struct string2$ *elem = &((struct string2$ *)((*_40).data))[_41];
53535408 {
5354- const struct StreamOut *_42 = &(*streams).out;
5355- Print$string2$(0 /* _41 */, &*_42, &*elem);
5409+ const struct StreamOut *_43 = &(*streams).out;
5410+ Print$string2$(0 /* _42 */, &*_43, &*elem);
53565411 }
53575412 {
5358- const struct StreamOut *_43 = &(*streams).out;
5359- struct string _44; memset(&_44, 0, sizeof(struct string));
5360- init$fromliteral(&_44, "", 0);
5361- PutStrLn(0 /* _42 */, &*_43, &_44);
5362- string$dest(&_44);
5413+ const struct StreamOut *_44 = &(*streams).out;
5414+ struct string _45; memset(&_45, 0, sizeof(struct string));
5415+ init$fromliteral(&_45, "", 0);
5416+ PutStrLn(0 /* _43 */, &*_44, &_45);
5417+ string$dest(&_45);
53635418 }
53645419 }
53655420 {
5366- const struct StreamOut *_42 = &(*streams).out;
5367- struct string _43; memset(&_43, 0, sizeof(struct string));
5368- init$fromliteral(&_43, "---", 3);
5369- PutStrLn(0 /* _41 */, &*_42, &_43);
5370- string$dest(&_43);
5421+ const struct StreamOut *_43 = &(*streams).out;
5422+ struct string _44; memset(&_44, 0, sizeof(struct string));
5423+ init$fromliteral(&_44, "---", 3);
5424+ PutStrLn(0 /* _42 */, &*_43, &_44);
5425+ string$dest(&_44);
53715426 }
53725427 {
5373- TestCompareStrings$(0 /* _42 */, &*streams, &_data);
5428+ TestCompareStrings$(0 /* _43 */, &*streams, &_data);
53745429 }
53755430 free$(&_data, sizeof(struct string2$), (void (*)(void *))string2$$dest);
53765431 }
@@ -5377,108 +5432,6 @@
53775432 {
53785433 struct stack/*tree2$*/ _data; memset(&_data, 0, sizeof(struct stack/*tree2$*/));
53795434 {
5380- struct tree2$ _30; memset(&_30, 0, sizeof(struct tree2$));
5381- {
5382- struct tree _31; memset(&_31, 0, sizeof(struct tree));
5383- {
5384- struct tree _32; memset(&_32, 0, sizeof(struct tree));
5385- {
5386- struct tree _33; memset(&_33, 0, sizeof(struct tree));
5387- {
5388- struct string _34; memset(&_34, 0, sizeof(struct string));
5389- init$fromliteral(&_34, "2", 1);
5390- leaf(&_33, &_34);
5391- string$dest(&_34);
5392- }
5393- struct tree _34; memset(&_34, 0, sizeof(struct tree));
5394- {
5395- struct string _35; memset(&_35, 0, sizeof(struct string));
5396- init$fromliteral(&_35, "B", 1);
5397- leaf(&_34, &_35);
5398- string$dest(&_35);
5399- }
5400- node(&_32, &_33, &_34);
5401- tree$dest(&_34);
5402- tree$dest(&_33);
5403- }
5404- struct tree _33; memset(&_33, 0, sizeof(struct tree));
5405- {
5406- struct tree _34; memset(&_34, 0, sizeof(struct tree));
5407- {
5408- struct string _35; memset(&_35, 0, sizeof(struct string));
5409- init$fromliteral(&_35, "C", 1);
5410- leaf(&_34, &_35);
5411- string$dest(&_35);
5412- }
5413- struct tree _35; memset(&_35, 0, sizeof(struct tree));
5414- {
5415- struct string _36; memset(&_36, 0, sizeof(struct string));
5416- init$fromliteral(&_36, "1", 1);
5417- leaf(&_35, &_36);
5418- string$dest(&_36);
5419- }
5420- node(&_33, &_34, &_35);
5421- tree$dest(&_35);
5422- tree$dest(&_34);
5423- }
5424- node(&_31, &_32, &_33);
5425- tree$dest(&_33);
5426- tree$dest(&_32);
5427- }
5428- struct tree _32; memset(&_32, 0, sizeof(struct tree));
5429- {
5430- struct tree _33; memset(&_33, 0, sizeof(struct tree));
5431- {
5432- struct tree _34; memset(&_34, 0, sizeof(struct tree));
5433- {
5434- struct string _35; memset(&_35, 0, sizeof(struct string));
5435- init$fromliteral(&_35, "1", 1);
5436- leaf(&_34, &_35);
5437- string$dest(&_35);
5438- }
5439- struct tree _35; memset(&_35, 0, sizeof(struct tree));
5440- {
5441- struct string _36; memset(&_36, 0, sizeof(struct string));
5442- init$fromliteral(&_36, "B", 1);
5443- leaf(&_35, &_36);
5444- string$dest(&_36);
5445- }
5446- node(&_33, &_34, &_35);
5447- tree$dest(&_35);
5448- tree$dest(&_34);
5449- }
5450- struct tree _34; memset(&_34, 0, sizeof(struct tree));
5451- {
5452- struct tree _35; memset(&_35, 0, sizeof(struct tree));
5453- {
5454- struct string _36; memset(&_36, 0, sizeof(struct string));
5455- init$fromliteral(&_36, "C", 1);
5456- leaf(&_35, &_36);
5457- string$dest(&_36);
5458- }
5459- struct tree _36; memset(&_36, 0, sizeof(struct tree));
5460- {
5461- struct string _37; memset(&_37, 0, sizeof(struct string));
5462- init$fromliteral(&_37, "2", 1);
5463- leaf(&_36, &_37);
5464- string$dest(&_37);
5465- }
5466- node(&_34, &_35, &_36);
5467- tree$dest(&_36);
5468- tree$dest(&_35);
5469- }
5470- node(&_32, &_33, &_34);
5471- tree$dest(&_34);
5472- tree$dest(&_33);
5473- }
5474- tree2$(&_30, &_31, &_32);
5475- tree$dest(&_32);
5476- tree$dest(&_31);
5477- }
5478- push(0 /* _29 */, &_data, &_30, sizeof(struct tree2$), (void (*)(void *))tree2$$dest, (void (*)(void *, const void *))tree2$$copy, 734);
5479- tree2$$dest(&_30);
5480- }
5481- {
54825435 struct tree2$ _31; memset(&_31, 0, sizeof(struct tree2$));
54835436 {
54845437 struct tree _32; memset(&_32, 0, sizeof(struct tree));
@@ -5488,7 +5441,7 @@
54885441 struct tree _34; memset(&_34, 0, sizeof(struct tree));
54895442 {
54905443 struct string _35; memset(&_35, 0, sizeof(struct string));
5491- init$fromliteral(&_35, "1", 1);
5444+ init$fromliteral(&_35, "2", 1);
54925445 leaf(&_34, &_35);
54935446 string$dest(&_35);
54945447 }
@@ -5515,7 +5468,7 @@
55155468 struct tree _36; memset(&_36, 0, sizeof(struct tree));
55165469 {
55175470 struct string _37; memset(&_37, 0, sizeof(struct string));
5518- init$fromliteral(&_37, "2", 1);
5471+ init$fromliteral(&_37, "1", 1);
55195472 leaf(&_36, &_37);
55205473 string$dest(&_37);
55215474 }
@@ -5534,7 +5487,7 @@
55345487 struct tree _35; memset(&_35, 0, sizeof(struct tree));
55355488 {
55365489 struct string _36; memset(&_36, 0, sizeof(struct string));
5537- init$fromliteral(&_36, "2", 1);
5490+ init$fromliteral(&_36, "1", 1);
55385491 leaf(&_35, &_36);
55395492 string$dest(&_36);
55405493 }
@@ -5561,7 +5514,7 @@
55615514 struct tree _37; memset(&_37, 0, sizeof(struct tree));
55625515 {
55635516 struct string _38; memset(&_38, 0, sizeof(struct string));
5564- init$fromliteral(&_38, "1", 1);
5517+ init$fromliteral(&_38, "2", 1);
55655518 leaf(&_37, &_38);
55665519 string$dest(&_38);
55675520 }
@@ -5577,7 +5530,7 @@
55775530 tree$dest(&_33);
55785531 tree$dest(&_32);
55795532 }
5580- push(0 /* _30 */, &_data, &_31, sizeof(struct tree2$), (void (*)(void *))tree2$$dest, (void (*)(void *, const void *))tree2$$copy, 735);
5533+ push(0 /* _30 */, &_data, &_31, sizeof(struct tree2$), (void (*)(void *))tree2$$dest, (void (*)(void *, const void *))tree2$$copy, 744);
55815534 tree2$$dest(&_31);
55825535 }
55835536 {
@@ -5590,7 +5543,7 @@
55905543 struct tree _35; memset(&_35, 0, sizeof(struct tree));
55915544 {
55925545 struct string _36; memset(&_36, 0, sizeof(struct string));
5593- init$fromliteral(&_36, "A", 1);
5546+ init$fromliteral(&_36, "1", 1);
55945547 leaf(&_35, &_36);
55955548 string$dest(&_36);
55965549 }
@@ -5617,7 +5570,7 @@
56175570 struct tree _37; memset(&_37, 0, sizeof(struct tree));
56185571 {
56195572 struct string _38; memset(&_38, 0, sizeof(struct string));
5620- init$fromliteral(&_38, "D", 1);
5573+ init$fromliteral(&_38, "2", 1);
56215574 leaf(&_37, &_38);
56225575 string$dest(&_38);
56235576 }
@@ -5636,7 +5589,7 @@
56365589 struct tree _36; memset(&_36, 0, sizeof(struct tree));
56375590 {
56385591 struct string _37; memset(&_37, 0, sizeof(struct string));
5639- init$fromliteral(&_37, "A", 1);
5592+ init$fromliteral(&_37, "2", 1);
56405593 leaf(&_36, &_37);
56415594 string$dest(&_37);
56425595 }
@@ -5663,7 +5616,7 @@
56635616 struct tree _38; memset(&_38, 0, sizeof(struct tree));
56645617 {
56655618 struct string _39; memset(&_39, 0, sizeof(struct string));
5666- init$fromliteral(&_39, "D", 1);
5619+ init$fromliteral(&_39, "1", 1);
56675620 leaf(&_38, &_39);
56685621 string$dest(&_39);
56695622 }
@@ -5679,7 +5632,7 @@
56795632 tree$dest(&_34);
56805633 tree$dest(&_33);
56815634 }
5682- push(0 /* _31 */, &_data, &_32, sizeof(struct tree2$), (void (*)(void *))tree2$$dest, (void (*)(void *, const void *))tree2$$copy, 736);
5635+ push(0 /* _31 */, &_data, &_32, sizeof(struct tree2$), (void (*)(void *))tree2$$dest, (void (*)(void *, const void *))tree2$$copy, 745);
56835636 tree2$$dest(&_32);
56845637 }
56855638 {
@@ -5689,17 +5642,43 @@
56895642 {
56905643 struct tree _35; memset(&_35, 0, sizeof(struct tree));
56915644 {
5692- struct string _36; memset(&_36, 0, sizeof(struct string));
5693- init$fromliteral(&_36, "A", 1);
5694- leaf(&_35, &_36);
5695- string$dest(&_36);
5645+ struct tree _36; memset(&_36, 0, sizeof(struct tree));
5646+ {
5647+ struct string _37; memset(&_37, 0, sizeof(struct string));
5648+ init$fromliteral(&_37, "A", 1);
5649+ leaf(&_36, &_37);
5650+ string$dest(&_37);
5651+ }
5652+ struct tree _37; memset(&_37, 0, sizeof(struct tree));
5653+ {
5654+ struct string _38; memset(&_38, 0, sizeof(struct string));
5655+ init$fromliteral(&_38, "B", 1);
5656+ leaf(&_37, &_38);
5657+ string$dest(&_38);
5658+ }
5659+ node(&_35, &_36, &_37);
5660+ tree$dest(&_37);
5661+ tree$dest(&_36);
56965662 }
56975663 struct tree _36; memset(&_36, 0, sizeof(struct tree));
56985664 {
5699- struct string _37; memset(&_37, 0, sizeof(struct string));
5700- init$fromliteral(&_37, "B", 1);
5701- leaf(&_36, &_37);
5702- string$dest(&_37);
5665+ struct tree _37; memset(&_37, 0, sizeof(struct tree));
5666+ {
5667+ struct string _38; memset(&_38, 0, sizeof(struct string));
5668+ init$fromliteral(&_38, "C", 1);
5669+ leaf(&_37, &_38);
5670+ string$dest(&_38);
5671+ }
5672+ struct tree _38; memset(&_38, 0, sizeof(struct tree));
5673+ {
5674+ struct string _39; memset(&_39, 0, sizeof(struct string));
5675+ init$fromliteral(&_39, "D", 1);
5676+ leaf(&_38, &_39);
5677+ string$dest(&_39);
5678+ }
5679+ node(&_36, &_37, &_38);
5680+ tree$dest(&_38);
5681+ tree$dest(&_37);
57035682 }
57045683 node(&_34, &_35, &_36);
57055684 tree$dest(&_36);
@@ -5709,17 +5688,43 @@
57095688 {
57105689 struct tree _36; memset(&_36, 0, sizeof(struct tree));
57115690 {
5712- struct string _37; memset(&_37, 0, sizeof(struct string));
5713- init$fromliteral(&_37, "A", 1);
5714- leaf(&_36, &_37);
5715- string$dest(&_37);
5691+ struct tree _37; memset(&_37, 0, sizeof(struct tree));
5692+ {
5693+ struct string _38; memset(&_38, 0, sizeof(struct string));
5694+ init$fromliteral(&_38, "A", 1);
5695+ leaf(&_37, &_38);
5696+ string$dest(&_38);
5697+ }
5698+ struct tree _38; memset(&_38, 0, sizeof(struct tree));
5699+ {
5700+ struct string _39; memset(&_39, 0, sizeof(struct string));
5701+ init$fromliteral(&_39, "B", 1);
5702+ leaf(&_38, &_39);
5703+ string$dest(&_39);
5704+ }
5705+ node(&_36, &_37, &_38);
5706+ tree$dest(&_38);
5707+ tree$dest(&_37);
57165708 }
57175709 struct tree _37; memset(&_37, 0, sizeof(struct tree));
57185710 {
5719- struct string _38; memset(&_38, 0, sizeof(struct string));
5720- init$fromliteral(&_38, "B", 1);
5721- leaf(&_37, &_38);
5722- string$dest(&_38);
5711+ struct tree _38; memset(&_38, 0, sizeof(struct tree));
5712+ {
5713+ struct string _39; memset(&_39, 0, sizeof(struct string));
5714+ init$fromliteral(&_39, "C", 1);
5715+ leaf(&_38, &_39);
5716+ string$dest(&_39);
5717+ }
5718+ struct tree _39; memset(&_39, 0, sizeof(struct tree));
5719+ {
5720+ struct string _40; memset(&_40, 0, sizeof(struct string));
5721+ init$fromliteral(&_40, "D", 1);
5722+ leaf(&_39, &_40);
5723+ string$dest(&_40);
5724+ }
5725+ node(&_37, &_38, &_39);
5726+ tree$dest(&_39);
5727+ tree$dest(&_38);
57235728 }
57245729 node(&_35, &_36, &_37);
57255730 tree$dest(&_37);
@@ -5729,7 +5734,7 @@
57295734 tree$dest(&_35);
57305735 tree$dest(&_34);
57315736 }
5732- push(0 /* _32 */, &_data, &_33, sizeof(struct tree2$), (void (*)(void *))tree2$$dest, (void (*)(void *, const void *))tree2$$copy, 737);
5737+ push(0 /* _32 */, &_data, &_33, sizeof(struct tree2$), (void (*)(void *))tree2$$dest, (void (*)(void *, const void *))tree2$$copy, 746);
57335738 tree2$$dest(&_33);
57345739 }
57355740 {
@@ -5737,10 +5742,23 @@
57375742 {
57385743 struct tree _35; memset(&_35, 0, sizeof(struct tree));
57395744 {
5740- struct string _36; memset(&_36, 0, sizeof(struct string));
5741- init$fromliteral(&_36, "A", 1);
5742- leaf(&_35, &_36);
5743- string$dest(&_36);
5745+ struct tree _36; memset(&_36, 0, sizeof(struct tree));
5746+ {
5747+ struct string _37; memset(&_37, 0, sizeof(struct string));
5748+ init$fromliteral(&_37, "A", 1);
5749+ leaf(&_36, &_37);
5750+ string$dest(&_37);
5751+ }
5752+ struct tree _37; memset(&_37, 0, sizeof(struct tree));
5753+ {
5754+ struct string _38; memset(&_38, 0, sizeof(struct string));
5755+ init$fromliteral(&_38, "B", 1);
5756+ leaf(&_37, &_38);
5757+ string$dest(&_38);
5758+ }
5759+ node(&_35, &_36, &_37);
5760+ tree$dest(&_37);
5761+ tree$dest(&_36);
57445762 }
57455763 struct tree _36; memset(&_36, 0, sizeof(struct tree));
57465764 {
@@ -5754,7 +5772,7 @@
57545772 struct tree _38; memset(&_38, 0, sizeof(struct tree));
57555773 {
57565774 struct string _39; memset(&_39, 0, sizeof(struct string));
5757- init$fromliteral(&_39, "A", 1);
5775+ init$fromliteral(&_39, "B", 1);
57585776 leaf(&_38, &_39);
57595777 string$dest(&_39);
57605778 }
@@ -5766,7 +5784,7 @@
57665784 tree$dest(&_36);
57675785 tree$dest(&_35);
57685786 }
5769- push(0 /* _33 */, &_data, &_34, sizeof(struct tree2$), (void (*)(void *))tree2$$dest, (void (*)(void *, const void *))tree2$$copy, 738);
5787+ push(0 /* _33 */, &_data, &_34, sizeof(struct tree2$), (void (*)(void *))tree2$$dest, (void (*)(void *, const void *))tree2$$copy, 747);
57705788 tree2$$dest(&_34);
57715789 }
57725790 {
@@ -5774,13 +5792,13 @@
57745792 {
57755793 struct tree _36; memset(&_36, 0, sizeof(struct tree));
57765794 {
5777- struct tree _37; memset(&_37, 0, sizeof(struct tree));
5778- {
5779- struct string _38; memset(&_38, 0, sizeof(struct string));
5780- init$fromliteral(&_38, "A", 1);
5781- leaf(&_37, &_38);
5782- string$dest(&_38);
5783- }
5795+ struct string _37; memset(&_37, 0, sizeof(struct string));
5796+ init$fromliteral(&_37, "A", 1);
5797+ leaf(&_36, &_37);
5798+ string$dest(&_37);
5799+ }
5800+ struct tree _37; memset(&_37, 0, sizeof(struct tree));
5801+ {
57845802 struct tree _38; memset(&_38, 0, sizeof(struct tree));
57855803 {
57865804 struct string _39; memset(&_39, 0, sizeof(struct string));
@@ -5788,22 +5806,22 @@
57885806 leaf(&_38, &_39);
57895807 string$dest(&_39);
57905808 }
5791- node(&_36, &_37, &_38);
5809+ struct tree _39; memset(&_39, 0, sizeof(struct tree));
5810+ {
5811+ struct string _40; memset(&_40, 0, sizeof(struct string));
5812+ init$fromliteral(&_40, "A", 1);
5813+ leaf(&_39, &_40);
5814+ string$dest(&_40);
5815+ }
5816+ node(&_37, &_38, &_39);
5817+ tree$dest(&_39);
57925818 tree$dest(&_38);
5793- tree$dest(&_37);
57945819 }
5795- struct tree _37; memset(&_37, 0, sizeof(struct tree));
5796- {
5797- struct string _38; memset(&_38, 0, sizeof(struct string));
5798- init$fromliteral(&_38, "A", 1);
5799- leaf(&_37, &_38);
5800- string$dest(&_38);
5801- }
58025820 tree2$(&_35, &_36, &_37);
58035821 tree$dest(&_37);
58045822 tree$dest(&_36);
58055823 }
5806- push(0 /* _34 */, &_data, &_35, sizeof(struct tree2$), (void (*)(void *))tree2$$dest, (void (*)(void *, const void *))tree2$$copy, 739);
5824+ push(0 /* _34 */, &_data, &_35, sizeof(struct tree2$), (void (*)(void *))tree2$$dest, (void (*)(void *, const void *))tree2$$copy, 748);
58075825 tree2$$dest(&_35);
58085826 }
58095827 {
@@ -5811,10 +5829,23 @@
58115829 {
58125830 struct tree _37; memset(&_37, 0, sizeof(struct tree));
58135831 {
5814- struct string _38; memset(&_38, 0, sizeof(struct string));
5815- init$fromliteral(&_38, "A", 1);
5816- leaf(&_37, &_38);
5817- string$dest(&_38);
5832+ struct tree _38; memset(&_38, 0, sizeof(struct tree));
5833+ {
5834+ struct string _39; memset(&_39, 0, sizeof(struct string));
5835+ init$fromliteral(&_39, "A", 1);
5836+ leaf(&_38, &_39);
5837+ string$dest(&_39);
5838+ }
5839+ struct tree _39; memset(&_39, 0, sizeof(struct tree));
5840+ {
5841+ struct string _40; memset(&_40, 0, sizeof(struct string));
5842+ init$fromliteral(&_40, "A", 1);
5843+ leaf(&_39, &_40);
5844+ string$dest(&_40);
5845+ }
5846+ node(&_37, &_38, &_39);
5847+ tree$dest(&_39);
5848+ tree$dest(&_38);
58185849 }
58195850 struct tree _38; memset(&_38, 0, sizeof(struct tree));
58205851 {
@@ -5827,84 +5858,108 @@
58275858 tree$dest(&_38);
58285859 tree$dest(&_37);
58295860 }
5830- push(0 /* _35 */, &_data, &_36, sizeof(struct tree2$), (void (*)(void *))tree2$$dest, (void (*)(void *, const void *))tree2$$copy, 740);
5861+ push(0 /* _35 */, &_data, &_36, sizeof(struct tree2$), (void (*)(void *))tree2$$dest, (void (*)(void *, const void *))tree2$$copy, 749);
58315862 tree2$$dest(&_36);
58325863 }
58335864 {
5834- TestCompareTrees$(0 /* _36 */, &*streams, &_data);
5865+ struct tree2$ _37; memset(&_37, 0, sizeof(struct tree2$));
5866+ {
5867+ struct tree _38; memset(&_38, 0, sizeof(struct tree));
5868+ {
5869+ struct string _39; memset(&_39, 0, sizeof(struct string));
5870+ init$fromliteral(&_39, "A", 1);
5871+ leaf(&_38, &_39);
5872+ string$dest(&_39);
5873+ }
5874+ struct tree _39; memset(&_39, 0, sizeof(struct tree));
5875+ {
5876+ struct string _40; memset(&_40, 0, sizeof(struct string));
5877+ init$fromliteral(&_40, "A", 1);
5878+ leaf(&_39, &_40);
5879+ string$dest(&_40);
5880+ }
5881+ tree2$(&_37, &_38, &_39);
5882+ tree$dest(&_39);
5883+ tree$dest(&_38);
5884+ }
5885+ push(0 /* _36 */, &_data, &_37, sizeof(struct tree2$), (void (*)(void *))tree2$$dest, (void (*)(void *, const void *))tree2$$copy, 750);
5886+ tree2$$dest(&_37);
58355887 }
5888+ {
5889+ TestCompareTrees$(0 /* _37 */, &*streams, &_data);
5890+ }
58365891 free$(&_data, sizeof(struct tree2$), (void (*)(void *))tree2$$dest);
58375892 }
58385893 struct stack/*string*/ _words; memset(&_words, 0, sizeof(struct stack/*string*/));
58395894 {
5840- struct string _30; memset(&_30, 0, sizeof(struct string));
5841- init$fromliteral(&_30, "123", 3);
5842- push(0 /* _29 */, &_words, &_30, sizeof(struct string), (void (*)(void *))string$dest, (void (*)(void *, const void *))string$copy, 746);
5843- string$dest(&_30);
5844- }
5845- {
58465895 struct string _31; memset(&_31, 0, sizeof(struct string));
5847- init$fromliteral(&_31, "456", 3);
5848- push(0 /* _30 */, &_words, &_31, sizeof(struct string), (void (*)(void *))string$dest, (void (*)(void *, const void *))string$copy, 746);
5896+ init$fromliteral(&_31, "123", 3);
5897+ push(0 /* _30 */, &_words, &_31, sizeof(struct string), (void (*)(void *))string$dest, (void (*)(void *, const void *))string$copy, 756);
58495898 string$dest(&_31);
58505899 }
58515900 {
58525901 struct string _32; memset(&_32, 0, sizeof(struct string));
5853- init$fromliteral(&_32, "789", 3);
5854- push(0 /* _31 */, &_words, &_32, sizeof(struct string), (void (*)(void *))string$dest, (void (*)(void *, const void *))string$copy, 746);
5902+ init$fromliteral(&_32, "456", 3);
5903+ push(0 /* _31 */, &_words, &_32, sizeof(struct string), (void (*)(void *))string$dest, (void (*)(void *, const void *))string$copy, 756);
58555904 string$dest(&_32);
58565905 }
58575906 {
5858- const struct StreamOut *_33 = &(*streams).out;
5859- struct string _34; memset(&_34, 0, sizeof(struct string));
5860- init$fromliteral(&_34, "traverse immutable stack totally", 32);
5861- PutStrLn(0 /* _32 */, &*_33, &_34);
5862- string$dest(&_34);
5907+ struct string _33; memset(&_33, 0, sizeof(struct string));
5908+ init$fromliteral(&_33, "789", 3);
5909+ push(0 /* _32 */, &_words, &_33, sizeof(struct string), (void (*)(void *))string$dest, (void (*)(void *, const void *))string$copy, 756);
5910+ string$dest(&_33);
58635911 }
58645912 {
5865- TraverseStack(0 /* _33 */, &*streams, &_words);
5913+ const struct StreamOut *_34 = &(*streams).out;
5914+ struct string _35; memset(&_35, 0, sizeof(struct string));
5915+ init$fromliteral(&_35, "traverse immutable stack totally", 32);
5916+ PutStrLn(0 /* _33 */, &*_34, &_35);
5917+ string$dest(&_35);
58665918 }
58675919 {
5868- const struct StreamOut *_35 = &(*streams).out;
5869- Print$stack(0 /* _34 */, &*_35, &_words, sizeof(struct string), (void (*)(void *, const struct StreamOut *, const void *))Print$string);
5920+ TraverseStack(0 /* _34 */, &*streams, &_words);
58705921 }
58715922 {
58725923 const struct StreamOut *_36 = &(*streams).out;
5873- struct string _37; memset(&_37, 0, sizeof(struct string));
5874- init$fromliteral(&_37, "\n", 1);
5875- PutStr(0 /* _35 */, &*_36, &_37);
5876- string$dest(&_37);
5924+ Print$stack(0 /* _35 */, &*_36, &_words, sizeof(struct string), (void (*)(void *, const struct StreamOut *, const void *))Print$string);
58775925 }
5926+ {
5927+ const struct StreamOut *_37 = &(*streams).out;
5928+ struct string _38; memset(&_38, 0, sizeof(struct string));
5929+ init$fromliteral(&_38, "\n", 1);
5930+ PutStr(0 /* _36 */, &*_37, &_38);
5931+ string$dest(&_38);
5932+ }
58785933 struct a$ _datatest; memset(&_datatest, 0, sizeof(struct a$));
58795934 {
5880- uint32_t _36; memset(&_36, 0, sizeof(uint32_t));
5881- _36 = 12345;
5882- d$(&_datatest, &_36);
5883- _IGNORE_(_36);
5935+ uint32_t _37; memset(&_37, 0, sizeof(uint32_t));
5936+ _37 = 12345;
5937+ d$(&_datatest, &_37);
5938+ _IGNORE_(_37);
58845939 }
58855940 {
5886- struct string _36; memset(&_36, 0, sizeof(struct string));
5887- init$fromliteral(&_36, "Hello NEW Data!", 15);
5888- uint64_t _37; memset(&_37, 0, sizeof(uint64_t));
5889- _37 = 42;
5890- uint8_t _38; memset(&_38, 0, sizeof(uint8_t));
5941+ struct string _37; memset(&_37, 0, sizeof(struct string));
5942+ init$fromliteral(&_37, "Hello NEW Data!", 15);
5943+ uint64_t _38; memset(&_38, 0, sizeof(uint64_t));
58915944 _38 = 42;
5892- b$(&_datatest, &_36, &_37, &_38);
5945+ uint8_t _39; memset(&_39, 0, sizeof(uint8_t));
5946+ _39 = 42;
5947+ b$(&_datatest, &_37, &_38, &_39);
5948+ _IGNORE_(_39);
58935949 _IGNORE_(_38);
5894- _IGNORE_(_37);
5895- string$dest(&_36);
5950+ string$dest(&_37);
58965951 }
5897- struct a$ *_36 = &(_datatest);
5898- switch((*_36).type)
5952+ struct a$ *_37 = &(_datatest);
5953+ switch((*_37).type)
58995954 {
59005955 case 0: // struct stack/*b$*/ b$:
59015956 {
5902- struct b$ *datatest = ((*_36).b$).data;
5957+ struct b$ *datatest = ((*_37).b$).data;
59035958 {
59045959 {
5905- const struct StreamOut *_39 = &(*streams).out;
5906- struct string *_40 = &(*datatest).s;
5907- PutStrLn(0 /* _38 */, &*_39, &*_40);
5960+ const struct StreamOut *_40 = &(*streams).out;
5961+ struct string *_41 = &(*datatest).s;
5962+ PutStrLn(0 /* _39 */, &*_40, &*_41);
59085963 }
59095964 }
59105965 break;
@@ -5912,23 +5967,23 @@
59125967 case 1: // void c$:
59135968 {
59145969 {
5915- const struct StreamOut *_39 = &(*streams).out;
5916- struct string _40; memset(&_40, 0, sizeof(struct string));
5917- init$fromliteral(&_40, "", 0);
5918- PutStr(0 /* _38 */, &*_39, &_40);
5919- string$dest(&_40);
5970+ const struct StreamOut *_40 = &(*streams).out;
5971+ struct string _41; memset(&_41, 0, sizeof(struct string));
5972+ init$fromliteral(&_41, "", 0);
5973+ PutStr(0 /* _39 */, &*_40, &_41);
5974+ string$dest(&_41);
59205975 }
59215976 break;
59225977 }
59235978 case 2: // struct stack/*d$*/ d$:
59245979 {
5925- struct d$ *datatest = ((*_36).d$).data;
5980+ struct d$ *datatest = ((*_37).d$).data;
59265981 {
5927- const struct StreamOut *_40 = &(*streams).out;
5928- struct string _41; memset(&_41, 0, sizeof(struct string));
5929- init$fromliteral(&_41, "", 0);
5930- PutStr(0 /* _39 */, &*_40, &_41);
5931- string$dest(&_41);
5982+ const struct StreamOut *_41 = &(*streams).out;
5983+ struct string _42; memset(&_42, 0, sizeof(struct string));
5984+ init$fromliteral(&_42, "", 0);
5985+ PutStr(0 /* _40 */, &*_41, &_42);
5986+ string$dest(&_42);
59325987 }
59335988 __SUPPRESS_WARNING_UNUSED_VARIABLE__(datatest);
59345989 break;
@@ -5940,26 +5995,26 @@
59405995 }
59415996 }
59425997 {
5943- const struct StreamOut *_41 = &(*streams).out;
5944- struct string _42; memset(&_42, 0, sizeof(struct string));
5945- struct a$ *_43 = &(_datatest);
5946- switch((*_43).type)
5998+ const struct StreamOut *_42 = &(*streams).out;
5999+ struct string _43; memset(&_43, 0, sizeof(struct string));
6000+ struct a$ *_44 = &(_datatest);
6001+ switch((*_44).type)
59476002 {
59486003 case 0: // struct stack/*b$*/ b$:
59496004 {
5950- struct b$ *datatest = ((*_43).b$).data;
5951- string$copy(&_42, &(*datatest).s);
6005+ struct b$ *datatest = ((*_44).b$).data;
6006+ string$copy(&_43, &(*datatest).s);
59526007 break;
59536008 }
59546009 case 1: // void c$:
59556010 {
5956- init$fromliteral(&_42, "", 0);
6011+ init$fromliteral(&_43, "", 0);
59576012 break;
59586013 }
59596014 case 2: // struct stack/*d$*/ d$:
59606015 {
5961- struct d$ *datatest = ((*_43).d$).data;
5962- init$fromliteral(&_42, "", 0);
6016+ struct d$ *datatest = ((*_44).d$).data;
6017+ init$fromliteral(&_43, "", 0);
59636018 __SUPPRESS_WARNING_UNUSED_VARIABLE__(datatest);
59646019 break;
59656020 }
@@ -5969,48 +6024,28 @@
59696024 break;
59706025 }
59716026 }
5972- PutStrLn(0 /* _40 */, &*_41, &_42);
5973- string$dest(&_42);
6027+ PutStrLn(0 /* _41 */, &*_42, &_43);
6028+ string$dest(&_43);
59746029 }
59756030 {
5976- const struct StreamOut *_42 = &(*streams).out;
5977- Print$a$(0 /* _41 */, &*_42, &_datatest);
6031+ const struct StreamOut *_43 = &(*streams).out;
6032+ Print$a$(0 /* _42 */, &*_43, &_datatest);
59786033 }
59796034 {
5980- const struct StreamOut *_43 = &(*streams).out;
5981- struct string _44; memset(&_44, 0, sizeof(struct string));
5982- init$fromliteral(&_44, "\n", 1);
5983- PutStr(0 /* _42 */, &*_43, &_44);
5984- string$dest(&_44);
6035+ const struct StreamOut *_44 = &(*streams).out;
6036+ struct string _45; memset(&_45, 0, sizeof(struct string));
6037+ init$fromliteral(&_45, "\n", 1);
6038+ PutStr(0 /* _43 */, &*_44, &_45);
6039+ string$dest(&_45);
59856040 }
59866041 struct tree _tree; memset(&_tree, 0, sizeof(struct tree));
59876042 {
5988- struct tree _43; memset(&_43, 0, sizeof(struct tree));
5989- {
5990- struct tree _44; memset(&_44, 0, sizeof(struct tree));
5991- {
5992- struct string _45; memset(&_45, 0, sizeof(struct string));
5993- init$fromliteral(&_45, "A", 1);
5994- leaf(&_44, &_45);
5995- string$dest(&_45);
5996- }
5997- struct tree _45; memset(&_45, 0, sizeof(struct tree));
5998- {
5999- struct string _46; memset(&_46, 0, sizeof(struct string));
6000- init$fromliteral(&_46, "B", 1);
6001- leaf(&_45, &_46);
6002- string$dest(&_46);
6003- }
6004- node(&_43, &_44, &_45);
6005- tree$dest(&_45);
6006- tree$dest(&_44);
6007- }
60086043 struct tree _44; memset(&_44, 0, sizeof(struct tree));
60096044 {
60106045 struct tree _45; memset(&_45, 0, sizeof(struct tree));
60116046 {
60126047 struct string _46; memset(&_46, 0, sizeof(struct string));
6013- init$fromliteral(&_46, "C", 1);
6048+ init$fromliteral(&_46, "A", 1);
60146049 leaf(&_45, &_46);
60156050 string$dest(&_46);
60166051 }
@@ -6017,7 +6052,7 @@
60176052 struct tree _46; memset(&_46, 0, sizeof(struct tree));
60186053 {
60196054 struct string _47; memset(&_47, 0, sizeof(struct string));
6020- init$fromliteral(&_47, "D", 1);
6055+ init$fromliteral(&_47, "B", 1);
60216056 leaf(&_46, &_47);
60226057 string$dest(&_47);
60236058 }
@@ -6025,47 +6060,49 @@
60256060 tree$dest(&_46);
60266061 tree$dest(&_45);
60276062 }
6028- node(&_tree, &_43, &_44);
6063+ struct tree _45; memset(&_45, 0, sizeof(struct tree));
6064+ {
6065+ struct tree _46; memset(&_46, 0, sizeof(struct tree));
6066+ {
6067+ struct string _47; memset(&_47, 0, sizeof(struct string));
6068+ init$fromliteral(&_47, "C", 1);
6069+ leaf(&_46, &_47);
6070+ string$dest(&_47);
6071+ }
6072+ struct tree _47; memset(&_47, 0, sizeof(struct tree));
6073+ {
6074+ struct string _48; memset(&_48, 0, sizeof(struct string));
6075+ init$fromliteral(&_48, "D", 1);
6076+ leaf(&_47, &_48);
6077+ string$dest(&_48);
6078+ }
6079+ node(&_45, &_46, &_47);
6080+ tree$dest(&_47);
6081+ tree$dest(&_46);
6082+ }
6083+ node(&_tree, &_44, &_45);
6084+ tree$dest(&_45);
60296085 tree$dest(&_44);
6030- tree$dest(&_43);
60316086 }
60326087 {
6033- uint64_t _43; memset(&_43, 0, sizeof(uint64_t));
6034- const struct StreamOut *_44 = &(*streams).out;
6035- PrintTreeMatch(&_43, &*_44, &_tree);
6036- _IGNORE_(_43);
6088+ uint64_t _44; memset(&_44, 0, sizeof(uint64_t));
6089+ const struct StreamOut *_45 = &(*streams).out;
6090+ PrintTreeMatch(&_44, &*_45, &_tree);
6091+ _IGNORE_(_44);
60376092 }
60386093 {
6039- const struct StreamOut *_44 = &(*streams).out;
6040- struct string _45; memset(&_45, 0, sizeof(struct string));
6041- init$fromliteral(&_45, "", 0);
6042- PutStrLn(0 /* _43 */, &*_44, &_45);
6043- string$dest(&_45);
6044- }
6045- {
60466094 const struct StreamOut *_45 = &(*streams).out;
6047- PrintTree(0 /* _44 */, &*_45, &_tree);
6095+ struct string _46; memset(&_46, 0, sizeof(struct string));
6096+ init$fromliteral(&_46, "", 0);
6097+ PutStrLn(0 /* _44 */, &*_45, &_46);
6098+ string$dest(&_46);
60486099 }
60496100 {
60506101 const struct StreamOut *_46 = &(*streams).out;
6051- struct string _47; memset(&_47, 0, sizeof(struct string));
6052- init$fromliteral(&_47, "", 0);
6053- PutStrLn(0 /* _45 */, &*_46, &_47);
6054- string$dest(&_47);
6102+ PrintTree(0 /* _45 */, &*_46, &_tree);
60556103 }
60566104 {
6057- uint64_t _46; memset(&_46, 0, sizeof(uint64_t));
60586105 const struct StreamOut *_47 = &(*streams).out;
6059- struct stack/*tree2*/ _48; memset(&_48, 0, sizeof(struct stack/*tree2*/));
6060- {
6061- tree_to_tree2(&_48, &_tree);
6062- }
6063- PrintTree2Match(&_46, &*_47, &_48);
6064- free$(&_48, sizeof(struct tree2), (void (*)(void *))tree2$dest);
6065- _IGNORE_(_46);
6066- }
6067- {
6068- const struct StreamOut *_47 = &(*streams).out;
60696106 struct string _48; memset(&_48, 0, sizeof(struct string));
60706107 init$fromliteral(&_48, "", 0);
60716108 PutStrLn(0 /* _46 */, &*_47, &_48);
@@ -6072,184 +6109,202 @@
60726109 string$dest(&_48);
60736110 }
60746111 {
6112+ uint64_t _47; memset(&_47, 0, sizeof(uint64_t));
60756113 const struct StreamOut *_48 = &(*streams).out;
60766114 struct stack/*tree2*/ _49; memset(&_49, 0, sizeof(struct stack/*tree2*/));
60776115 {
60786116 tree_to_tree2(&_49, &_tree);
60796117 }
6080- PrintTree2(0 /* _47 */, &*_48, &_49);
6118+ PrintTree2Match(&_47, &*_48, &_49);
60816119 free$(&_49, sizeof(struct tree2), (void (*)(void *))tree2$dest);
6120+ _IGNORE_(_47);
60826121 }
60836122 {
6123+ const struct StreamOut *_48 = &(*streams).out;
6124+ struct string _49; memset(&_49, 0, sizeof(struct string));
6125+ init$fromliteral(&_49, "", 0);
6126+ PutStrLn(0 /* _47 */, &*_48, &_49);
6127+ string$dest(&_49);
6128+ }
6129+ {
60846130 const struct StreamOut *_49 = &(*streams).out;
6085- struct string _50; memset(&_50, 0, sizeof(struct string));
6086- init$fromliteral(&_50, "", 0);
6087- PutStrLn(0 /* _48 */, &*_49, &_50);
6088- string$dest(&_50);
6131+ struct stack/*tree2*/ _50; memset(&_50, 0, sizeof(struct stack/*tree2*/));
6132+ {
6133+ tree_to_tree2(&_50, &_tree);
6134+ }
6135+ PrintTree2(0 /* _48 */, &*_49, &_50);
6136+ free$(&_50, sizeof(struct tree2), (void (*)(void *))tree2$dest);
60896137 }
60906138 {
60916139 const struct StreamOut *_50 = &(*streams).out;
6092- Print$tree(0 /* _49 */, &*_50, &_tree);
6140+ struct string _51; memset(&_51, 0, sizeof(struct string));
6141+ init$fromliteral(&_51, "", 0);
6142+ PutStrLn(0 /* _49 */, &*_50, &_51);
6143+ string$dest(&_51);
60936144 }
60946145 {
60956146 const struct StreamOut *_51 = &(*streams).out;
6096- struct string _52; memset(&_52, 0, sizeof(struct string));
6097- init$fromliteral(&_52, "\n", 1);
6098- PutStr(0 /* _50 */, &*_51, &_52);
6099- string$dest(&_52);
6147+ Print$tree(0 /* _50 */, &*_51, &_tree);
61006148 }
61016149 {
6150+ const struct StreamOut *_52 = &(*streams).out;
6151+ struct string _53; memset(&_53, 0, sizeof(struct string));
6152+ init$fromliteral(&_53, "\n", 1);
6153+ PutStr(0 /* _51 */, &*_52, &_53);
6154+ string$dest(&_53);
6155+ }
6156+ {
61026157 {
6103- const struct StreamOut *_53 = &(*streams).out;
6104- struct string _54; memset(&_54, 0, sizeof(struct string));
6105- init$fromliteral(&_54, "for-test 1: ", 12);
6106- PutStrLn(0 /* _52 */, &*_53, &_54);
6107- string$dest(&_54);
6158+ const struct StreamOut *_54 = &(*streams).out;
6159+ struct string _55; memset(&_55, 0, sizeof(struct string));
6160+ init$fromliteral(&_55, "for-test 1: ", 12);
6161+ PutStrLn(0 /* _53 */, &*_54, &_55);
6162+ string$dest(&_55);
61086163 }
61096164 uint32_t _n; memset(&_n, 0, sizeof(uint32_t));
61106165 _n = 5;
61116166 {
6112- uint32_t _53 = _n;
6113- uint32_t *i = &_53;
6167+ uint32_t _54 = _n;
6168+ uint32_t *i = &_54;
61146169 while((*i)--)
61156170 {
61166171 {
6117- const struct StreamOut *_55 = &(*streams).out;
6118- Print$u32(0 /* _54 */, &*_55, &*i);
6172+ const struct StreamOut *_56 = &(*streams).out;
6173+ Print$u32(0 /* _55 */, &*_56, &*i);
61196174 }
61206175 }
61216176 }
61226177 {
6123- const struct StreamOut *_55 = &(*streams).out;
6124- struct string _56; memset(&_56, 0, sizeof(struct string));
6125- init$fromliteral(&_56, "", 0);
6126- PutStrLn(0 /* _54 */, &*_55, &_56);
6127- string$dest(&_56);
6128- }
6129- {
61306178 const struct StreamOut *_56 = &(*streams).out;
61316179 struct string _57; memset(&_57, 0, sizeof(struct string));
6132- init$fromliteral(&_57, "for-test 2: ", 12);
6180+ init$fromliteral(&_57, "", 0);
61336181 PutStrLn(0 /* _55 */, &*_56, &_57);
61346182 string$dest(&_57);
61356183 }
61366184 {
6137- uint32_t _57 = _n;
6138- uint32_t *_56 = &_57;
6139- while((*_56)--)
6185+ const struct StreamOut *_57 = &(*streams).out;
6186+ struct string _58; memset(&_58, 0, sizeof(struct string));
6187+ init$fromliteral(&_58, "for-test 2: ", 12);
6188+ PutStrLn(0 /* _56 */, &*_57, &_58);
6189+ string$dest(&_58);
6190+ }
6191+ {
6192+ uint32_t _58 = _n;
6193+ uint32_t *_57 = &_58;
6194+ while((*_57)--)
61406195 {
61416196 {
6142- const struct StreamOut *_59 = &(*streams).out;
6143- struct string _60; memset(&_60, 0, sizeof(struct string));
6144- init$fromliteral(&_60, ".", 1);
6145- PutStr(0 /* _58 */, &*_59, &_60);
6146- string$dest(&_60);
6197+ const struct StreamOut *_60 = &(*streams).out;
6198+ struct string _61; memset(&_61, 0, sizeof(struct string));
6199+ init$fromliteral(&_61, ".", 1);
6200+ PutStr(0 /* _59 */, &*_60, &_61);
6201+ string$dest(&_61);
61476202 }
61486203 }
6149- __SUPPRESS_WARNING_UNUSED_VARIABLE__(&*_56);
6204+ __SUPPRESS_WARNING_UNUSED_VARIABLE__(&*_57);
61506205 }
61516206 {
6152- const struct StreamOut *_59 = &(*streams).out;
6153- struct string _60; memset(&_60, 0, sizeof(struct string));
6154- init$fromliteral(&_60, "", 0);
6155- PutStrLn(0 /* _58 */, &*_59, &_60);
6156- string$dest(&_60);
6157- }
6158- {
61596207 const struct StreamOut *_60 = &(*streams).out;
61606208 struct string _61; memset(&_61, 0, sizeof(struct string));
6161- init$fromliteral(&_61, "for-test 3: ", 12);
6209+ init$fromliteral(&_61, "", 0);
61626210 PutStrLn(0 /* _59 */, &*_60, &_61);
61636211 string$dest(&_61);
61646212 }
6213+ {
6214+ const struct StreamOut *_61 = &(*streams).out;
6215+ struct string _62; memset(&_62, 0, sizeof(struct string));
6216+ init$fromliteral(&_62, "for-test 3: ", 12);
6217+ PutStrLn(0 /* _60 */, &*_61, &_62);
6218+ string$dest(&_62);
6219+ }
61656220 struct string _s; memset(&_s, 0, sizeof(struct string));
61666221 init$fromliteral(&_s, "Test!", 5);
61676222 struct stack/*u8*/ _sd; memset(&_sd, 0, sizeof(struct stack/*u8*/));
61686223 clone$(&_sd, &(_s).data, sizeof(uint8_t), 0/*DEST*/, 0/*COPY*/);
6169- const struct stack/*u8*/ *_61 = &(_sd);
6170- for(uint64_t _62 = 0; _62 < (*_61).fill; ++_62)
6224+ const struct stack/*u8*/ *_62 = &(_sd);
6225+ for(uint64_t _63 = 0; _63 < (*_62).fill; ++_63)
61716226 {
6172- const uint8_t *_60 = &((uint8_t *)((*_61).data))[_62];
6227+ const uint8_t *_61 = &((uint8_t *)((*_62).data))[_63];
61736228 {
6174- const struct StreamOut *_64 = &(*streams).out;
6175- uint8_t _65; memset(&_65, 0, sizeof(uint8_t));
6176- _65 = 35;
6177- Put(0 /* _63 */, &*_64, &_65);
6178- _IGNORE_(_65);
6229+ const struct StreamOut *_65 = &(*streams).out;
6230+ uint8_t _66; memset(&_66, 0, sizeof(uint8_t));
6231+ _66 = 35;
6232+ Put(0 /* _64 */, &*_65, &_66);
6233+ _IGNORE_(_66);
61796234 }
6180- __SUPPRESS_WARNING_UNUSED_VARIABLE__(&*_60);
6235+ __SUPPRESS_WARNING_UNUSED_VARIABLE__(&*_61);
61816236 }
61826237 {
6183- const struct StreamOut *_64 = &(*streams).out;
6184- struct string _65; memset(&_65, 0, sizeof(struct string));
6185- init$fromliteral(&_65, "", 0);
6186- PutStrLn(0 /* _63 */, &*_64, &_65);
6187- string$dest(&_65);
6188- }
6189- {
61906238 const struct StreamOut *_65 = &(*streams).out;
61916239 struct string _66; memset(&_66, 0, sizeof(struct string));
6192- init$fromliteral(&_66, "for-test 4: ", 12);
6240+ init$fromliteral(&_66, "", 0);
61936241 PutStrLn(0 /* _64 */, &*_65, &_66);
61946242 string$dest(&_66);
61956243 }
61966244 {
6245+ const struct StreamOut *_66 = &(*streams).out;
6246+ struct string _67; memset(&_67, 0, sizeof(struct string));
6247+ init$fromliteral(&_67, "for-test 4: ", 12);
6248+ PutStrLn(0 /* _65 */, &*_66, &_67);
6249+ string$dest(&_67);
6250+ }
6251+ {
61976252 {
6198- struct string _66; memset(&_66, 0, sizeof(struct string));
6199- init$fromliteral(&_66, "Test!", 5);
6200- struct string *s = &_66;
6253+ struct string _67; memset(&_67, 0, sizeof(struct string));
6254+ init$fromliteral(&_67, "Test!", 5);
6255+ struct string *s = &_67;
62016256 {
6202- struct stack/*u8*/ _67; memset(&_67, 0, sizeof(struct stack/*u8*/));
6203- clone$(&_67, &(*s).data, sizeof(uint8_t), 0/*DEST*/, 0/*COPY*/);
6204- struct stack/*u8*/ *sd = &_67;
6257+ struct stack/*u8*/ _68; memset(&_68, 0, sizeof(struct stack/*u8*/));
6258+ clone$(&_68, &(*s).data, sizeof(uint8_t), 0/*DEST*/, 0/*COPY*/);
6259+ struct stack/*u8*/ *sd = &_68;
62056260 {
6206- const struct StreamOut *_69 = &(*streams).out;
6207- PrintStack(0 /* _68 */, &*_69, &*sd);
6208- }
6209- {
62106261 const struct StreamOut *_70 = &(*streams).out;
6211- struct string _71; memset(&_71, 0, sizeof(struct string));
6212- init$fromliteral(&_71, "", 0);
6213- PutStrLn(0 /* _69 */, &*_70, &_71);
6214- string$dest(&_71);
6262+ PrintStack(0 /* _69 */, &*_70, &*sd);
62156263 }
62166264 {
6217- uint8_t _71; memset(&_71, 0, sizeof(uint8_t));
6218- _71 = 35;
6219- WipeMutStack(0 /* _70 */, &*sd, &_71);
6220- _IGNORE_(_71);
6265+ const struct StreamOut *_71 = &(*streams).out;
6266+ struct string _72; memset(&_72, 0, sizeof(struct string));
6267+ init$fromliteral(&_72, "", 0);
6268+ PutStrLn(0 /* _70 */, &*_71, &_72);
6269+ string$dest(&_72);
62216270 }
62226271 {
6223- const struct StreamOut *_72 = &(*streams).out;
6224- PrintStack(0 /* _71 */, &*_72, &*sd);
6272+ uint8_t _72; memset(&_72, 0, sizeof(uint8_t));
6273+ _72 = 35;
6274+ WipeMutStack(0 /* _71 */, &*sd, &_72);
6275+ _IGNORE_(_72);
62256276 }
62266277 {
62276278 const struct StreamOut *_73 = &(*streams).out;
6228- struct string _74; memset(&_74, 0, sizeof(struct string));
6229- init$fromliteral(&_74, "", 0);
6230- PutStrLn(0 /* _72 */, &*_73, &_74);
6231- string$dest(&_74);
6279+ PrintStack(0 /* _72 */, &*_73, &*sd);
62326280 }
62336281 {
6234- uint8_t _74; memset(&_74, 0, sizeof(uint8_t));
6235- _74 = 42;
6236- WipeStackMut(0 /* _73 */, &*sd, &_74);
6237- _IGNORE_(_74);
6282+ const struct StreamOut *_74 = &(*streams).out;
6283+ struct string _75; memset(&_75, 0, sizeof(struct string));
6284+ init$fromliteral(&_75, "", 0);
6285+ PutStrLn(0 /* _73 */, &*_74, &_75);
6286+ string$dest(&_75);
62386287 }
62396288 {
6240- const struct StreamOut *_75 = &(*streams).out;
6241- PrintStack(0 /* _74 */, &*_75, &*sd);
6289+ uint8_t _75; memset(&_75, 0, sizeof(uint8_t));
6290+ _75 = 42;
6291+ WipeStackMut(0 /* _74 */, &*sd, &_75);
6292+ _IGNORE_(_75);
62426293 }
62436294 {
62446295 const struct StreamOut *_76 = &(*streams).out;
6245- struct string _77; memset(&_77, 0, sizeof(struct string));
6246- init$fromliteral(&_77, "", 0);
6247- PutStrLn(0 /* _75 */, &*_76, &_77);
6248- string$dest(&_77);
6296+ PrintStack(0 /* _75 */, &*_76, &*sd);
62496297 }
6250- free$(&_67, sizeof(uint8_t), 0/*DEST*/);
6298+ {
6299+ const struct StreamOut *_77 = &(*streams).out;
6300+ struct string _78; memset(&_78, 0, sizeof(struct string));
6301+ init$fromliteral(&_78, "", 0);
6302+ PutStrLn(0 /* _76 */, &*_77, &_78);
6303+ string$dest(&_78);
62516304 }
6252- string$dest(&_66);
6305+ free$(&_68, sizeof(uint8_t), 0/*DEST*/);
6306+ }
6307+ string$dest(&_67);
62536308 }
62546309 }
62556310 free$(&_sd, sizeof(uint8_t), 0/*DEST*/);
@@ -6257,72 +6312,72 @@
62576312 _IGNORE_(_n);
62586313 }
62596314 {
6260- const struct StreamOut *_53 = &(*streams).out;
6261- TstStk$(0 /* _52 */, &*_53);
6262- }
6263- {
62646315 const struct StreamOut *_54 = &(*streams).out;
6265- TstDyn$(0 /* _53 */, &*_54);
6316+ TstStk$(0 /* _53 */, &*_54);
62666317 }
62676318 {
62686319 const struct StreamOut *_55 = &(*streams).out;
6269- struct string _56; memset(&_56, 0, sizeof(struct string));
6270- {
6271- testTemporaryDynamics$(&_56);
6272- }
6273- PutStr(0 /* _54 */, &*_55, &_56);
6274- string$dest(&_56);
6320+ TstDyn$(0 /* _54 */, &*_55);
62756321 }
62766322 {
62776323 const struct StreamOut *_56 = &(*streams).out;
62786324 struct string _57; memset(&_57, 0, sizeof(struct string));
62796325 {
6280- struct string _58; memset(&_58, 0, sizeof(struct string));
6281- init$fromliteral(&_58, "Hello ", 6);
6282- struct string _59; memset(&_59, 0, sizeof(struct string));
6283- init$fromliteral(&_59, "World\n", 6);
6284- strcat$(&_57, &_58, &_59, 817);
6285- string$dest(&_59);
6286- string$dest(&_58);
6326+ testTemporaryDynamics$(&_57);
62876327 }
62886328 PutStr(0 /* _55 */, &*_56, &_57);
62896329 string$dest(&_57);
62906330 }
6331+ {
6332+ const struct StreamOut *_57 = &(*streams).out;
6333+ struct string _58; memset(&_58, 0, sizeof(struct string));
6334+ {
6335+ struct string _59; memset(&_59, 0, sizeof(struct string));
6336+ init$fromliteral(&_59, "Hello ", 6);
6337+ struct string _60; memset(&_60, 0, sizeof(struct string));
6338+ init$fromliteral(&_60, "World\n", 6);
6339+ strcat$(&_58, &_59, &_60, 827);
6340+ string$dest(&_60);
6341+ string$dest(&_59);
6342+ }
6343+ PutStr(0 /* _56 */, &*_57, &_58);
6344+ string$dest(&_58);
6345+ }
62916346 struct U$ _test; memset(&_test, 0, sizeof(struct U$));
62926347 {
6293- struct string _56; memset(&_56, 0, sizeof(struct string));
6294- init$fromliteral(&_56, "Hello???", 8);
6295- s$(&_test, &_56);
6296- string$dest(&_56);
6348+ struct string _57; memset(&_57, 0, sizeof(struct string));
6349+ init$fromliteral(&_57, "Hello???", 8);
6350+ s$(&_test, &_57);
6351+ string$dest(&_57);
62976352 }
62986353 {
6299- struct string _56; memset(&_56, 0, sizeof(struct string));
6300- init$fromliteral(&_56, "Hello Union!!!", 14);
6301- s$(&_test, &_56);
6302- string$dest(&_56);
6354+ struct string _57; memset(&_57, 0, sizeof(struct string));
6355+ init$fromliteral(&_57, "Hello Union!!!", 14);
6356+ s$(&_test, &_57);
6357+ string$dest(&_57);
63036358 }
63046359 {
6305- const struct StreamOut *_57 = &(*streams).out;
6306- struct string _58; memset(&_58, 0, sizeof(struct string));
6360+ const struct StreamOut *_58 = &(*streams).out;
6361+ struct string _59; memset(&_59, 0, sizeof(struct string));
63076362 {
6308- getstr$(&_58, &_test);
6363+ getstr$(&_59, &_test);
63096364 }
6310- PutStrLn(0 /* _56 */, &*_57, &_58);
6311- string$dest(&_58);
6365+ PutStrLn(0 /* _57 */, &*_58, &_59);
6366+ string$dest(&_59);
63126367 }
6313- struct U$ *_57 = &(_test);
6314- switch((*_57).type)
6368+ struct U$ *_58 = &(_test);
6369+ switch((*_58).type)
63156370 {
63166371 case 0: // uint32_t x:
63176372 {
6318- uint32_t *test = &((*_57).x);
6373+ uint32_t *test = &((*_58).x);
63196374 {
63206375 {
6321- const struct StreamOut *_60 = &(*streams).out;
6322- struct string _61; memset(&_61, 0, sizeof(struct string));
6323- init$fromliteral(&_61, "u", 1);
6324- PutStrLn(0 /* _59 */, &*_60, &_61);
6325- string$dest(&_61);
6376+ const struct StreamOut *_61 = &(*streams).out;
6377+ struct string _62; memset(&_62, 0, sizeof(struct string));
6378+ init$fromliteral(&_62, "u", 1);
6379+ PutStrLn(0 /* _60 */, &*_61, &_62);
6380+ string$dest(&_62);
63266381 }
63276382 }
63286383 __SUPPRESS_WARNING_UNUSED_VARIABLE__(test);
@@ -6330,13 +6385,13 @@
63306385 }
63316386 case 1: // bool b:
63326387 {
6333- bool *test = &((*_57).b);
6388+ bool *test = &((*_58).b);
63346389 {
6335- const struct StreamOut *_60 = &(*streams).out;
6336- struct string _61; memset(&_61, 0, sizeof(struct string));
6337- init$fromliteral(&_61, "nr", 2);
6338- PutStrLn(0 /* _59 */, &*_60, &_61);
6339- string$dest(&_61);
6390+ const struct StreamOut *_61 = &(*streams).out;
6391+ struct string _62; memset(&_62, 0, sizeof(struct string));
6392+ init$fromliteral(&_62, "nr", 2);
6393+ PutStrLn(0 /* _60 */, &*_61, &_62);
6394+ string$dest(&_62);
63406395 }
63416396 __SUPPRESS_WARNING_UNUSED_VARIABLE__(test);
63426397 break;
@@ -6344,20 +6399,20 @@
63446399 case 2: // void v:
63456400 {
63466401 {
6347- const struct StreamOut *_61 = &(*streams).out;
6348- struct string _62; memset(&_62, 0, sizeof(struct string));
6349- init$fromliteral(&_62, "v", 1);
6350- PutStrLn(0 /* _60 */, &*_61, &_62);
6351- string$dest(&_62);
6402+ const struct StreamOut *_62 = &(*streams).out;
6403+ struct string _63; memset(&_63, 0, sizeof(struct string));
6404+ init$fromliteral(&_63, "v", 1);
6405+ PutStrLn(0 /* _61 */, &*_62, &_63);
6406+ string$dest(&_63);
63526407 }
63536408 break;
63546409 }
63556410 case 3: // struct string s$:
63566411 {
6357- struct string *test = &((*_57).s$);
6412+ struct string *test = &((*_58).s$);
63586413 {
6359- const struct StreamOut *_62 = &(*streams).out;
6360- PutStrLn(0 /* _61 */, &*_62, &*test);
6414+ const struct StreamOut *_63 = &(*streams).out;
6415+ PutStrLn(0 /* _62 */, &*_63, &*test);
63616416 }
63626417 break;
63636418 }
@@ -6374,42 +6429,42 @@
63746429 {
63756430 two(&_en);
63766431 }
6377- struct enu *_62 = &(_en);
6378- switch((*_62).type)
6432+ struct enu *_63 = &(_en);
6433+ switch((*_63).type)
63796434 {
63806435 case 0: // void zero:
63816436 {
63826437 {
6383- const struct StreamOut *_64 = &(*streams).out;
6384- struct string _65; memset(&_65, 0, sizeof(struct string));
6385- init$fromliteral(&_65, "zero", 4);
6386- PutStrLn(0 /* _63 */, &*_64, &_65);
6387- string$dest(&_65);
6388- }
6389- break;
6390- }
6391- case 1: // void one:
6392- {
6393- {
63946438 const struct StreamOut *_65 = &(*streams).out;
63956439 struct string _66; memset(&_66, 0, sizeof(struct string));
6396- init$fromliteral(&_66, "one", 3);
6440+ init$fromliteral(&_66, "zero", 4);
63976441 PutStrLn(0 /* _64 */, &*_65, &_66);
63986442 string$dest(&_66);
63996443 }
64006444 break;
64016445 }
6402- case 2: // void two:
6446+ case 1: // void one:
64036447 {
64046448 {
64056449 const struct StreamOut *_66 = &(*streams).out;
64066450 struct string _67; memset(&_67, 0, sizeof(struct string));
6407- init$fromliteral(&_67, "two", 3);
6451+ init$fromliteral(&_67, "one", 3);
64086452 PutStrLn(0 /* _65 */, &*_66, &_67);
64096453 string$dest(&_67);
64106454 }
64116455 break;
64126456 }
6457+ case 2: // void two:
6458+ {
6459+ {
6460+ const struct StreamOut *_67 = &(*streams).out;
6461+ struct string _68; memset(&_68, 0, sizeof(struct string));
6462+ init$fromliteral(&_68, "two", 3);
6463+ PutStrLn(0 /* _66 */, &*_67, &_68);
6464+ string$dest(&_68);
6465+ }
6466+ break;
6467+ }
64136468 default:
64146469 {
64156470 fprintf(stderr, "INTERNAL ERROR IN SWITCH");
@@ -6420,42 +6475,42 @@
64206475 {
64216476 zero2(&_en2);
64226477 }
6423- struct enu2 *_66 = &(_en2);
6424- switch((*_66).type)
6478+ struct enu2 *_67 = &(_en2);
6479+ switch((*_67).type)
64256480 {
64266481 case 0: // void zero2:
64276482 {
64286483 {
6429- const struct StreamOut *_68 = &(*streams).out;
6430- struct string _69; memset(&_69, 0, sizeof(struct string));
6431- init$fromliteral(&_69, "zero2", 5);
6432- PutStrLn(0 /* _67 */, &*_68, &_69);
6433- string$dest(&_69);
6434- }
6435- break;
6436- }
6437- case 1: // void one2:
6438- {
6439- {
64406484 const struct StreamOut *_69 = &(*streams).out;
64416485 struct string _70; memset(&_70, 0, sizeof(struct string));
6442- init$fromliteral(&_70, "one2", 4);
6486+ init$fromliteral(&_70, "zero2", 5);
64436487 PutStrLn(0 /* _68 */, &*_69, &_70);
64446488 string$dest(&_70);
64456489 }
64466490 break;
64476491 }
6448- case 2: // void two2:
6492+ case 1: // void one2:
64496493 {
64506494 {
64516495 const struct StreamOut *_70 = &(*streams).out;
64526496 struct string _71; memset(&_71, 0, sizeof(struct string));
6453- init$fromliteral(&_71, "two2", 4);
6497+ init$fromliteral(&_71, "one2", 4);
64546498 PutStrLn(0 /* _69 */, &*_70, &_71);
64556499 string$dest(&_71);
64566500 }
64576501 break;
64586502 }
6503+ case 2: // void two2:
6504+ {
6505+ {
6506+ const struct StreamOut *_71 = &(*streams).out;
6507+ struct string _72; memset(&_72, 0, sizeof(struct string));
6508+ init$fromliteral(&_72, "two2", 4);
6509+ PutStrLn(0 /* _70 */, &*_71, &_72);
6510+ string$dest(&_72);
6511+ }
6512+ break;
6513+ }
64596514 default:
64606515 {
64616516 fprintf(stderr, "INTERNAL ERROR IN SWITCH");
@@ -6464,44 +6519,44 @@
64646519 }
64656520 struct stack/*string*/ _other; memset(&_other, 0, sizeof(struct stack/*string*/));
64666521 {
6467- struct string _70; memset(&_70, 0, sizeof(struct string));
6468- init$fromliteral(&_70, "SOLID", 5);
6469- solid(&_other, &_70, sizeof(struct string), (void (*)(void *))string$dest, (void (*)(void *, const void *))string$copy, 844);
6470- string$dest(&_70);
6522+ struct string _71; memset(&_71, 0, sizeof(struct string));
6523+ init$fromliteral(&_71, "SOLID", 5);
6524+ solid(&_other, &_71, sizeof(struct string), (void (*)(void *))string$dest, (void (*)(void *, const void *))string$copy, 854);
6525+ string$dest(&_71);
64716526 }
64726527 {
6473- const struct StreamOut *_71 = &(*streams).out;
6474- struct string _72; memset(&_72, 0, sizeof(struct string));
6475- const struct stack/*string*/ *_73 = &(_other);
6476- if(!(*_73).size)
6528+ const struct StreamOut *_72 = &(*streams).out;
6529+ struct string _73; memset(&_73, 0, sizeof(struct string));
6530+ const struct stack/*string*/ *_74 = &(_other);
6531+ if(!(*_74).size)
64776532 {
6478- init$fromliteral(&_72, "EMPTY", 5);
6533+ init$fromliteral(&_73, "EMPTY", 5);
64796534 }
64806535 else
64816536 {
6482- const struct string *other = (*_73).data;
6483- string$copy(&_72, &(*other));
6537+ const struct string *other = (*_74).data;
6538+ string$copy(&_73, &(*other));
64846539 }
6485- PutStrLn(0 /* _70 */, &*_71, &_72);
6486- string$dest(&_72);
6540+ PutStrLn(0 /* _71 */, &*_72, &_73);
6541+ string$dest(&_73);
64876542 }
6488- const struct stack/*string*/ *_71 = &(_other);
6489- if(!(*_71).size)
6543+ const struct stack/*string*/ *_72 = &(_other);
6544+ if(!(*_72).size)
64906545 {
64916546 {
6492- const struct StreamOut *_73 = &(*streams).out;
6493- struct string _74; memset(&_74, 0, sizeof(struct string));
6494- init$fromliteral(&_74, "EMPTY", 5);
6495- PutStrLn(0 /* _72 */, &*_73, &_74);
6496- string$dest(&_74);
6547+ const struct StreamOut *_74 = &(*streams).out;
6548+ struct string _75; memset(&_75, 0, sizeof(struct string));
6549+ init$fromliteral(&_75, "EMPTY", 5);
6550+ PutStrLn(0 /* _73 */, &*_74, &_75);
6551+ string$dest(&_75);
64976552 }
64986553 }
64996554 else
65006555 {
6501- const struct string *other = (*_71).data;
6556+ const struct string *other = (*_72).data;
65026557 {
6503- const struct StreamOut *_74 = &(*streams).out;
6504- PutStrLn(0 /* _73 */, &*_74, &*other);
6558+ const struct StreamOut *_75 = &(*streams).out;
6559+ PutStrLn(0 /* _74 */, &*_75, &*other);
65056560 }
65066561 }
65076562 struct string _str; memset(&_str, 0, sizeof(struct string));
@@ -6508,76 +6563,76 @@
65086563 init$fromliteral(&_str, "test...", 7);
65096564 struct stack/*string*/ _stk; memset(&_stk, 0, sizeof(struct stack/*string*/));
65106565 {
6511- push(0 /* _74 */, &_stk, &_str, sizeof(struct string), (void (*)(void *))string$dest, (void (*)(void *, const void *))string$copy, 853);
6566+ push(0 /* _75 */, &_stk, &_str, sizeof(struct string), (void (*)(void *))string$dest, (void (*)(void *, const void *))string$copy, 863);
65126567 }
65136568 {
6514- push(0 /* _75 */, &_stk, &_str, sizeof(struct string), (void (*)(void *))string$dest, (void (*)(void *, const void *))string$copy, 854);
6569+ push(0 /* _76 */, &_stk, &_str, sizeof(struct string), (void (*)(void *))string$dest, (void (*)(void *, const void *))string$copy, 864);
65156570 }
65166571 {
6517- struct stack/*string*/ _76; memset(&_76, 0, sizeof(struct stack/*string*/));
6518- pop_opt(&_76, &_stk, sizeof(struct string), (void (*)(void *))string$dest, (void (*)(void *, const void *))string$copy, 855);
6519- free$(&_76, sizeof(struct string), (void (*)(void *))string$dest);
6572+ struct stack/*string*/ _77; memset(&_77, 0, sizeof(struct stack/*string*/));
6573+ pop_opt(&_77, &_stk, sizeof(struct string), (void (*)(void *))string$dest, (void (*)(void *, const void *))string$copy, 865);
6574+ free$(&_77, sizeof(struct string), (void (*)(void *))string$dest);
65206575 }
65216576 {
6522- stack(&_stk, sizeof(struct string), (void (*)(void *))string$dest, (void (*)(void *, const void *))string$copy, 856);
6577+ stack(&_stk, sizeof(struct string), (void (*)(void *))string$dest, (void (*)(void *, const void *))string$copy, 866);
65236578 }
65246579 {
6525- struct stack/*u8*/ _76; memset(&_76, 0, sizeof(struct stack/*u8*/));
6526- access$(&_76, &_str);
6527- free$(&_76, sizeof(uint8_t), 0/*DEST*/);
6580+ struct stack/*u8*/ _77; memset(&_77, 0, sizeof(struct stack/*u8*/));
6581+ access$(&_77, &_str);
6582+ free$(&_77, sizeof(uint8_t), 0/*DEST*/);
65286583 }
65296584 struct box$ _A; memset(&_A, 0, sizeof(struct box$));
65306585 {
6531- struct string _76; memset(&_76, 0, sizeof(struct string));
6532- init$fromliteral(&_76, "ABC", 3);
6533- box$(&_A, &_76);
6534- string$dest(&_76);
6535- }
6536- {
65376586 struct string _77; memset(&_77, 0, sizeof(struct string));
6538- init$fromliteral(&_77, "ref-count box test", 18);
6539- boxset$(0 /* _76 */, &_A, &_77);
6587+ init$fromliteral(&_77, "ABC", 3);
6588+ box$(&_A, &_77);
65406589 string$dest(&_77);
65416590 }
6591+ {
6592+ struct string _78; memset(&_78, 0, sizeof(struct string));
6593+ init$fromliteral(&_78, "ref-count box test", 18);
6594+ boxset$(0 /* _77 */, &_A, &_78);
6595+ string$dest(&_78);
6596+ }
65426597 struct box$ _B; memset(&_B, 0, sizeof(struct box$));
65436598 box$$copy(&_B, &(_A));
65446599 struct box$ _C; memset(&_C, 0, sizeof(struct box$));
65456600 {
6546- struct string _77; memset(&_77, 0, sizeof(struct string));
6547- init$fromliteral(&_77, "DEF", 3);
6548- box$(&_C, &_77);
6549- string$dest(&_77);
6601+ struct string _78; memset(&_78, 0, sizeof(struct string));
6602+ init$fromliteral(&_78, "DEF", 3);
6603+ box$(&_C, &_78);
6604+ string$dest(&_78);
65506605 }
65516606 box$$copy(&_C, &(_B));
65526607 {
6553- const struct StreamOut *_78 = &(*streams).out;
6554- struct string _79; memset(&_79, 0, sizeof(struct string));
6555- {
6556- boxget$(&_79, &_C);
6557- }
6558- PutStrLn(0 /* _77 */, &*_78, &_79);
6559- string$dest(&_79);
6560- }
6561- {
65626608 const struct StreamOut *_79 = &(*streams).out;
65636609 struct string _80; memset(&_80, 0, sizeof(struct string));
65646610 {
6565- shadow(&_80);
6611+ boxget$(&_80, &_C);
65666612 }
6567- Print$string(0 /* _78 */, &*_79, &_80);
6613+ PutStrLn(0 /* _78 */, &*_79, &_80);
65686614 string$dest(&_80);
65696615 }
65706616 {
65716617 const struct StreamOut *_80 = &(*streams).out;
65726618 struct string _81; memset(&_81, 0, sizeof(struct string));
6573- init$fromliteral(&_81, "", 0);
6574- PutStrLn(0 /* _79 */, &*_80, &_81);
6619+ {
6620+ shadow(&_81);
6621+ }
6622+ Print$string(0 /* _79 */, &*_80, &_81);
65756623 string$dest(&_81);
65766624 }
6577- int32_t _80; memset(&_80, 0, sizeof(int32_t));
6578- _80 = 0;
6579- *_0 = _80;
6580- _IGNORE_(_80);
6625+ {
6626+ const struct StreamOut *_81 = &(*streams).out;
6627+ struct string _82; memset(&_82, 0, sizeof(struct string));
6628+ init$fromliteral(&_82, "", 0);
6629+ PutStrLn(0 /* _80 */, &*_81, &_82);
6630+ string$dest(&_82);
6631+ }
6632+ int32_t _81; memset(&_81, 0, sizeof(int32_t));
6633+ _81 = 0;
6634+ *_0 = _81;
6635+ _IGNORE_(_81);
65816636 box$$dest(&_C);
65826637 box$$dest(&_B);
65836638 box$$dest(&_A);
Show on old repository browser