#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);
char *ieee_p_3499444699_sub_3760106476388108256_3536714472(char *, char *,
                                                           int /*<<< orphan*/,
                                                           char *, char *);
int /*<<< orphan*/ memcpy(char *, char *, unsigned int);
char *xsi_get_transient_memory(unsigned int);
int /*<<< orphan*/ xsi_type_set_default_value(char *, char *, char *);
char *ieee_p_3499444699_sub_420192188731145490_3536714472(char *t1, char *t2,
                                                          char *t3, char *t4) {
  char t5[128];
  char t6[24];
  char t9[16];
  char t29[16];
  char *t0;
  char *t7;
  unsigned int t8;
  char *t10;
  int t11;
  char *t12;
  int t13;
  char *t14;
  int t15;
  char *t16;
  char *t17;
  int t18;
  unsigned int t19;
  char *t20;
  char *t21;
  char *t22;
  char *t23;
  char *t24;
  char *t25;
  char *t26;
  unsigned char t27;
  char *t28;
  char *t30;
  char *t31;
  char *t32;
  char *t33;
  unsigned int t34;
LAB0:
  t7 = (t4 + 12U);
  t8 = *((unsigned int *)t7);
  t8 = (t8 * 1U);
  t10 = (t4 + 0U);
  t11 = *((int *)t10);
  t12 = (t4 + 4U);
  t13 = *((int *)t12);
  t14 = (t4 + 8U);
  t15 = *((int *)t14);
  t16 = (t9 + 0U);
  t17 = (t16 + 0U);
  *((int *)t17) = t11;
  t17 = (t16 + 4U);
  *((int *)t17) = t13;
  t17 = (t16 + 8U);
  *((int *)t17) = t15;
  t18 = (t13 - t11);
  t19 = (t18 * t15);
  t19 = (t19 + 1);
  t17 = (t16 + 12U);
  *((unsigned int *)t17) = t19;
  t17 = (t5 + 4U);
  t20 = (t1 + 2704);
  t21 = (t17 + 88U);
  *((char **)t21) = t20;
  t22 = (char *)alloca(t8);
  t23 = (t17 + 56U);
  *((char **)t23) = t22;
  xsi_type_set_default_value(t20, t22, t9);
  t24 = (t17 + 64U);
  *((char **)t24) = t9;
  t25 = (t17 + 80U);
  *((unsigned int *)t25) = t8;
  t26 = (t6 + 4U);
  t27 = (t3 != 0);
  if (t27 == 1)
    goto LAB3;
LAB2:
  t28 = (t6 + 12U);
  *((char **)t28) = t4;
  t30 =
      ieee_p_3499444699_sub_3760106476388108256_3536714472(t1, t29, 0, t3, t4);
  t31 = (t17 + 56U);
  t32 = *((char **)t31);
  t31 = (t32 + 0);
  t33 = (t29 + 12U);
  t19 = *((unsigned int *)t33);
  t34 = (1U * t19);
  memcpy(t31, t30, t34);
  t7 = (t17 + 56U);
  t10 = *((char **)t7);
  t7 = (t9 + 12U);
  t8 = *((unsigned int *)t7);
  t8 = (t8 * 1U);
  t0 = xsi_get_transient_memory(t8);
  memcpy(t0, t10, t8);
  t12 = (t9 + 0U);
  t11 = *((int *)t12);
  t14 = (t9 + 4U);
  t13 = *((int *)t14);
  t16 = (t9 + 8U);
  t15 = *((int *)t16);
  t20 = (t2 + 0U);
  t21 = (t20 + 0U);
  *((int *)t21) = t11;
  t21 = (t20 + 4U);
  *((int *)t21) = t13;
  t21 = (t20 + 8U);
  *((int *)t21) = t15;
  t18 = (t13 - t11);
  t19 = (t18 * t15);
  t19 = (t19 + 1);
  t21 = (t20 + 12U);
  *((unsigned int *)t21) = t19;
LAB1:
  return t0;
LAB3:
  *((char **)t26) = t3;
  goto LAB2;
LAB4:;
}


