#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 */

/* Variables and functions */
int _ada_use_c2phc4c(int, int *, int *, double *, int /*<<< orphan*/);
int standard_condition_report(int maxit, double tolres, double tolerr,
                              double tolsing, int nbc, char *name, int *cntfail,
                              int *cntreal, int *cntcmplx, int *cntregu,
                              int *cntsing, int *cntclus, int *t_err,
                              int *t_rco, int *t_res, int verbose) {
  int fail, idx;
  int a[6];
  double c[3];
  a[0] = maxit;
  a[1] = verbose;
  a[2] = nbc;
  c[0] = tolres;
  c[1] = tolerr;
  c[2] = tolsing;
  if (nbc == 0) {
    int b[48];
    fail = _ada_use_c2phc4c(920, a, b, c, 0);
    idx = 0;
    for (int i = 0; i < 16; i++)
      t_err[i] = b[idx++];
    for (int i = 0; i < 16; i++)
      t_rco[i] = b[idx++];
    for (int i = 0; i < 16; i++)
      t_res[i] = b[idx++];
  } else if (nbc > 48) {
    int b[nbc];
    for (int i = 0; i < nbc; i++)
      b[i] = (int)name[i];
    fail = _ada_use_c2phc4c(920, a, b, c, 0);
    idx = 0;
    for (int i = 0; i < 16; i++)
      t_err[i] = b[idx++];
    for (int i = 0; i < 16; i++)
      t_rco[i] = b[idx++];
    for (int i = 0; i < 16; i++)
      t_res[i] = b[idx++];
  } else {
    int b[48];
    for (int i = 0; i < nbc; i++)
      b[i] = (int)name[i];
    fail = _ada_use_c2phc4c(920, a, b, c, 0);
    idx = 0;
    for (int i = 0; i < 16; i++)
      t_err[i] = b[idx++];
    for (int i = 0; i < 16; i++)
      t_rco[i] = b[idx++];
    for (int i = 0; i < 16; i++)
      t_res[i] = b[idx++];
  }
  *cntfail = a[0];
  *cntreal = a[1];
  *cntcmplx = a[2];
  *cntregu = a[3];
  *cntsing = a[4];
  *cntclus = a[5];
  return fail;
}


