#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 */
scalar_t__ alloca(unsigned int);
int /*<<< orphan*/ memcpy(char *, char *, unsigned int);
int /*<<< orphan*/ memset(char *, unsigned char, unsigned int);
char *xsi_get_transient_memory(unsigned int);
char *ieee_p_3499444699_sub_2763780858403406230_3536714472(char *t1, char *t2,
                                                           char *t3, char *t4,
                                                           char *t5, char *t6) {
  char t7[128];
  char t8[40];
  char t19[16];
  char *t0;
  char *t9;
  int t10;
  int t11;
  unsigned int t12;
  char *t13;
  char *t14;
  char *t15;
  int t16;
  int t17;
  unsigned int t18;
  char *t20;
  int t21;
  char *t22;
  char *t23;
  int t24;
  unsigned int t25;
  char *t26;
  char *t27;
  char *t28;
  char *t29;
  char *t30;
  char *t31;
  char *t32;
  unsigned char t33;
  char *t34;
  char *t35;
  unsigned char t36;
  char *t37;
  char *t38;
  char *t39;
  char *t40;
  int t41;
  char *t42;
  int t43;
  char *t44;
  int t45;
  char *t46;
  char *t47;
  int t48;
  unsigned int t49;
LAB0:
  t9 = (t4 + 0U);
  t10 = *((int *)t9);
  t11 = (0 - t10);
  t12 = (t11 * -1);
  t12 = (t12 + 1);
  t12 = (t12 * 1U);
  t13 = xsi_get_transient_memory(t12);
  memset(t13, 0, t12);
  t14 = t13;
  memset(t14, (unsigned char)1, t12);
  t15 = (t4 + 0U);
  t16 = *((int *)t15);
  t17 = (0 - t16);
  t18 = (t17 * -1);
  t18 = (t18 + 1);
  t18 = (t18 * 1U);
  t20 = (t4 + 0U);
  t21 = *((int *)t20);
  t22 = (t19 + 0U);
  t23 = (t22 + 0U);
  *((int *)t23) = t21;
  t23 = (t22 + 4U);
  *((int *)t23) = 0;
  t23 = (t22 + 8U);
  *((int *)t23) = -1;
  t24 = (0 - t21);
  t25 = (t24 * -1);
  t25 = (t25 + 1);
  t23 = (t22 + 12U);
  *((unsigned int *)t23) = t25;
  t23 = (t7 + 4U);
  t26 = (t1 + 2600);
  t27 = (t23 + 88U);
  *((char **)t27) = t26;
  t28 = (char *)alloca(t18);
  t29 = (t23 + 56U);
  *((char **)t29) = t28;
  memcpy(t28, t13, t18);
  t30 = (t23 + 64U);
  *((char **)t30) = t19;
  t31 = (t23 + 80U);
  *((unsigned int *)t31) = t18;
  t32 = (t8 + 4U);
  t33 = (t3 != 0);
  if (t33 == 1)
    goto LAB3;
LAB2:
  t34 = (t8 + 12U);
  *((char **)t34) = t4;
  t35 = (t8 + 20U);
  t36 = (t5 != 0);
  if (t36 == 1)
    goto LAB5;
LAB4:
  t37 = (t8 + 28U);
  *((char **)t37) = t6;
  t38 = (t23 + 56U);
  t39 = *((char **)t38);
  t38 = (t19 + 12U);
  t25 = *((unsigned int *)t38);
  t25 = (t25 * 1U);
  t0 = xsi_get_transient_memory(t25);
  memcpy(t0, t39, t25);
  t40 = (t19 + 0U);
  t41 = *((int *)t40);
  t42 = (t19 + 4U);
  t43 = *((int *)t42);
  t44 = (t19 + 8U);
  t45 = *((int *)t44);
  t46 = (t2 + 0U);
  t47 = (t46 + 0U);
  *((int *)t47) = t41;
  t47 = (t46 + 4U);
  *((int *)t47) = t43;
  t47 = (t46 + 8U);
  *((int *)t47) = t45;
  t48 = (t43 - t41);
  t49 = (t48 * t45);
  t49 = (t49 + 1);
  t47 = (t46 + 12U);
  *((unsigned int *)t47) = t49;
LAB1:
  return t0;
LAB3:
  *((char **)t32) = t3;
  goto LAB2;
LAB5:
  *((char **)t35) = t5;
  goto LAB4;
LAB6:;
}


