#define NULL ((void *)0)
typedef unsigned long size_t; // Customize by platform.
typedef long intptr_t;
typedef unsigned long uintptr_t;
typedef long scalar_t__; // Either arithmetic or pointer type.
/* By default, we understand bool (as a convenience). */
typedef int bool;
#define false 0
#define true 1

/* Forward declarations */

/* Type definitions */
struct value_vstack {
  int dummy;
};
typedef int /*<<< orphan*/ n;

/* Variables and functions */
int /*<<< orphan*/ assert(int);
int /*<<< orphan*/ fail(char *, ...);
float round(float);
int vstack_pop_vector(float *, struct value_vstack *);
int /*<<< orphan*/ vstack_push_scalar(struct value_vstack *, float);
int /*<<< orphan*/ vstack_push_vector(struct value_vstack *, float *, int);
void vstack_process_op(struct value_vstack *s, int opid) {
  switch (opid) {
  case 1:
    vstack_pop_vector(NULL, s);
    break;
  case 2: {
    float x[0x100];
    int n = vstack_pop_vector(x, s);
    vstack_push_vector(s, x, n);
    vstack_push_vector(s, x, n);
  } break;
  case 3: {
    float x[0x100];
    int n = vstack_pop_vector(x, s);
    for (int i = 0; i < (n); i++)
      vstack_push_scalar(s, x[i]);
  } break;
  case 4: {
    float x[0x100];
    float y[0x100];
    int m = vstack_pop_vector(y, s);
    int n = vstack_pop_vector(x, s);
    if (n + m >= 0x100)
      fail("merging vectors results in large vector");
    for (int i = 0; i < (m); i++)
      x[n + i] = y[i];
    vstack_push_vector(s, x, n + m);
  } break;
  case 6: {
    float x[0x100];
    float y[0x100];
    float z[0x100];
    int nz = vstack_pop_vector(z, s);
    int ny = vstack_pop_vector(y, s);
    int nx = vstack_pop_vector(x, s);
    if (nx + ny + nz >= 0x100)
      fail("merging vectors results in large vector");
    for (int i = 0; i < (ny); i++)
      x[nx + i] = y[i];
    for (int i = 0; i < (nz); i++)
      x[nx + ny + i] = z[i];
    vstack_push_vector(s, x, nx + ny + nz);
  } break;
  case 5: {
    float x[0x100];
    float y[0x100];
    int n = vstack_pop_vector(x, s);
    int m = vstack_pop_vector(y, s);
    vstack_push_vector(s, x, n);
    vstack_push_vector(s, y, m);
    break;
  }
  case 7:
    fail("mergeall not implemented");
    break;
  case 10: {
    float nn[0x100];
    int n = vstack_pop_vector(nn, s);
    if (n != 1 || nn[0] < 1 || round(nn[0]) != nn[0] || nn[0] >= 0x100)
      fail("can not nmerge \"%g\" things", nn[0]);
    n = nn[0];
    float x[n][0x100], y[0x100];
    int d[n], sdi = 0;
    for (int i = 0; i < (n); i++) {
      int j = n - i - 1;
      d[j] = vstack_pop_vector(x[j], s);
      sdi += d[j];
    }
    if (sdi >= 0x100)
      fail("merging vectors results in large vector");
    int cx = 0;
    for (int i = 0; i < (n); i++)
      for (int j = 0; j < (d[i]); j++)
        y[cx++] = x[i][j];
    assert(cx == sdi);
    vstack_push_vector(s, y, sdi);
    break;
  }
  case 11: {
    float x[0x100];
    float y[0x100];
    int n = vstack_pop_vector(x, s);
    if (((n)&1))
      fail("can not interleave an odd number %d!", n);
    for (int i = 0; i < (n / 2); i++) {
      y[2 * i] = x[i];
      y[2 * i + 1] = x[i + n / 2];
    }
    vstack_push_vector(s, y, n);
    break;
  }
  case 12: {
    float x[0x100];
    float y[0x100];
    int n = vstack_pop_vector(x, s);
    if (((n)&1))
      fail("can not deinterleave an odd number %d!", n);
    for (int i = 0; i < (n / 2); i++) {
      y[i] = x[2 * i];
      y[i + n / 2] = x[2 * i + 1];
    }
    vstack_push_vector(s, y, n);
    break;
  }
  case 13: {
    float x[0x100];
    float y[0x100];
    int n = vstack_pop_vector(x, s);
    if (((n)&1))
      fail("can not halve a vector of odd length %d!", n);
    for (int i = 0; i < (n / 2); i++)
      y[i] = x[i + n / 2];
    vstack_push_vector(s, x, n / 2);
    vstack_push_vector(s, y, n / 2);
    break;
  }
  case 14: {
    float nn[0x100];
    int n = vstack_pop_vector(nn, s);
    if (n != 1 || nn[0] < 1 || round(nn[0]) != nn[0])
      fail("can not split into \"%g\" things", nn[0]);
    int nparts = nn[0];
    float x[0x100];
    n = vstack_pop_vector(x, s);
    if (0 != n % nparts)
      fail("can not split \"%d\" in \"%d\" parts", n, nparts);
    int partsize = n / nparts;
    assert(n == nparts * partsize);
    float y[nparts][partsize];
    for (int i = 0; i < (nparts); i++)
      for (int j = 0; j < (partsize); j++)
        y[i][j] = x[i * partsize + j];
    for (int i = 0; i < (nparts); i++)
      vstack_push_vector(s, y[i], partsize);
  } break;
  default:
    fail("impossible condition (stackop %d)", opid);
  }
}