x86 assembly (clang, -O0):
<standard_condition_report>:
push   %rbp
mov    %rsp,%rbp
sub    $0x260,%rsp
mov    0x40(%rbp),%eax
mov    0x38(%rbp),%rax
mov    0x30(%rbp),%rax
mov    0x28(%rbp),%rax
mov    0x20(%rbp),%rax
mov    0x18(%rbp),%rax
mov    0x10(%rbp),%rax
mov    %edi,-0x4(%rbp)
movsd  %xmm0,-0x10(%rbp)
movsd  %xmm1,-0x18(%rbp)
movsd  %xmm2,-0x20(%rbp)
mov    %esi,-0x24(%rbp)
mov    %rdx,-0x30(%rbp)
mov    %rcx,-0x38(%rbp)
mov    %r8,-0x40(%rbp)
mov    %r9,-0x48(%rbp)
mov    -0x4(%rbp),%eax
mov    %eax,-0x70(%rbp)
mov    0x40(%rbp),%eax
mov    %eax,-0x6c(%rbp)
mov    -0x24(%rbp),%eax
mov    %eax,-0x68(%rbp)
movsd  -0x10(%rbp),%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
movsd  -0x18(%rbp),%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
movsd  -0x20(%rbp),%xmm0
movsd  %xmm0,-0x80(%rbp)
cmpl   $0x0,-0x24(%rbp)
jne    12b0 <standard_condition_report+0x1a0>
lea    -0x70(%rbp),%rsi
lea    -0x150(%rbp),%rdx
lea    -0x90(%rbp),%rcx
mov    $0x398,%edi
xor    %r8d,%r8d
call   1030 <_ada_use_c2phc4c@plt>
mov    %eax,-0x4c(%rbp)
movl   $0x0,-0x50(%rbp)
movl   $0x0,-0x154(%rbp)
cmpl   $0x10,-0x154(%rbp)
jge    1211 <standard_condition_report+0x101>
mov    -0x50(%rbp),%eax
mov    %eax,%ecx
add    $0x1,%ecx
mov    %ecx,-0x50(%rbp)
cltq
mov    -0x150(%rbp,%rax,4),%edx
mov    0x28(%rbp),%rax
movslq -0x154(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x154(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x154(%rbp)
jmp    11ce <standard_condition_report+0xbe>
movl   $0x0,-0x158(%rbp)
cmpl   $0x10,-0x158(%rbp)
jge    125e <standard_condition_report+0x14e>
mov    -0x50(%rbp),%eax
mov    %eax,%ecx
add    $0x1,%ecx
mov    %ecx,-0x50(%rbp)
cltq
mov    -0x150(%rbp,%rax,4),%edx
mov    0x30(%rbp),%rax
movslq -0x158(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x158(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x158(%rbp)
jmp    121b <standard_condition_report+0x10b>
movl   $0x0,-0x15c(%rbp)
cmpl   $0x10,-0x15c(%rbp)
jge    12ab <standard_condition_report+0x19b>
mov    -0x50(%rbp),%eax
mov    %eax,%ecx
add    $0x1,%ecx
mov    %ecx,-0x50(%rbp)
cltq
mov    -0x150(%rbp,%rax,4),%edx
mov    0x38(%rbp),%rax
movslq -0x15c(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x15c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x15c(%rbp)
jmp    1268 <standard_condition_report+0x158>
jmp    15c6 <standard_condition_report+0x4b6>
cmpl   $0x30,-0x24(%rbp)
jle    1462 <standard_condition_report+0x352>
mov    -0x24(%rbp),%eax
mov    %rsp,%rcx
mov    %rcx,-0x168(%rbp)
lea    0xf(,%rax,4),%rdx
and    $0xfffffffffffffff0,%rdx
mov    %rsp,%rcx
sub    %rdx,%rcx
mov    %rcx,-0x258(%rbp)
mov    %rcx,%rsp
mov    %rax,-0x170(%rbp)
movl   $0x0,-0x174(%rbp)
mov    -0x174(%rbp),%eax
cmp    -0x24(%rbp),%eax
jge    1337 <standard_condition_report+0x227>
mov    -0x258(%rbp),%rax
mov    -0x30(%rbp),%rcx
movslq -0x174(%rbp),%rdx
movsbl (%rcx,%rdx,1),%edx
movslq -0x174(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x174(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x174(%rbp)
jmp    12f4 <standard_condition_report+0x1e4>
mov    -0x258(%rbp),%rdx
lea    -0x70(%rbp),%rsi
lea    -0x90(%rbp),%rcx
mov    $0x398,%edi
xor    %r8d,%r8d
call   1030 <_ada_use_c2phc4c@plt>
mov    %eax,-0x4c(%rbp)
movl   $0x0,-0x50(%rbp)
movl   $0x0,-0x178(%rbp)
cmpl   $0x10,-0x178(%rbp)
jge    13b1 <standard_condition_report+0x2a1>
mov    -0x258(%rbp),%rax
mov    -0x50(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0x50(%rbp)
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%edx
mov    0x28(%rbp),%rax
movslq -0x178(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x178(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x178(%rbp)
jmp    136a <standard_condition_report+0x25a>
movl   $0x0,-0x17c(%rbp)
cmpl   $0x10,-0x17c(%rbp)
jge    1402 <standard_condition_report+0x2f2>
mov    -0x258(%rbp),%rax
mov    -0x50(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0x50(%rbp)
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%edx
mov    0x30(%rbp),%rax
movslq -0x17c(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x17c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x17c(%rbp)
jmp    13bb <standard_condition_report+0x2ab>
movl   $0x0,-0x180(%rbp)
cmpl   $0x10,-0x180(%rbp)
jge    1453 <standard_condition_report+0x343>
mov    -0x258(%rbp),%rax
mov    -0x50(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0x50(%rbp)
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%edx
mov    0x38(%rbp),%rax
movslq -0x180(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x180(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x180(%rbp)
jmp    140c <standard_condition_report+0x2fc>
mov    -0x168(%rbp),%rax
mov    %rax,%rsp
jmp    15c1 <standard_condition_report+0x4b1>
movl   $0x0,-0x244(%rbp)
mov    -0x244(%rbp),%eax
cmp    -0x24(%rbp),%eax
jge    14ac <standard_condition_report+0x39c>
mov    -0x30(%rbp),%rax
movslq -0x244(%rbp),%rcx
movsbl (%rax,%rcx,1),%ecx
movslq -0x244(%rbp),%rax
mov    %ecx,-0x240(%rbp,%rax,4)
mov    -0x244(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x244(%rbp)
jmp    146c <standard_condition_report+0x35c>
lea    -0x70(%rbp),%rsi
lea    -0x240(%rbp),%rdx
lea    -0x90(%rbp),%rcx
mov    $0x398,%edi
xor    %r8d,%r8d
call   1030 <_ada_use_c2phc4c@plt>
mov    %eax,-0x4c(%rbp)
movl   $0x0,-0x50(%rbp)
movl   $0x0,-0x248(%rbp)
cmpl   $0x10,-0x248(%rbp)
jge    1522 <standard_condition_report+0x412>
mov    -0x50(%rbp),%eax
mov    %eax,%ecx
add    $0x1,%ecx
mov    %ecx,-0x50(%rbp)
cltq
mov    -0x240(%rbp,%rax,4),%edx
mov    0x28(%rbp),%rax
movslq -0x248(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x248(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x248(%rbp)
jmp    14df <standard_condition_report+0x3cf>
movl   $0x0,-0x24c(%rbp)
cmpl   $0x10,-0x24c(%rbp)
jge    156f <standard_condition_report+0x45f>
mov    -0x50(%rbp),%eax
mov    %eax,%ecx
add    $0x1,%ecx
mov    %ecx,-0x50(%rbp)
cltq
mov    -0x240(%rbp,%rax,4),%edx
mov    0x30(%rbp),%rax
movslq -0x24c(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x24c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24c(%rbp)
jmp    152c <standard_condition_report+0x41c>
movl   $0x0,-0x250(%rbp)
cmpl   $0x10,-0x250(%rbp)
jge    15bc <standard_condition_report+0x4ac>
mov    -0x50(%rbp),%eax
mov    %eax,%ecx
add    $0x1,%ecx
mov    %ecx,-0x50(%rbp)
cltq
mov    -0x240(%rbp,%rax,4),%edx
mov    0x38(%rbp),%rax
movslq -0x250(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x250(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x250(%rbp)
jmp    1579 <standard_condition_report+0x469>
jmp    15c1 <standard_condition_report+0x4b1>
jmp    15c6 <standard_condition_report+0x4b6>
mov    -0x70(%rbp),%ecx
mov    -0x38(%rbp),%rax
mov    %ecx,(%rax)
mov    -0x6c(%rbp),%ecx
mov    -0x40(%rbp),%rax
mov    %ecx,(%rax)
mov    -0x68(%rbp),%ecx
mov    -0x48(%rbp),%rax
mov    %ecx,(%rax)
mov    -0x64(%rbp),%ecx
mov    0x10(%rbp),%rax
mov    %ecx,(%rax)
mov    -0x60(%rbp),%ecx
mov    0x18(%rbp),%rax
mov    %ecx,(%rax)
mov    -0x5c(%rbp),%ecx
mov    0x20(%rbp),%rax
mov    %ecx,(%rax)
mov    -0x4c(%rbp),%eax
mov    %rbp,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<standard_condition_report>:
push   %rbp
mov    %rsp,%rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x118,%rsp
mov    %r9,%rbx
mov    %r8,-0x78(%rbp)
mov    %rcx,%r12
mov    0x38(%rbp),%r13
mov    0x30(%rbp),%r14
mov    0x28(%rbp),%r15
mov    0x40(%rbp),%eax
mov    %edi,-0x40(%rbp)
mov    %eax,-0x3c(%rbp)
mov    %esi,-0x38(%rbp)
movq   %xmm0,-0x60(%rbp)
movq   %xmm1,-0x58(%rbp)
movsd  %xmm2,-0x50(%rbp)
test   %esi,%esi
je     1454 <standard_condition_report+0x344>
cmp    $0x31,%esi
jl     130a <standard_condition_report+0x1fa>
mov    %rbx,-0x70(%rbp)
mov    %rsp,-0x68(%rbp)
mov    %esi,%eax
mov    %rsp,%rbx
lea    0xf(,%rax,4),%rcx
and    $0xfffffffffffffff0,%rcx
sub    %rcx,%rbx
mov    %rbx,%rsp
mov    %eax,%ecx
and    $0xfffffff8,%ecx
lea    -0x8(%rcx),%rsi
mov    %rsi,%r8
shr    $0x3,%r8
add    $0x1,%r8
test   %rsi,%rsi
je     1320 <standard_condition_report+0x210>
mov    %r8,%rdi
and    $0xfffffffffffffffe,%rdi
xor    %esi,%esi
nopl   0x0(%rax,%rax,1)
movd   (%rdx,%rsi,1),%xmm0
punpcklbw %xmm0,%xmm0
punpcklwd %xmm0,%xmm0
movd   0x4(%rdx,%rsi,1),%xmm1
punpcklbw %xmm1,%xmm1
punpcklwd %xmm1,%xmm1
psrad  $0x18,%xmm0
psrad  $0x18,%xmm1
movdqa %xmm0,(%rbx,%rsi,4)
movdqa %xmm1,0x10(%rbx,%rsi,4)
movd   0x8(%rdx,%rsi,1),%xmm0
punpcklbw %xmm0,%xmm0
punpcklwd %xmm0,%xmm0
movd   0xc(%rdx,%rsi,1),%xmm1
punpcklbw %xmm1,%xmm1
punpcklwd %xmm1,%xmm1
psrad  $0x18,%xmm0
psrad  $0x18,%xmm1
movdqa %xmm0,0x20(%rbx,%rsi,4)
movdqa %xmm1,0x30(%rbx,%rsi,4)
add    $0x10,%rsi
add    $0xfffffffffffffffe,%rdi
jne    11b0 <standard_condition_report+0xa0>
test   $0x1,%r8b
je     1252 <standard_condition_report+0x142>
movd   (%rdx,%rsi,1),%xmm0
movd   0x4(%rdx,%rsi,1),%xmm1
punpcklbw %xmm0,%xmm0
punpcklwd %xmm0,%xmm0
psrad  $0x18,%xmm0
punpcklbw %xmm1,%xmm1
punpcklwd %xmm1,%xmm1
psrad  $0x18,%xmm1
movdqa %xmm0,(%rbx,%rsi,4)
movdqa %xmm1,0x10(%rbx,%rsi,4)
cmp    %rax,%rcx
je     1270 <standard_condition_report+0x160>
nopw   0x0(%rax,%rax,1)
movsbl (%rdx,%rcx,1),%esi
mov    %esi,(%rbx,%rcx,4)
add    $0x1,%rcx
cmp    %rcx,%rax
jne    1260 <standard_condition_report+0x150>
lea    -0x40(%rbp),%rsi
lea    -0x60(%rbp),%rcx
mov    $0x398,%edi
mov    %rbx,%rdx
xor    %r8d,%r8d
call   1030 <_ada_use_c2phc4c@plt>
movups (%rbx),%xmm0
movups 0x10(%rbx),%xmm1
movups 0x20(%rbx),%xmm2
movups 0x30(%rbx),%xmm3
movups %xmm3,0x30(%r15)
movups %xmm2,0x20(%r15)
movups %xmm1,0x10(%r15)
movups %xmm0,(%r15)
movups 0x40(%rbx),%xmm0
movups 0x50(%rbx),%xmm1
movups 0x60(%rbx),%xmm2
movups 0x70(%rbx),%xmm3
movups %xmm3,0x30(%r14)
movups %xmm2,0x20(%r14)
movups %xmm1,0x10(%r14)
movups %xmm0,(%r14)
movups 0x80(%rbx),%xmm0
movups 0x90(%rbx),%xmm1
movups 0xa0(%rbx),%xmm2
movups 0xb0(%rbx),%xmm3
movups %xmm0,0x0(%r13)
movups %xmm1,0x10(%r13)
movups %xmm2,0x20(%r13)
movups %xmm3,0x30(%r13)
mov    -0x68(%rbp),%rsp
mov    -0x70(%rbp),%rbx
jmp    14fe <standard_condition_report+0x3ee>
test   %esi,%esi
jle    1454 <standard_condition_report+0x344>
mov    %esi,%eax
cmp    $0x4,%esi
jae    1331 <standard_condition_report+0x221>
xor    %ecx,%ecx
jmp    1440 <standard_condition_report+0x330>
xor    %esi,%esi
test   $0x1,%r8b
jne    1222 <standard_condition_report+0x112>
jmp    1252 <standard_condition_report+0x142>
mov    %eax,%ecx
and    $0xfffffffc,%ecx
lea    -0x4(%rcx),%rdi
mov    %rdi,%rsi
shr    $0x2,%rsi
add    $0x1,%rsi
mov    %esi,%r8d
and    $0x3,%r8d
mov    %rbx,%r9
cmp    $0xc,%rdi
jae    135c <standard_condition_report+0x24c>
xor    %edi,%edi
jmp    13e9 <standard_condition_report+0x2d9>
and    $0xfffffffffffffffc,%rsi
xor    %edi,%edi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movd   (%rdx,%rdi,1),%xmm0
punpcklbw %xmm0,%xmm0
punpcklwd %xmm0,%xmm0
psrad  $0x18,%xmm0
movdqa %xmm0,-0x140(%rbp,%rdi,4)
ff ff
movd   0x4(%rdx,%rdi,1),%xmm0
punpcklbw %xmm0,%xmm0
punpcklwd %xmm0,%xmm0
psrad  $0x18,%xmm0
movdqa %xmm0,-0x130(%rbp,%rdi,4)
ff ff
movd   0x8(%rdx,%rdi,1),%xmm0
punpcklbw %xmm0,%xmm0
punpcklwd %xmm0,%xmm0
psrad  $0x18,%xmm0
movdqa %xmm0,-0x120(%rbp,%rdi,4)
ff ff
movd   0xc(%rdx,%rdi,1),%xmm0
punpcklbw %xmm0,%xmm0
punpcklwd %xmm0,%xmm0
psrad  $0x18,%xmm0
movdqa %xmm0,-0x110(%rbp,%rdi,4)
ff ff
add    $0x10,%rdi
add    $0xfffffffffffffffc,%rsi
jne    1370 <standard_condition_report+0x260>
test   %r8,%r8
je     1430 <standard_condition_report+0x320>
lea    -0x140(,%rdi,4),%rsi
ff
add    %rbp,%rsi
add    %rdx,%rdi
shl    $0x2,%r8
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movd   (%rdi,%rbx,1),%xmm0
punpcklbw %xmm0,%xmm0
punpcklwd %xmm0,%xmm0
psrad  $0x18,%xmm0
movdqa %xmm0,(%rsi,%rbx,4)
add    $0x4,%rbx
cmp    %rbx,%r8
jne    1410 <standard_condition_report+0x300>
cmp    %rax,%rcx
mov    %r9,%rbx
je     1454 <standard_condition_report+0x344>
nopl   0x0(%rax,%rax,1)
movsbl (%rdx,%rcx,1),%esi
mov    %esi,-0x140(%rbp,%rcx,4)
add    $0x1,%rcx
cmp    %rcx,%rax
jne    1440 <standard_condition_report+0x330>
lea    -0x40(%rbp),%rsi
lea    -0x140(%rbp),%rdx
lea    -0x60(%rbp),%rcx
mov    $0x398,%edi
xor    %r8d,%r8d
call   1030 <_ada_use_c2phc4c@plt>
movaps -0x140(%rbp),%xmm0
movaps -0x130(%rbp),%xmm1
movaps -0x120(%rbp),%xmm2
movaps -0x110(%rbp),%xmm3
movups %xmm3,0x30(%r15)
movups %xmm2,0x20(%r15)
movups %xmm1,0x10(%r15)
movups %xmm0,(%r15)
movaps -0x100(%rbp),%xmm0
movaps -0xf0(%rbp),%xmm1
movaps -0xe0(%rbp),%xmm2
movaps -0xd0(%rbp),%xmm3
movups %xmm3,0x30(%r14)
movups %xmm2,0x20(%r14)
movups %xmm1,0x10(%r14)
movups %xmm0,(%r14)
movaps -0xc0(%rbp),%xmm0
movaps -0xb0(%rbp),%xmm1
movaps -0xa0(%rbp),%xmm2
movaps -0x90(%rbp),%xmm3
movups %xmm0,0x0(%r13)
movups %xmm1,0x10(%r13)
movups %xmm2,0x20(%r13)
movups %xmm3,0x30(%r13)
mov    -0x40(%rbp),%ecx
mov    %ecx,(%r12)
mov    -0x3c(%rbp),%ecx
mov    -0x78(%rbp),%rdx
mov    %ecx,(%rdx)
mov    -0x38(%rbp),%ecx
mov    %ecx,(%rbx)
mov    -0x34(%rbp),%ecx
mov    0x10(%rbp),%rdx
mov    %ecx,(%rdx)
mov    -0x30(%rbp),%ecx
mov    0x18(%rbp),%rdx
mov    %ecx,(%rdx)
mov    -0x2c(%rbp),%ecx
mov    0x20(%rbp),%rdx
mov    %ecx,(%rdx)
lea    -0x28(%rbp),%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
define i32 @standard_condition_report(i32 %0, double %1, double %2, double %3, i32 %4, i8* %5, i32* %6, i32* %7, i32* %8, i32* %9, i32* %10, i32* %11, i32* %12, i32* %13, i32* %14, i32 %15) {
%17 = alloca i32
%18 = alloca double
%19 = alloca double
%20 = alloca double
%21 = alloca i32
%22 = alloca i8*
%23 = alloca i32*
%24 = alloca i32*
%25 = alloca i32*
%26 = alloca i32*
%27 = alloca i32*
%28 = alloca i32*
%29 = alloca i32*
%30 = alloca i32*
%31 = alloca i32*
%32 = alloca i32
%33 = alloca i32
%34 = alloca i32
%35 = alloca [6 x i32]
%36 = alloca [3 x double]
%37 = alloca [48 x i32]
%38 = alloca i32
%39 = alloca i32
%40 = alloca i32
%41 = alloca i8*
%42 = alloca i64
%43 = alloca i32
%44 = alloca i32
%45 = alloca i32
%46 = alloca i32
%47 = alloca [48 x i32]
%48 = alloca i32
%49 = alloca i32
%50 = alloca i32
%51 = alloca i32
store i32 %0, i32* %17
store double %1, double* %18
store double %2, double* %19
store double %3, double* %20
store i32 %4, i32* %21
store i8* %5, i8** %22
store i32* %6, i32** %23
store i32* %7, i32** %24
store i32* %8, i32** %25
store i32* %9, i32** %26
store i32* %10, i32** %27
store i32* %11, i32** %28
store i32* %12, i32** %29
store i32* %13, i32** %30
store i32* %14, i32** %31
store i32 %15, i32* %32
%52 = load i32, i32* %17
%53 = getelementptr inbounds [6 x i32], [6 x i32]* %35, i64 0, i64 0
store i32 %52, i32* %53
%54 = load i32, i32* %32
%55 = getelementptr inbounds [6 x i32], [6 x i32]* %35, i64 0, i64 1
store i32 %54, i32* %55
%56 = load i32, i32* %21
%57 = getelementptr inbounds [6 x i32], [6 x i32]* %35, i64 0, i64 2
store i32 %56, i32* %57
%58 = load double, double* %18
%59 = getelementptr inbounds [3 x double], [3 x double]* %36, i64 0, i64 0
store double %58, double* %59
%60 = load double, double* %19
%61 = getelementptr inbounds [3 x double], [3 x double]* %36, i64 0, i64 1
store double %60, double* %61
%62 = load double, double* %20
%63 = getelementptr inbounds [3 x double], [3 x double]* %36, i64 0, i64 2
store double %62, double* %63
%64 = load i32, i32* %21
%65 = icmp eq i32 %64, 0
br i1 %65, label %66, label %122
66: ; preds = %16
%67 = getelementptr inbounds [6 x i32], [6 x i32]* %35, i64 0, i64 0
%68 = getelementptr inbounds [48 x i32], [48 x i32]* %37, i64 0, i64 0
%69 = getelementptr inbounds [3 x double], [3 x double]* %36, i64 0, i64 0
%70 = call i32 @_ada_use_c2phc4c(i32 920, i32* %67, i32* %68, double* %69, i32 0)
store i32 %70, i32* %33
store i32 0, i32* %34
store i32 0, i32* %38
br label %71
71: ; preds = %84, %66
%72 = load i32, i32* %38
%73 = icmp slt i32 %72, 16
br i1 %73, label %74, label %87
74: ; preds = %71
%75 = load i32, i32* %34
%76 = add nsw i32 %75, 1
store i32 %76, i32* %34
%77 = sext i32 %75 to i64
%78 = getelementptr inbounds [48 x i32], [48 x i32]* %37, i64 0, i64 %77
%79 = load i32, i32* %78
%80 = load i32*, i32** %29
%81 = load i32, i32* %38
%82 = sext i32 %81 to i64
%83 = getelementptr inbounds i32, i32* %80, i64 %82
store i32 %79, i32* %83
br label %84
84: ; preds = %74
%85 = load i32, i32* %38
%86 = add nsw i32 %85, 1
store i32 %86, i32* %38
br label %71
87: ; preds = %71
store i32 0, i32* %39
br label %88
88: ; preds = %101, %87
%89 = load i32, i32* %39
%90 = icmp slt i32 %89, 16
br i1 %90, label %91, label %104
91: ; preds = %88
%92 = load i32, i32* %34
%93 = add nsw i32 %92, 1
store i32 %93, i32* %34
%94 = sext i32 %92 to i64
%95 = getelementptr inbounds [48 x i32], [48 x i32]* %37, i64 0, i64 %94
%96 = load i32, i32* %95
%97 = load i32*, i32** %30
%98 = load i32, i32* %39
%99 = sext i32 %98 to i64
%100 = getelementptr inbounds i32, i32* %97, i64 %99
store i32 %96, i32* %100
br label %101
101: ; preds = %91
%102 = load i32, i32* %39
%103 = add nsw i32 %102, 1
store i32 %103, i32* %39
br label %88
104: ; preds = %88
store i32 0, i32* %40
br label %105
105: ; preds = %118, %104
%106 = load i32, i32* %40
%107 = icmp slt i32 %106, 16
br i1 %107, label %108, label %121
108: ; preds = %105
%109 = load i32, i32* %34
%110 = add nsw i32 %109, 1
store i32 %110, i32* %34
%111 = sext i32 %109 to i64
%112 = getelementptr inbounds [48 x i32], [48 x i32]* %37, i64 0, i64 %111
%113 = load i32, i32* %112
%114 = load i32*, i32** %31
%115 = load i32, i32* %40
%116 = sext i32 %115 to i64
%117 = getelementptr inbounds i32, i32* %114, i64 %116
store i32 %113, i32* %117
br label %118
118: ; preds = %108
%119 = load i32, i32* %40
%120 = add nsw i32 %119, 1
store i32 %120, i32* %40
br label %105
121: ; preds = %105
br label %278
122: ; preds = %16
%123 = load i32, i32* %21
%124 = icmp sgt i32 %123, 48
br i1 %124, label %125, label %203
125: ; preds = %122
%126 = load i32, i32* %21
%127 = zext i32 %126 to i64
%128 = call i8* @llvm.stacksave()
store i8* %128, i8** %41
%129 = alloca i32, i64 %127
store i64 %127, i64* %42
store i32 0, i32* %43
br label %130
130: ; preds = %144, %125
%131 = load i32, i32* %43
%132 = load i32, i32* %21
%133 = icmp slt i32 %131, %132
br i1 %133, label %134, label %147
134: ; preds = %130
%135 = load i8*, i8** %22
%136 = load i32, i32* %43
%137 = sext i32 %136 to i64
%138 = getelementptr inbounds i8, i8* %135, i64 %137
%139 = load i8, i8* %138
%140 = sext i8 %139 to i32
%141 = load i32, i32* %43
%142 = sext i32 %141 to i64
%143 = getelementptr inbounds i32, i32* %129, i64 %142
store i32 %140, i32* %143
br label %144
144: ; preds = %134
%145 = load i32, i32* %43
%146 = add nsw i32 %145, 1
store i32 %146, i32* %43
br label %130
147: ; preds = %130
%148 = getelementptr inbounds [6 x i32], [6 x i32]* %35, i64 0, i64 0
%149 = getelementptr inbounds [3 x double], [3 x double]* %36, i64 0, i64 0
%150 = call i32 @_ada_use_c2phc4c(i32 920, i32* %148, i32* %129, double* %149, i32 0)
store i32 %150, i32* %33
store i32 0, i32* %34
store i32 0, i32* %44
br label %151
151: ; preds = %164, %147
%152 = load i32, i32* %44
%153 = icmp slt i32 %152, 16
br i1 %153, label %154, label %167
154: ; preds = %151
%155 = load i32, i32* %34
%156 = add nsw i32 %155, 1
store i32 %156, i32* %34
%157 = sext i32 %155 to i64
%158 = getelementptr inbounds i32, i32* %129, i64 %157
%159 = load i32, i32* %158
%160 = load i32*, i32** %29
%161 = load i32, i32* %44
%162 = sext i32 %161 to i64
%163 = getelementptr inbounds i32, i32* %160, i64 %162
store i32 %159, i32* %163
br label %164
164: ; preds = %154
%165 = load i32, i32* %44
%166 = add nsw i32 %165, 1
store i32 %166, i32* %44
br label %151
167: ; preds = %151
store i32 0, i32* %45
br label %168
168: ; preds = %181, %167
%169 = load i32, i32* %45
%170 = icmp slt i32 %169, 16
br i1 %170, label %171, label %184
171: ; preds = %168
%172 = load i32, i32* %34
%173 = add nsw i32 %172, 1
store i32 %173, i32* %34
%174 = sext i32 %172 to i64
%175 = getelementptr inbounds i32, i32* %129, i64 %174
%176 = load i32, i32* %175
%177 = load i32*, i32** %30
%178 = load i32, i32* %45
%179 = sext i32 %178 to i64
%180 = getelementptr inbounds i32, i32* %177, i64 %179
store i32 %176, i32* %180
br label %181
181: ; preds = %171
%182 = load i32, i32* %45
%183 = add nsw i32 %182, 1
store i32 %183, i32* %45
br label %168
184: ; preds = %168
store i32 0, i32* %46
br label %185
185: ; preds = %198, %184
%186 = load i32, i32* %46
%187 = icmp slt i32 %186, 16
br i1 %187, label %188, label %201
188: ; preds = %185
%189 = load i32, i32* %34
%190 = add nsw i32 %189, 1
store i32 %190, i32* %34
%191 = sext i32 %189 to i64
%192 = getelementptr inbounds i32, i32* %129, i64 %191
%193 = load i32, i32* %192
%194 = load i32*, i32** %31
%195 = load i32, i32* %46
%196 = sext i32 %195 to i64
%197 = getelementptr inbounds i32, i32* %194, i64 %196
store i32 %193, i32* %197
br label %198
198: ; preds = %188
%199 = load i32, i32* %46
%200 = add nsw i32 %199, 1
store i32 %200, i32* %46
br label %185
201: ; preds = %185
%202 = load i8*, i8** %41
br label %277
203: ; preds = %122
store i32 0, i32* %48
br label %204
204: ; preds = %218, %203
%205 = load i32, i32* %48
%206 = load i32, i32* %21
%207 = icmp slt i32 %205, %206
br i1 %207, label %208, label %221
208: ; preds = %204
%209 = load i8*, i8** %22
%210 = load i32, i32* %48
%211 = sext i32 %210 to i64
%212 = getelementptr inbounds i8, i8* %209, i64 %211
%213 = load i8, i8* %212
%214 = sext i8 %213 to i32
%215 = load i32, i32* %48
%216 = sext i32 %215 to i64
%217 = getelementptr inbounds [48 x i32], [48 x i32]* %47, i64 0, i64 %216
store i32 %214, i32* %217
br label %218
218: ; preds = %208
%219 = load i32, i32* %48
%220 = add nsw i32 %219, 1
store i32 %220, i32* %48
br label %204
221: ; preds = %204
%222 = getelementptr inbounds [6 x i32], [6 x i32]* %35, i64 0, i64 0
%223 = getelementptr inbounds [48 x i32], [48 x i32]* %47, i64 0, i64 0
%224 = getelementptr inbounds [3 x double], [3 x double]* %36, i64 0, i64 0
%225 = call i32 @_ada_use_c2phc4c(i32 920, i32* %222, i32* %223, double* %224, i32 0)
store i32 %225, i32* %33
store i32 0, i32* %34
store i32 0, i32* %49
br label %226
226: ; preds = %239, %221
%227 = load i32, i32* %49
%228 = icmp slt i32 %227, 16
br i1 %228, label %229, label %242
229: ; preds = %226
%230 = load i32, i32* %34
%231 = add nsw i32 %230, 1
store i32 %231, i32* %34
%232 = sext i32 %230 to i64
%233 = getelementptr inbounds [48 x i32], [48 x i32]* %47, i64 0, i64 %232
%234 = load i32, i32* %233
%235 = load i32*, i32** %29
%236 = load i32, i32* %49
%237 = sext i32 %236 to i64
%238 = getelementptr inbounds i32, i32* %235, i64 %237
store i32 %234, i32* %238
br label %239
239: ; preds = %229
%240 = load i32, i32* %49
%241 = add nsw i32 %240, 1
store i32 %241, i32* %49
br label %226
242: ; preds = %226
store i32 0, i32* %50
br label %243
243: ; preds = %256, %242
%244 = load i32, i32* %50
%245 = icmp slt i32 %244, 16
br i1 %245, label %246, label %259
246: ; preds = %243
%247 = load i32, i32* %34
%248 = add nsw i32 %247, 1
store i32 %248, i32* %34
%249 = sext i32 %247 to i64
%250 = getelementptr inbounds [48 x i32], [48 x i32]* %47, i64 0, i64 %249
%251 = load i32, i32* %250
%252 = load i32*, i32** %30
%253 = load i32, i32* %50
%254 = sext i32 %253 to i64
%255 = getelementptr inbounds i32, i32* %252, i64 %254
store i32 %251, i32* %255
br label %256
256: ; preds = %246
%257 = load i32, i32* %50
%258 = add nsw i32 %257, 1
store i32 %258, i32* %50
br label %243
259: ; preds = %243
store i32 0, i32* %51
br label %260
260: ; preds = %273, %259
%261 = load i32, i32* %51
%262 = icmp slt i32 %261, 16
br i1 %262, label %263, label %276
263: ; preds = %260
%264 = load i32, i32* %34
%265 = add nsw i32 %264, 1
store i32 %265, i32* %34
%266 = sext i32 %264 to i64
%267 = getelementptr inbounds [48 x i32], [48 x i32]* %47, i64 0, i64 %266
%268 = load i32, i32* %267
%269 = load i32*, i32** %31
%270 = load i32, i32* %51
%271 = sext i32 %270 to i64
%272 = getelementptr inbounds i32, i32* %269, i64 %271
store i32 %268, i32* %272
br label %273
273: ; preds = %263
%274 = load i32, i32* %51
%275 = add nsw i32 %274, 1
store i32 %275, i32* %51
br label %260
276: ; preds = %260
br label %277
277: ; preds = %276, %201
br label %278
278: ; preds = %277, %121
%279 = getelementptr inbounds [6 x i32], [6 x i32]* %35, i64 0, i64 0
%280 = load i32, i32* %279
%281 = load i32*, i32** %23
store i32 %280, i32* %281
%282 = getelementptr inbounds [6 x i32], [6 x i32]* %35, i64 0, i64 1
%283 = load i32, i32* %282
%284 = load i32*, i32** %24
store i32 %283, i32* %284
%285 = getelementptr inbounds [6 x i32], [6 x i32]* %35, i64 0, i64 2
%286 = load i32, i32* %285
%287 = load i32*, i32** %25
store i32 %286, i32* %287
%288 = getelementptr inbounds [6 x i32], [6 x i32]* %35, i64 0, i64 3
%289 = load i32, i32* %288
%290 = load i32*, i32** %26
store i32 %289, i32* %290
%291 = getelementptr inbounds [6 x i32], [6 x i32]* %35, i64 0, i64 4
%292 = load i32, i32* %291
%293 = load i32*, i32** %27
store i32 %292, i32* %293
%294 = getelementptr inbounds [6 x i32], [6 x i32]* %35, i64 0, i64 5
%295 = load i32, i32* %294
%296 = load i32*, i32** %28
store i32 %295, i32* %296
%297 = load i32, i32* %33
ret i32 %297
}

LLVM IR (-O2):
define i32 @standard_condition_report(i32 %0, double %1, double %2, double %3, i32 %4, i8* nocapture %5, i32* nocapture writeonly %6, i32* nocapture writeonly %7, i32* nocapture writeonly %8, i32* nocapture writeonly %9, i32* nocapture writeonly %10, i32* nocapture writeonly %11, i32* nocapture writeonly %12, i32* nocapture writeonly %13, i32* nocapture writeonly %14, i32 %15) {
%17 = bitcast i32* %12 to i8*
%18 = bitcast i32* %13 to i8*
%19 = bitcast i32* %14 to i8*
%20 = alloca [6 x i32]
%21 = alloca [3 x double]
%22 = alloca [48 x i32]
%23 = bitcast [48 x i32]* %22 to i8*
%24 = alloca [48 x i32]
%25 = bitcast [48 x i32]* %24 to i8*
%26 = bitcast [6 x i32]* %20 to i8*
%27 = bitcast [3 x double]* %21 to i8*
%28 = getelementptr inbounds [6 x i32], [6 x i32]* %20, i64 0, i64 0
store i32 %0, i32* %28
%29 = getelementptr inbounds [6 x i32], [6 x i32]* %20, i64 0, i64 1
store i32 %15, i32* %29
%30 = getelementptr inbounds [6 x i32], [6 x i32]* %20, i64 0, i64 2
store i32 %4, i32* %30
%31 = getelementptr inbounds [3 x double], [3 x double]* %21, i64 0, i64 0
store double %1, double* %31
%32 = getelementptr inbounds [3 x double], [3 x double]* %21, i64 0, i64 1
store double %2, double* %32
%33 = getelementptr inbounds [3 x double], [3 x double]* %21, i64 0, i64 2
store double %3, double* %33
%34 = icmp eq i32 %4, 0
br i1 %34, label %35, label %42
35: ; preds = %16
%36 = getelementptr inbounds [48 x i32], [48 x i32]* %22, i64 0, i64 0
%37 = call i32 @_ada_use_c2phc4c(i32 920, i32* %28, i32* %36, double* %31, i32 0)
%38 = getelementptr inbounds [48 x i32], [48 x i32]* %22, i64 0, i64 16
%39 = bitcast i32* %38 to i8*
%40 = getelementptr inbounds [48 x i32], [48 x i32]* %22, i64 0, i64 32
%41 = bitcast i32* %40 to i8*
br label %201
42: ; preds = %16
%43 = icmp sgt i32 %4, 48
br i1 %43, label %44, label %120
44: ; preds = %42
%45 = zext i32 %4 to i64
%46 = tail call i8* @llvm.stacksave()
%47 = alloca i32, i64 %45
%48 = bitcast i32* %47 to i8*
%49 = and i64 %45, 4294967288
%50 = add nsw i64 %49, -8
%51 = lshr exact i64 %50, 3
%52 = add nuw nsw i64 %51, 1
%53 = and i64 %52, 1
%54 = icmp eq i64 %50, 0
br i1 %54, label %88, label %55
55: ; preds = %44
%56 = and i64 %52, 4611686018427387902
br label %57
57: ; preds = %57, %55
%58 = phi i64 [ 0, %55 ], [ %85, %57 ]
%59 = phi i64 [ 0, %55 ], [ %86, %57 ]
%60 = getelementptr inbounds i8, i8* %5, i64 %58
%61 = bitcast i8* %60 to <4 x i8>*
%62 = load <4 x i8>, <4 x i8>* %61
%63 = getelementptr inbounds i8, i8* %60, i64 4
%64 = bitcast i8* %63 to <4 x i8>*
%65 = load <4 x i8>, <4 x i8>* %64
%66 = sext <4 x i8> %62 to <4 x i32>
%67 = sext <4 x i8> %65 to <4 x i32>
%68 = getelementptr inbounds i32, i32* %47, i64 %58
%69 = bitcast i32* %68 to <4 x i32>*
store <4 x i32> %66, <4 x i32>* %69
%70 = getelementptr inbounds i32, i32* %68, i64 4
%71 = bitcast i32* %70 to <4 x i32>*
store <4 x i32> %67, <4 x i32>* %71
%72 = or i64 %58, 8
%73 = getelementptr inbounds i8, i8* %5, i64 %72
%74 = bitcast i8* %73 to <4 x i8>*
%75 = load <4 x i8>, <4 x i8>* %74
%76 = getelementptr inbounds i8, i8* %73, i64 4
%77 = bitcast i8* %76 to <4 x i8>*
%78 = load <4 x i8>, <4 x i8>* %77
%79 = sext <4 x i8> %75 to <4 x i32>
%80 = sext <4 x i8> %78 to <4 x i32>
%81 = getelementptr inbounds i32, i32* %47, i64 %72
%82 = bitcast i32* %81 to <4 x i32>*
store <4 x i32> %79, <4 x i32>* %82
%83 = getelementptr inbounds i32, i32* %81, i64 4
%84 = bitcast i32* %83 to <4 x i32>*
store <4 x i32> %80, <4 x i32>* %84
%85 = add nuw nsw i64 %58, 16
%86 = add nuw nsw i64 %59, 2
%87 = icmp eq i64 %86, %56
br i1 %87, label %88, label %57
88: ; preds = %57, %44
%89 = phi i64 [ 0, %44 ], [ %85, %57 ]
%90 = icmp eq i64 %53, 0
br i1 %90, label %104, label %91
91: ; preds = %88
%92 = getelementptr inbounds i8, i8* %5, i64 %89
%93 = bitcast i8* %92 to <4 x i8>*
%94 = load <4 x i8>, <4 x i8>* %93
%95 = getelementptr inbounds i8, i8* %92, i64 4
%96 = bitcast i8* %95 to <4 x i8>*
%97 = load <4 x i8>, <4 x i8>* %96
%98 = sext <4 x i8> %94 to <4 x i32>
%99 = sext <4 x i8> %97 to <4 x i32>
%100 = getelementptr inbounds i32, i32* %47, i64 %89
%101 = bitcast i32* %100 to <4 x i32>*
store <4 x i32> %98, <4 x i32>* %101
%102 = getelementptr inbounds i32, i32* %100, i64 4
%103 = bitcast i32* %102 to <4 x i32>*
store <4 x i32> %99, <4 x i32>* %103
br label %104
104: ; preds = %88, %91
%105 = icmp eq i64 %49, %45
br i1 %105, label %106, label %112
106: ; preds = %112, %104
%107 = call i32 @_ada_use_c2phc4c(i32 920, i32* %28, i32* %47, double* %31, i32 0)
%108 = getelementptr i32, i32* %47, i64 16
%109 = bitcast i32* %108 to i8*
%110 = getelementptr i32, i32* %47, i64 32
%111 = bitcast i32* %110 to i8*
br label %201
112: ; preds = %104, %112
%113 = phi i64 [ %118, %112 ], [ %49, %104 ]
%114 = getelementptr inbounds i8, i8* %5, i64 %113
%115 = load i8, i8* %114
%116 = sext i8 %115 to i32
%117 = getelementptr inbounds i32, i32* %47, i64 %113
store i32 %116, i32* %117
%118 = add nuw nsw i64 %113, 1
%119 = icmp eq i64 %118, %45
br i1 %119, label %106, label %112
120: ; preds = %42
%121 = icmp sgt i32 %4, 0
br i1 %121, label %122, label %186
122: ; preds = %120
%123 = zext i32 %4 to i64
%124 = icmp ult i32 %4, 4
br i1 %124, label %184, label %125
125: ; preds = %122
%126 = and i64 %123, 4294967292
%127 = add nsw i64 %126, -4
%128 = lshr exact i64 %127, 2
%129 = add nuw nsw i64 %128, 1
%130 = and i64 %129, 3
%131 = icmp ult i64 %127, 12
br i1 %131, label %167, label %132
132: ; preds = %125
%133 = and i64 %129, 9223372036854775804
br label %134
134: ; preds = %134, %132
%135 = phi i64 [ 0, %132 ], [ %164, %134 ]
%136 = phi i64 [ 0, %132 ], [ %165, %134 ]
%137 = getelementptr inbounds i8, i8* %5, i64 %135
%138 = bitcast i8* %137 to <4 x i8>*
%139 = load <4 x i8>, <4 x i8>* %138
%140 = sext <4 x i8> %139 to <4 x i32>
%141 = getelementptr inbounds [48 x i32], [48 x i32]* %24, i64 0, i64 %135
%142 = bitcast i32* %141 to <4 x i32>*
store <4 x i32> %140, <4 x i32>* %142
%143 = or i64 %135, 4
%144 = getelementptr inbounds i8, i8* %5, i64 %143
%145 = bitcast i8* %144 to <4 x i8>*
%146 = load <4 x i8>, <4 x i8>* %145
%147 = sext <4 x i8> %146 to <4 x i32>
%148 = getelementptr inbounds [48 x i32], [48 x i32]* %24, i64 0, i64 %143
%149 = bitcast i32* %148 to <4 x i32>*
store <4 x i32> %147, <4 x i32>* %149
%150 = or i64 %135, 8
%151 = getelementptr inbounds i8, i8* %5, i64 %150
%152 = bitcast i8* %151 to <4 x i8>*
%153 = load <4 x i8>, <4 x i8>* %152
%154 = sext <4 x i8> %153 to <4 x i32>
%155 = getelementptr inbounds [48 x i32], [48 x i32]* %24, i64 0, i64 %150
%156 = bitcast i32* %155 to <4 x i32>*
store <4 x i32> %154, <4 x i32>* %156
%157 = or i64 %135, 12
%158 = getelementptr inbounds i8, i8* %5, i64 %157
%159 = bitcast i8* %158 to <4 x i8>*
%160 = load <4 x i8>, <4 x i8>* %159
%161 = sext <4 x i8> %160 to <4 x i32>
%162 = getelementptr inbounds [48 x i32], [48 x i32]* %24, i64 0, i64 %157
%163 = bitcast i32* %162 to <4 x i32>*
store <4 x i32> %161, <4 x i32>* %163
%164 = add nuw i64 %135, 16
%165 = add nuw i64 %136, 4
%166 = icmp eq i64 %165, %133
br i1 %166, label %167, label %134
167: ; preds = %134, %125
%168 = phi i64 [ 0, %125 ], [ %164, %134 ]
%169 = icmp eq i64 %130, 0
br i1 %169, label %182, label %170
170: ; preds = %167, %170
%171 = phi i64 [ %179, %170 ], [ %168, %167 ]
%172 = phi i64 [ %180, %170 ], [ 0, %167 ]
%173 = getelementptr inbounds i8, i8* %5, i64 %171
%174 = bitcast i8* %173 to <4 x i8>*
%175 = load <4 x i8>, <4 x i8>* %174
%176 = sext <4 x i8> %175 to <4 x i32>
%177 = getelementptr inbounds [48 x i32], [48 x i32]* %24, i64 0, i64 %171
%178 = bitcast i32* %177 to <4 x i32>*
store <4 x i32> %176, <4 x i32>* %178
%179 = add nuw i64 %171, 4
%180 = add i64 %172, 1
%181 = icmp eq i64 %180, %130
br i1 %181, label %182, label %170
182: ; preds = %170, %167
%183 = icmp eq i64 %126, %123
br i1 %183, label %186, label %184
184: ; preds = %122, %182
%185 = phi i64 [ 0, %122 ], [ %126, %182 ]
br label %193
186: ; preds = %193, %182, %120
%187 = getelementptr inbounds [48 x i32], [48 x i32]* %24, i64 0, i64 0
%188 = call i32 @_ada_use_c2phc4c(i32 920, i32* %28, i32* %187, double* %31, i32 0)
%189 = getelementptr inbounds [48 x i32], [48 x i32]* %24, i64 0, i64 16
%190 = bitcast i32* %189 to i8*
%191 = getelementptr inbounds [48 x i32], [48 x i32]* %24, i64 0, i64 32
%192 = bitcast i32* %191 to i8*
br label %201
193: ; preds = %184, %193
%194 = phi i64 [ %199, %193 ], [ %185, %184 ]
%195 = getelementptr inbounds i8, i8* %5, i64 %194
%196 = load i8, i8* %195
%197 = sext i8 %196 to i32
%198 = getelementptr inbounds [48 x i32], [48 x i32]* %24, i64 0, i64 %194
store i32 %197, i32* %198
%199 = add nuw nsw i64 %194, 1
%200 = icmp eq i64 %199, %123
br i1 %200, label %186, label %193
201: ; preds = %106, %186, %35
%202 = phi i32 [ %37, %35 ], [ %107, %106 ], [ %188, %186 ]
%203 = load i32, i32* %28
store i32 %203, i32* %6
%204 = load i32, i32* %29
store i32 %204, i32* %7
%205 = load i32, i32* %30
store i32 %205, i32* %8
%206 = getelementptr inbounds [6 x i32], [6 x i32]* %20, i64 0, i64 3
%207 = load i32, i32* %206
store i32 %207, i32* %9
%208 = getelementptr inbounds [6 x i32], [6 x i32]* %20, i64 0, i64 4
%209 = load i32, i32* %208
store i32 %209, i32* %10
%210 = getelementptr inbounds [6 x i32], [6 x i32]* %20, i64 0, i64 5
%211 = load i32, i32* %210
store i32 %211, i32* %11
ret i32 %202
}