← Back to branch summary

~ubuntu-branches/ubuntu/vivid/emscripten/vivid

« back to all changes in this revision

Viewing changes to tools/test-js-optimizer-asm-pre-output.js

  • Committer: Package Import Robot
  • Author(s): Sylvestre Ledru
  • Date: 2013-09-20 22:44:35 UTC
  • mfrom: (4.1.1 sid)
  • Revision ID: package-import@ubuntu.com-20130920224435-apuwj4fsl3fqv1a6
Tags: 1.5.6~20130920~6010666-1
http://bugs.debian.org/723129
* New snapshot release
* Update the list of supported architectures to the same as libv8
  (Closes: #723129)
* emlibtool has been removed from upstream.
* Fix warning syntax-error-in-dep5-copyright
* Refresh of the patches

Show diffs side-by-side

added added

removed removed

Lines of Context:
tools/test-js-optimizer-asm-pre-output.js
1
1
function a() {
2
 
  f((HEAPU8[10202] | 0) + 5 | 0);
3
 
  f(HEAPU8[10202] | 0);
4
 
  f(347);
5
 
  f(351);
6
 
  f(8);
7
 
  HEAP[1024] = 5;
8
 
  HEAP[1024] = 5;
9
 
  whee(12, 13);
10
 
  whee(12, 13);
11
 
  f((g = t(), g + g | 0) | 0);
 
2
 f((HEAPU8[10202] | 0) + 5 | 0);
 
3
 f(HEAPU8[10202] | 0);
 
4
 f(347);
 
5
 f(351);
 
6
 f(8);
 
7
 HEAP[1024] = 5;
 
8
 HEAP[1024] = 5;
 
9
 whee(12, 13) | 0;
 
10
 +whee(12, 13);
 
11
 f((g = t(), g + g | 0) | 0);
 
12
 f() | 0;
 
13
 f((h() | 0) + 5 | 0);
 
14
 f(x + y + z | 0);
 
15
 +f();
 
16
 f(+(+h() + 5));
 
17
 $140 = $p_3_i + (-$mantSize_0_i | 0) | 0;
 
18
 f(g() | 0);
 
19
 f(g() | 0 & -1);
 
20
 f((g() | 0) >> 2);
 
21
 $56 = _fcntl() | 0 | 1;
 
22
 FUNCTION_TABLE_ii[55 & 127]() | 0;
12
23
}
13
24
function b($this, $__n) {
14
 
  $this = $this | 0;
15
 
  $__n = $__n | 0;
16
 
  var $4 = 0, $5 = 0, $10 = 0, $13 = 0, $14 = 0, $15 = 0, $23 = 0, $30 = 0, $38 = 0, $40 = 0;
17
 
  if (($__n | 0) == 0) {
18
 
    return;
19
 
  }
20
 
  $4 = $this;
21
 
  $5 = HEAP8[$4 & 16777215] | 0;
22
 
  if (($5 & 1) == 0) {
23
 
    $14 = 10;
24
 
    $13 = $5;
25
 
  } else {
26
 
    $10 = HEAP32[($this & 16777215) >> 2] | 0;
27
 
    $14 = ($10 & -2) - 1 | 0;
28
 
    $13 = $10 & 255;
29
 
  }
30
 
  $15 = $13 & 255;
31
 
  if (($15 & 1 | 0) == 0) {
32
 
    $23 = $15 >>> 1;
33
 
  } else {
34
 
    $23 = HEAP32[($this + 4 & 16777215) >> 2] | 0;
35
 
  }
36
 
  if (($14 - $23 | 0) >>> 0 < $__n >>> 0) {
37
 
    __ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE9__grow_byEjjjjjj($this, $14, ($__n - $14 | 0) + $23 | 0, $23, $23);
38
 
    $30 = HEAP8[$4 & 16777215] | 0;
39
 
  } else {
40
 
    $30 = $13;
41
 
  }
42
 
  if (($30 & 1) == 0) {
43
 
    $38 = $this + 1 | 0;
44
 
  } else {
45
 
    $38 = HEAP32[($this + 8 & 16777215) >> 2] | 0;
46
 
  }
47
 
  _memset($38 + $23 | 0, 0, $__n | 0, 1, 1213141516);
48
 
  $40 = $23 + $__n | 0;
49
 
  if ((HEAP8[$4 & 16777215] & 1) == 0) {
50
 
    HEAP8[$4 & 16777215] = $40 << 1 & 255;
51
 
  } else {
52
 
    HEAP32[($this + 4 & 16777215) >> 2] = $40;
53
 
  }
54
 
  HEAP8[$38 + $40 & 16777215] = 0;
 
25
 $this = $this | 0;
 
26
 $__n = $__n | 0;
 
27
 var $4 = 0, $5 = 0, $10 = 0, $13 = 0, $14 = 0, $15 = 0, $23 = 0, $30 = 0, $38 = 0, $40 = 0;
 
28
 if (($__n | 0) == 0) {
55
29
  return;
 
30
 }
 
31
 $4 = $this;
 
32
 $5 = HEAP8[$4 & 16777215] | 0;
 
33
 if (($5 & 1) == 0) {
 
34
  $14 = 10;
 
35
  $13 = $5;
 
36
 } else {
 
37
  $10 = HEAP32[($this & 16777215) >> 2] | 0;
 
38
  $14 = ($10 & -2) - 1 | 0;
 
39
  $13 = $10 & 255;
 
40
 }
 
41
 $15 = $13 & 255;
 
42
 if (($15 & 1 | 0) == 0) {
 
43
  $23 = $15 >>> 1;
 
44
 } else {
 
45
  $23 = HEAP32[($this + 4 & 16777215) >> 2] | 0;
 
46
 }
 
47
 if (($14 - $23 | 0) >>> 0 < $__n >>> 0) {
 
48
  __ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE9__grow_byEjjjjjj($this, $14, $__n - $14 + $23 | 0, $23, $23);
 
49
  $30 = HEAP8[$4 & 16777215] | 0;
 
50
 } else {
 
51
  $30 = $13;
 
52
 }
 
53
 if (($30 & 1) == 0) {
 
54
  $38 = $this + 1 | 0;
 
55
 } else {
 
56
  $38 = HEAP32[($this + 8 & 16777215) >> 2] | 0;
 
57
 }
 
58
 _memset($38 + $23 | 0, 0, $__n | 0, 1, 1213141516);
 
59
 $40 = $23 + $__n | 0;
 
60
 if ((HEAP8[$4 & 16777215] & 1) == 0) {
 
61
  HEAP8[$4 & 16777215] = $40 << 1 & 255;
 
62
 } else {
 
63
  HEAP32[($this + 4 & 16777215) >> 2] = $40;
 
64
 }
 
65
 HEAP8[$38 + $40 & 16777215] = 0;
 
66
 HEAP32[$4] = ~HEAP32[$5];
 
67
 HEAP32[$4] = ~HEAP32[$5];
 
68
 HEAP32[$4] = ~HEAP32[$5];
 
69
 h(~~g ^ -1);
 
70
 return;
56
71
}
57
72
function rett() {
58
 
  if (f()) {
59
 
    g();
60
 
    return 5;
61
 
  }
62
 
  return 0;
 
73
 if (f()) {
 
74
  g();
 
75
  return 5;
 
76
 }
 
77
 return 0;
63
78
}
64
79
function ret2t() {
65
 
  if (f()) {
66
 
    g();
67
 
    return;
68
 
  }
 
80
 if (f()) {
 
81
  g();
 
82
  return;
 
83
 }
69
84
}
70
85
function retf() {
71
 
  if (f()) {
72
 
    g();
73
 
    return +h();
74
 
  }
75
 
  return +0;
 
86
 if (f()) {
 
87
  g();
 
88
  return +h();
 
89
 }
 
90
 return +0;
76
91
}
77
92
function i32_8() {
78
 
  if ((HEAP8[$4 & 16777215] | 0) == 0) {
79
 
    print(5);
80
 
  }
81
 
  if ((HEAP8[$5 & 16777215] | 0) == 0) {
82
 
    print(5);
83
 
  }
84
 
  if ((HEAP8[$6 & 16777215] | 0) == 0) {
85
 
    print(5);
86
 
  }
87
 
  if ((HEAP8[$7 & 16777215] | 0) == 0) {
88
 
    print(5);
89
 
  }
90
 
  if (HEAPU8[$8 & 16777215] << 24 >> 16 == 0) {
91
 
    print(5);
92
 
  }
93
 
  if (HEAPU8[$9 & 16777215] << 16 >> 16 == 0) {
94
 
    print(5);
95
 
  }
 
93
 if ((HEAP8[$4 & 16777215] | 0) == 0) {
 
94
  print(5);
 
95
 }
 
96
 if ((HEAP8[$5 & 16777215] | 0) == 0) {
 
97
  print(5);
 
98
 }
 
99
 if ((HEAP8[$6 & 16777215] | 0) == 0) {
 
100
  print(5);
 
101
 }
 
102
 if ((HEAP8[$7 & 16777215] | 0) == 0) {
 
103
  print(5);
 
104
 }
 
105
 if (HEAPU8[$8 & 16777215] << 24 >> 16 == 0) {
 
106
  print(5);
 
107
 }
 
108
 if (HEAPU8[$9 & 16777215] << 16 >> 16 == 0) {
 
109
  print(5);
 
110
 }
96
111
}
97
112
function sign_extension_simplification() {
98
 
  if ((HEAP8[$4 & 16777215] & 127) == 0) {
99
 
    print(5);
100
 
  }
101
 
  if ((HEAP8[$4 & 16777215] & 128) << 24 >> 24 == 0) {
102
 
    print(5);
103
 
  }
104
 
  if ((HEAP32[$5 & 16777215] & 32767) == 0) {
105
 
    print(5);
106
 
  }
107
 
  if ((HEAP32[$5 & 16777215] & 32768) << 16 >> 16 == 0) {
108
 
    print(5);
109
 
  }
 
113
 if ((HEAP8[$4 & 16777215] & 127) == 0) {
 
114
  print(5);
 
115
 }
 
116
 if ((HEAP8[$4 & 16777215] & 128) << 24 >> 24 == 0) {
 
117
  print(5);
 
118
 }
 
119
 if ((HEAP32[$5 & 16777215] & 32767) == 0) {
 
120
  print(5);
 
121
 }
 
122
 if ((HEAP32[$5 & 16777215] & 32768) << 16 >> 16 == 0) {
 
123
  print(5);
 
124
 }
 
125
}
 
126
function compare_result_simplification() {
 
127
 HEAP32[$4] = HEAP32[$5] < HEAP32[$6];
 
128
 HEAP32[$4] = HEAP32[$5] > HEAP32[$6];
 
129
 HEAP32[$4] = HEAP32[$5] <= HEAP32[$6];
 
130
 HEAP32[$4] = HEAP32[$5] <= HEAP32[$6];
 
131
 HEAP32[$4] = HEAP32[$5] == HEAP32[$6];
 
132
 HEAP32[$4] = HEAP32[$5] === HEAP32[$6];
 
133
 HEAP32[$4] = HEAP32[$5] != HEAP32[$6];
 
134
 HEAP32[$4] = HEAP32[$5] !== HEAP32[$6];
 
135
 var x = HEAP32[$5] != HEAP32[$6] | 0;
110
136
}
111
137
function tempDoublePtr($45, $14, $28, $42) {
112
 
  $45 = $45 | 0;
113
 
  $14 = $14 | 0;
114
 
  $28 = $28 | 0;
115
 
  $42 = $42 | 0;
116
 
  var unelim = +0, bad = 0, unelim2 = +0;
117
 
  unelim = +(127.5 * +$14);
118
 
  HEAPF32[$45 >> 2] = ($14 < $28 ? $14 : $28) - $42;
119
 
  HEAP32[$world + 102916 >> 2] = _malloc(192) | 0;
120
 
  f(+HEAPF32[$45 >> 2]);
121
 
  g(HEAP32[$14 >> 2] | 0);
122
 
  $42 = +HEAPF32[$42 >> 2];
123
 
  ch($42);
124
 
  HEAPF32[$45 >> 2] = unelim;
125
 
  moar();
126
 
  bad = (HEAPF32[tempDoublePtr >> 2] = 127.5 * +$14, HEAP32[tempDoublePtr >> 2] | 0);
127
 
  func();
128
 
  HEAP32[4] = bad;
129
 
  HEAP32[5] = bad + 1;
130
 
  moar();
131
 
  unelim2 = 127 + $14 | 0;
132
 
  func();
133
 
  HEAP32[4] = unelim2;
 
138
 $45 = $45 | 0;
 
139
 $14 = $14 | 0;
 
140
 $28 = $28 | 0;
 
141
 $42 = $42 | 0;
 
142
 var unelim = +0, bad = 0, unelim2 = +0;
 
143
 unelim = +(127.5 * +$14);
 
144
 HEAPF32[$45 >> 2] = ($14 < $28 ? $14 : $28) - $42;
 
145
 HEAP32[$world + 102916 >> 2] = _malloc(192) | 0;
 
146
 f(+HEAPF32[$45 >> 2]);
 
147
 g(HEAP32[$14 >> 2] | 0);
 
148
 $42 = +HEAPF32[$42 >> 2];
 
149
 ch($42);
 
150
 HEAPF32[$45 >> 2] = unelim;
 
151
 moar();
 
152
 bad = (HEAPF32[tempDoublePtr >> 2] = 127.5 * +$14, HEAP32[tempDoublePtr >> 2] | 0);
 
153
 func();
 
154
 HEAP32[4] = bad;
 
155
 HEAP32[5] = bad + 1;
 
156
 moar();
 
157
 unelim2 = 127 + $14 | 0;
 
158
 func();
 
159
 HEAP32[4] = unelim2;
 
160
 barrier();
 
161
 $f163 = (HEAP32[tempDoublePtr >> 2] = HEAP32[$f165 >> 2], HEAP32[tempDoublePtr + 4 >> 2] = HEAP32[$f165 + 4 >> 2], +HEAPF64[tempDoublePtr >> 3]);
134
162
}
135
163
function boxx($this, $aabb, $xf, $childIndex) {
136
 
  $this = $this | 0;
137
 
  $aabb = $aabb | 0;
138
 
  $xf = $xf | 0;
139
 
  $childIndex = $childIndex | 0;
140
 
  var $2 = +0, $4 = +0, $7 = +0, $9 = +0, $13 = +0, $14 = +0, $19 = +0, $20 = +0, $22 = +0, $25 = +0, $28 = +0, $32 = +0, $42 = +0, $45 = 0, $_sroa_06_0_insert_insert$1 = +0, $51 = 0, $_sroa_0_0_insert_insert$1 = +0;
141
 
  $2 = +HEAPF32[$xf + 12 >> 2];
142
 
  $4 = +HEAPF32[$this + 12 >> 2];
143
 
  $7 = +HEAPF32[$xf + 8 >> 2];
144
 
  $9 = +HEAPF32[$this + 16 >> 2];
145
 
  $13 = +HEAPF32[$xf >> 2];
146
 
  $14 = $13 + ($2 * $4 - $7 * $9);
147
 
  $19 = +HEAPF32[$xf + 4 >> 2];
148
 
  $20 = $4 * $7 + $2 * $9 + $19;
149
 
  $22 = +HEAPF32[$this + 20 >> 2];
150
 
  $25 = +HEAPF32[$this + 24 >> 2];
151
 
  $28 = $13 + ($2 * $22 - $7 * $25);
152
 
  $32 = $19 + ($7 * $22 + $2 * $25);
153
 
  $42 = +HEAPF32[$this + 8 >> 2];
154
 
  $45 = $aabb;
155
 
  $_sroa_06_0_insert_insert$1 = +(($20 < $32 ? $20 : $32) - $42);
156
 
  HEAPF32[$45 >> 2] = ($14 < $28 ? $14 : $28) - $42;
157
 
  HEAPF32[$45 + 4 >> 2] = $_sroa_06_0_insert_insert$1;
158
 
  $51 = $aabb + 8 | 0;
159
 
  $_sroa_0_0_insert_insert$1 = +($42 + ($20 > $32 ? $20 : $32));
160
 
  HEAPF32[$51 >> 2] = $42 + ($14 > $28 ? $14 : $28);
161
 
  HEAPF32[$51 + 4 >> 2] = $_sroa_0_0_insert_insert$1;
162
 
  return;
 
164
 $this = $this | 0;
 
165
 $aabb = $aabb | 0;
 
166
 $xf = $xf | 0;
 
167
 $childIndex = $childIndex | 0;
 
168
 var $2 = +0, $4 = +0, $7 = +0, $9 = +0, $13 = +0, $14 = +0, $19 = +0, $20 = +0, $22 = +0, $25 = +0, $28 = +0, $32 = +0, $42 = +0, $45 = 0, $_sroa_06_0_insert_insert$1 = +0, $51 = 0, $_sroa_0_0_insert_insert$1 = +0;
 
169
 $2 = +HEAPF32[$xf + 12 >> 2];
 
170
 $4 = +HEAPF32[$this + 12 >> 2];
 
171
 $7 = +HEAPF32[$xf + 8 >> 2];
 
172
 $9 = +HEAPF32[$this + 16 >> 2];
 
173
 $13 = +HEAPF32[$xf >> 2];
 
174
 $14 = $13 + ($2 * $4 - $7 * $9);
 
175
 $19 = +HEAPF32[$xf + 4 >> 2];
 
176
 $20 = $4 * $7 + $2 * $9 + $19;
 
177
 $22 = +HEAPF32[$this + 20 >> 2];
 
178
 $25 = +HEAPF32[$this + 24 >> 2];
 
179
 $28 = $13 + ($2 * $22 - $7 * $25);
 
180
 $32 = $19 + ($7 * $22 + $2 * $25);
 
181
 $42 = +HEAPF32[$this + 8 >> 2];
 
182
 $45 = $aabb;
 
183
 $_sroa_06_0_insert_insert$1 = +(($20 < $32 ? $20 : $32) - $42);
 
184
 HEAPF32[$45 >> 2] = ($14 < $28 ? $14 : $28) - $42;
 
185
 HEAPF32[$45 + 4 >> 2] = $_sroa_06_0_insert_insert$1;
 
186
 $51 = $aabb + 8 | 0;
 
187
 $_sroa_0_0_insert_insert$1 = +($42 + ($20 > $32 ? $20 : $32));
 
188
 HEAPF32[$51 >> 2] = $42 + ($14 > $28 ? $14 : $28);
 
189
 HEAPF32[$51 + 4 >> 2] = $_sroa_0_0_insert_insert$1;
 
190
 return;
 
191
}
 
192
function _main($argc, $argv) {
 
193
 $argc = $argc | 0;
 
194
 $argv = $argv | 0;
 
195
 var $def_i21 = 0, $def_i = 0, $world = 0, $bd = 0, $shape = 0, $shape1 = 0, $bd2 = 0, $result = 0, $6 = 0, $WARMUP_0 = 0, $14 = 0, $15 = 0, $17 = 0, $i_09_i_i = 0, $j_08_i_i = 0, $34 = 0, $j_1_i_i = 0, $38 = 0, $46 = 0, $48 = 0, $50 = 0, $54 = 0, $i_05_i_i_i = 0, $56 = 0, $62 = 0, $_lcssa_i_i_i = 0, $87 = 0, $96 = 0, $97 = 0, $98 = 0, $112 = 0, $115 = 0, $116 = 0, $118 = 0, $121 = 0, $126 = 0, $135 = 0, $137 = 0, $174 = 0, $176 = 0, $177 = 0, $178 = 0, $179 = 0, $180 = 0, $181 = 0, $182 = 0, $183 = 0, $185 = 0, $186 = 0, $188 = 0, $189 = 0, $190 = 0, $191 = 0, $192 = 0, $193 = 0, $194 = 0, $195 = 0, $196 = 0, $i_057 = 0, $x_sroa_0_0_load303656 = +0, $x_sroa_1_4_load313755 = +0, $j_052 = 0, $y_sroa_0_0_load283451 = +0, $y_sroa_1_4_load293550 = +0, $y_sroa_0_0_insert_insert$1 = +0, $205 = 0, $208 = 0, $209 = 0, $213 = 0, $223 = 0, $236 = 0, $i3_042 = 0, $241 = 0, $242 = 0, $243 = 0, $i4_038 = 0, $245 = 0, $260 = +0, $_0 = 0, label = 0, __stackBase__ = 0;
 
196
 __stackBase__ = STACKTOP;
 
197
 STACKTOP = STACKTOP + 103416 | 0;
 
198
 $def_i21 = __stackBase__ | 0;
 
199
 $def_i = __stackBase__ + 32 | 0;
 
200
 $world = __stackBase__ + 64 | 0;
 
201
 $bd = __stackBase__ + 103096 | 0;
 
202
 $shape = __stackBase__ + 103152 | 0;
 
203
 $shape1 = __stackBase__ + 103200 | 0;
 
204
 $bd2 = __stackBase__ + 103352 | 0;
 
205
 $result = __stackBase__ + 103408 | 0;
 
206
 do {
 
207
  if (($argc | 0) > 1) {
 
208
   $6 = HEAP8[HEAP32[$argv + 4 >> 2] | 0] | 0;
 
209
   if (($6 | 0) == 49) {
 
210
    HEAP32[2414] = 35;
 
211
    $WARMUP_0 = 5;
 
212
    break;
 
213
   } else if (($6 | 0) == 50) {
 
214
    HEAP32[2414] = 161;
 
215
    $WARMUP_0 = 32;
 
216
    break;
 
217
   } else if (($6 | 0) == 51) {
 
218
    label = 43;
 
219
    break;
 
220
   } else if (($6 | 0) == 52) {
 
221
    HEAP32[2414] = 2331;
 
222
    $WARMUP_0 = 320;
 
223
    break;
 
224
   } else if (($6 | 0) == 53) {
 
225
    HEAP32[2414] = 5661;
 
226
    $WARMUP_0 = 640;
 
227
    break;
 
228
   } else if (($6 | 0) == 48) {
 
229
    $_0 = 0;
 
230
    STACKTOP = __stackBase__;
 
231
    return $_0 | 0;
 
232
   } else {
 
233
    _printf(3512, (tempInt = STACKTOP, STACKTOP = STACKTOP + 8 | 0, HEAP32[tempInt >> 2] = $6 - 48, tempInt) | 0) | 0;
 
234
    $_0 = -1;
 
235
    STACKTOP = __stackBase__;
 
236
    return $_0 | 0;
 
237
   }
 
238
  } else {
 
239
   label = 43;
 
240
  }
 
241
 } while (0);
 
242
 if ((label | 0) == 43) {
 
243
  HEAP32[2414] = 333;
 
244
  $WARMUP_0 = 64;
 
245
 }
 
246
 $14 = $world | 0;
 
247
 $15 = $world + 8 | 0;
 
248
 HEAP32[$15 >> 2] = 128;
 
249
 HEAP32[$world + 4 >> 2] = 0;
 
250
 $17 = _malloc(1024) | 0;
 
251
 HEAP32[$world >> 2] = $17;
 
252
 _memset($17 | 0, 0, HEAP32[$15 >> 2] << 3 | 0);
 
253
 _memset($world + 12 | 0, 0, 56);
 
254
 $j_08_i_i = 0;
 
255
 $i_09_i_i = 1;
 
256
 while (1) {
 
257
  if (($j_08_i_i | 0) >= 14) {
 
258
   label = 49;
 
259
   break;
 
260
  }
 
261
  if (($i_09_i_i | 0) > (HEAP32[9600 + ($j_08_i_i << 2) >> 2] | 0)) {
 
262
   $34 = $j_08_i_i + 1 | 0;
 
263
   HEAP8[$i_09_i_i + 8952 | 0] = $34 & 255;
 
264
   $j_1_i_i = $34;
 
265
  } else {
 
266
   HEAP8[$i_09_i_i + 8952 | 0] = $j_08_i_i & 255;
 
267
   $j_1_i_i = $j_08_i_i;
 
268
  }
 
269
  $38 = $i_09_i_i + 1 | 0;
 
270
  if (($38 | 0) < 641) {
 
271
   $j_08_i_i = $j_1_i_i;
 
272
   $i_09_i_i = $38;
 
273
  } else {
 
274
   break;
 
275
  }
 
276
 }
 
277
 if ((label | 0) == 49) {
 
278
  ___assert_func(3248, 73, 6448, 3360);
 
279
  return 0;
 
280
 }
 
281
 HEAP32[$world + 102468 >> 2] = 0;
 
282
 HEAP32[$world + 102472 >> 2] = 0;
 
283
 HEAP32[$world + 102476 >> 2] = 0;
 
284
 HEAP32[$world + 102864 >> 2] = 0;
 
285
 HEAP32[$world + 102872 >> 2] = -1;
 
286
 $46 = $world + 102884 | 0;
 
287
 HEAP32[$46 >> 2] = 16;
 
288
 HEAP32[$world + 102880 >> 2] = 0;
 
289
 $48 = _malloc(576) | 0;
 
290
 $50 = $world + 102876 | 0;
 
291
 HEAP32[$50 >> 2] = $48;
 
292
 _memset($48 | 0, 0, (HEAP32[$46 >> 2] | 0) * 36 & -1 | 0);
 
293
 $54 = (HEAP32[$46 >> 2] | 0) - 1 | 0;
 
294
 if (($54 | 0) > 0) {
 
295
  $i_05_i_i_i = 0;
 
296
  while (1) {
 
297
   $56 = $i_05_i_i_i + 1 | 0;
 
298
   HEAP32[(HEAP32[$50 >> 2] | 0) + ($i_05_i_i_i * 36 & -1) + 20 >> 2] = $56;
 
299
   HEAP32[(HEAP32[$50 >> 2] | 0) + ($i_05_i_i_i * 36 & -1) + 32 >> 2] = -1;
 
300
   $62 = (HEAP32[$46 >> 2] | 0) - 1 | 0;
 
301
   if (($56 | 0) < ($62 | 0)) {
 
302
    $i_05_i_i_i = $56;
 
303
   } else {
 
304
    $_lcssa_i_i_i = $62;
 
305
    break;
 
306
   }
 
307
  }
 
308
 } else {
 
309
  $_lcssa_i_i_i = $54;
 
310
 }
 
311
 HEAP32[(HEAP32[$50 >> 2] | 0) + ($_lcssa_i_i_i * 36 & -1) + 20 >> 2] = -1;
 
312
 HEAP32[(HEAP32[$50 >> 2] | 0) + (((HEAP32[$46 >> 2] | 0) - 1 | 0) * 36 & -1) + 32 >> 2] = -1;
 
313
 _memset($world + 102888 | 0, 0, 16);
 
314
 HEAP32[$world + 102920 >> 2] = 16;
 
315
 HEAP32[$world + 102924 >> 2] = 0;
 
316
 HEAP32[$world + 102916 >> 2] = _malloc(192) | 0;
 
317
 HEAP32[$world + 102908 >> 2] = 16;
 
318
 HEAP32[$world + 102912 >> 2] = 0;
 
319
 HEAP32[$world + 102904 >> 2] = _malloc(64) | 0;
 
320
 HEAP32[$world + 102932 >> 2] = 0;
 
321
 HEAP32[$world + 102936 >> 2] = 0;
 
322
 HEAP32[$world + 102940 >> 2] = 104;
 
323
 HEAP32[$world + 102944 >> 2] = 96;
 
324
 $87 = $world + 102948 | 0;
 
325
 HEAP32[$world + 102980 >> 2] = 0;
 
326
 HEAP32[$world + 102984 >> 2] = 0;
 
327
 _memset($87 | 0, 0, 20);
 
328
 HEAP8[$world + 102992 | 0] = 1;
 
329
 HEAP8[$world + 102993 | 0] = 1;
 
330
 HEAP8[$world + 102994 | 0] = 0;
 
331
 HEAP8[$world + 102995 | 0] = 1;
 
332
 $96 = $world + 102976 | 0;
 
333
 HEAP8[$96] = 1;
 
334
 $97 = $world + 102968 | 0;
 
335
 HEAP32[$97 >> 2] = 0;
 
336
 HEAP32[$97 + 4 >> 2] = -1054867456;
 
337
 $98 = $world + 102868 | 0;
 
338
 HEAP32[$98 >> 2] = 4;
 
339
 HEAPF32[$world + 102988 >> 2] = +0;
 
340
 HEAP32[$87 >> 2] = $14;
 
341
 _memset($world + 102996 | 0, 0, 32);
 
342
 HEAP8[$96] = 0;
 
343
 HEAP32[$bd + 44 >> 2] = 0;
 
344
 _memset($bd + 4 | 0, 0, 32);
 
345
 HEAP8[$bd + 36 | 0] = 1;
 
346
 HEAP8[$bd + 37 | 0] = 1;
 
347
 HEAP8[$bd + 38 | 0] = 0;
 
348
 HEAP8[$bd + 39 | 0] = 0;
 
349
 HEAP32[$bd >> 2] = 0;
 
350
 HEAP8[$bd + 40 | 0] = 1;
 
351
 HEAPF32[$bd + 48 >> 2] = +1;
 
352
 $112 = __ZN16b2BlockAllocator8AllocateEi($14, 152) | 0;
 
353
 if (($112 | 0) == 0) {
 
354
  $116 = 0;
 
355
 } else {
 
356
  $115 = $112;
 
357
  __ZN6b2BodyC2EPK9b2BodyDefP7b2World($115, $bd, $world);
 
358
  $116 = $115;
 
359
 }
 
360
 HEAP32[$116 + 92 >> 2] = 0;
 
361
 $118 = $world + 102952 | 0;
 
362
 HEAP32[$116 + 96 >> 2] = HEAP32[$118 >> 2];
 
363
 $121 = HEAP32[$118 >> 2] | 0;
 
364
 if (($121 | 0) != 0) {
 
365
  HEAP32[$121 + 92 >> 2] = $116;
 
366
 }
 
367
 HEAP32[$118 >> 2] = $116;
 
368
 $126 = $world + 102960 | 0;
 
369
 HEAP32[$126 >> 2] = (HEAP32[$126 >> 2] | 0) + 1;
 
370
 HEAP32[$shape >> 2] = 8016;
 
371
 HEAP32[$shape + 4 >> 2] = 1;
 
372
 HEAPF32[$shape + 8 >> 2] = +.009999999776482582;
 
373
 _memset($shape + 28 | 0, 0, 18);
 
374
 $135 = $shape + 12 | 0;
 
375
 HEAP32[$135 >> 2] = -1038090240;
 
376
 HEAP32[$135 + 4 >> 2] = 0;
 
377
 $137 = $shape + 20 | 0;
 
378
 HEAP32[$137 >> 2] = 1109393408;
 
379
 HEAP32[$137 + 4 >> 2] = 0;
 
380
 HEAP8[$shape + 44 | 0] = 0;
 
381
 HEAP8[$shape + 45 | 0] = 0;
 
382
 HEAP16[$def_i + 22 >> 1] = 1;
 
383
 HEAP16[$def_i + 24 >> 1] = -1;
 
384
 HEAP16[$def_i + 26 >> 1] = 0;
 
385
 HEAP32[$def_i + 4 >> 2] = 0;
 
386
 HEAPF32[$def_i + 8 >> 2] = +.20000000298023224;
 
387
 HEAPF32[$def_i + 12 >> 2] = +0;
 
388
 HEAP8[$def_i + 20 | 0] = 0;
 
389
 HEAP32[$def_i >> 2] = $shape;
 
390
 HEAPF32[$def_i + 16 >> 2] = +0;
 
391
 __ZN6b2Body13CreateFixtureEPK12b2FixtureDef($116, $def_i);
 
392
 HEAP32[$shape1 >> 2] = 7968;
 
393
 HEAP32[$shape1 + 4 >> 2] = 2;
 
394
 HEAPF32[$shape1 + 8 >> 2] = +.009999999776482582;
 
395
 HEAP32[$shape1 + 148 >> 2] = 4;
 
396
 HEAPF32[$shape1 + 20 >> 2] = +-.5;
 
397
 HEAPF32[$shape1 + 24 >> 2] = +-.5;
 
398
 HEAPF32[$shape1 + 28 >> 2] = +.5;
 
399
 HEAPF32[$shape1 + 32 >> 2] = +-.5;
 
400
 HEAPF32[$shape1 + 36 >> 2] = +.5;
 
401
 HEAPF32[$shape1 + 40 >> 2] = +.5;
 
402
 HEAPF32[$shape1 + 44 >> 2] = +-.5;
 
403
 HEAPF32[$shape1 + 48 >> 2] = +.5;
 
404
 HEAPF32[$shape1 + 84 >> 2] = +0;
 
405
 HEAPF32[$shape1 + 88 >> 2] = +-1;
 
406
 HEAPF32[$shape1 + 92 >> 2] = +1;
 
407
 HEAPF32[$shape1 + 96 >> 2] = +0;
 
408
 HEAPF32[$shape1 + 100 >> 2] = +0;
 
409
 HEAPF32[$shape1 + 104 >> 2] = +1;
 
410
 HEAPF32[$shape1 + 108 >> 2] = +-1;
 
411
 HEAPF32[$shape1 + 112 >> 2] = +0;
 
412
 HEAPF32[$shape1 + 12 >> 2] = +0;
 
413
 HEAPF32[$shape1 + 16 >> 2] = +0;
 
414
 $174 = $bd2 + 44 | 0;
 
415
 $176 = $bd2 + 36 | 0;
 
416
 $177 = $bd2 + 4 | 0;
 
417
 $178 = $bd2 + 37 | 0;
 
418
 $179 = $bd2 + 38 | 0;
 
419
 $180 = $bd2 + 39 | 0;
 
420
 $181 = $bd2 | 0;
 
421
 $182 = $bd2 + 40 | 0;
 
422
 $183 = $bd2 + 48 | 0;
 
423
 $185 = $bd2 + 4 | 0;
 
424
 $186 = $shape1 | 0;
 
425
 $188 = $def_i21 + 22 | 0;
 
426
 $189 = $def_i21 + 24 | 0;
 
427
 $190 = $def_i21 + 26 | 0;
 
428
 $191 = $def_i21 | 0;
 
429
 $192 = $def_i21 + 4 | 0;
 
430
 $193 = $def_i21 + 8 | 0;
 
431
 $194 = $def_i21 + 12 | 0;
 
432
 $195 = $def_i21 + 16 | 0;
 
433
 $196 = $def_i21 + 20 | 0;
 
434
 $x_sroa_1_4_load313755 = +.75;
 
435
 $x_sroa_0_0_load303656 = +-7;
 
436
 $i_057 = 0;
 
437
 L82 : while (1) {
 
438
  $y_sroa_1_4_load293550 = $x_sroa_1_4_load313755;
 
439
  $y_sroa_0_0_load283451 = $x_sroa_0_0_load303656;
 
440
  $j_052 = $i_057;
 
441
  while (1) {
 
442
   HEAP32[$174 >> 2] = 0;
 
443
   _memset($177 | 0, 0, 32);
 
444
   HEAP8[$176] = 1;
 
445
   HEAP8[$178] = 1;
 
446
   HEAP8[$179] = 0;
 
447
   HEAP8[$180] = 0;
 
448
   HEAP8[$182] = 1;
 
449
   HEAPF32[$183 >> 2] = +1;
 
450
   HEAP32[$181 >> 2] = 2;
 
451
   $y_sroa_0_0_insert_insert$1 = +$y_sroa_1_4_load293550;
 
452
   HEAPF32[$185 >> 2] = $y_sroa_0_0_load283451;
 
453
   HEAPF32[$185 + 4 >> 2] = $y_sroa_0_0_insert_insert$1;
 
454
   if ((HEAP32[$98 >> 2] & 2 | 0) != 0) {
 
455
    label = 65;
 
456
    break L82;
 
457
   }
 
458
   $205 = __ZN16b2BlockAllocator8AllocateEi($14, 152) | 0;
 
459
   if (($205 | 0) == 0) {
 
460
    $209 = 0;
 
461
   } else {
 
462
    $208 = $205;
 
463
    __ZN6b2BodyC2EPK9b2BodyDefP7b2World($208, $bd2, $world);
 
464
    $209 = $208;
 
465
   }
 
466
   HEAP32[$209 + 92 >> 2] = 0;
 
467
   HEAP32[$209 + 96 >> 2] = HEAP32[$118 >> 2];
 
468
   $213 = HEAP32[$118 >> 2] | 0;
 
469
   if (($213 | 0) != 0) {
 
470
    HEAP32[$213 + 92 >> 2] = $209;
 
471
   }
 
472
   HEAP32[$118 >> 2] = $209;
 
473
   HEAP32[$126 >> 2] = (HEAP32[$126 >> 2] | 0) + 1;
 
474
   HEAP16[$188 >> 1] = 1;
 
475
   HEAP16[$189 >> 1] = -1;
 
476
   HEAP16[$190 >> 1] = 0;
 
477
   HEAP32[$192 >> 2] = 0;
 
478
   HEAPF32[$193 >> 2] = +.20000000298023224;
 
479
   HEAPF32[$194 >> 2] = +0;
 
480
   HEAP8[$196] = 0;
 
481
   HEAP32[$191 >> 2] = $186;
 
482
   HEAPF32[$195 >> 2] = +5;
 
483
   __ZN6b2Body13CreateFixtureEPK12b2FixtureDef($209, $def_i21);
 
484
   $223 = $j_052 + 1 | 0;
 
485
   if (($223 | 0) < 40) {
 
486
    $y_sroa_1_4_load293550 = $y_sroa_1_4_load293550 + +0;
 
487
    $y_sroa_0_0_load283451 = $y_sroa_0_0_load283451 + 1.125;
 
488
    $j_052 = $223;
 
489
   } else {
 
490
    break;
 
491
   }
 
492
  }
 
493
  $236 = $i_057 + 1 | 0;
 
494
  if (($236 | 0) < 40) {
 
495
   $x_sroa_1_4_load313755 = $x_sroa_1_4_load313755 + +1;
 
496
   $x_sroa_0_0_load303656 = $x_sroa_0_0_load303656 + +.5625;
 
497
   $i_057 = $236;
 
498
  } else {
 
499
   $i3_042 = 0;
 
500
   break;
 
501
  }
 
502
 }
 
503
 if ((label | 0) == 65) {
 
504
  ___assert_func(112, 109, 5328, 2520);
 
505
  return 0;
 
506
 }
 
507
 while (1) {
 
508
  __ZN7b2World4StepEfii($world);
 
509
  $i3_042 = $i3_042 + 1 | 0;
 
510
  if (($i3_042 | 0) >= ($WARMUP_0 | 0)) {
 
511
   break;
 
512
  }
 
513
 }
 
514
 $241 = HEAP32[2414] | 0;
 
515
 $242 = _llvm_stacksave() | 0;
 
516
 $243 = STACKTOP;
 
517
 STACKTOP = STACKTOP + ($241 * 4 & -1) | 0;
 
518
 STACKTOP = STACKTOP + 7 >> 3 << 3;
 
519
 if (($241 | 0) > 0) {
 
520
  $i4_038 = 0;
 
521
  while (1) {
 
522
   $245 = _clock() | 0;
 
523
   __ZN7b2World4StepEfii($world);
 
524
   HEAP32[$243 + ($i4_038 << 2) >> 2] = (_clock() | 0) - $245;
 
525
   $i4_038 = $i4_038 + 1 | 0;
 
526
   if (($i4_038 | 0) >= (HEAP32[2414] | 0)) {
 
527
    break;
 
528
   }
 
529
  }
 
530
 }
 
531
 __Z7measurePm($result, $243);
 
532
 $260 = +HEAPF32[$result + 4 >> 2];
 
533
 _printf(3480, (tempInt = STACKTOP, STACKTOP = STACKTOP + 16 | 0, HEAPF64[tempInt >> 3] = +HEAPF32[$result >> 2], HEAPF64[tempInt + 8 >> 3] = $260, tempInt) | 0) | 0;
 
534
 _llvm_stackrestore($242 | 0);
 
535
 __ZN7b2WorldD2Ev($world);
 
536
 $_0 = 0;
 
537
 STACKTOP = __stackBase__;
 
538
 return $_0 | 0;
163
539
}
164
540