x86 assembly (clang, -O0):
<ieee_p_3499444699_sub_420192188731145490_3536714472>:
push   %rbp
mov    %rsp,%rbp
sub    $0x1c0,%rsp
mov    %rdi,-0x10(%rbp)
mov    %rsi,-0x18(%rbp)
mov    %rdx,-0x20(%rbp)
mov    %rcx,-0x28(%rbp)
mov    -0x28(%rbp),%rax
add    $0xc,%rax
mov    %rax,-0x100(%rbp)
mov    -0x100(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x104(%rbp)
mov    -0x104(%rbp),%eax
shl    $0x0,%eax
mov    %eax,-0x104(%rbp)
mov    -0x28(%rbp),%rax
mov    %rax,-0x110(%rbp)
mov    -0x110(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x114(%rbp)
mov    -0x28(%rbp),%rax
add    $0x4,%rax
mov    %rax,-0x120(%rbp)
mov    -0x120(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x124(%rbp)
mov    -0x28(%rbp),%rax
add    $0x8,%rax
mov    %rax,-0x130(%rbp)
mov    -0x130(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x134(%rbp)
lea    -0xe0(%rbp),%rax
mov    %rax,-0x140(%rbp)
mov    -0x140(%rbp),%rax
mov    %rax,-0x148(%rbp)
mov    -0x114(%rbp),%ecx
mov    -0x148(%rbp),%rax
mov    %ecx,(%rax)
mov    -0x140(%rbp),%rax
add    $0x4,%rax
mov    %rax,-0x148(%rbp)
mov    -0x124(%rbp),%ecx
mov    -0x148(%rbp),%rax
mov    %ecx,(%rax)
mov    -0x140(%rbp),%rax
add    $0x8,%rax
mov    %rax,-0x148(%rbp)
mov    -0x134(%rbp),%ecx
mov    -0x148(%rbp),%rax
mov    %ecx,(%rax)
mov    -0x124(%rbp),%eax
sub    -0x114(%rbp),%eax
mov    %eax,-0x14c(%rbp)
mov    -0x14c(%rbp),%eax
imul   -0x134(%rbp),%eax
mov    %eax,-0x150(%rbp)
mov    -0x150(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x150(%rbp)
mov    -0x140(%rbp),%rax
add    $0xc,%rax
mov    %rax,-0x148(%rbp)
mov    -0x150(%rbp),%ecx
mov    -0x148(%rbp),%rax
mov    %ecx,(%rax)
lea    -0xb0(%rbp),%rax
add    $0x4,%rax
mov    %rax,-0x148(%rbp)
mov    -0x10(%rbp),%rax
add    $0xa90,%rax
mov    %rax,-0x158(%rbp)
mov    -0x148(%rbp),%rax
add    $0x58,%rax
mov    %rax,-0x160(%rbp)
mov    -0x158(%rbp),%rcx
mov    -0x160(%rbp),%rax
mov    %rcx,(%rax)
mov    -0x104(%rbp),%edi
call   1040 <alloca@plt>
mov    %rax,-0x168(%rbp)
mov    -0x148(%rbp),%rax
add    $0x38,%rax
mov    %rax,-0x170(%rbp)
mov    -0x168(%rbp),%rcx
mov    -0x170(%rbp),%rax
mov    %rcx,(%rax)
mov    -0x158(%rbp),%rdi
mov    -0x168(%rbp),%rsi
lea    -0xe0(%rbp),%rdx
call   1030 <xsi_type_set_default_value@plt>
mov    -0x148(%rbp),%rax
add    $0x40,%rax
mov    %rax,-0x178(%rbp)
lea    -0xe0(%rbp),%rcx
mov    -0x178(%rbp),%rax
mov    %rcx,(%rax)
mov    -0x148(%rbp),%rax
add    $0x50,%rax
mov    %rax,-0x180(%rbp)
mov    -0x104(%rbp),%ecx
mov    -0x180(%rbp),%rax
mov    %ecx,(%rax)
lea    -0xd0(%rbp),%rax
add    $0x4,%rax
mov    %rax,-0x188(%rbp)
cmpq   $0x0,-0x20(%rbp)
setne  %al
and    $0x1,%al
movzbl %al,%eax
mov    %al,-0x189(%rbp)
movzbl -0x189(%rbp),%eax
cmp    $0x1,%eax
jne    13c3 <ieee_p_3499444699_sub_420192188731145490_3536714472+0x273>
jmp    162f <ieee_p_3499444699_sub_420192188731145490_3536714472+0x4df>
jmp    13c8 <ieee_p_3499444699_sub_420192188731145490_3536714472+0x278>
lea    -0xd0(%rbp),%rax
add    $0xc,%rax
mov    %rax,-0x198(%rbp)
mov    -0x28(%rbp),%rcx
mov    -0x198(%rbp),%rax
mov    %rcx,(%rax)
mov    -0x10(%rbp),%rdi
lea    -0xf0(%rbp),%rsi
mov    -0x20(%rbp),%rcx
mov    -0x28(%rbp),%r8
xor    %edx,%edx
call   1060 <ieee_p_3499444699_sub_3760106476388108256_3536714472@plt>
mov    %rax,-0x1a0(%rbp)
mov    -0x148(%rbp),%rax
add    $0x38,%rax
mov    %rax,-0x1a8(%rbp)
mov    -0x1a8(%rbp),%rax
mov    (%rax),%rax
mov    %rax,-0x1b0(%rbp)
mov    -0x1b0(%rbp),%rax
mov    %rax,-0x1a8(%rbp)
lea    -0xf0(%rbp),%rax
add    $0xc,%rax
mov    %rax,-0x1b8(%rbp)
mov    -0x1b8(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x150(%rbp)
mov    -0x150(%rbp),%eax
shl    $0x0,%eax
mov    %eax,-0x1bc(%rbp)
mov    -0x1a8(%rbp),%rdi
mov    -0x1a0(%rbp),%rsi
mov    -0x1bc(%rbp),%edx
call   1050 <memcpy@plt>
mov    -0x148(%rbp),%rax
add    $0x38,%rax
mov    %rax,-0x100(%rbp)
mov    -0x100(%rbp),%rax
mov    (%rax),%rax
mov    %rax,-0x110(%rbp)
lea    -0xe0(%rbp),%rax
add    $0xc,%rax
mov    %rax,-0x100(%rbp)
mov    -0x100(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x104(%rbp)
mov    -0x104(%rbp),%eax
shl    $0x0,%eax
mov    %eax,-0x104(%rbp)
mov    -0x104(%rbp),%edi
call   1070 <xsi_get_transient_memory@plt>
mov    %rax,-0xf8(%rbp)
mov    -0xf8(%rbp),%rdi
mov    -0x110(%rbp),%rsi
mov    -0x104(%rbp),%edx
call   1050 <memcpy@plt>
lea    -0xe0(%rbp),%rax
mov    %rax,-0x120(%rbp)
mov    -0x120(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x114(%rbp)
lea    -0xe0(%rbp),%rax
add    $0x4,%rax
mov    %rax,-0x130(%rbp)
mov    -0x130(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x124(%rbp)
lea    -0xe0(%rbp),%rax
add    $0x8,%rax
mov    %rax,-0x140(%rbp)
mov    -0x140(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x134(%rbp)
mov    -0x18(%rbp),%rax
mov    %rax,-0x158(%rbp)
mov    -0x158(%rbp),%rax
mov    %rax,-0x160(%rbp)
mov    -0x114(%rbp),%ecx
mov    -0x160(%rbp),%rax
mov    %ecx,(%rax)
mov    -0x158(%rbp),%rax
add    $0x4,%rax
mov    %rax,-0x160(%rbp)
mov    -0x124(%rbp),%ecx
mov    -0x160(%rbp),%rax
mov    %ecx,(%rax)
mov    -0x158(%rbp),%rax
add    $0x8,%rax
mov    %rax,-0x160(%rbp)
mov    -0x134(%rbp),%ecx
mov    -0x160(%rbp),%rax
mov    %ecx,(%rax)
mov    -0x124(%rbp),%eax
sub    -0x114(%rbp),%eax
mov    %eax,-0x14c(%rbp)
mov    -0x14c(%rbp),%eax
imul   -0x134(%rbp),%eax
mov    %eax,-0x150(%rbp)
mov    -0x150(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x150(%rbp)
mov    -0x158(%rbp),%rax
add    $0xc,%rax
mov    %rax,-0x160(%rbp)
mov    -0x150(%rbp),%ecx
mov    -0x160(%rbp),%rax
mov    %ecx,(%rax)
mov    -0xf8(%rbp),%rax
mov    %rax,-0x8(%rbp)
jmp    1642 <ieee_p_3499444699_sub_420192188731145490_3536714472+0x4f2>
mov    -0x20(%rbp),%rcx
mov    -0x188(%rbp),%rax
mov    %rcx,(%rax)
jmp    13c8 <ieee_p_3499444699_sub_420192188731145490_3536714472+0x278>
mov    -0x8(%rbp),%rax
add    $0x1c0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<ieee_p_3499444699_sub_420192188731145490_3536714472>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x28,%rsp
mov    %rcx,%rbx
mov    %rdx,%r15
mov    %rsi,%r14
mov    %rdi,%r13
mov    0xc(%rcx),%edi
mov    (%rcx),%eax
mov    0x4(%rcx),%ecx
mov    0x8(%rbx),%edx
mov    %eax,(%rsp)
mov    %ecx,0x4(%rsp)
mov    %edx,0x8(%rsp)
sub    %eax,%ecx
imul   %edx,%ecx
add    $0x1,%ecx
mov    %ecx,0xc(%rsp)
lea    0xa90(%r13),%rbp
call   1040 <alloca@plt>
mov    %rax,%r12
mov    %rsp,%rdx
mov    %rbp,%rdi
mov    %rax,%rsi
call   1030 <xsi_type_set_default_value@plt>
lea    0x10(%rsp),%rsi
mov    %r13,%rdi
xor    %edx,%edx
mov    %r15,%rcx
mov    %rbx,%r8
call   1060 <ieee_p_3499444699_sub_3760106476388108256_3536714472@plt>
mov    0x1c(%rsp),%edx
mov    %r12,%rdi
mov    %rax,%rsi
call   1050 <memcpy@plt>
mov    0xc(%rsp),%ebx
mov    %ebx,%edi
call   1070 <xsi_get_transient_memory@plt>
mov    %rax,%rbp
mov    %rax,%rdi
mov    %r12,%rsi
mov    %ebx,%edx
call   1050 <memcpy@plt>
mov    (%rsp),%eax
mov    0x4(%rsp),%ecx
mov    0x8(%rsp),%edx
mov    %eax,(%r14)
mov    %ecx,0x4(%r14)
mov    %edx,0x8(%r14)
sub    %eax,%ecx
imul   %edx,%ecx
add    $0x1,%ecx
mov    %ecx,0xc(%r14)
mov    %rbp,%rax
add    $0x28,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

LLVM IR (-O2):
define i8* @ieee_p_3499444699_sub_420192188731145490_3536714472(i8* %0, i8* nocapture writeonly %1, i8* %2, i8* %3) {
%5 = alloca [16 x i8]
%6 = alloca [16 x i8]
%7 = getelementptr inbounds [16 x i8], [16 x i8]* %5, i64 0, i64 0
%8 = getelementptr inbounds [16 x i8], [16 x i8]* %6, i64 0, i64 0
%9 = getelementptr inbounds i8, i8* %3, i64 12
%10 = bitcast i8* %9 to i32*
%11 = load i32, i32* %10
%12 = bitcast i8* %3 to i32*
%13 = load i32, i32* %12
%14 = getelementptr inbounds i8, i8* %3, i64 4
%15 = bitcast i8* %14 to i32*
%16 = load i32, i32* %15
%17 = getelementptr inbounds i8, i8* %3, i64 8
%18 = bitcast i8* %17 to i32*
%19 = load i32, i32* %18
%20 = bitcast [16 x i8]* %5 to i32*
store i32 %13, i32* %20
%21 = getelementptr inbounds [16 x i8], [16 x i8]* %5, i64 0, i64 4
%22 = bitcast i8* %21 to i32*
store i32 %16, i32* %22
%23 = getelementptr inbounds [16 x i8], [16 x i8]* %5, i64 0, i64 8
%24 = bitcast i8* %23 to i32*
store i32 %19, i32* %24
%25 = sub nsw i32 %16, %13
%26 = mul nsw i32 %25, %19
%27 = add i32 %26, 1
%28 = getelementptr inbounds [16 x i8], [16 x i8]* %5, i64 0, i64 12
%29 = bitcast i8* %28 to i32*
store i32 %27, i32* %29
%30 = getelementptr inbounds i8, i8* %0, i64 2704
%31 = tail call i64 @alloca(i32 %11)
%32 = inttoptr i64 %31 to i8*
%33 = call i32 @xsi_type_set_default_value(i8* %30, i8* %32, i8* %7)
%34 = call i8* @ieee_p_3499444699_sub_3760106476388108256_3536714472(i8* %0, i8* %8, i32 0, i8* %2, i8* %3)
%35 = getelementptr inbounds [16 x i8], [16 x i8]* %6, i64 0, i64 12
%36 = bitcast i8* %35 to i32*
%37 = load i32, i32* %36
%38 = call i32 @memcpy(i8* %32, i8* %34, i32 %37)
%39 = load i32, i32* %29
%40 = call i8* @xsi_get_transient_memory(i32 %39)
%41 = call i32 @memcpy(i8* %40, i8* %32, i32 %39)
%42 = load i32, i32* %20
%43 = load i32, i32* %22
%44 = load i32, i32* %24
%45 = bitcast i8* %1 to i32*
store i32 %42, i32* %45
%46 = getelementptr inbounds i8, i8* %1, i64 4
%47 = bitcast i8* %46 to i32*
store i32 %43, i32* %47
%48 = getelementptr inbounds i8, i8* %1, i64 8
%49 = bitcast i8* %48 to i32*
store i32 %44, i32* %49
%50 = sub nsw i32 %43, %42
%51 = mul nsw i32 %50, %44
%52 = add i32 %51, 1
%53 = getelementptr inbounds i8, i8* %1, i64 12
%54 = bitcast i8* %53 to i32*
store i32 %52, i32* %54
ret i8* %40
}