x86 assembly (clang, -O0):
<vstack_process_op>:
push   %rbp
mov    %rsp,%rbp
sub    $0x4d60,%rsp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    -0xc(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,%ecx
mov    %rcx,-0x4d28(%rbp)
sub    $0xd,%eax
ja     1d03 <vstack_process_op+0xba3>
mov    -0x4d28(%rbp),%rax
lea    0xe70(%rip),%rcx
movslq (%rcx,%rax,4),%rax
add    %rcx,%rax
jmp    *%rax
mov    -0x8(%rbp),%rsi
xor    %eax,%eax
mov    %eax,%edi
call   1070 <vstack_pop_vector@plt>
jmp    1d14 <vstack_process_op+0xbb4>
lea    -0x410(%rbp),%rdi
mov    -0x8(%rbp),%rsi
call   1070 <vstack_pop_vector@plt>
mov    %eax,-0x414(%rbp)
mov    -0x8(%rbp),%rdi
lea    -0x410(%rbp),%rsi
mov    -0x414(%rbp),%edx
call   1040 <vstack_push_vector@plt>
mov    -0x8(%rbp),%rdi
lea    -0x410(%rbp),%rsi
mov    -0x414(%rbp),%edx
call   1040 <vstack_push_vector@plt>
jmp    1d14 <vstack_process_op+0xbb4>
lea    -0x820(%rbp),%rdi
mov    -0x8(%rbp),%rsi
call   1070 <vstack_pop_vector@plt>
mov    %eax,-0x824(%rbp)
movl   $0x0,-0x828(%rbp)
mov    -0x828(%rbp),%eax
cmp    -0x824(%rbp),%eax
jge    1259 <vstack_process_op+0xf9>
mov    -0x8(%rbp),%rdi
movslq -0x828(%rbp),%rax
movss  -0x820(%rbp,%rax,4),%xmm0
ff ff
call   1050 <vstack_push_scalar@plt>
mov    -0x828(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x828(%rbp)
jmp    121a <vstack_process_op+0xba>
jmp    1d14 <vstack_process_op+0xbb4>
lea    -0x1030(%rbp),%rdi
mov    -0x8(%rbp),%rsi
call   1070 <vstack_pop_vector@plt>
mov    %eax,-0x1034(%rbp)
lea    -0xc30(%rbp),%rdi
mov    -0x8(%rbp),%rsi
call   1070 <vstack_pop_vector@plt>
mov    %eax,-0x1038(%rbp)
mov    -0x1038(%rbp),%eax
add    -0x1034(%rbp),%eax
cmp    $0x100,%eax
jl     12af <vstack_process_op+0x14f>
lea    0xd98(%rip),%rdi
mov    $0x0,%al
call   1030 <fail@plt>
movl   $0x0,-0x103c(%rbp)
mov    -0x103c(%rbp),%eax
cmp    -0x1034(%rbp),%eax
jge    1306 <vstack_process_op+0x1a6>
movslq -0x103c(%rbp),%rax
movss  -0x1030(%rbp,%rax,4),%xmm0
ff ff
mov    -0x1038(%rbp),%eax
add    -0x103c(%rbp),%eax
cltq
movss  %xmm0,-0xc30(%rbp,%rax,4)
ff ff
mov    -0x103c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x103c(%rbp)
jmp    12b9 <vstack_process_op+0x159>
mov    -0x8(%rbp),%rdi
lea    -0xc30(%rbp),%rsi
mov    -0x1038(%rbp),%edx
add    -0x1034(%rbp),%edx
call   1040 <vstack_push_vector@plt>
jmp    1d14 <vstack_process_op+0xbb4>
lea    -0x1c40(%rbp),%rdi
mov    -0x8(%rbp),%rsi
call   1070 <vstack_pop_vector@plt>
mov    %eax,-0x1c44(%rbp)
lea    -0x1840(%rbp),%rdi
mov    -0x8(%rbp),%rsi
call   1070 <vstack_pop_vector@plt>
mov    %eax,-0x1c48(%rbp)
lea    -0x1440(%rbp),%rdi
mov    -0x8(%rbp),%rsi
call   1070 <vstack_pop_vector@plt>
mov    %eax,-0x1c4c(%rbp)
mov    -0x1c4c(%rbp),%eax
add    -0x1c48(%rbp),%eax
add    -0x1c44(%rbp),%eax
cmp    $0x100,%eax
jl     1394 <vstack_process_op+0x234>
lea    0xcb3(%rip),%rdi
mov    $0x0,%al
call   1030 <fail@plt>
movl   $0x0,-0x1c50(%rbp)
mov    -0x1c50(%rbp),%eax
cmp    -0x1c48(%rbp),%eax
jge    13eb <vstack_process_op+0x28b>
movslq -0x1c50(%rbp),%rax
movss  -0x1840(%rbp,%rax,4),%xmm0
ff ff
mov    -0x1c4c(%rbp),%eax
add    -0x1c50(%rbp),%eax
cltq
movss  %xmm0,-0x1440(%rbp,%rax,4)
ff ff
mov    -0x1c50(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c50(%rbp)
jmp    139e <vstack_process_op+0x23e>
movl   $0x0,-0x1c54(%rbp)
mov    -0x1c54(%rbp),%eax
cmp    -0x1c44(%rbp),%eax
jge    1448 <vstack_process_op+0x2e8>
movslq -0x1c54(%rbp),%rax
movss  -0x1c40(%rbp,%rax,4),%xmm0
ff ff
mov    -0x1c4c(%rbp),%eax
add    -0x1c48(%rbp),%eax
add    -0x1c54(%rbp),%eax
cltq
movss  %xmm0,-0x1440(%rbp,%rax,4)
ff ff
mov    -0x1c54(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c54(%rbp)
jmp    13f5 <vstack_process_op+0x295>
mov    -0x8(%rbp),%rdi
lea    -0x1440(%rbp),%rsi
mov    -0x1c4c(%rbp),%edx
add    -0x1c48(%rbp),%edx
add    -0x1c44(%rbp),%edx
call   1040 <vstack_push_vector@plt>
jmp    1d14 <vstack_process_op+0xbb4>
lea    -0x2060(%rbp),%rdi
mov    -0x8(%rbp),%rsi
call   1070 <vstack_pop_vector@plt>
mov    %eax,-0x2464(%rbp)
lea    -0x2460(%rbp),%rdi
mov    -0x8(%rbp),%rsi
call   1070 <vstack_pop_vector@plt>
mov    %eax,-0x2468(%rbp)
mov    -0x8(%rbp),%rdi
lea    -0x2060(%rbp),%rsi
mov    -0x2464(%rbp),%edx
call   1040 <vstack_push_vector@plt>
mov    -0x8(%rbp),%rdi
lea    -0x2460(%rbp),%rsi
mov    -0x2468(%rbp),%edx
call   1040 <vstack_push_vector@plt>
jmp    1d14 <vstack_process_op+0xbb4>
lea    0xb95(%rip),%rdi
mov    $0x0,%al
call   1030 <fail@plt>
jmp    1d14 <vstack_process_op+0xbb4>
lea    -0x2870(%rbp),%rdi
mov    -0x8(%rbp),%rsi
call   1070 <vstack_pop_vector@plt>
mov    %eax,-0x2874(%rbp)
cmpl   $0x1,-0x2874(%rbp)
jne    1550 <vstack_process_op+0x3f0>
movss  0xaf6(%rip),%xmm0
ucomiss -0x2870(%rbp),%xmm0
ja     1550 <vstack_process_op+0x3f0>
movss  -0x2870(%rbp),%xmm0
ff
call   1080 <round@plt>
ucomiss -0x2870(%rbp),%xmm0
jne    1550 <vstack_process_op+0x3f0>
jp     1550 <vstack_process_op+0x3f0>
movss  -0x2870(%rbp),%xmm0
ff
movss  0xabd(%rip),%xmm1
ucomiss %xmm1,%xmm0
jb     156a <vstack_process_op+0x40a>
movss  -0x2870(%rbp),%xmm0
ff
cvtss2sd %xmm0,%xmm0
lea    0xb1e(%rip),%rdi
mov    $0x1,%al
call   1030 <fail@plt>
cvttss2si -0x2870(%rbp),%eax
ff
mov    %eax,-0x2874(%rbp)
mov    -0x2874(%rbp),%eax
mov    %rsp,%rcx
mov    %rcx,-0x2880(%rbp)
mov    %rax,%rdx
shl    $0xa,%rdx
mov    %rsp,%rcx
sub    %rdx,%rcx
mov    %rcx,-0x4d38(%rbp)
mov    %rcx,%rsp
mov    %rax,-0x2888(%rbp)
mov    -0x2874(%rbp),%eax
lea    0xf(,%rax,4),%rdx
and    $0xfffffffffffffff0,%rdx
mov    %rsp,%rcx
sub    %rdx,%rcx
mov    %rcx,-0x4d30(%rbp)
mov    %rcx,%rsp
mov    %rax,-0x2c98(%rbp)
movl   $0x0,-0x2c9c(%rbp)
movl   $0x0,-0x2ca0(%rbp)
mov    -0x2ca0(%rbp),%eax
cmp    -0x2874(%rbp),%eax
jge    1665 <vstack_process_op+0x505>
mov    -0x4d38(%rbp),%rdi
mov    -0x2874(%rbp),%eax
sub    -0x2ca0(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x2ca4(%rbp)
movslq -0x2ca4(%rbp),%rax
shl    $0xa,%rax
add    %rax,%rdi
mov    -0x8(%rbp),%rsi
call   1070 <vstack_pop_vector@plt>
mov    %eax,%edx
mov    -0x4d30(%rbp),%rax
movslq -0x2ca4(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
movslq -0x2ca4(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
add    -0x2c9c(%rbp),%eax
mov    %eax,-0x2c9c(%rbp)
mov    -0x2ca0(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2ca0(%rbp)
jmp    15e3 <vstack_process_op+0x483>
cmpl   $0x100,-0x2c9c(%rbp)
jl     1683 <vstack_process_op+0x523>
lea    0x9c4(%rip),%rdi
mov    $0x0,%al
call   1030 <fail@plt>
movl   $0x0,-0x2ca8(%rbp)
movl   $0x0,-0x2cac(%rbp)
mov    -0x2cac(%rbp),%eax
cmp    -0x2874(%rbp),%eax
jge    173a <vstack_process_op+0x5da>
movl   $0x0,-0x2cb0(%rbp)
mov    -0x4d30(%rbp),%rcx
mov    -0x2cb0(%rbp),%eax
movslq -0x2cac(%rbp),%rdx
cmp    (%rcx,%rdx,4),%eax
jge    1721 <vstack_process_op+0x5c1>
mov    -0x4d38(%rbp),%rax
movslq -0x2cac(%rbp),%rcx
shl    $0xa,%rcx
add    %rcx,%rax
movslq -0x2cb0(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x2ca8(%rbp),%eax
mov    %eax,%ecx
add    $0x1,%ecx
mov    %ecx,-0x2ca8(%rbp)
cltq
movss  %xmm0,-0x2c90(%rbp,%rax,4)
ff ff
mov    -0x2cb0(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2cb0(%rbp)
jmp    16b3 <vstack_process_op+0x553>
jmp    1726 <vstack_process_op+0x5c6>
mov    -0x2cac(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2cac(%rbp)
jmp    1697 <vstack_process_op+0x537>
mov    -0x2ca8(%rbp),%eax
cmp    -0x2c9c(%rbp),%eax
sete   %al
and    $0x1,%al
movzbl %al,%edi
call   1060 <assert@plt>
mov    -0x8(%rbp),%rdi
lea    -0x2c90(%rbp),%rsi
mov    -0x2c9c(%rbp),%edx
call   1040 <vstack_push_vector@plt>
mov    -0x2880(%rbp),%rax
mov    %rax,%rsp
jmp    1d14 <vstack_process_op+0xbb4>
lea    -0x30b0(%rbp),%rdi
mov    -0x8(%rbp),%rsi
call   1070 <vstack_pop_vector@plt>
mov    %eax,-0x34b4(%rbp)
mov    -0x34b4(%rbp),%eax
and    $0x1,%eax
cmp    $0x0,%eax
je     17b4 <vstack_process_op+0x654>
mov    -0x34b4(%rbp),%esi
lea    0x8ef(%rip),%rdi
mov    $0x0,%al
call   1030 <fail@plt>
movl   $0x0,-0x34b8(%rbp)
mov    -0x34b8(%rbp),%eax
mov    %eax,-0x4d3c(%rbp)
mov    -0x34b4(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0x4d3c(%rbp),%eax
cmp    %ecx,%eax
jge    1866 <vstack_process_op+0x706>
movslq -0x34b8(%rbp),%rax
movss  -0x30b0(%rbp,%rax,4),%xmm0
ff ff
mov    -0x34b8(%rbp),%eax
shl    $0x1,%eax
cltq
movss  %xmm0,-0x34b0(%rbp,%rax,4)
ff ff
mov    -0x34b8(%rbp),%eax
mov    %eax,-0x4d40(%rbp)
mov    -0x34b4(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0x4d40(%rbp),%eax
add    %ecx,%eax
cltq
movss  -0x30b0(%rbp,%rax,4),%xmm0
ff ff
mov    -0x34b8(%rbp),%eax
shl    $0x1,%eax
add    $0x1,%eax
cltq
movss  %xmm0,-0x34b0(%rbp,%rax,4)
ff ff
mov    -0x34b8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34b8(%rbp)
jmp    17be <vstack_process_op+0x65e>
mov    -0x8(%rbp),%rdi
lea    -0x34b0(%rbp),%rsi
mov    -0x34b4(%rbp),%edx
call   1040 <vstack_push_vector@plt>
jmp    1d14 <vstack_process_op+0xbb4>
lea    -0x38c0(%rbp),%rdi
mov    -0x8(%rbp),%rsi
call   1070 <vstack_pop_vector@plt>
mov    %eax,-0x3cc4(%rbp)
mov    -0x3cc4(%rbp),%eax
and    $0x1,%eax
cmp    $0x0,%eax
je     18bd <vstack_process_op+0x75d>
mov    -0x3cc4(%rbp),%esi
lea    0x80b(%rip),%rdi
mov    $0x0,%al
call   1030 <fail@plt>
movl   $0x0,-0x3cc8(%rbp)
mov    -0x3cc8(%rbp),%eax
mov    %eax,-0x4d44(%rbp)
mov    -0x3cc4(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0x4d44(%rbp),%eax
cmp    %ecx,%eax
jge    196f <vstack_process_op+0x80f>
mov    -0x3cc8(%rbp),%eax
shl    $0x1,%eax
cltq
movss  -0x38c0(%rbp,%rax,4),%xmm0
ff ff
movslq -0x3cc8(%rbp),%rax
movss  %xmm0,-0x3cc0(%rbp,%rax,4)
ff ff
mov    -0x3cc8(%rbp),%eax
shl    $0x1,%eax
add    $0x1,%eax
cltq
movss  -0x38c0(%rbp,%rax,4),%xmm0
ff ff
mov    -0x3cc8(%rbp),%eax
mov    %eax,-0x4d48(%rbp)
mov    -0x3cc4(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0x4d48(%rbp),%eax
add    %ecx,%eax
cltq
movss  %xmm0,-0x3cc0(%rbp,%rax,4)
ff ff
mov    -0x3cc8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3cc8(%rbp)
jmp    18c7 <vstack_process_op+0x767>
mov    -0x8(%rbp),%rdi
lea    -0x3cc0(%rbp),%rsi
mov    -0x3cc4(%rbp),%edx
call   1040 <vstack_push_vector@plt>
jmp    1d14 <vstack_process_op+0xbb4>
lea    -0x40d0(%rbp),%rdi
mov    -0x8(%rbp),%rsi
call   1070 <vstack_pop_vector@plt>
mov    %eax,-0x44d4(%rbp)
mov    -0x44d4(%rbp),%eax
and    $0x1,%eax
cmp    $0x0,%eax
je     19c6 <vstack_process_op+0x866>
mov    -0x44d4(%rbp),%esi
lea    0x729(%rip),%rdi
mov    $0x0,%al
call   1030 <fail@plt>
movl   $0x0,-0x44d8(%rbp)
mov    -0x44d8(%rbp),%eax
mov    %eax,-0x4d4c(%rbp)
mov    -0x44d4(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0x4d4c(%rbp),%eax
cmp    %ecx,%eax
jge    1a4d <vstack_process_op+0x8ed>
mov    -0x44d8(%rbp),%eax
mov    %eax,-0x4d50(%rbp)
mov    -0x44d4(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0x4d50(%rbp),%eax
add    %ecx,%eax
cltq
movss  -0x40d0(%rbp,%rax,4),%xmm0
ff ff
movslq -0x44d8(%rbp),%rax
movss  %xmm0,-0x44d0(%rbp,%rax,4)
ff ff
mov    -0x44d8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44d8(%rbp)
jmp    19d0 <vstack_process_op+0x870>
mov    -0x8(%rbp),%rdi
lea    -0x40d0(%rbp),%rsi
mov    -0x44d4(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%edx
call   1040 <vstack_push_vector@plt>
mov    -0x8(%rbp),%rdi
lea    -0x44d0(%rbp),%rsi
mov    -0x44d4(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%edx
call   1040 <vstack_push_vector@plt>
jmp    1d14 <vstack_process_op+0xbb4>
lea    -0x48e0(%rbp),%rdi
mov    -0x8(%rbp),%rsi
call   1070 <vstack_pop_vector@plt>
mov    %eax,-0x48e4(%rbp)
cmpl   $0x1,-0x48e4(%rbp)
jne    1aef <vstack_process_op+0x98f>
movss  0x543(%rip),%xmm0
ucomiss -0x48e0(%rbp),%xmm0
ja     1aef <vstack_process_op+0x98f>
movss  -0x48e0(%rbp),%xmm0
ff
call   1080 <round@plt>
ucomiss -0x48e0(%rbp),%xmm0
jne    1aef <vstack_process_op+0x98f>
jp     1aef <vstack_process_op+0x98f>
jmp    1b09 <vstack_process_op+0x9a9>
movss  -0x48e0(%rbp),%xmm0
ff
cvtss2sd %xmm0,%xmm0
lea    0x60f(%rip),%rdi
mov    $0x1,%al
call   1030 <fail@plt>
cvttss2si -0x48e0(%rbp),%eax
ff
mov    %eax,-0x48e8(%rbp)
lea    -0x4cf0(%rbp),%rdi
mov    -0x8(%rbp),%rsi
call   1070 <vstack_pop_vector@plt>
mov    %eax,-0x48e4(%rbp)
mov    -0x48e4(%rbp),%eax
cltd
idivl  -0x48e8(%rbp)
xor    %eax,%eax
cmp    %edx,%eax
je     1b5e <vstack_process_op+0x9fe>
mov    -0x48e4(%rbp),%esi
mov    -0x48e8(%rbp),%edx
lea    0x5d9(%rip),%rdi
mov    $0x0,%al
call   1030 <fail@plt>
mov    -0x48e4(%rbp),%eax
mov    -0x48e8(%rbp),%ecx
cltd
idiv   %ecx
mov    %eax,-0x4cf4(%rbp)
mov    -0x48e4(%rbp),%eax
mov    -0x48e8(%rbp),%ecx
mov    -0x4cf4(%rbp),%edx
imul   %edx,%ecx
sub    %ecx,%eax
sete   %al
movzbl %al,%edi
call   1060 <assert@plt>
mov    -0x48e8(%rbp),%eax
mov    %eax,%ecx
mov    -0x4cf4(%rbp),%eax
mov    %rax,-0x4d60(%rbp)
mov    %rsp,%rdx
mov    %rdx,-0x4d00(%rbp)
mov    %rcx,%rdx
imul   %rax,%rdx
lea    0xf(,%rdx,4),%rsi
and    $0xfffffffffffffff0,%rsi
mov    %rsp,%rdx
sub    %rsi,%rdx
mov    %rdx,-0x4d58(%rbp)
mov    %rdx,%rsp
mov    %rcx,-0x4d08(%rbp)
mov    %rax,-0x4d10(%rbp)
movl   $0x0,-0x4d14(%rbp)
mov    -0x4d14(%rbp),%eax
cmp    -0x48e8(%rbp),%eax
jge    1c95 <vstack_process_op+0xb35>
movl   $0x0,-0x4d18(%rbp)
mov    -0x4d18(%rbp),%eax
cmp    -0x4cf4(%rbp),%eax
jge    1c7c <vstack_process_op+0xb1c>
mov    -0x4d58(%rbp),%rax
mov    -0x4d60(%rbp),%rdx
mov    -0x4d14(%rbp),%ecx
imul   -0x4cf4(%rbp),%ecx
add    -0x4d18(%rbp),%ecx
movslq %ecx,%rcx
movss  -0x4cf0(%rbp,%rcx,4),%xmm0
ff ff
movslq -0x4d14(%rbp),%rcx
imul   %rdx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
movslq -0x4d18(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x4d18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4d18(%rbp)
jmp    1c0b <vstack_process_op+0xaab>
jmp    1c81 <vstack_process_op+0xb21>
mov    -0x4d14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4d14(%rbp)
jmp    1bef <vstack_process_op+0xa8f>
movl   $0x0,-0x4d1c(%rbp)
mov    -0x4d1c(%rbp),%eax
cmp    -0x48e8(%rbp),%eax
jge    1cf4 <vstack_process_op+0xb94>
mov    -0x4d58(%rbp),%rsi
mov    -0x4d60(%rbp),%rcx
mov    -0x8(%rbp),%rdi
movslq -0x4d1c(%rbp),%rax
imul   %rcx,%rax
shl    $0x2,%rax
add    %rax,%rsi
mov    -0x4cf4(%rbp),%edx
call   1040 <vstack_push_vector@plt>
mov    -0x4d1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4d1c(%rbp)
jmp    1c9f <vstack_process_op+0xb3f>
mov    -0x4d00(%rbp),%rax
mov    %rax,%rsp
jmp    1d14 <vstack_process_op+0xbb4>
mov    -0xc(%rbp),%esi
lea    0x444(%rip),%rdi
mov    $0x0,%al
call   1030 <fail@plt>
mov    %rbp,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<vstack_process_op>:
push   %rbp
mov    %rsp,%rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0xc58,%rsp
lea    -0x1(%rsi),%eax
cmp    $0xd,%eax
ja     13ac <vstack_process_op+0x23c>
mov    %rdi,%r12
lea    0xe6e(%rip),%rcx
movslq (%rcx,%rax,4),%rax
add    %rcx,%rax
jmp    *%rax
xor    %edi,%edi
mov    %r12,%rsi
lea    -0x28(%rbp),%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
jmp    1080 <vstack_pop_vector@plt>
lea    -0x480(%rbp),%r15
mov    %r15,%rdi
mov    %r12,%rsi
call   1080 <vstack_pop_vector@plt>
mov    %eax,%ebx
mov    %r12,%rdi
mov    %r15,%rsi
mov    %eax,%edx
call   1040 <vstack_push_vector@plt>
mov    %r12,%rdi
mov    %r15,%rsi
jmp    1be2 <vstack_process_op+0xa72>
lea    -0x480(%rbp),%rdi
mov    %r12,%rsi
call   1080 <vstack_pop_vector@plt>
test   %eax,%eax
jle    1be9 <vstack_process_op+0xa79>
mov    %eax,%r14d
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movss  -0x480(%rbp,%rbx,4),%xmm0
ff ff
mov    %r12,%rdi
call   1050 <vstack_push_scalar@plt>
add    $0x1,%rbx
cmp    %rbx,%r14
jne    1210 <vstack_process_op+0xa0>
jmp    1be9 <vstack_process_op+0xa79>
lea    -0x880(%rbp),%rdi
mov    %r12,%rsi
call   1080 <vstack_pop_vector@plt>
mov    %eax,%ebx
lea    -0x480(%rbp),%rdi
mov    %r12,%r14
mov    %r12,%rsi
call   1080 <vstack_pop_vector@plt>
mov    %eax,%r12d
lea    (%r12,%rbx,1),%r15d
cmp    $0x100,%r15d
jl     1270 <vstack_process_op+0x100>
lea    0xdd7(%rip),%rdi
xor    %eax,%eax
call   1030 <fail@plt>
test   %ebx,%ebx
jle    1294 <vstack_process_op+0x124>
movslq %r12d,%rax
lea    -0x480(,%rax,4),%rdi
ff
add    %rbp,%rdi
mov    %ebx,%edx
shl    $0x2,%rdx
lea    -0x880(%rbp),%rsi
call   1070 <memcpy@plt>
lea    -0x480(%rbp),%rsi
mov    %r14,%rdi
mov    %r15d,%edx
jmp    1be4 <vstack_process_op+0xa74>
lea    -0x480(%rbp),%r15
mov    %r15,%rdi
mov    %r12,%rsi
call   1080 <vstack_pop_vector@plt>
mov    %eax,%r13d
mov    %r12,%rbx
lea    -0x880(%rbp),%r12
mov    %r12,%rdi
mov    %rbx,%rsi
call   1080 <vstack_pop_vector@plt>
mov    %eax,%r14d
mov    %rbx,%rdi
mov    %r15,%rsi
mov    %r13d,%edx
call   1040 <vstack_push_vector@plt>
mov    %rbx,%rdi
mov    %r12,%rsi
mov    %r14d,%edx
jmp    1be4 <vstack_process_op+0xa74>
lea    -0xc80(%rbp),%rdi
mov    %r12,%rsi
call   1080 <vstack_pop_vector@plt>
mov    %r12,%rbx
mov    %eax,%r12d
lea    -0x880(%rbp),%rdi
mov    %rbx,%rsi
call   1080 <vstack_pop_vector@plt>
mov    %eax,%r15d
lea    -0x480(%rbp),%rdi
mov    %rbx,-0x40(%rbp)
mov    %rbx,%rsi
call   1080 <vstack_pop_vector@plt>
mov    %eax,%r13d
lea    (%r15,%r13,1),%r14d
lea    (%r14,%r12,1),%ebx
cmp    $0x100,%ebx
jl     134a <vstack_process_op+0x1da>
lea    0xcfd(%rip),%rdi
xor    %eax,%eax
call   1030 <fail@plt>
test   %r15d,%r15d
jle    1370 <vstack_process_op+0x200>
movslq %r13d,%rax
lea    -0x480(,%rax,4),%rdi
ff
add    %rbp,%rdi
mov    %r15d,%edx
shl    $0x2,%rdx
lea    -0x880(%rbp),%rsi
call   1070 <memcpy@plt>
test   %r12d,%r12d
jle    1bd7 <vstack_process_op+0xa67>
movslq %r14d,%r8
mov    %r12d,%eax
cmp    $0x8,%r12d
jae    184a <vstack_process_op+0x6da>
xor    %ecx,%ecx
jmp    1bb3 <vstack_process_op+0xa43>
lea    0xcd1(%rip),%rdi
xor    %eax,%eax
lea    -0x28(%rbp),%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
jmp    1030 <fail@plt>
lea    0xd9e(%rip),%rdi
xor    %eax,%eax
lea    -0x28(%rbp),%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
jmp    1030 <fail@plt>
lea    -0x480(%rbp),%rdi
mov    %r12,%rsi
call   1080 <vstack_pop_vector@plt>
movss  -0x480(%rbp),%xmm1
ff
cmp    $0x1,%eax
jne    1413 <vstack_process_op+0x2a3>
movss  0xc14(%rip),%xmm0
ucomiss %xmm1,%xmm0
ja     1413 <vstack_process_op+0x2a3>
movaps %xmm1,%xmm0
movss  %xmm1,-0x30(%rbp)
call   1090 <roundf@plt>
movss  -0x30(%rbp),%xmm1
ucomiss 0xbfa(%rip),%xmm1
jae    1413 <vstack_process_op+0x2a3>
ucomiss %xmm1,%xmm0
jne    1413 <vstack_process_op+0x2a3>
jnp    1430 <vstack_process_op+0x2c0>
xorps  %xmm0,%xmm0
cvtss2sd %xmm1,%xmm0
lea    0xc60(%rip),%rdi
mov    $0x1,%al
call   1030 <fail@plt>
movss  -0x480(%rbp),%xmm1
ff
mov    %rsp,%r14
cvttss2si %xmm1,%ebx
mov    %rsp,%r15
mov    %rbx,%rax
shl    $0xa,%rax
sub    %rax,%r15
mov    %r15,%rsp
mov    %rsp,%rcx
lea    0xf(,%rbx,4),%rax
and    $0xfffffffffffffff0,%rax
sub    %rax,%rcx
mov    %rcx,%rsp
test   %ebx,%ebx
jle    1840 <vstack_process_op+0x6d0>
mov    %r14,-0x48(%rbp)
mov    %r15,-0x30(%rbp)
xor    %r13d,%r13d
mov    %rbx,-0x50(%rbp)
mov    %r12,%r15
cs nopw 0x0(%rax,%rax,1)
add    $0xffffffffffffffff,%rbx
movslq %ebx,%r14
mov    %r14,%rdi
shl    $0xa,%rdi
add    -0x30(%rbp),%rdi
mov    %r15,%rsi
mov    %rcx,%r12
call   1080 <vstack_pop_vector@plt>
mov    %r12,%rcx
mov    %eax,(%r12,%r14,4)
add    %eax,%r13d
test   %rbx,%rbx
jne    1480 <vstack_process_op+0x310>
cmp    $0xff,%r13d
jle    14c6 <vstack_process_op+0x356>
lea    0xb84(%rip),%rdi
xor    %eax,%eax
call   1030 <fail@plt>
mov    %r12,%rcx
mov    -0x50(%rbp),%rax
test   %eax,%eax
mov    -0x48(%rbp),%r14
jle    19c8 <vstack_process_op+0x858>
mov    %r15,-0x40(%rbp)
cmp    $0x1,%eax
jne    19d2 <vstack_process_op+0x862>
xor    %r15d,%r15d
xor    %eax,%eax
testb  $0x1,-0x50(%rbp)
jne    1a6e <vstack_process_op+0x8fe>
mov    -0x40(%rbp),%r12
jmp    1aa6 <vstack_process_op+0x936>
lea    -0x480(%rbp),%rdi
mov    %r12,%rsi
call   1080 <vstack_pop_vector@plt>
mov    %eax,%ebx
test   $0x1,%bl
je     1521 <vstack_process_op+0x3b1>
lea    0xb84(%rip),%rdi
mov    %ebx,%esi
xor    %eax,%eax
call   1030 <fail@plt>
cmp    $0x2,%ebx
jl     19b9 <vstack_process_op+0x849>
mov    %ebx,%eax
shr    $0x1f,%eax
add    %ebx,%eax
sar    %eax
movslq %eax,%r8
mov    %r8d,%eax
cmp    $0x4,%r8d
jae    1915 <vstack_process_op+0x7a5>
xor    %ecx,%ecx
jmp    1981 <vstack_process_op+0x811>
lea    -0x480(%rbp),%rdi
mov    %r12,%rsi
call   1080 <vstack_pop_vector@plt>
mov    %eax,%ebx
test   $0x1,%bl
je     1570 <vstack_process_op+0x400>
lea    0xb5a(%rip),%rdi
mov    %ebx,%esi
xor    %eax,%eax
call   1030 <fail@plt>
cmp    $0x2,%ebx
jl     19b9 <vstack_process_op+0x849>
mov    %ebx,%eax
shr    $0x1f,%eax
add    %ebx,%eax
sar    %eax
movslq %eax,%r9
mov    %r9d,%eax
cmp    $0x4,%r9d
jb     15cc <vstack_process_op+0x45c>
lea    (%r9,%rax,1),%rcx
lea    -0x880(,%rcx,4),%rcx
ff
add    %rbp,%rcx
lea    -0x880(%rbp),%rdx
cmp    %rcx,%rdx
jae    1bf8 <vstack_process_op+0xa88>
lea    -0x880(,%rax,4),%rcx
ff
add    %rbp,%rcx
lea    -0x880(,%r9,4),%rdx
ff
add    %rbp,%rdx
cmp    %rcx,%rdx
jae    1bf8 <vstack_process_op+0xa88>
xor    %edx,%edx
mov    %rdx,%rcx
not    %rcx
test   $0x1,%al
je     1604 <vstack_process_op+0x494>
movss  -0x480(%rbp,%rdx,8),%xmm0
ff ff
movss  -0x47c(%rbp,%rdx,8),%xmm1
ff ff
movss  %xmm0,-0x880(%rbp,%rdx,4)
ff ff
lea    (%rdx,%r9,1),%rsi
movss  %xmm1,-0x880(%rbp,%rsi,4)
ff ff
or     $0x1,%rdx
add    %rax,%rcx
je     19b9 <vstack_process_op+0x849>
lea    -0x87c(,%r9,4),%rcx
ff
add    %rbp,%rcx
nopl   0x0(%rax,%rax,1)
movss  -0x480(%rbp,%rdx,8),%xmm0
ff ff
movss  -0x47c(%rbp,%rdx,8),%xmm1
ff ff
movss  %xmm0,-0x880(%rbp,%rdx,4)
ff ff
movss  %xmm1,-0x4(%rcx,%rdx,4)
movss  -0x478(%rbp,%rdx,8),%xmm0
ff ff
movss  -0x474(%rbp,%rdx,8),%xmm1
ff ff
movss  %xmm0,-0x87c(%rbp,%rdx,4)
ff ff
movss  %xmm1,(%rcx,%rdx,4)
add    $0x2,%rdx
cmp    %rdx,%rax
jne    1620 <vstack_process_op+0x4b0>
jmp    19b9 <vstack_process_op+0x849>
lea    -0x480(%rbp),%rdi
mov    %r12,%rsi
call   1080 <vstack_pop_vector@plt>
mov    %eax,%r15d
test   $0x1,%r15b
je     1698 <vstack_process_op+0x528>
lea    0xa5a(%rip),%rdi
mov    %r15d,%esi
xor    %eax,%eax
call   1030 <fail@plt>
mov    %r15d,%ebx
shr    $0x1f,%ebx
add    %r15d,%ebx
sar    %ebx
cmp    $0x2,%r15d
jl     16ce <vstack_process_op+0x55e>
movslq %ebx,%rax
lea    -0x480(,%rax,4),%rsi
ff
add    %rbp,%rsi
add    $0xffffffff,%eax
lea    0x4(,%rax,4),%rdx
lea    -0x880(%rbp),%rdi
call   1070 <memcpy@plt>
lea    -0x480(%rbp),%rsi
mov    %r12,%rdi
mov    %ebx,%edx
call   1040 <vstack_push_vector@plt>
jmp    19b9 <vstack_process_op+0x849>
lea    -0x480(%rbp),%rdi
mov    %r12,%rsi
call   1080 <vstack_pop_vector@plt>
mov    %eax,%ebx
movss  -0x480(%rbp),%xmm0
ff
movss  %xmm0,-0x30(%rbp)
call   1090 <roundf@plt>
movss  -0x30(%rbp),%xmm2
cmp    $0x1,%ebx
jne    1725 <vstack_process_op+0x5b5>
movss  0x8e7(%rip),%xmm1
ucomiss %xmm2,%xmm1
ja     1725 <vstack_process_op+0x5b5>
ucomiss %xmm2,%xmm0
jne    1725 <vstack_process_op+0x5b5>
jnp    1742 <vstack_process_op+0x5d2>
xorps  %xmm0,%xmm0
cvtss2sd %xmm2,%xmm0
lea    0x9de(%rip),%rdi
mov    $0x1,%al
call   1030 <fail@plt>
movss  -0x480(%rbp),%xmm2
ff
cvttss2si %xmm2,%r14d
lea    -0x880(%rbp),%rdi
mov    %r12,%rsi
call   1080 <vstack_pop_vector@plt>
mov    %eax,%ebx
cltd
idiv   %r14d
mov    %eax,%r13d
test   %edx,%edx
je     1776 <vstack_process_op+0x606>
lea    0x9c6(%rip),%rdi
mov    %ebx,%esi
mov    %r14d,%edx
xor    %eax,%eax
call   1030 <fail@plt>
mov    %r13d,%eax
imul   %r14d,%eax
xor    %edi,%edi
cmp    %eax,%ebx
sete   %dil
call   1060 <assert@plt>
mov    %rsp,-0x70(%rbp)
mov    %r14d,%ecx
mov    %r14d,%r14d
mov    %r13d,%edx
mov    %rdx,%rax
imul   %r14,%rax
lea    0xf(,%rax,4),%rax
and    $0xfffffffffffffff0,%rax
mov    %rsp,%r15
sub    %rax,%r15
mov    %r15,%rsp
test   %ecx,%ecx
jle    1837 <vstack_process_op+0x6c7>
mov    %r13d,-0x30(%rbp)
mov    %r12,-0x40(%rbp)
lea    0x0(,%rdx,4),%rax
mov    %rax,-0x38(%rbp)
mov    %ecx,-0x5c(%rbp)
cmp    $0x1,%ecx
mov    %rdx,-0x68(%rbp)
jne    1877 <vstack_process_op+0x707>
xor    %r12d,%r12d
test   $0x1,%r14b
mov    -0x30(%rbp),%r13d
je     1811 <vstack_process_op+0x6a1>
test   %r13d,%r13d
jle    1811 <vstack_process_op+0x6a1>
imul   -0x68(%rbp),%r12
movslq %r12d,%rax
lea    -0x880(,%rax,4),%rsi
add    %rbp,%rsi
lea    (%r15,%r12,4),%rdi
mov    -0x38(%rbp),%rdx
call   1070 <memcpy@plt>
cmpl   $0x0,-0x5c(%rbp)
mov    -0x40(%rbp),%r12
mov    -0x38(%rbp),%rbx
jle    1837 <vstack_process_op+0x6c7>
nop
mov    %r12,%rdi
mov    %r15,%rsi
mov    %r13d,%edx
call   1040 <vstack_push_vector@plt>
add    %rbx,%r15
add    $0xffffffffffffffff,%r14
jne    1820 <vstack_process_op+0x6b0>
mov    -0x70(%rbp),%rsp
jmp    1be9 <vstack_process_op+0xa79>
xor    %r13d,%r13d
xor    %eax,%eax
jmp    1aaa <vstack_process_op+0x93a>
mov    %eax,%ecx
and    $0xfffffff8,%ecx
lea    -0x8(%rcx),%rdx
mov    %rdx,%rdi
shr    $0x3,%rdi
add    $0x1,%rdi
mov    %edi,%esi
and    $0x3,%esi
mov    %ebx,%r9d
cmp    $0x18,%rdx
jae    1ad2 <vstack_process_op+0x962>
xor    %ebx,%ebx
jmp    1b61 <vstack_process_op+0x9f1>
mov    %r14d,%eax
and    $0xfffffffe,%eax
mov    %rax,-0x58(%rbp)
lea    0x0(,%rdx,8),%rax
mov    %rax,-0x50(%rbp)
mov    %rdx,%rax
shl    $0x20,%rax
mov    %rax,-0x78(%rbp)
shl    $0x21,%rdx
mov    %rdx,-0x48(%rbp)
xor    %r13d,%r13d
mov    %r15,%rbx
xor    %r12d,%r12d
jmp    18c6 <vstack_process_op+0x756>
nopl   0x0(%rax,%rax,1)
add    $0x2,%r12
add    -0x50(%rbp),%rbx
add    -0x48(%rbp),%r13
cmp    %r12,-0x58(%rbp)
je     17e2 <vstack_process_op+0x672>
cmpl   $0x0,-0x30(%rbp)
jle    18ea <vstack_process_op+0x77a>
mov    %r13,%rax
sar    $0x1e,%rax
lea    (%rax,%rbp,1),%rsi
add    $0xfffffffffffff780,%rsi
mov    %rbx,%rdi
mov    -0x38(%rbp),%rdx
call   1070 <memcpy@plt>
cmpl   $0x0,-0x30(%rbp)
jle    18b0 <vstack_process_op+0x740>
mov    -0x78(%rbp),%rax
add    %r13,%rax
sar    $0x1e,%rax
lea    (%rax,%rbp,1),%rsi
add    $0xfffffffffffff780,%rsi
mov    -0x38(%rbp),%rdx
lea    (%rbx,%rdx,1),%rdi
call   1070 <memcpy@plt>
jmp    18b0 <vstack_process_op+0x740>
mov    %eax,%ecx
and    $0xfffffffc,%ecx
lea    -0x478(,%r8,4),%rsi
ff
add    %rbp,%rsi
lea    0x0(,%rax,4),%rdi
and    $0xfffffffffffffff0,%rdi
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movsd  -0x480(%rbp,%rdx,1),%xmm0
ff ff
movsd  -0x478(%rbp,%rdx,1),%xmm1
ff ff
movsd  -0x8(%rsi,%rdx,1),%xmm2
unpcklps %xmm2,%xmm0
movsd  (%rsi,%rdx,1),%xmm2
unpcklps %xmm2,%xmm1
movaps %xmm0,-0x880(%rbp,%rdx,2)
ff
movaps %xmm1,-0x870(%rbp,%rdx,2)
ff
add    $0x10,%rdx
cmp    %rdx,%rdi
jne    1940 <vstack_process_op+0x7d0>
cmp    %rax,%rcx
je     19b9 <vstack_process_op+0x849>
lea    -0x480(,%r8,4),%rdx
ff
add    %rbp,%rdx
nopl   0x0(%rax)
movss  -0x480(%rbp,%rcx,4),%xmm0
ff ff
movss  %xmm0,-0x880(%rbp,%rcx,8)
ff ff
movss  (%rdx,%rcx,4),%xmm0
movss  %xmm0,-0x87c(%rbp,%rcx,8)
ff ff
add    $0x1,%rcx
cmp    %rcx,%rax
jne    1990 <vstack_process_op+0x820>
lea    -0x880(%rbp),%rsi
mov    %r12,%rdi
jmp    1be2 <vstack_process_op+0xa72>
xor    %eax,%eax
mov    %r15,%r12
jmp    1aaa <vstack_process_op+0x93a>
and    $0xfffffffe,%eax
mov    %rax,-0x58(%rbp)
mov    -0x30(%rbp),%rax
lea    0x400(%rax),%r14
xor    %r15d,%r15d
xor    %eax,%eax
jmp    1a05 <vstack_process_op+0x895>
nopl   0x0(%rax,%rax,1)
add    $0x2,%r15
add    $0x800,%r14
cmp    %r15,-0x58(%rbp)
je     14e8 <vstack_process_op+0x378>
mov    (%rcx,%r15,4),%ebx
test   %ebx,%ebx
jle    1a3a <vstack_process_op+0x8ca>
lea    -0x400(%r14),%rsi
cltq
mov    %rax,-0x38(%rbp)
lea    -0x880(,%rax,4),%rdi
ff
add    %rbp,%rdi
mov    %rbx,%rdx
shl    $0x2,%rdx
call   1070 <memcpy@plt>
mov    -0x38(%rbp),%rax
mov    %r12,%rcx
add    %ebx,%eax
mov    0x4(%rcx,%r15,4),%ebx
test   %ebx,%ebx
jle    19f0 <vstack_process_op+0x880>
cltq
mov    %rax,-0x38(%rbp)
lea    -0x880(,%rax,4),%rdi
ff
add    %rbp,%rdi
mov    %rbx,%rdx
shl    $0x2,%rdx
mov    %r14,%rsi
call   1070 <memcpy@plt>
mov    -0x38(%rbp),%rax
mov    %r12,%rcx
add    %ebx,%eax
jmp    19f0 <vstack_process_op+0x880>
mov    (%rcx,%r15,4),%ebx
test   %ebx,%ebx
mov    -0x40(%rbp),%r12
jle    1aa6 <vstack_process_op+0x936>
shl    $0xa,%r15
mov    -0x30(%rbp),%rsi
add    %r15,%rsi
cltq
lea    -0x880(,%rax,4),%rdi
ff
add    %rbp,%rdi
mov    %rbx,%rdx
shl    $0x2,%rdx
mov    %rax,%r14
call   1070 <memcpy@plt>
mov    %r14,%rax
add    %ebx,%eax
mov    -0x48(%rbp),%r14
xor    %edi,%edi
cmp    %r13d,%eax
sete   %dil
call   1060 <assert@plt>
lea    -0x880(%rbp),%rsi
mov    %r12,%rdi
mov    %r13d,%edx
call   1040 <vstack_push_vector@plt>
mov    %r14,%rsp
jmp    1be9 <vstack_process_op+0xa79>
and    $0xfffffffffffffffc,%rdi
lea    -0x410(,%r8,4),%rdx
ff
add    %rbp,%rdx
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movaps -0xc80(%rbp,%rbx,4),%xmm0
ff
movaps -0xc70(%rbp,%rbx,4),%xmm1
ff
movups %xmm0,-0x70(%rdx,%rbx,4)
movups %xmm1,-0x60(%rdx,%rbx,4)
movaps -0xc60(%rbp,%rbx,4),%xmm0
ff
movaps -0xc50(%rbp,%rbx,4),%xmm1
ff
movups %xmm0,-0x50(%rdx,%rbx,4)
movups %xmm1,-0x40(%rdx,%rbx,4)
movaps -0xc40(%rbp,%rbx,4),%xmm0
ff
movaps -0xc30(%rbp,%rbx,4),%xmm1
ff
movups %xmm0,-0x30(%rdx,%rbx,4)
movups %xmm1,-0x20(%rdx,%rbx,4)
movaps -0xc20(%rbp,%rbx,4),%xmm0
ff
movaps -0xc10(%rbp,%rbx,4),%xmm1
ff
movups %xmm0,-0x10(%rdx,%rbx,4)
movups %xmm1,(%rdx,%rbx,4)
add    $0x20,%rbx
add    $0xfffffffffffffffc,%rdi
jne    1af0 <vstack_process_op+0x980>
test   %rsi,%rsi
je     1bab <vstack_process_op+0xa3b>
lea    (%rbx,%r8,1),%rdx
lea    -0x470(,%rdx,4),%rdx
ff
add    %rbp,%rdx
lea    -0xc70(,%rbx,4),%rdi
ff
add    %rbp,%rdi
shl    $0x5,%rsi
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
movaps -0x10(%rdi,%rbx,1),%xmm0
movaps (%rdi,%rbx,1),%xmm1
movups %xmm0,-0x10(%rdx,%rbx,1)
movups %xmm1,(%rdx,%rbx,1)
add    $0x20,%rbx
cmp    %rbx,%rsi
jne    1b90 <vstack_process_op+0xa20>
cmp    %rax,%rcx
mov    %r9d,%ebx
je     1bd7 <vstack_process_op+0xa67>
lea    -0x480(,%r8,4),%rdx
ff
add    %rbp,%rdx
xchg   %ax,%ax
movss  -0xc80(%rbp,%rcx,4),%xmm0
ff ff
movss  %xmm0,(%rdx,%rcx,4)
add    $0x1,%rcx
cmp    %rcx,%rax
jne    1bc0 <vstack_process_op+0xa50>
lea    -0x480(%rbp),%rsi
mov    -0x40(%rbp),%rdi
mov    %ebx,%edx
call   1040 <vstack_push_vector@plt>
lea    -0x28(%rbp),%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
mov    %eax,%edx
and    $0xfffffffc,%edx
lea    -0x4(%rdx),%rcx
mov    %rcx,%r8
shr    $0x2,%r8
add    $0x1,%r8
test   %rcx,%rcx
je     1c80 <vstack_process_op+0xb10>
mov    %r8,%rdi
and    $0xfffffffffffffffe,%rdi
lea    -0x870(,%r9,4),%rcx
ff
add    %rbp,%rcx
xor    %esi,%esi
movaps -0x480(%rbp,%rsi,8),%xmm0
ff
movaps -0x470(%rbp,%rsi,8),%xmm1
ff
movaps %xmm0,%xmm2
shufps $0x88,%xmm1,%xmm2
shufps $0xdd,%xmm1,%xmm0
movaps %xmm2,-0x880(%rbp,%rsi,4)
ff
movups %xmm0,-0x10(%rcx,%rsi,4)
movaps -0x460(%rbp,%rsi,8),%xmm0
ff
movaps -0x450(%rbp,%rsi,8),%xmm1
ff
movaps %xmm0,%xmm2
shufps $0x88,%xmm1,%xmm2
shufps $0xdd,%xmm1,%xmm0
movaps %xmm2,-0x870(%rbp,%rsi,4)
ff
movups %xmm0,(%rcx,%rsi,4)
add    $0x8,%rsi
add    $0xfffffffffffffffe,%rdi
jne    1c25 <vstack_process_op+0xab5>
jmp    1c82 <vstack_process_op+0xb12>
xor    %esi,%esi
test   $0x1,%r8b
je     1cb6 <vstack_process_op+0xb46>
movaps -0x480(%rbp,%rsi,8),%xmm0
ff
movaps -0x470(%rbp,%rsi,8),%xmm1
ff
movaps %xmm0,%xmm2
shufps $0x88,%xmm1,%xmm2
shufps $0xdd,%xmm1,%xmm0
movaps %xmm2,-0x880(%rbp,%rsi,4)
ff
add    %r9,%rsi
movups %xmm0,-0x880(%rbp,%rsi,4)
ff
cmp    %rax,%rdx
je     19b9 <vstack_process_op+0x849>
jmp    15ce <vstack_process_op+0x45e>

LLVM IR (-O0):
%struct.value_vstack = type { i32 }
@.str = [40 x i8] c"merging vectors results in large vector\00"
@.str.1 = [25 x i8] c"mergeall not implemented\00"
@.str.2 = [27 x i8] c"can not nmerge \22%g\22 things\00"
@.str.3 = [37 x i8] c"can not interleave an odd number %d!\00"
@.str.4 = [39 x i8] c"can not deinterleave an odd number %d!\00"
@.str.5 = [41 x i8] c"can not halve a vector of odd length %d!\00"
@.str.6 = [31 x i8] c"can not split into \22%g\22 things\00"
@.str.7 = [33 x i8] c"can not split \22%d\22 in \22%d\22 parts\00"
@.str.8 = [34 x i8] c"impossible condition (stackop %d)\00"
define void @vstack_process_op(%struct.value_vstack* %0, i32 %1) {
%3 = alloca %struct.value_vstack*
%4 = alloca i32
%5 = alloca [256 x float]
%6 = alloca i32
%7 = alloca [256 x float]
%8 = alloca i32
%9 = alloca i32
%10 = alloca [256 x float]
%11 = alloca [256 x float]
%12 = alloca i32
%13 = alloca i32
%14 = alloca i32
%15 = alloca [256 x float]
%16 = alloca [256 x float]
%17 = alloca [256 x float]
%18 = alloca i32
%19 = alloca i32
%20 = alloca i32
%21 = alloca i32
%22 = alloca i32
%23 = alloca [256 x float]
%24 = alloca [256 x float]
%25 = alloca i32
%26 = alloca i32
%27 = alloca [256 x float]
%28 = alloca i32
%29 = alloca i8*
%30 = alloca i64
%31 = alloca [256 x float]
%32 = alloca i64
%33 = alloca i32
%34 = alloca i32
%35 = alloca i32
%36 = alloca i32
%37 = alloca i32
%38 = alloca i32
%39 = alloca [256 x float]
%40 = alloca [256 x float]
%41 = alloca i32
%42 = alloca i32
%43 = alloca [256 x float]
%44 = alloca [256 x float]
%45 = alloca i32
%46 = alloca i32
%47 = alloca [256 x float]
%48 = alloca [256 x float]
%49 = alloca i32
%50 = alloca i32
%51 = alloca [256 x float]
%52 = alloca i32
%53 = alloca i32
%54 = alloca [256 x float]
%55 = alloca i32
%56 = alloca i8*
%57 = alloca i64
%58 = alloca i64
%59 = alloca i32
%60 = alloca i32
%61 = alloca i32
store %struct.value_vstack* %0, %struct.value_vstack** %3
store i32 %1, i32* %4
%62 = load i32, i32* %4
switch i32 %62, label %565 [
i32 1, label %63
i32 2, label %66
i32 3, label %78
i32 4, label %97
i32 6, label %135
i32 5, label %200
i32 7, label %215
i32 10, label %217
i32 11, label %329
i32 12, label %374
i32 13, label %419
i32 14, label %460
]
63: ; preds = %2
%64 = load %struct.value_vstack*, %struct.value_vstack** %3
%65 = call i32 @vstack_pop_vector(float* null, %struct.value_vstack* %64)
br label %568
66: ; preds = %2
%67 = getelementptr inbounds [256 x float], [256 x float]* %5, i64 0, i64 0
%68 = load %struct.value_vstack*, %struct.value_vstack** %3
%69 = call i32 @vstack_pop_vector(float* %67, %struct.value_vstack* %68)
store i32 %69, i32* %6
%70 = load %struct.value_vstack*, %struct.value_vstack** %3
%71 = getelementptr inbounds [256 x float], [256 x float]* %5, i64 0, i64 0
%72 = load i32, i32* %6
%73 = call i32 @vstack_push_vector(%struct.value_vstack* %70, float* %71, i32 %72)
%74 = load %struct.value_vstack*, %struct.value_vstack** %3
%75 = getelementptr inbounds [256 x float], [256 x float]* %5, i64 0, i64 0
%76 = load i32, i32* %6
%77 = call i32 @vstack_push_vector(%struct.value_vstack* %74, float* %75, i32 %76)
br label %568
78: ; preds = %2
%79 = getelementptr inbounds [256 x float], [256 x float]* %7, i64 0, i64 0
%80 = load %struct.value_vstack*, %struct.value_vstack** %3
%81 = call i32 @vstack_pop_vector(float* %79, %struct.value_vstack* %80)
store i32 %81, i32* %8
store i32 0, i32* %9
br label %82
82: ; preds = %93, %78
%83 = load i32, i32* %9
%84 = load i32, i32* %8
%85 = icmp slt i32 %83, %84
br i1 %85, label %86, label %96
86: ; preds = %82
%87 = load %struct.value_vstack*, %struct.value_vstack** %3
%88 = load i32, i32* %9
%89 = sext i32 %88 to i64
%90 = getelementptr inbounds [256 x float], [256 x float]* %7, i64 0, i64 %89
%91 = load float, float* %90
%92 = call i32 @vstack_push_scalar(%struct.value_vstack* %87, float %91)
br label %93
93: ; preds = %86
%94 = load i32, i32* %9
%95 = add nsw i32 %94, 1
store i32 %95, i32* %9
br label %82
96: ; preds = %82
br label %568
97: ; preds = %2
%98 = getelementptr inbounds [256 x float], [256 x float]* %11, i64 0, i64 0
%99 = load %struct.value_vstack*, %struct.value_vstack** %3
%100 = call i32 @vstack_pop_vector(float* %98, %struct.value_vstack* %99)
store i32 %100, i32* %12
%101 = getelementptr inbounds [256 x float], [256 x float]* %10, i64 0, i64 0
%102 = load %struct.value_vstack*, %struct.value_vstack** %3
%103 = call i32 @vstack_pop_vector(float* %101, %struct.value_vstack* %102)
store i32 %103, i32* %13
%104 = load i32, i32* %13
%105 = load i32, i32* %12
%106 = add nsw i32 %104, %105
%107 = icmp sge i32 %106, 256
br i1 %107, label %108, label %110
108: ; preds = %97
%109 = call i32 (i8*, ...) @fail(i8* getelementptr inbounds ([40 x i8], [40 x i8]* @.str, i64 0, i64 0))
br label %110
110: ; preds = %108, %97
store i32 0, i32* %14
br label %111
111: ; preds = %125, %110
%112 = load i32, i32* %14
%113 = load i32, i32* %12
%114 = icmp slt i32 %112, %113
br i1 %114, label %115, label %128
115: ; preds = %111
%116 = load i32, i32* %14
%117 = sext i32 %116 to i64
%118 = getelementptr inbounds [256 x float], [256 x float]* %11, i64 0, i64 %117
%119 = load float, float* %118
%120 = load i32, i32* %13
%121 = load i32, i32* %14
%122 = add nsw i32 %120, %121
%123 = sext i32 %122 to i64
%124 = getelementptr inbounds [256 x float], [256 x float]* %10, i64 0, i64 %123
store float %119, float* %124
br label %125
125: ; preds = %115
%126 = load i32, i32* %14
%127 = add nsw i32 %126, 1
store i32 %127, i32* %14
br label %111
128: ; preds = %111
%129 = load %struct.value_vstack*, %struct.value_vstack** %3
%130 = getelementptr inbounds [256 x float], [256 x float]* %10, i64 0, i64 0
%131 = load i32, i32* %13
%132 = load i32, i32* %12
%133 = add nsw i32 %131, %132
%134 = call i32 @vstack_push_vector(%struct.value_vstack* %129, float* %130, i32 %133)
br label %568
135: ; preds = %2
%136 = getelementptr inbounds [256 x float], [256 x float]* %17, i64 0, i64 0
%137 = load %struct.value_vstack*, %struct.value_vstack** %3
%138 = call i32 @vstack_pop_vector(float* %136, %struct.value_vstack* %137)
store i32 %138, i32* %18
%139 = getelementptr inbounds [256 x float], [256 x float]* %16, i64 0, i64 0
%140 = load %struct.value_vstack*, %struct.value_vstack** %3
%141 = call i32 @vstack_pop_vector(float* %139, %struct.value_vstack* %140)
store i32 %141, i32* %19
%142 = getelementptr inbounds [256 x float], [256 x float]* %15, i64 0, i64 0
%143 = load %struct.value_vstack*, %struct.value_vstack** %3
%144 = call i32 @vstack_pop_vector(float* %142, %struct.value_vstack* %143)
store i32 %144, i32* %20
%145 = load i32, i32* %20
%146 = load i32, i32* %19
%147 = add nsw i32 %145, %146
%148 = load i32, i32* %18
%149 = add nsw i32 %147, %148
%150 = icmp sge i32 %149, 256
br i1 %150, label %151, label %153
151: ; preds = %135
%152 = call i32 (i8*, ...) @fail(i8* getelementptr inbounds ([40 x i8], [40 x i8]* @.str, i64 0, i64 0))
br label %153
153: ; preds = %151, %135
store i32 0, i32* %21
br label %154
154: ; preds = %168, %153
%155 = load i32, i32* %21
%156 = load i32, i32* %19
%157 = icmp slt i32 %155, %156
br i1 %157, label %158, label %171
158: ; preds = %154
%159 = load i32, i32* %21
%160 = sext i32 %159 to i64
%161 = getelementptr inbounds [256 x float], [256 x float]* %16, i64 0, i64 %160
%162 = load float, float* %161
%163 = load i32, i32* %20
%164 = load i32, i32* %21
%165 = add nsw i32 %163, %164
%166 = sext i32 %165 to i64
%167 = getelementptr inbounds [256 x float], [256 x float]* %15, i64 0, i64 %166
store float %162, float* %167
br label %168
168: ; preds = %158
%169 = load i32, i32* %21
%170 = add nsw i32 %169, 1
store i32 %170, i32* %21
br label %154
171: ; preds = %154
store i32 0, i32* %22
br label %172
172: ; preds = %188, %171
%173 = load i32, i32* %22
%174 = load i32, i32* %18
%175 = icmp slt i32 %173, %174
br i1 %175, label %176, label %191
176: ; preds = %172
%177 = load i32, i32* %22
%178 = sext i32 %177 to i64
%179 = getelementptr inbounds [256 x float], [256 x float]* %17, i64 0, i64 %178
%180 = load float, float* %179
%181 = load i32, i32* %20
%182 = load i32, i32* %19
%183 = add nsw i32 %181, %182
%184 = load i32, i32* %22
%185 = add nsw i32 %183, %184
%186 = sext i32 %185 to i64
%187 = getelementptr inbounds [256 x float], [256 x float]* %15, i64 0, i64 %186
store float %180, float* %187
br label %188
188: ; preds = %176
%189 = load i32, i32* %22
%190 = add nsw i32 %189, 1
store i32 %190, i32* %22
br label %172
191: ; preds = %172
%192 = load %struct.value_vstack*, %struct.value_vstack** %3
%193 = getelementptr inbounds [256 x float], [256 x float]* %15, i64 0, i64 0
%194 = load i32, i32* %20
%195 = load i32, i32* %19
%196 = add nsw i32 %194, %195
%197 = load i32, i32* %18
%198 = add nsw i32 %196, %197
%199 = call i32 @vstack_push_vector(%struct.value_vstack* %192, float* %193, i32 %198)
br label %568
200: ; preds = %2
%201 = getelementptr inbounds [256 x float], [256 x float]* %23, i64 0, i64 0
%202 = load %struct.value_vstack*, %struct.value_vstack** %3
%203 = call i32 @vstack_pop_vector(float* %201, %struct.value_vstack* %202)
store i32 %203, i32* %25
%204 = getelementptr inbounds [256 x float], [256 x float]* %24, i64 0, i64 0
%205 = load %struct.value_vstack*, %struct.value_vstack** %3
%206 = call i32 @vstack_pop_vector(float* %204, %struct.value_vstack* %205)
store i32 %206, i32* %26
%207 = load %struct.value_vstack*, %struct.value_vstack** %3
%208 = getelementptr inbounds [256 x float], [256 x float]* %23, i64 0, i64 0
%209 = load i32, i32* %25
%210 = call i32 @vstack_push_vector(%struct.value_vstack* %207, float* %208, i32 %209)
%211 = load %struct.value_vstack*, %struct.value_vstack** %3
%212 = getelementptr inbounds [256 x float], [256 x float]* %24, i64 0, i64 0
%213 = load i32, i32* %26
%214 = call i32 @vstack_push_vector(%struct.value_vstack* %211, float* %212, i32 %213)
br label %568
215: ; preds = %2
%216 = call i32 (i8*, ...) @fail(i8* getelementptr inbounds ([25 x i8], [25 x i8]* @.str.1, i64 0, i64 0))
br label %568
217: ; preds = %2
%218 = getelementptr inbounds [256 x float], [256 x float]* %27, i64 0, i64 0
%219 = load %struct.value_vstack*, %struct.value_vstack** %3
%220 = call i32 @vstack_pop_vector(float* %218, %struct.value_vstack* %219)
store i32 %220, i32* %28
%221 = load i32, i32* %28
%222 = icmp ne i32 %221, 1
br i1 %222, label %238, label %223
223: ; preds = %217
%224 = getelementptr inbounds [256 x float], [256 x float]* %27, i64 0, i64 0
%225 = load float, float* %224
%226 = fcmp olt float %225, 1.000000e+00
br i1 %226, label %238, label %227
227: ; preds = %223
%228 = getelementptr inbounds [256 x float], [256 x float]* %27, i64 0, i64 0
%229 = load float, float* %228
%230 = call float @round(float %229)
%231 = getelementptr inbounds [256 x float], [256 x float]* %27, i64 0, i64 0
%232 = load float, float* %231
%233 = fcmp une float %230, %232
br i1 %233, label %238, label %234
234: ; preds = %227
%235 = getelementptr inbounds [256 x float], [256 x float]* %27, i64 0, i64 0
%236 = load float, float* %235
%237 = fcmp oge float %236, 2.560000e+02
br i1 %237, label %238, label %243
238: ; preds = %234, %227, %223, %217
%239 = getelementptr inbounds [256 x float], [256 x float]* %27, i64 0, i64 0
%240 = load float, float* %239
%241 = fpext float %240 to double
%242 = call i32 (i8*, ...) @fail(i8* getelementptr inbounds ([27 x i8], [27 x i8]* @.str.2, i64 0, i64 0), double %241)
br label %243
243: ; preds = %238, %234
%244 = getelementptr inbounds [256 x float], [256 x float]* %27, i64 0, i64 0
%245 = load float, float* %244
%246 = fptosi float %245 to i32
store i32 %246, i32* %28
%247 = load i32, i32* %28
%248 = zext i32 %247 to i64
%249 = call i8* @llvm.stacksave()
store i8* %249, i8** %29
%250 = alloca [256 x float], i64 %248
store i64 %248, i64* %30
%251 = load i32, i32* %28
%252 = zext i32 %251 to i64
%253 = alloca i32, i64 %252
store i64 %252, i64* %32
store i32 0, i32* %33
store i32 0, i32* %34
br label %254
254: ; preds = %278, %243
%255 = load i32, i32* %34
%256 = load i32, i32* %28
%257 = icmp slt i32 %255, %256
br i1 %257, label %258, label %281
258: ; preds = %254
%259 = load i32, i32* %28
%260 = load i32, i32* %34
%261 = sub nsw i32 %259, %260
%262 = sub nsw i32 %261, 1
store i32 %262, i32* %35
%263 = load i32, i32* %35
%264 = sext i32 %263 to i64
%265 = getelementptr inbounds [256 x float], [256 x float]* %250, i64 %264
%266 = getelementptr inbounds [256 x float], [256 x float]* %265, i64 0, i64 0
%267 = load %struct.value_vstack*, %struct.value_vstack** %3
%268 = call i32 @vstack_pop_vector(float* %266, %struct.value_vstack* %267)
%269 = load i32, i32* %35
%270 = sext i32 %269 to i64
%271 = getelementptr inbounds i32, i32* %253, i64 %270
store i32 %268, i32* %271
%272 = load i32, i32* %35
%273 = sext i32 %272 to i64
%274 = getelementptr inbounds i32, i32* %253, i64 %273
%275 = load i32, i32* %274
%276 = load i32, i32* %33
%277 = add nsw i32 %276, %275
store i32 %277, i32* %33
br label %278
278: ; preds = %258
%279 = load i32, i32* %34
%280 = add nsw i32 %279, 1
store i32 %280, i32* %34
br label %254
281: ; preds = %254
%282 = load i32, i32* %33
%283 = icmp sge i32 %282, 256
br i1 %283, label %284, label %286
284: ; preds = %281
%285 = call i32 (i8*, ...) @fail(i8* getelementptr inbounds ([40 x i8], [40 x i8]* @.str, i64 0, i64 0))
br label %286
286: ; preds = %284, %281
store i32 0, i32* %36
store i32 0, i32* %37
br label %287
287: ; preds = %315, %286
%288 = load i32, i32* %37
%289 = load i32, i32* %28
%290 = icmp slt i32 %288, %289
br i1 %290, label %291, label %318
291: ; preds = %287
store i32 0, i32* %38
br label %292
292: ; preds = %311, %291
%293 = load i32, i32* %38
%294 = load i32, i32* %37
%295 = sext i32 %294 to i64
%296 = getelementptr inbounds i32, i32* %253, i64 %295
%297 = load i32, i32* %296
%298 = icmp slt i32 %293, %297
br i1 %298, label %299, label %314
299: ; preds = %292
%300 = load i32, i32* %37
%301 = sext i32 %300 to i64
%302 = getelementptr inbounds [256 x float], [256 x float]* %250, i64 %301
%303 = load i32, i32* %38
%304 = sext i32 %303 to i64
%305 = getelementptr inbounds [256 x float], [256 x float]* %302, i64 0, i64 %304
%306 = load float, float* %305
%307 = load i32, i32* %36
%308 = add nsw i32 %307, 1
store i32 %308, i32* %36
%309 = sext i32 %307 to i64
%310 = getelementptr inbounds [256 x float], [256 x float]* %31, i64 0, i64 %309
store float %306, float* %310
br label %311
311: ; preds = %299
%312 = load i32, i32* %38
%313 = add nsw i32 %312, 1
store i32 %313, i32* %38
br label %292
314: ; preds = %292
br label %315
315: ; preds = %314
%316 = load i32, i32* %37
%317 = add nsw i32 %316, 1
store i32 %317, i32* %37
br label %287
318: ; preds = %287
%319 = load i32, i32* %36
%320 = load i32, i32* %33
%321 = icmp eq i32 %319, %320
%322 = zext i1 %321 to i32
%323 = call i32 @assert(i32 %322)
%324 = load %struct.value_vstack*, %struct.value_vstack** %3
%325 = getelementptr inbounds [256 x float], [256 x float]* %31, i64 0, i64 0
%326 = load i32, i32* %33
%327 = call i32 @vstack_push_vector(%struct.value_vstack* %324, float* %325, i32 %326)
%328 = load i8*, i8** %29
br label %568
329: ; preds = %2
%330 = getelementptr inbounds [256 x float], [256 x float]* %39, i64 0, i64 0
%331 = load %struct.value_vstack*, %struct.value_vstack** %3
%332 = call i32 @vstack_pop_vector(float* %330, %struct.value_vstack* %331)
store i32 %332, i32* %41
%333 = load i32, i32* %41
%334 = and i32 %333, 1
%335 = icmp ne i32 %334, 0
br i1 %335, label %336, label %339
336: ; preds = %329
%337 = load i32, i32* %41
%338 = call i32 (i8*, ...) @fail(i8* getelementptr inbounds ([37 x i8], [37 x i8]* @.str.3, i64 0, i64 0), i32 %337)
br label %339
339: ; preds = %336, %329
store i32 0, i32* %42
br label %340
340: ; preds = %366, %339
%341 = load i32, i32* %42
%342 = load i32, i32* %41
%343 = sdiv i32 %342, 2
%344 = icmp slt i32 %341, %343
br i1 %344, label %345, label %369
345: ; preds = %340
%346 = load i32, i32* %42
%347 = sext i32 %346 to i64
%348 = getelementptr inbounds [256 x float], [256 x float]* %39, i64 0, i64 %347
%349 = load float, float* %348
%350 = load i32, i32* %42
%351 = mul nsw i32 2, %350
%352 = sext i32 %351 to i64
%353 = getelementptr inbounds [256 x float], [256 x float]* %40, i64 0, i64 %352
store float %349, float* %353
%354 = load i32, i32* %42
%355 = load i32, i32* %41
%356 = sdiv i32 %355, 2
%357 = add nsw i32 %354, %356
%358 = sext i32 %357 to i64
%359 = getelementptr inbounds [256 x float], [256 x float]* %39, i64 0, i64 %358
%360 = load float, float* %359
%361 = load i32, i32* %42
%362 = mul nsw i32 2, %361
%363 = add nsw i32 %362, 1
%364 = sext i32 %363 to i64
%365 = getelementptr inbounds [256 x float], [256 x float]* %40, i64 0, i64 %364
store float %360, float* %365
br label %366
366: ; preds = %345
%367 = load i32, i32* %42
%368 = add nsw i32 %367, 1
store i32 %368, i32* %42
br label %340
369: ; preds = %340
%370 = load %struct.value_vstack*, %struct.value_vstack** %3
%371 = getelementptr inbounds [256 x float], [256 x float]* %40, i64 0, i64 0
%372 = load i32, i32* %41
%373 = call i32 @vstack_push_vector(%struct.value_vstack* %370, float* %371, i32 %372)
br label %568
374: ; preds = %2
%375 = getelementptr inbounds [256 x float], [256 x float]* %43, i64 0, i64 0
%376 = load %struct.value_vstack*, %struct.value_vstack** %3
%377 = call i32 @vstack_pop_vector(float* %375, %struct.value_vstack* %376)
store i32 %377, i32* %45
%378 = load i32, i32* %45
%379 = and i32 %378, 1
%380 = icmp ne i32 %379, 0
br i1 %380, label %381, label %384
381: ; preds = %374
%382 = load i32, i32* %45
%383 = call i32 (i8*, ...) @fail(i8* getelementptr inbounds ([39 x i8], [39 x i8]* @.str.4, i64 0, i64 0), i32 %382)
br label %384
384: ; preds = %381, %374
store i32 0, i32* %46
br label %385
385: ; preds = %411, %384
%386 = load i32, i32* %46
%387 = load i32, i32* %45
%388 = sdiv i32 %387, 2
%389 = icmp slt i32 %386, %388
br i1 %389, label %390, label %414
390: ; preds = %385
%391 = load i32, i32* %46
%392 = mul nsw i32 2, %391
%393 = sext i32 %392 to i64
%394 = getelementptr inbounds [256 x float], [256 x float]* %43, i64 0, i64 %393
%395 = load float, float* %394
%396 = load i32, i32* %46
%397 = sext i32 %396 to i64
%398 = getelementptr inbounds [256 x float], [256 x float]* %44, i64 0, i64 %397
store float %395, float* %398
%399 = load i32, i32* %46
%400 = mul nsw i32 2, %399
%401 = add nsw i32 %400, 1
%402 = sext i32 %401 to i64
%403 = getelementptr inbounds [256 x float], [256 x float]* %43, i64 0, i64 %402
%404 = load float, float* %403
%405 = load i32, i32* %46
%406 = load i32, i32* %45
%407 = sdiv i32 %406, 2
%408 = add nsw i32 %405, %407
%409 = sext i32 %408 to i64
%410 = getelementptr inbounds [256 x float], [256 x float]* %44, i64 0, i64 %409
store float %404, float* %410
br label %411
411: ; preds = %390
%412 = load i32, i32* %46
%413 = add nsw i32 %412, 1
store i32 %413, i32* %46
br label %385
414: ; preds = %385
%415 = load %struct.value_vstack*, %struct.value_vstack** %3
%416 = getelementptr inbounds [256 x float], [256 x float]* %44, i64 0, i64 0
%417 = load i32, i32* %45
%418 = call i32 @vstack_push_vector(%struct.value_vstack* %415, float* %416, i32 %417)
br label %568
419: ; preds = %2
%420 = getelementptr inbounds [256 x float], [256 x float]* %47, i64 0, i64 0
%421 = load %struct.value_vstack*, %struct.value_vstack** %3
%422 = call i32 @vstack_pop_vector(float* %420, %struct.value_vstack* %421)
store i32 %422, i32* %49
%423 = load i32, i32* %49
%424 = and i32 %423, 1
%425 = icmp ne i32 %424, 0
br i1 %425, label %426, label %429
426: ; preds = %419
%427 = load i32, i32* %49
%428 = call i32 (i8*, ...) @fail(i8* getelementptr inbounds ([41 x i8], [41 x i8]* @.str.5, i64 0, i64 0), i32 %427)
br label %429
429: ; preds = %426, %419
store i32 0, i32* %50
br label %430
430: ; preds = %446, %429
%431 = load i32, i32* %50
%432 = load i32, i32* %49
%433 = sdiv i32 %432, 2
%434 = icmp slt i32 %431, %433
br i1 %434, label %435, label %449
435: ; preds = %430
%436 = load i32, i32* %50
%437 = load i32, i32* %49
%438 = sdiv i32 %437, 2
%439 = add nsw i32 %436, %438
%440 = sext i32 %439 to i64
%441 = getelementptr inbounds [256 x float], [256 x float]* %47, i64 0, i64 %440
%442 = load float, float* %441
%443 = load i32, i32* %50
%444 = sext i32 %443 to i64
%445 = getelementptr inbounds [256 x float], [256 x float]* %48, i64 0, i64 %444
store float %442, float* %445
br label %446
446: ; preds = %435
%447 = load i32, i32* %50
%448 = add nsw i32 %447, 1
store i32 %448, i32* %50
br label %430
449: ; preds = %430
%450 = load %struct.value_vstack*, %struct.value_vstack** %3
%451 = getelementptr inbounds [256 x float], [256 x float]* %47, i64 0, i64 0
%452 = load i32, i32* %49
%453 = sdiv i32 %452, 2
%454 = call i32 @vstack_push_vector(%struct.value_vstack* %450, float* %451, i32 %453)
%455 = load %struct.value_vstack*, %struct.value_vstack** %3
%456 = getelementptr inbounds [256 x float], [256 x float]* %48, i64 0, i64 0
%457 = load i32, i32* %49
%458 = sdiv i32 %457, 2
%459 = call i32 @vstack_push_vector(%struct.value_vstack* %455, float* %456, i32 %458)
br label %568
460: ; preds = %2
%461 = getelementptr inbounds [256 x float], [256 x float]* %51, i64 0, i64 0
%462 = load %struct.value_vstack*, %struct.value_vstack** %3
%463 = call i32 @vstack_pop_vector(float* %461, %struct.value_vstack* %462)
store i32 %463, i32* %52
%464 = load i32, i32* %52
%465 = icmp ne i32 %464, 1
br i1 %465, label %477, label %466
466: ; preds = %460
%467 = getelementptr inbounds [256 x float], [256 x float]* %51, i64 0, i64 0
%468 = load float, float* %467
%469 = fcmp olt float %468, 1.000000e+00
br i1 %469, label %477, label %470
470: ; preds = %466
%471 = getelementptr inbounds [256 x float], [256 x float]* %51, i64 0, i64 0
%472 = load float, float* %471
%473 = call float @round(float %472)
%474 = getelementptr inbounds [256 x float], [256 x float]* %51, i64 0, i64 0
%475 = load float, float* %474
%476 = fcmp une float %473, %475
br i1 %476, label %477, label %482
477: ; preds = %470, %466, %460
%478 = getelementptr inbounds [256 x float], [256 x float]* %51, i64 0, i64 0
%479 = load float, float* %478
%480 = fpext float %479 to double
%481 = call i32 (i8*, ...) @fail(i8* getelementptr inbounds ([31 x i8], [31 x i8]* @.str.6, i64 0, i64 0), double %480)
br label %482
482: ; preds = %477, %470
%483 = getelementptr inbounds [256 x float], [256 x float]* %51, i64 0, i64 0
%484 = load float, float* %483
%485 = fptosi float %484 to i32
store i32 %485, i32* %53
%486 = getelementptr inbounds [256 x float], [256 x float]* %54, i64 0, i64 0
%487 = load %struct.value_vstack*, %struct.value_vstack** %3
%488 = call i32 @vstack_pop_vector(float* %486, %struct.value_vstack* %487)
store i32 %488, i32* %52
%489 = load i32, i32* %52
%490 = load i32, i32* %53
%491 = srem i32 %489, %490
%492 = icmp ne i32 0, %491
br i1 %492, label %493, label %497
493: ; preds = %482
%494 = load i32, i32* %52
%495 = load i32, i32* %53
%496 = call i32 (i8*, ...) @fail(i8* getelementptr inbounds ([33 x i8], [33 x i8]* @.str.7, i64 0, i64 0), i32 %494, i32 %495)
br label %497
497: ; preds = %493, %482
%498 = load i32, i32* %52
%499 = load i32, i32* %53
%500 = sdiv i32 %498, %499
store i32 %500, i32* %55
%501 = load i32, i32* %52
%502 = load i32, i32* %53
%503 = load i32, i32* %55
%504 = mul nsw i32 %502, %503
%505 = icmp eq i32 %501, %504
%506 = zext i1 %505 to i32
%507 = call i32 @assert(i32 %506)
%508 = load i32, i32* %53
%509 = zext i32 %508 to i64
%510 = load i32, i32* %55
%511 = zext i32 %510 to i64
%512 = call i8* @llvm.stacksave()
store i8* %512, i8** %56
%513 = mul nuw i64 %509, %511
%514 = alloca float, i64 %513
store i64 %509, i64* %57
store i64 %511, i64* %58
store i32 0, i32* %59
br label %515
515: ; preds = %544, %497
%516 = load i32, i32* %59
%517 = load i32, i32* %53
%518 = icmp slt i32 %516, %517
br i1 %518, label %519, label %547
519: ; preds = %515
store i32 0, i32* %60
br label %520
520: ; preds = %540, %519
%521 = load i32, i32* %60
%522 = load i32, i32* %55
%523 = icmp slt i32 %521, %522
br i1 %523, label %524, label %543
524: ; preds = %520
%525 = load i32, i32* %59
%526 = load i32, i32* %55
%527 = mul nsw i32 %525, %526
%528 = load i32, i32* %60
%529 = add nsw i32 %527, %528
%530 = sext i32 %529 to i64
%531 = getelementptr inbounds [256 x float], [256 x float]* %54, i64 0, i64 %530
%532 = load float, float* %531
%533 = load i32, i32* %59
%534 = sext i32 %533 to i64
%535 = mul nsw i64 %534, %511
%536 = getelementptr inbounds float, float* %514, i64 %535
%537 = load i32, i32* %60
%538 = sext i32 %537 to i64
%539 = getelementptr inbounds float, float* %536, i64 %538
store float %532, float* %539
br label %540
540: ; preds = %524
%541 = load i32, i32* %60
%542 = add nsw i32 %541, 1
store i32 %542, i32* %60
br label %520
543: ; preds = %520
br label %544
544: ; preds = %543
%545 = load i32, i32* %59
%546 = add nsw i32 %545, 1
store i32 %546, i32* %59
br label %515
547: ; preds = %515
store i32 0, i32* %61
br label %548
548: ; preds = %560, %547
%549 = load i32, i32* %61
%550 = load i32, i32* %53
%551 = icmp slt i32 %549, %550
br i1 %551, label %552, label %563
552: ; preds = %548
%553 = load %struct.value_vstack*, %struct.value_vstack** %3
%554 = load i32, i32* %61
%555 = sext i32 %554 to i64
%556 = mul nsw i64 %555, %511
%557 = getelementptr inbounds float, float* %514, i64 %556
%558 = load i32, i32* %55
%559 = call i32 @vstack_push_vector(%struct.value_vstack* %553, float* %557, i32 %558)
br label %560
560: ; preds = %552
%561 = load i32, i32* %61
%562 = add nsw i32 %561, 1
store i32 %562, i32* %61
br label %548
563: ; preds = %548
%564 = load i8*, i8** %56
br label %568
565: ; preds = %2
%566 = load i32, i32* %4
%567 = call i32 (i8*, ...) @fail(i8* getelementptr inbounds ([34 x i8], [34 x i8]* @.str.8, i64 0, i64 0), i32 %566)
br label %568
568: ; preds = %565, %563, %449, %414, %369, %318, %215, %200, %191, %128, %96, %66, %63
ret void
}

LLVM IR (-O2):
%struct.value_vstack = type { i32 }
@.str = [40 x i8] c"merging vectors results in large vector\00"
@.str.1 = [25 x i8] c"mergeall not implemented\00"
@.str.2 = [27 x i8] c"can not nmerge \22%g\22 things\00"
@.str.3 = [37 x i8] c"can not interleave an odd number %d!\00"
@.str.4 = [39 x i8] c"can not deinterleave an odd number %d!\00"
@.str.5 = [41 x i8] c"can not halve a vector of odd length %d!\00"
@.str.6 = [31 x i8] c"can not split into \22%g\22 things\00"
@.str.7 = [33 x i8] c"can not split \22%d\22 in \22%d\22 parts\00"
@.str.8 = [34 x i8] c"impossible condition (stackop %d)\00"
define void @vstack_process_op(%struct.value_vstack* %0, i32 %1) {
%3 = alloca [256 x float]
%4 = alloca [256 x float]
%5 = alloca [256 x float]
%6 = alloca [256 x float]
%7 = bitcast [256 x float]* %6 to i8*
%8 = alloca [256 x float]
%9 = alloca [256 x float]
%10 = bitcast [256 x float]* %9 to i8*
%11 = alloca [256 x float]
%12 = alloca [256 x float]
%13 = alloca [256 x float]
%14 = alloca [256 x float]
%15 = alloca [256 x float]
%16 = alloca [256 x float]
%17 = alloca [256 x float]
%18 = alloca [256 x float]
%19 = alloca [256 x float]
%20 = alloca [256 x float]
%21 = alloca [256 x float]
%22 = bitcast [256 x float]* %21 to i8*
%23 = alloca [256 x float]
%24 = alloca [256 x float]
switch i32 %1, label %620 [
i32 1, label %25
i32 2, label %27
i32 3, label %33
i32 4, label %48
i32 6, label %68
i32 5, label %192
i32 7, label %201
i32 10, label %203
i32 11, label %314
i32 12, label %381
i32 13, label %507
i32 14, label %530
]
25: ; preds = %2
%26 = tail call i32 @vstack_pop_vector(float* null, %struct.value_vstack* %0)
br label %622
27: ; preds = %2
%28 = bitcast [256 x float]* %3 to i8*
%29 = getelementptr inbounds [256 x float], [256 x float]* %3, i64 0, i64 0
%30 = call i32 @vstack_pop_vector(float* %29, %struct.value_vstack* %0)
%31 = call i32 @vstack_push_vector(%struct.value_vstack* %0, float* %29, i32 %30)
%32 = call i32 @vstack_push_vector(%struct.value_vstack* %0, float* %29, i32 %30)
br label %622
33: ; preds = %2
%34 = bitcast [256 x float]* %4 to i8*
%35 = getelementptr inbounds [256 x float], [256 x float]* %4, i64 0, i64 0
%36 = call i32 @vstack_pop_vector(float* %35, %struct.value_vstack* %0)
%37 = icmp sgt i32 %36, 0
br i1 %37, label %38, label %40
38: ; preds = %33
%39 = zext i32 %36 to i64
br label %41
40: ; preds = %41, %33
br label %622
41: ; preds = %38, %41
%42 = phi i64 [ 0, %38 ], [ %46, %41 ]
%43 = getelementptr inbounds [256 x float], [256 x float]* %4, i64 0, i64 %42
%44 = load float, float* %43
%45 = call i32 @vstack_push_scalar(%struct.value_vstack* %0, float %44)
%46 = add nuw nsw i64 %42, 1
%47 = icmp eq i64 %46, %39
br i1 %47, label %40, label %41
48: ; preds = %2
%49 = bitcast [256 x float]* %5 to i8*
%50 = getelementptr inbounds [256 x float], [256 x float]* %6, i64 0, i64 0
%51 = call i32 @vstack_pop_vector(float* %50, %struct.value_vstack* %0)
%52 = getelementptr inbounds [256 x float], [256 x float]* %5, i64 0, i64 0
%53 = call i32 @vstack_pop_vector(float* %52, %struct.value_vstack* %0)
%54 = add nsw i32 %53, %51
%55 = icmp sgt i32 %54, 255
br i1 %55, label %56, label %58
56: ; preds = %48
%57 = call i32 (i8*, ...) @fail(i8* getelementptr inbounds ([40 x i8], [40 x i8]* @.str, i64 0, i64 0))
br label %58
58: ; preds = %56, %48
%59 = icmp sgt i32 %51, 0
br i1 %59, label %60, label %66
60: ; preds = %58
%61 = sext i32 %53 to i64
%62 = getelementptr [256 x float], [256 x float]* %5, i64 0, i64 %61
%63 = bitcast float* %62 to i8*
%64 = zext i32 %51 to i64
%65 = shl nuw nsw i64 %64, 2
br label %66
66: ; preds = %60, %58
%67 = call i32 @vstack_push_vector(%struct.value_vstack* %0, float* %52, i32 %54)
br label %622
68: ; preds = %2
%69 = bitcast [256 x float]* %8 to i8*
%70 = bitcast [256 x float]* %11 to i8*
%71 = getelementptr inbounds [256 x float], [256 x float]* %11, i64 0, i64 0
%72 = call i32 @vstack_pop_vector(float* %71, %struct.value_vstack* %0)
%73 = getelementptr inbounds [256 x float], [256 x float]* %9, i64 0, i64 0
%74 = call i32 @vstack_pop_vector(float* %73, %struct.value_vstack* %0)
%75 = getelementptr inbounds [256 x float], [256 x float]* %8, i64 0, i64 0
%76 = call i32 @vstack_pop_vector(float* %75, %struct.value_vstack* %0)
%77 = add nsw i32 %76, %74
%78 = add nsw i32 %77, %72
%79 = icmp sgt i32 %78, 255
br i1 %79, label %80, label %82
80: ; preds = %68
%81 = call i32 (i8*, ...) @fail(i8* getelementptr inbounds ([40 x i8], [40 x i8]* @.str, i64 0, i64 0))
br label %82
82: ; preds = %80, %68
%83 = icmp sgt i32 %74, 0
br i1 %83, label %84, label %90
84: ; preds = %82
%85 = sext i32 %76 to i64
%86 = getelementptr [256 x float], [256 x float]* %8, i64 0, i64 %85
%87 = bitcast float* %86 to i8*
%88 = zext i32 %74 to i64
%89 = shl nuw nsw i64 %88, 2
br label %90
90: ; preds = %84, %82
%91 = icmp sgt i32 %72, 0
br i1 %91, label %92, label %182
92: ; preds = %90
%93 = sext i32 %77 to i64
%94 = zext i32 %72 to i64
%95 = icmp ult i32 %72, 8
br i1 %95, label %180, label %96
96: ; preds = %92
%97 = and i64 %94, 4294967288
%98 = add nsw i64 %97, -8
%99 = lshr exact i64 %98, 3
%100 = add nuw nsw i64 %99, 1
%101 = and i64 %100, 3
%102 = icmp ult i64 %98, 24
br i1 %102, label %158, label %103
103: ; preds = %96
%104 = and i64 %100, 4611686018427387900
br label %105
105: ; preds = %105, %103
%106 = phi i64 [ 0, %103 ], [ %155, %105 ]
%107 = phi i64 [ 0, %103 ], [ %156, %105 ]
%108 = getelementptr inbounds [256 x float], [256 x float]* %11, i64 0, i64 %106
%109 = bitcast float* %108 to <4 x float>*
%110 = load <4 x float>, <4 x float>* %109
%111 = getelementptr inbounds float, float* %108, i64 4
%112 = bitcast float* %111 to <4 x float>*
%113 = load <4 x float>, <4 x float>* %112
%114 = add nsw i64 %106, %93
%115 = getelementptr inbounds [256 x float], [256 x float]* %8, i64 0, i64 %114
%116 = bitcast float* %115 to <4 x float>*
store <4 x float> %110, <4 x float>* %116
%117 = getelementptr inbounds float, float* %115, i64 4
%118 = bitcast float* %117 to <4 x float>*
store <4 x float> %113, <4 x float>* %118
%119 = or i64 %106, 8
%120 = getelementptr inbounds [256 x float], [256 x float]* %11, i64 0, i64 %119
%121 = bitcast float* %120 to <4 x float>*
%122 = load <4 x float>, <4 x float>* %121
%123 = getelementptr inbounds float, float* %120, i64 4
%124 = bitcast float* %123 to <4 x float>*
%125 = load <4 x float>, <4 x float>* %124
%126 = add nsw i64 %119, %93
%127 = getelementptr inbounds [256 x float], [256 x float]* %8, i64 0, i64 %126
%128 = bitcast float* %127 to <4 x float>*
store <4 x float> %122, <4 x float>* %128
%129 = getelementptr inbounds float, float* %127, i64 4
%130 = bitcast float* %129 to <4 x float>*
store <4 x float> %125, <4 x float>* %130
%131 = or i64 %106, 16
%132 = getelementptr inbounds [256 x float], [256 x float]* %11, i64 0, i64 %131
%133 = bitcast float* %132 to <4 x float>*
%134 = load <4 x float>, <4 x float>* %133
%135 = getelementptr inbounds float, float* %132, i64 4
%136 = bitcast float* %135 to <4 x float>*
%137 = load <4 x float>, <4 x float>* %136
%138 = add nsw i64 %131, %93
%139 = getelementptr inbounds [256 x float], [256 x float]* %8, i64 0, i64 %138
%140 = bitcast float* %139 to <4 x float>*
store <4 x float> %134, <4 x float>* %140
%141 = getelementptr inbounds float, float* %139, i64 4
%142 = bitcast float* %141 to <4 x float>*
store <4 x float> %137, <4 x float>* %142
%143 = or i64 %106, 24
%144 = getelementptr inbounds [256 x float], [256 x float]* %11, i64 0, i64 %143
%145 = bitcast float* %144 to <4 x float>*
%146 = load <4 x float>, <4 x float>* %145
%147 = getelementptr inbounds float, float* %144, i64 4
%148 = bitcast float* %147 to <4 x float>*
%149 = load <4 x float>, <4 x float>* %148
%150 = add nsw i64 %143, %93
%151 = getelementptr inbounds [256 x float], [256 x float]* %8, i64 0, i64 %150
%152 = bitcast float* %151 to <4 x float>*
store <4 x float> %146, <4 x float>* %152
%153 = getelementptr inbounds float, float* %151, i64 4
%154 = bitcast float* %153 to <4 x float>*
store <4 x float> %149, <4 x float>* %154
%155 = add nuw i64 %106, 32
%156 = add i64 %107, 4
%157 = icmp eq i64 %156, %104
br i1 %157, label %158, label %105
158: ; preds = %105, %96
%159 = phi i64 [ 0, %96 ], [ %155, %105 ]
%160 = icmp eq i64 %101, 0
br i1 %160, label %178, label %161
161: ; preds = %158, %161
%162 = phi i64 [ %175, %161 ], [ %159, %158 ]
%163 = phi i64 [ %176, %161 ], [ 0, %158 ]
%164 = getelementptr inbounds [256 x float], [256 x float]* %11, i64 0, i64 %162
%165 = bitcast float* %164 to <4 x float>*
%166 = load <4 x float>, <4 x float>* %165
%167 = getelementptr inbounds float, float* %164, i64 4
%168 = bitcast float* %167 to <4 x float>*
%169 = load <4 x float>, <4 x float>* %168
%170 = add nsw i64 %162, %93
%171 = getelementptr inbounds [256 x float], [256 x float]* %8, i64 0, i64 %170
%172 = bitcast float* %171 to <4 x float>*
store <4 x float> %166, <4 x float>* %172
%173 = getelementptr inbounds float, float* %171, i64 4
%174 = bitcast float* %173 to <4 x float>*
store <4 x float> %169, <4 x float>* %174
%175 = add nuw i64 %162, 8
%176 = add i64 %163, 1
%177 = icmp eq i64 %176, %101
br i1 %177, label %178, label %161
178: ; preds = %161, %158
%179 = icmp eq i64 %97, %94
br i1 %179, label %182, label %180
180: ; preds = %92, %178
%181 = phi i64 [ 0, %92 ], [ %97, %178 ]
br label %184
182: ; preds = %184, %178, %90
%183 = call i32 @vstack_push_vector(%struct.value_vstack* %0, float* %75, i32 %78)
br label %622
184: ; preds = %180, %184
%185 = phi i64 [ %190, %184 ], [ %181, %180 ]
%186 = getelementptr inbounds [256 x float], [256 x float]* %11, i64 0, i64 %185
%187 = load float, float* %186
%188 = add nsw i64 %185, %93
%189 = getelementptr inbounds [256 x float], [256 x float]* %8, i64 0, i64 %188
store float %187, float* %189
%190 = add nuw nsw i64 %185, 1
%191 = icmp eq i64 %190, %94
br i1 %191, label %182, label %184
192: ; preds = %2
%193 = bitcast [256 x float]* %12 to i8*
%194 = bitcast [256 x float]* %13 to i8*
%195 = getelementptr inbounds [256 x float], [256 x float]* %12, i64 0, i64 0
%196 = call i32 @vstack_pop_vector(float* %195, %struct.value_vstack* %0)
%197 = getelementptr inbounds [256 x float], [256 x float]* %13, i64 0, i64 0
%198 = call i32 @vstack_pop_vector(float* %197, %struct.value_vstack* %0)
%199 = call i32 @vstack_push_vector(%struct.value_vstack* %0, float* %195, i32 %196)
%200 = call i32 @vstack_push_vector(%struct.value_vstack* %0, float* %197, i32 %198)
br label %622
201: ; preds = %2
%202 = tail call i32 (i8*, ...) @fail(i8* getelementptr inbounds ([25 x i8], [25 x i8]* @.str.1, i64 0, i64 0))
br label %622
203: ; preds = %2
%204 = bitcast [256 x float]* %14 to i8*
%205 = getelementptr inbounds [256 x float], [256 x float]* %14, i64 0, i64 0
%206 = call i32 @vstack_pop_vector(float* %205, %struct.value_vstack* %0)
%207 = icmp ne i32 %206, 1
%208 = load float, float* %205
%209 = fcmp olt float %208, 1.000000e+00
%210 = select i1 %207, i1 true, i1 %209
br i1 %210, label %216, label %211
211: ; preds = %203
%212 = call float @llvm.round.f32(float %208)
%213 = fcmp une float %212, %208
%214 = fcmp oge float %208, 2.560000e+02
%215 = or i1 %214, %213
br i1 %215, label %216, label %220
216: ; preds = %211, %203
%217 = fpext float %208 to double
%218 = call i32 (i8*, ...) @fail(i8* getelementptr inbounds ([27 x i8], [27 x i8]* @.str.2, i64 0, i64 0), double %217)
%219 = load float, float* %205
br label %220
220: ; preds = %211, %216
%221 = phi float [ %208, %211 ], [ %219, %216 ]
%222 = fptosi float %221 to i32
%223 = zext i32 %222 to i64
%224 = call i8* @llvm.stacksave()
%225 = alloca [256 x float], i64 %223
%226 = bitcast [256 x float]* %15 to i8*
%227 = alloca i32, i64 %223
%228 = icmp sgt i32 %222, 0
br i1 %228, label %231, label %286
229: ; preds = %231
%230 = icmp sgt i32 %241, 255
br i1 %230, label %244, label %246
231: ; preds = %220, %231
%232 = phi i64 [ %242, %231 ], [ 0, %220 ]
%233 = phi i32 [ %241, %231 ], [ 0, %220 ]
%234 = trunc i64 %232 to i32
%235 = xor i32 %234, -1
%236 = add i32 %235, %222
%237 = sext i32 %236 to i64
%238 = getelementptr inbounds [256 x float], [256 x float]* %225, i64 %237, i64 0
%239 = call i32 @vstack_pop_vector(float* %238, %struct.value_vstack* %0)
%240 = getelementptr inbounds i32, i32* %227, i64 %237
store i32 %239, i32* %240
%241 = add nsw i32 %239, %233
%242 = add nuw nsw i64 %232, 1
%243 = icmp eq i64 %242, %223
br i1 %243, label %229, label %231
244: ; preds = %229
%245 = call i32 (i8*, ...) @fail(i8* getelementptr inbounds ([40 x i8], [40 x i8]* @.str, i64 0, i64 0))
br label %246
246: ; preds = %244, %229
br i1 %228, label %247, label %286
247: ; preds = %246
%248 = and i64 %223, 1
%249 = icmp eq i32 %222, 1
br i1 %249, label %268, label %250
250: ; preds = %247
%251 = and i64 %223, 4294967294
br label %252
252: ; preds = %309, %250
%253 = phi i64 [ 0, %250 ], [ %311, %309 ]
%254 = phi i32 [ 0, %250 ], [ %310, %309 ]
%255 = phi i64 [ 0, %250 ], [ %312, %309 ]
%256 = getelementptr inbounds i32, i32* %227, i64 %253
%257 = load i32, i32* %256
%258 = icmp sgt i32 %257, 0
br i1 %258, label %259, label %294
259: ; preds = %252
%260 = getelementptr [256 x float], [256 x float]* %225, i64 %253, i64 0
%261 = bitcast float* %260 to i8*
%262 = sext i32 %254 to i64
%263 = getelementptr [256 x float], [256 x float]* %15, i64 0, i64 %262
%264 = bitcast float* %263 to i8*
%265 = zext i32 %257 to i64
%266 = shl nuw nsw i64 %265, 2
%267 = add i32 %254, %257
br label %294
268: ; preds = %309, %247
%269 = phi i32 [ undef, %247 ], [ %310, %309 ]
%270 = phi i64 [ 0, %247 ], [ %311, %309 ]
%271 = phi i32 [ 0, %247 ], [ %310, %309 ]
%272 = icmp eq i64 %248, 0
br i1 %272, label %286, label %273
273: ; preds = %268
%274 = getelementptr inbounds i32, i32* %227, i64 %270
%275 = load i32, i32* %274
%276 = icmp sgt i32 %275, 0
br i1 %276, label %277, label %286
277: ; preds = %273
%278 = getelementptr [256 x float], [256 x float]* %225, i64 %270, i64 0
%279 = bitcast float* %278 to i8*
%280 = sext i32 %271 to i64
%281 = getelementptr [256 x float], [256 x float]* %15, i64 0, i64 %280
%282 = bitcast float* %281 to i8*
%283 = zext i32 %275 to i64
%284 = shl nuw nsw i64 %283, 2
%285 = add i32 %271, %275
br label %286
286: ; preds = %268, %277, %273, %220, %246
%287 = phi i32 [ %241, %246 ], [ 0, %220 ], [ %241, %273 ], [ %241, %277 ], [ %241, %268 ]
%288 = phi i32 [ 0, %246 ], [ 0, %220 ], [ %269, %268 ], [ %271, %273 ], [ %285, %277 ]
%289 = icmp eq i32 %288, %287
%290 = zext i1 %289 to i32
%291 = call i32 @assert(i32 %290)
%292 = getelementptr inbounds [256 x float], [256 x float]* %15, i64 0, i64 0
%293 = call i32 @vstack_push_vector(%struct.value_vstack* %0, float* %292, i32 %287)
br label %622
294: ; preds = %259, %252
%295 = phi i32 [ %254, %252 ], [ %267, %259 ]
%296 = or i64 %253, 1
%297 = getelementptr inbounds i32, i32* %227, i64 %296
%298 = load i32, i32* %297
%299 = icmp sgt i32 %298, 0
br i1 %299, label %300, label %309
300: ; preds = %294
%301 = getelementptr [256 x float], [256 x float]* %225, i64 %296, i64 0
%302 = bitcast float* %301 to i8*
%303 = sext i32 %295 to i64
%304 = getelementptr [256 x float], [256 x float]* %15, i64 0, i64 %303
%305 = bitcast float* %304 to i8*
%306 = zext i32 %298 to i64
%307 = shl nuw nsw i64 %306, 2
%308 = add i32 %295, %298
br label %309
309: ; preds = %300, %294
%310 = phi i32 [ %295, %294 ], [ %308, %300 ]
%311 = add nuw nsw i64 %253, 2
%312 = add i64 %255, 2
%313 = icmp eq i64 %312, %251
br i1 %313, label %268, label %252
314: ; preds = %2
%315 = bitcast [256 x float]* %16 to i8*
%316 = bitcast [256 x float]* %17 to i8*
%317 = getelementptr inbounds [256 x float], [256 x float]* %16, i64 0, i64 0
%318 = call i32 @vstack_pop_vector(float* %317, %struct.value_vstack* %0)
%319 = and i32 %318, 1
%320 = icmp eq i32 %319, 0
br i1 %320, label %323, label %321
321: ; preds = %314
%322 = call i32 (i8*, ...) @fail(i8* getelementptr inbounds ([37 x i8], [37 x i8]* @.str.3, i64 0, i64 0), i32 %318)
br label %323
323: ; preds = %321, %314
%324 = sdiv i32 %318, 2
%325 = icmp sgt i32 %318, 1
br i1 %325, label %326, label %365
326: ; preds = %323
%327 = sext i32 %324 to i64
%328 = zext i32 %324 to i64
%329 = icmp ult i32 %324, 4
br i1 %329, label %363, label %330
330: ; preds = %326
%331 = and i64 %328, 4294967292
br label %332
332: ; preds = %332, %330
%333 = phi i64 [ 0, %330 ], [ %359, %332 ]
%334 = getelementptr inbounds [256 x float], [256 x float]* %16, i64 0, i64 %333
%335 = bitcast float* %334 to <2 x float>*
%336 = load <2 x float>, <2 x float>* %335
%337 = getelementptr inbounds float, float* %334, i64 2
%338 = bitcast float* %337 to <2 x float>*
%339 = load <2 x float>, <2 x float>* %338
%340 = shl nuw nsw i64 %333, 1
%341 = shl i64 %333, 1
%342 = add nsw i64 %333, %327
%343 = getelementptr inbounds [256 x float], [256 x float]* %16, i64 0, i64 %342
%344 = bitcast float* %343 to <2 x float>*
%345 = load <2 x float>, <2 x float>* %344
%346 = getelementptr inbounds float, float* %343, i64 2
%347 = bitcast float* %346 to <2 x float>*
%348 = load <2 x float>, <2 x float>* %347
%349 = or i64 %340, 1
%350 = or i64 %341, 5
%351 = getelementptr inbounds [256 x float], [256 x float]* %17, i64 0, i64 %349
%352 = getelementptr inbounds [256 x float], [256 x float]* %17, i64 0, i64 %350
%353 = getelementptr inbounds float, float* %351, i64 -1
%354 = bitcast float* %353 to <4 x float>*
%355 = getelementptr inbounds float, float* %352, i64 -1
%356 = bitcast float* %355 to <4 x float>*
%357 = shufflevector <2 x float> %336, <2 x float> %345, <4 x i32> <i32 0, i32 2, i32 1, i32 3>
store <4 x float> %357, <4 x float>* %354
%358 = shufflevector <2 x float> %339, <2 x float> %348, <4 x i32> <i32 0, i32 2, i32 1, i32 3>
store <4 x float> %358, <4 x float>* %356
%359 = add nuw i64 %333, 4
%360 = icmp eq i64 %359, %331
br i1 %360, label %361, label %332
361: ; preds = %332
%362 = icmp eq i64 %331, %328
br i1 %362, label %365, label %363
363: ; preds = %326, %361
%364 = phi i64 [ 0, %326 ], [ %331, %361 ]
br label %368
365: ; preds = %368, %361, %323
%366 = getelementptr inbounds [256 x float], [256 x float]* %17, i64 0, i64 0
%367 = call i32 @vstack_push_vector(%struct.value_vstack* %0, float* %366, i32 %318)
br label %622
368: ; preds = %363, %368
%369 = phi i64 [ %379, %368 ], [ %364, %363 ]
%370 = getelementptr inbounds [256 x float], [256 x float]* %16, i64 0, i64 %369
%371 = load float, float* %370
%372 = shl nuw nsw i64 %369, 1
%373 = getelementptr inbounds [256 x float], [256 x float]* %17, i64 0, i64 %372
store float %371, float* %373
%374 = add nsw i64 %369, %327
%375 = getelementptr inbounds [256 x float], [256 x float]* %16, i64 0, i64 %374
%376 = load float, float* %375
%377 = or i64 %372, 1
%378 = getelementptr inbounds [256 x float], [256 x float]* %17, i64 0, i64 %377
store float %376, float* %378
%379 = add nuw nsw i64 %369, 1
%380 = icmp eq i64 %379, %328
br i1 %380, label %365, label %368
381: ; preds = %2
%382 = bitcast [256 x float]* %18 to i8*
%383 = bitcast [256 x float]* %19 to i8*
%384 = getelementptr inbounds [256 x float], [256 x float]* %18, i64 0, i64 0
%385 = call i32 @vstack_pop_vector(float* %384, %struct.value_vstack* %0)
%386 = and i32 %385, 1
%387 = icmp eq i32 %386, 0
br i1 %387, label %390, label %388
388: ; preds = %381
%389 = call i32 (i8*, ...) @fail(i8* getelementptr inbounds ([39 x i8], [39 x i8]* @.str.4, i64 0, i64 0), i32 %385)
br label %390
390: ; preds = %388, %381
%391 = sdiv i32 %385, 2
%392 = icmp sgt i32 %385, 1
br i1 %392, label %393, label %481
393: ; preds = %390
%394 = sext i32 %391 to i64
%395 = zext i32 %391 to i64
%396 = icmp ult i32 %391, 4
br i1 %396, label %461, label %397
397: ; preds = %393
%398 = getelementptr [256 x float], [256 x float]* %19, i64 0, i64 %395
%399 = getelementptr [256 x float], [256 x float]* %19, i64 0, i64 %394
%400 = add nsw i64 %394, %395
%401 = getelementptr [256 x float], [256 x float]* %19, i64 0, i64 %400
%402 = bitcast float* %401 to [256 x float]*
%403 = icmp ult [256 x float]* %19, %402
%404 = icmp ult float* %399, %398
%405 = and i1 %403, %404
br i1 %405, label %461, label %406
406: ; preds = %397
%407 = and i64 %395, 4294967292
%408 = add nsw i64 %407, -4
%409 = lshr exact i64 %408, 2
%410 = add nuw nsw i64 %409, 1
%411 = and i64 %410, 1
%412 = icmp eq i64 %408, 0
br i1 %412, label %444, label %413
413: ; preds = %406
%414 = and i64 %410, 9223372036854775806
br label %415
415: ; preds = %415, %413
%416 = phi i64 [ 0, %413 ], [ %441, %415 ]
%417 = phi i64 [ 0, %413 ], [ %442, %415 ]
%418 = shl nuw nsw i64 %416, 1
%419 = getelementptr inbounds [256 x float], [256 x float]* %18, i64 0, i64 %418
%420 = bitcast float* %419 to <8 x float>*
%421 = load <8 x float>, <8 x float>* %420
%422 = shufflevector <8 x float> %421, <8 x float> poison, <4 x i32> <i32 0, i32 2, i32 4, i32 6>
%423 = shufflevector <8 x float> %421, <8 x float> poison, <4 x i32> <i32 1, i32 3, i32 5, i32 7>
%424 = getelementptr inbounds [256 x float], [256 x float]* %19, i64 0, i64 %416
%425 = bitcast float* %424 to <4 x float>*
store <4 x float> %422, <4 x float>* %425
%426 = add nsw i64 %416, %394
%427 = getelementptr inbounds [256 x float], [256 x float]* %19, i64 0, i64 %426
%428 = bitcast float* %427 to <4 x float>*
store <4 x float> %423, <4 x float>* %428
%429 = or i64 %416, 4
%430 = shl nuw nsw i64 %429, 1
%431 = getelementptr inbounds [256 x float], [256 x float]* %18, i64 0, i64 %430
%432 = bitcast float* %431 to <8 x float>*
%433 = load <8 x float>, <8 x float>* %432
%434 = shufflevector <8 x float> %433, <8 x float> poison, <4 x i32> <i32 0, i32 2, i32 4, i32 6>
%435 = shufflevector <8 x float> %433, <8 x float> poison, <4 x i32> <i32 1, i32 3, i32 5, i32 7>
%436 = getelementptr inbounds [256 x float], [256 x float]* %19, i64 0, i64 %429
%437 = bitcast float* %436 to <4 x float>*
store <4 x float> %434, <4 x float>* %437
%438 = add nsw i64 %429, %394
%439 = getelementptr inbounds [256 x float], [256 x float]* %19, i64 0, i64 %438
%440 = bitcast float* %439 to <4 x float>*
store <4 x float> %435, <4 x float>* %440
%441 = add nuw i64 %416, 8
%442 = add i64 %417, 2
%443 = icmp eq i64 %442, %414
br i1 %443, label %444, label %415
444: ; preds = %415, %406
%445 = phi i64 [ 0, %406 ], [ %441, %415 ]
%446 = icmp eq i64 %411, 0
br i1 %446, label %459, label %447
447: ; preds = %444
%448 = shl nuw nsw i64 %445, 1
%449 = getelementptr inbounds [256 x float], [256 x float]* %18, i64 0, i64 %448
%450 = bitcast float* %449 to <8 x float>*
%451 = load <8 x float>, <8 x float>* %450
%452 = shufflevector <8 x float> %451, <8 x float> poison, <4 x i32> <i32 0, i32 2, i32 4, i32 6>
%453 = shufflevector <8 x float> %451, <8 x float> poison, <4 x i32> <i32 1, i32 3, i32 5, i32 7>
%454 = getelementptr inbounds [256 x float], [256 x float]* %19, i64 0, i64 %445
%455 = bitcast float* %454 to <4 x float>*
store <4 x float> %452, <4 x float>* %455
%456 = add nsw i64 %445, %394
%457 = getelementptr inbounds [256 x float], [256 x float]* %19, i64 0, i64 %456
%458 = bitcast float* %457 to <4 x float>*
store <4 x float> %453, <4 x float>* %458
br label %459
459: ; preds = %444, %447
%460 = icmp eq i64 %407, %395
br i1 %460, label %481, label %461
461: ; preds = %397, %393, %459
%462 = phi i64 [ 0, %397 ], [ 0, %393 ], [ %407, %459 ]
%463 = xor i64 %462, -1
%464 = and i64 %395, 1
%465 = icmp eq i64 %464, 0
br i1 %465, label %477, label %466
466: ; preds = %461
%467 = shl nuw nsw i64 %462, 1
%468 = getelementptr inbounds [256 x float], [256 x float]* %18, i64 0, i64 %467
%469 = load float, float* %468
%470 = getelementptr inbounds [256 x float], [256 x float]* %19, i64 0, i64 %462
store float %469, float* %470
%471 = or i64 %467, 1
%472 = getelementptr inbounds [256 x float], [256 x float]* %18, i64 0, i64 %471
%473 = load float, float* %472
%474 = add nsw i64 %462, %394
%475 = getelementptr inbounds [256 x float], [256 x float]* %19, i64 0, i64 %474
store float %473, float* %475
%476 = or i64 %462, 1
br label %477
477: ; preds = %466, %461
%478 = phi i64 [ %462, %461 ], [ %476, %466 ]
%479 = sub nsw i64 0, %395
%480 = icmp eq i64 %463, %479
br i1 %480, label %481, label %484
481: ; preds = %477, %484, %459, %390
%482 = getelementptr inbounds [256 x float], [256 x float]* %19, i64 0, i64 0
%483 = call i32 @vstack_push_vector(%struct.value_vstack* %0, float* %482, i32 %385)
br label %622
484: ; preds = %477, %484
%485 = phi i64 [ %505, %484 ], [ %478, %477 ]
%486 = shl nuw nsw i64 %485, 1
%487 = getelementptr inbounds [256 x float], [256 x float]* %18, i64 0, i64 %486
%488 = load float, float* %487
%489 = getelementptr inbounds [256 x float], [256 x float]* %19, i64 0, i64 %485
store float %488, float* %489
%490 = or i64 %486, 1
%491 = getelementptr inbounds [256 x float], [256 x float]* %18, i64 0, i64 %490
%492 = load float, float* %491
%493 = add nsw i64 %485, %394
%494 = getelementptr inbounds [256 x float], [256 x float]* %19, i64 0, i64 %493
store float %492, float* %494
%495 = add nuw nsw i64 %485, 1
%496 = shl nuw nsw i64 %495, 1
%497 = getelementptr inbounds [256 x float], [256 x float]* %18, i64 0, i64 %496
%498 = load float, float* %497
%499 = getelementptr inbounds [256 x float], [256 x float]* %19, i64 0, i64 %495
store float %498, float* %499
%500 = or i64 %496, 1
%501 = getelementptr inbounds [256 x float], [256 x float]* %18, i64 0, i64 %500
%502 = load float, float* %501
%503 = add nsw i64 %495, %394
%504 = getelementptr inbounds [256 x float], [256 x float]* %19, i64 0, i64 %503
store float %502, float* %504
%505 = add nuw nsw i64 %485, 2
%506 = icmp eq i64 %505, %395
br i1 %506, label %481, label %484
507: ; preds = %2
%508 = bitcast [256 x float]* %20 to i8*
%509 = getelementptr inbounds [256 x float], [256 x float]* %20, i64 0, i64 0
%510 = call i32 @vstack_pop_vector(float* %509, %struct.value_vstack* %0)
%511 = and i32 %510, 1
%512 = icmp eq i32 %511, 0
br i1 %512, label %515, label %513
513: ; preds = %507
%514 = call i32 (i8*, ...) @fail(i8* getelementptr inbounds ([41 x i8], [41 x i8]* @.str.5, i64 0, i64 0), i32 %510)
br label %515
515: ; preds = %513, %507
%516 = sdiv i32 %510, 2
%517 = icmp sgt i32 %510, 1
br i1 %517, label %518, label %526
518: ; preds = %515
%519 = sext i32 %516 to i64
%520 = getelementptr [256 x float], [256 x float]* %20, i64 0, i64 %519
%521 = bitcast float* %520 to i8*
%522 = add nsw i32 %516, -1
%523 = zext i32 %522 to i64
%524 = shl nuw nsw i64 %523, 2
%525 = add nuw nsw i64 %524, 4
br label %526
526: ; preds = %518, %515
%527 = call i32 @vstack_push_vector(%struct.value_vstack* %0, float* %509, i32 %516)
%528 = getelementptr inbounds [256 x float], [256 x float]* %21, i64 0, i64 0
%529 = call i32 @vstack_push_vector(%struct.value_vstack* %0, float* %528, i32 %516)
br label %622
530: ; preds = %2
%531 = bitcast [256 x float]* %23 to i8*
%532 = getelementptr inbounds [256 x float], [256 x float]* %23, i64 0, i64 0
%533 = call i32 @vstack_pop_vector(float* %532, %struct.value_vstack* %0)
%534 = icmp ne i32 %533, 1
%535 = load float, float* %532
%536 = fcmp olt float %535, 1.000000e+00
%537 = select i1 %534, i1 true, i1 %536
%538 = call float @llvm.round.f32(float %535)
%539 = fcmp une float %538, %535
%540 = select i1 %537, i1 true, i1 %539
br i1 %540, label %541, label %545
541: ; preds = %530
%542 = fpext float %535 to double
%543 = call i32 (i8*, ...) @fail(i8* getelementptr inbounds ([31 x i8], [31 x i8]* @.str.6, i64 0, i64 0), double %542)
%544 = load float, float* %532
br label %545
545: ; preds = %530, %541
%546 = phi float [ %535, %530 ], [ %544, %541 ]
%547 = fptosi float %546 to i32
%548 = bitcast [256 x float]* %24 to i8*
%549 = getelementptr inbounds [256 x float], [256 x float]* %24, i64 0, i64 0
%550 = call i32 @vstack_pop_vector(float* %549, %struct.value_vstack* %0)
%551 = srem i32 %550, %547
%552 = sdiv i32 %550, %547
%553 = icmp eq i32 %551, 0
br i1 %553, label %556, label %554
554: ; preds = %545
%555 = call i32 (i8*, ...) @fail(i8* getelementptr inbounds ([33 x i8], [33 x i8]* @.str.7, i64 0, i64 0), i32 %550, i32 %547)
br label %556
556: ; preds = %554, %545
%557 = mul nsw i32 %552, %547
%558 = icmp eq i32 %550, %557
%559 = zext i1 %558 to i32
%560 = call i32 @assert(i32 %559)
%561 = zext i32 %547 to i64
%562 = zext i32 %552 to i64
%563 = call i8* @llvm.stacksave()
%564 = mul nuw i64 %562, %561
%565 = alloca float, i64 %564
%566 = icmp sgt i32 %547, 0
br i1 %566, label %567, label %612
567: ; preds = %556
%568 = icmp sgt i32 %552, 0
%569 = shl nuw nsw i64 %562, 2
%570 = and i64 %561, 1
%571 = icmp eq i32 %547, 1
br i1 %571, label %585, label %572
572: ; preds = %567
%573 = and i64 %561, 4294967294
br label %574
574: ; preds = %608, %572
%575 = phi i64 [ 0, %572 ], [ %609, %608 ]
%576 = phi i64 [ 0, %572 ], [ %610, %608 ]
%577 = mul nuw nsw i64 %575, %562
br i1 %568, label %578, label %598
578: ; preds = %574
%579 = shl i64 %577, 32
%580 = ashr exact i64 %579, 32
%581 = getelementptr [256 x float], [256 x float]* %24, i64 0, i64 %580
%582 = bitcast float* %581 to i8*
%583 = getelementptr float, float* %565, i64 %577
%584 = bitcast float* %583 to i8*
br label %598
585: ; preds = %608, %567
%586 = phi i64 [ 0, %567 ], [ %609, %608 ]
%587 = icmp eq i64 %570, 0
br i1 %587, label %597, label %588
588: ; preds = %585
%589 = mul nuw nsw i64 %586, %562
br i1 %568, label %590, label %597
590: ; preds = %588
%591 = shl i64 %589, 32
%592 = ashr exact i64 %591, 32
%593 = getelementptr [256 x float], [256 x float]* %24, i64 0, i64 %592
%594 = bitcast float* %593 to i8*
%595 = getelementptr float, float* %565, i64 %589
%596 = bitcast float* %595 to i8*
br label %597
597: ; preds = %588, %590, %585
br i1 %566, label %613, label %612
598: ; preds = %578, %574
%599 = or i64 %575, 1
%600 = mul nuw nsw i64 %599, %562
br i1 %568, label %601, label %608
601: ; preds = %598
%602 = shl i64 %600, 32
%603 = ashr exact i64 %602, 32
%604 = getelementptr [256 x float], [256 x float]* %24, i64 0, i64 %603
%605 = bitcast float* %604 to i8*
%606 = getelementptr float, float* %565, i64 %600
%607 = bitcast float* %606 to i8*
br label %608
608: ; preds = %601, %598
%609 = add nuw nsw i64 %575, 2
%610 = add i64 %576, 2
%611 = icmp eq i64 %610, %573
br i1 %611, label %585, label %574
612: ; preds = %613, %556, %597
br label %622
613: ; preds = %597, %613
%614 = phi i64 [ %618, %613 ], [ 0, %597 ]
%615 = mul nuw nsw i64 %614, %562
%616 = getelementptr inbounds float, float* %565, i64 %615
%617 = call i32 @vstack_push_vector(%struct.value_vstack* %0, float* %616, i32 %552)
%618 = add nuw nsw i64 %614, 1
%619 = icmp eq i64 %618, %561
br i1 %619, label %612, label %613
620: ; preds = %2
%621 = tail call i32 (i8*, ...) @fail(i8* getelementptr inbounds ([34 x i8], [34 x i8]* @.str.8, i64 0, i64 0), i32 %1)
br label %622
622: ; preds = %620, %612, %526, %481, %365, %286, %201, %192, %182, %66, %40, %27, %25
ret void
}