x86 assembly (clang, -O0):
<ieee_p_3499444699_sub_2763780858403406230_3536714472>:
push   %rbp
mov    %rsp,%rbp
sub    $0x230,%rsp
mov    %rdi,-0x10(%rbp)
mov    %rsi,-0x18(%rbp)
mov    %rdx,-0x20(%rbp)
mov    %rcx,-0x28(%rbp)
mov    %r8,-0x30(%rbp)
mov    %r9,-0x38(%rbp)
mov    -0x28(%rbp),%rax
mov    %rax,-0x110(%rbp)
mov    -0x110(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x114(%rbp)
xor    %eax,%eax
sub    -0x114(%rbp),%eax
mov    %eax,-0x118(%rbp)
imul   $0xffffffff,-0x118(%rbp),%eax
mov    %eax,-0x11c(%rbp)
mov    -0x11c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x11c(%rbp)
mov    -0x11c(%rbp),%eax
shl    $0x0,%eax
mov    %eax,-0x11c(%rbp)
mov    -0x11c(%rbp),%edi
call   1060 <xsi_get_transient_memory@plt>
mov    %rax,-0x128(%rbp)
mov    -0x128(%rbp),%rdi
mov    -0x11c(%rbp),%edx
xor    %esi,%esi
call   1030 <memset@plt>
mov    -0x128(%rbp),%rax
mov    %rax,-0x130(%rbp)
mov    -0x130(%rbp),%rdi
mov    -0x11c(%rbp),%edx
mov    $0x1,%esi
call   1030 <memset@plt>
mov    -0x28(%rbp),%rax
mov    %rax,-0x138(%rbp)
mov    -0x138(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x13c(%rbp)
xor    %eax,%eax
sub    -0x13c(%rbp),%eax
mov    %eax,-0x140(%rbp)
imul   $0xffffffff,-0x140(%rbp),%eax
mov    %eax,-0x144(%rbp)
mov    -0x144(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x144(%rbp)
mov    -0x144(%rbp),%eax
shl    $0x0,%eax
mov    %eax,-0x144(%rbp)
mov    -0x28(%rbp),%rax
mov    %rax,-0x150(%rbp)
mov    -0x150(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x154(%rbp)
lea    -0x100(%rbp),%rax
mov    %rax,-0x160(%rbp)
mov    -0x160(%rbp),%rax
mov    %rax,-0x168(%rbp)
mov    -0x154(%rbp),%ecx
mov    -0x168(%rbp),%rax
mov    %ecx,(%rax)
mov    -0x160(%rbp),%rax
add    $0x4,%rax
mov    %rax,-0x168(%rbp)
mov    -0x168(%rbp),%rax
movl   $0x0,(%rax)
mov    -0x160(%rbp),%rax
add    $0x8,%rax
mov    %rax,-0x168(%rbp)
mov    -0x168(%rbp),%rax
movl   $0xffffffff,(%rax)
xor    %eax,%eax
sub    -0x154(%rbp),%eax
mov    %eax,-0x16c(%rbp)
imul   $0xffffffff,-0x16c(%rbp),%eax
mov    %eax,-0x170(%rbp)
mov    -0x170(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x170(%rbp)
mov    -0x160(%rbp),%rax
add    $0xc,%rax
mov    %rax,-0x168(%rbp)
mov    -0x170(%rbp),%ecx
mov    -0x168(%rbp),%rax
mov    %ecx,(%rax)
lea    -0xc0(%rbp),%rax
add    $0x4,%rax
mov    %rax,-0x168(%rbp)
mov    -0x10(%rbp),%rax
add    $0xa28,%rax
mov    %rax,-0x178(%rbp)
mov    -0x168(%rbp),%rax
add    $0x58,%rax
mov    %rax,-0x180(%rbp)
mov    -0x178(%rbp),%rcx
mov    -0x180(%rbp),%rax
mov    %rcx,(%rax)
mov    -0x144(%rbp),%edi
call   1040 <alloca@plt>
mov    %rax,-0x188(%rbp)
mov    -0x168(%rbp),%rax
add    $0x38,%rax
mov    %rax,-0x190(%rbp)
mov    -0x188(%rbp),%rcx
mov    -0x190(%rbp),%rax
mov    %rcx,(%rax)
mov    -0x188(%rbp),%rdi
mov    -0x128(%rbp),%rsi
mov    -0x144(%rbp),%edx
call   1050 <memcpy@plt>
mov    -0x168(%rbp),%rax
add    $0x40,%rax
mov    %rax,-0x198(%rbp)
lea    -0x100(%rbp),%rcx
mov    -0x198(%rbp),%rax
mov    %rcx,(%rax)
mov    -0x168(%rbp),%rax
add    $0x50,%rax
mov    %rax,-0x1a0(%rbp)
mov    -0x144(%rbp),%ecx
mov    -0x1a0(%rbp),%rax
mov    %ecx,(%rax)
lea    -0xf0(%rbp),%rax
add    $0x4,%rax
mov    %rax,-0x1a8(%rbp)
cmpq   $0x0,-0x20(%rbp)
setne  %al
and    $0x1,%al
movzbl %al,%eax
mov    %al,-0x1a9(%rbp)
movzbl -0x1a9(%rbp),%eax
cmp    $0x1,%eax
jne    1434 <ieee_p_3499444699_sub_2763780858403406230_3536714472+0x2f4>
jmp    1664 <ieee_p_3499444699_sub_2763780858403406230_3536714472+0x524>
jmp    1439 <ieee_p_3499444699_sub_2763780858403406230_3536714472+0x2f9>
lea    -0xf0(%rbp),%rax
add    $0xc,%rax
mov    %rax,-0x1b8(%rbp)
mov    -0x28(%rbp),%rcx
mov    -0x1b8(%rbp),%rax
mov    %rcx,(%rax)
lea    -0xf0(%rbp),%rax
add    $0x14,%rax
mov    %rax,-0x1c0(%rbp)
cmpq   $0x0,-0x30(%rbp)
setne  %al
and    $0x1,%al
movzbl %al,%eax
mov    %al,-0x1c1(%rbp)
movzbl -0x1c1(%rbp),%eax
cmp    $0x1,%eax
jne    1493 <ieee_p_3499444699_sub_2763780858403406230_3536714472+0x353>
jmp    1677 <ieee_p_3499444699_sub_2763780858403406230_3536714472+0x537>
jmp    1498 <ieee_p_3499444699_sub_2763780858403406230_3536714472+0x358>
lea    -0xf0(%rbp),%rax
add    $0x1c,%rax
mov    %rax,-0x1d0(%rbp)
mov    -0x38(%rbp),%rcx
mov    -0x1d0(%rbp),%rax
mov    %rcx,(%rax)
mov    -0x168(%rbp),%rax
add    $0x38,%rax
mov    %rax,-0x1d8(%rbp)
mov    -0x1d8(%rbp),%rax
mov    (%rax),%rax
mov    %rax,-0x1e0(%rbp)
lea    -0x100(%rbp),%rax
add    $0xc,%rax
mov    %rax,-0x1d8(%rbp)
mov    -0x1d8(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x170(%rbp)
mov    -0x170(%rbp),%eax
shl    $0x0,%eax
mov    %eax,-0x170(%rbp)
mov    -0x170(%rbp),%edi
call   1060 <xsi_get_transient_memory@plt>
mov    %rax,-0x108(%rbp)
mov    -0x108(%rbp),%rdi
mov    -0x1e0(%rbp),%rsi
mov    -0x170(%rbp),%edx
call   1050 <memcpy@plt>
lea    -0x100(%rbp),%rax
mov    %rax,-0x1e8(%rbp)
mov    -0x1e8(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x1ec(%rbp)
lea    -0x100(%rbp),%rax
add    $0x4,%rax
mov    %rax,-0x1f8(%rbp)
mov    -0x1f8(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x1fc(%rbp)
lea    -0x100(%rbp),%rax
add    $0x8,%rax
mov    %rax,-0x208(%rbp)
mov    -0x208(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x20c(%rbp)
mov    -0x18(%rbp),%rax
mov    %rax,-0x218(%rbp)
mov    -0x218(%rbp),%rax
mov    %rax,-0x220(%rbp)
mov    -0x1ec(%rbp),%ecx
mov    -0x220(%rbp),%rax
mov    %ecx,(%rax)
mov    -0x218(%rbp),%rax
add    $0x4,%rax
mov    %rax,-0x220(%rbp)
mov    -0x1fc(%rbp),%ecx
mov    -0x220(%rbp),%rax
mov    %ecx,(%rax)
mov    -0x218(%rbp),%rax
add    $0x8,%rax
mov    %rax,-0x220(%rbp)
mov    -0x20c(%rbp),%ecx
mov    -0x220(%rbp),%rax
mov    %ecx,(%rax)
mov    -0x1fc(%rbp),%eax
sub    -0x1ec(%rbp),%eax
mov    %eax,-0x224(%rbp)
mov    -0x224(%rbp),%eax
imul   -0x20c(%rbp),%eax
mov    %eax,-0x228(%rbp)
mov    -0x228(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x228(%rbp)
mov    -0x218(%rbp),%rax
add    $0xc,%rax
mov    %rax,-0x220(%rbp)
mov    -0x228(%rbp),%ecx
mov    -0x220(%rbp),%rax
mov    %ecx,(%rax)
mov    -0x108(%rbp),%rax
mov    %rax,-0x8(%rbp)
jmp    168a <ieee_p_3499444699_sub_2763780858403406230_3536714472+0x54a>
mov    -0x20(%rbp),%rcx
mov    -0x1a8(%rbp),%rax
mov    %rcx,(%rax)
jmp    1439 <ieee_p_3499444699_sub_2763780858403406230_3536714472+0x2f9>
mov    -0x30(%rbp),%rcx
mov    -0x1c0(%rbp),%rax
mov    %rcx,(%rax)
jmp    1498 <ieee_p_3499444699_sub_2763780858403406230_3536714472+0x358>
mov    -0x8(%rbp),%rax
add    $0x230,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<ieee_p_3499444699_sub_2763780858403406230_3536714472>:
push   %rbp
push   %r15
push   %r14
push   %r12
push   %rbx
mov    %rcx,%r15
mov    %rsi,%r14
mov    (%rcx),%ebp
add    $0x1,%ebp
mov    %ebp,%edi
call   1060 <xsi_get_transient_memory@plt>
mov    %rax,%rbx
mov    %rax,%rdi
xor    %esi,%esi
mov    %ebp,%edx
call   1030 <memset@plt>
mov    %rbx,%rdi
mov    $0x1,%esi
mov    %ebp,%edx
call   1030 <memset@plt>
mov    (%r15),%r12d
lea    0x1(%r12),%ebp
mov    %ebp,%edi
call   1040 <alloca@plt>
mov    %rax,%r15
mov    %rax,%rdi
mov    %rbx,%rsi
mov    %ebp,%edx
call   1050 <memcpy@plt>
mov    %ebp,%edi
call   1060 <xsi_get_transient_memory@plt>
mov    %rax,%rbx
mov    %rax,%rdi
mov    %r15,%rsi
mov    %ebp,%edx
call   1050 <memcpy@plt>
mov    %r12d,(%r14)
movabs $0xffffffff00000000,%rax
ff ff ff
mov    %rax,0x4(%r14)
mov    %ebp,0xc(%r14)
mov    %rbx,%rax
pop    %rbx
pop    %r12
pop    %r14
pop    %r15
pop    %rbp
ret

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

LLVM IR (-O2):
define i8* @ieee_p_3499444699_sub_2763780858403406230_3536714472(i8* nocapture readnone %0, i8* nocapture writeonly %1, i8* nocapture readnone %2, i8* nocapture %3, i8* nocapture readnone %4, i8* nocapture readnone %5) {
%7 = bitcast i8* %3 to i32*
%8 = load i32, i32* %7
%9 = add i32 %8, 1
%10 = tail call i8* @xsi_get_transient_memory(i32 %9)
%11 = tail call i32 @memset(i8* %10, i8 zeroext 0, i32 %9)
%12 = tail call i32 @memset(i8* %10, i8 zeroext 1, i32 %9)
%13 = load i32, i32* %7
%14 = add i32 %13, 1
%15 = tail call i64 @alloca(i32 %14)
%16 = inttoptr i64 %15 to i8*
%17 = tail call i32 @memcpy(i8* %16, i8* %10, i32 %14)
%18 = tail call i8* @xsi_get_transient_memory(i32 %14)
%19 = tail call i32 @memcpy(i8* %18, i8* %16, i32 %14)
%20 = bitcast i8* %1 to i32*
store i32 %13, i32* %20
%21 = getelementptr inbounds i8, i8* %1, i64 4
%22 = bitcast i8* %21 to i32*
store i32 0, i32* %22
%23 = getelementptr inbounds i8, i8* %1, i64 8
%24 = bitcast i8* %23 to i32*
store i32 -1, i32* %24
%25 = getelementptr inbounds i8, i8* %1, i64 12
%26 = bitcast i8* %25 to i32*
store i32 %14, i32* %26
ret i8* %18
}