#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);
char *xsi_get_transient_memory(unsigned int);
int /*<<< orphan*/ xsi_type_set_default_value(char *, char *, char *);
int /*<<< orphan*/ xsi_vhdl_check_range_of_index(int, int, int, int);
char *ieee_p_2592010699_sub_7372912886822346862_503743352(char *t1, char *t2,
                                                          char *t3, char *t4) {
  char t5[128];
  char t6[24];
  char t7[16];
  char t18[16];
  char *t0;
  char *t8;
  unsigned int t9;
  int t10;
  char *t11;
  char *t12;
  int t13;
  unsigned int t14;
  int t15;
  int t16;
  unsigned int t17;
  char *t19;
  unsigned int 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;
  int t36;
  char *t37;
  int t38;
  char *t39;
  int t40;
  int t41;
  int t42;
  int t43;
  int t44;
  char *t45;
  char *t46;
  int t47;
  char *t48;
  int t49;
  int t50;
  char *t51;
  int t52;
  unsigned int t53;
  unsigned int t54;
  char *t55;
  unsigned char t56;
  char *t57;
  char *t58;
  int t59;
  char *t60;
  int t61;
  int t62;
  unsigned int t63;
  unsigned int t64;
  unsigned int t65;
  char *t66;
LAB0:
  t8 = (t4 + 12U);
  t9 = *((unsigned int *)t8);
  t10 = (t9 - 1);
  t11 = (t7 + 0U);
  t12 = (t11 + 0U);
  *((int *)t12) = t10;
  t12 = (t11 + 4U);
  *((int *)t12) = 0;
  t12 = (t11 + 8U);
  *((int *)t12) = -1;
  t13 = (0 - t10);
  t14 = (t13 * -1);
  t14 = (t14 + 1);
  t12 = (t11 + 12U);
  *((unsigned int *)t12) = t14;
  t12 = (t4 + 12U);
  t14 = *((unsigned int *)t12);
  t15 = (t14 - 1);
  t16 = (0 - t15);
  t17 = (t16 * -1);
  t17 = (t17 + 1);
  t17 = (t17 * 1U);
  t19 = (t4 + 12U);
  t20 = *((unsigned int *)t19);
  t21 = (t20 - 1);
  t22 = (t18 + 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 = (t5 + 4U);
  t26 = (t1 + 3896);
  t27 = (t23 + 88U);
  *((char **)t27) = t26;
  t28 = (char *)alloca(t17);
  t29 = (t23 + 56U);
  *((char **)t29) = t28;
  xsi_type_set_default_value(t26, t28, t18);
  t30 = (t23 + 64U);
  *((char **)t30) = t18;
  t31 = (t23 + 80U);
  *((unsigned int *)t31) = t17;
  t32 = (t6 + 4U);
  t33 = (t3 != 0);
  if (t33 == 1)
    goto LAB3;
LAB2:
  t34 = (t6 + 12U);
  *((char **)t34) = t4;
  t35 = (t18 + 8U);
  t36 = *((int *)t35);
  t37 = (t18 + 4U);
  t38 = *((int *)t37);
  t39 = (t18 + 0U);
  t40 = *((int *)t39);
  t41 = t40;
  t42 = t38;
LAB4:
  t43 = (t42 * t36);
  t44 = (t41 * t36);
  if (t44 <= t43)
    goto LAB5;
LAB7:
  t8 = (t23 + 56U);
  t11 = *((char **)t8);
  t8 = (t18 + 12U);
  t9 = *((unsigned int *)t8);
  t9 = (t9 * 1U);
  t0 = xsi_get_transient_memory(t9);
  memcpy(t0, t11, t9);
  t12 = (t18 + 0U);
  t10 = *((int *)t12);
  t19 = (t18 + 4U);
  t13 = *((int *)t19);
  t22 = (t18 + 8U);
  t15 = *((int *)t22);
  t26 = (t2 + 0U);
  t27 = (t26 + 0U);
  *((int *)t27) = t10;
  t27 = (t26 + 4U);
  *((int *)t27) = t13;
  t27 = (t26 + 8U);
  *((int *)t27) = t15;
  t16 = (t13 - t10);
  t14 = (t16 * t15);
  t14 = (t14 + 1);
  t27 = (t26 + 12U);
  *((unsigned int *)t27) = t14;
LAB1:
  return t0;
LAB3:
  *((char **)t32) = t3;
  goto LAB2;
LAB5:
  t45 = (t3 + 0);
  t46 = (t7 + 0U);
  t47 = *((int *)t46);
  t48 = (t7 + 8U);
  t49 = *((int *)t48);
  t50 = (t41 - t47);
  t25 = (t50 * t49);
  t51 = (t7 + 4U);
  t52 = *((int *)t51);
  xsi_vhdl_check_range_of_index(t47, t52, t49, t41);
  t53 = (1U * t25);
  t54 = (0 + t53);
  t55 = (t45 + t54);
  t56 = *((unsigned char *)t55);
  t57 = (t23 + 56U);
  t58 = *((char **)t57);
  t57 = (t18 + 0U);
  t59 = *((int *)t57);
  t60 = (t18 + 8U);
  t61 = *((int *)t60);
  t62 = (t41 - t59);
  t63 = (t62 * t61);
  t64 = (1U * t63);
  t65 = (0 + t64);
  t66 = (t58 + t65);
  *((unsigned char *)t66) = t56;
LAB6:
  if (t41 == t42)
    goto LAB7;
LAB8:
  t10 = (t41 + t36);
  t41 = t10;
  goto LAB4;
LAB9:;
}


x86 assembly (clang, -O0):
<ieee_p_2592010699_sub_7372912886822346862_503743352>:
push   %rbp
mov    %rsp,%rbp
sub    $0x270,%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
sub    $0x1,%eax
mov    %eax,-0x108(%rbp)
lea    -0xe0(%rbp),%rax
mov    %rax,-0x110(%rbp)
mov    -0x110(%rbp),%rax
mov    %rax,-0x118(%rbp)
mov    -0x108(%rbp),%ecx
mov    -0x118(%rbp),%rax
mov    %ecx,(%rax)
mov    -0x110(%rbp),%rax
add    $0x4,%rax
mov    %rax,-0x118(%rbp)
mov    -0x118(%rbp),%rax
movl   $0x0,(%rax)
mov    -0x110(%rbp),%rax
add    $0x8,%rax
mov    %rax,-0x118(%rbp)
mov    -0x118(%rbp),%rax
movl   $0xffffffff,(%rax)
xor    %eax,%eax
sub    -0x108(%rbp),%eax
mov    %eax,-0x11c(%rbp)
imul   $0xffffffff,-0x11c(%rbp),%eax
mov    %eax,-0x120(%rbp)
mov    -0x120(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x120(%rbp)
mov    -0x110(%rbp),%rax
add    $0xc,%rax
mov    %rax,-0x118(%rbp)
mov    -0x120(%rbp),%ecx
mov    -0x118(%rbp),%rax
mov    %ecx,(%rax)
mov    -0x28(%rbp),%rax
add    $0xc,%rax
mov    %rax,-0x118(%rbp)
mov    -0x118(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x120(%rbp)
mov    -0x120(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x124(%rbp)
xor    %eax,%eax
sub    -0x124(%rbp),%eax
mov    %eax,-0x128(%rbp)
imul   $0xffffffff,-0x128(%rbp),%eax
mov    %eax,-0x12c(%rbp)
mov    -0x12c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x12c(%rbp)
mov    -0x12c(%rbp),%eax
shl    $0x0,%eax
mov    %eax,-0x12c(%rbp)
mov    -0x28(%rbp),%rax
add    $0xc,%rax
mov    %rax,-0x138(%rbp)
mov    -0x138(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x13c(%rbp)
mov    -0x13c(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x140(%rbp)
lea    -0xf0(%rbp),%rax
mov    %rax,-0x148(%rbp)
mov    -0x148(%rbp),%rax
mov    %rax,-0x150(%rbp)
mov    -0x140(%rbp),%ecx
mov    -0x150(%rbp),%rax
mov    %ecx,(%rax)
mov    -0x148(%rbp),%rax
add    $0x4,%rax
mov    %rax,-0x150(%rbp)
mov    -0x150(%rbp),%rax
movl   $0x0,(%rax)
mov    -0x148(%rbp),%rax
add    $0x8,%rax
mov    %rax,-0x150(%rbp)
mov    -0x150(%rbp),%rax
movl   $0xffffffff,(%rax)
xor    %eax,%eax
sub    -0x140(%rbp),%eax
mov    %eax,-0x154(%rbp)
imul   $0xffffffff,-0x154(%rbp),%eax
mov    %eax,-0x158(%rbp)
mov    -0x158(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x158(%rbp)
mov    -0x148(%rbp),%rax
add    $0xc,%rax
mov    %rax,-0x150(%rbp)
mov    -0x158(%rbp),%ecx
mov    -0x150(%rbp),%rax
mov    %ecx,(%rax)
lea    -0xb0(%rbp),%rax
add    $0x4,%rax
mov    %rax,-0x150(%rbp)
mov    -0x10(%rbp),%rax
add    $0xf38,%rax
mov    %rax,-0x160(%rbp)
mov    -0x150(%rbp),%rax
add    $0x58,%rax
mov    %rax,-0x168(%rbp)
mov    -0x160(%rbp),%rcx
mov    -0x168(%rbp),%rax
mov    %rcx,(%rax)
mov    -0x12c(%rbp),%edi
call   1040 <alloca@plt>
mov    %rax,-0x170(%rbp)
mov    -0x150(%rbp),%rax
add    $0x38,%rax
mov    %rax,-0x178(%rbp)
mov    -0x170(%rbp),%rcx
mov    -0x178(%rbp),%rax
mov    %rcx,(%rax)
mov    -0x160(%rbp),%rdi
mov    -0x170(%rbp),%rsi
lea    -0xf0(%rbp),%rdx
call   1030 <xsi_type_set_default_value@plt>
mov    -0x150(%rbp),%rax
add    $0x40,%rax
mov    %rax,-0x180(%rbp)
lea    -0xf0(%rbp),%rcx
mov    -0x180(%rbp),%rax
mov    %rcx,(%rax)
mov    -0x150(%rbp),%rax
add    $0x50,%rax
mov    %rax,-0x188(%rbp)
mov    -0x12c(%rbp),%ecx
mov    -0x188(%rbp),%rax
mov    %ecx,(%rax)
lea    -0xd0(%rbp),%rax
add    $0x4,%rax
mov    %rax,-0x190(%rbp)
cmpq   $0x0,-0x20(%rbp)
setne  %al
and    $0x1,%al
movzbl %al,%eax
mov    %al,-0x191(%rbp)
movzbl -0x191(%rbp),%eax
cmp    $0x1,%eax
jne    14a6 <ieee_p_2592010699_sub_7372912886822346862_503743352+0x356>
jmp    1730 <ieee_p_2592010699_sub_7372912886822346862_503743352+0x5e0>
jmp    14ab <ieee_p_2592010699_sub_7372912886822346862_503743352+0x35b>
lea    -0xd0(%rbp),%rax
add    $0xc,%rax
mov    %rax,-0x1a0(%rbp)
mov    -0x28(%rbp),%rcx
mov    -0x1a0(%rbp),%rax
mov    %rcx,(%rax)
lea    -0xf0(%rbp),%rax
add    $0x8,%rax
mov    %rax,-0x1a8(%rbp)
mov    -0x1a8(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x1ac(%rbp)
lea    -0xf0(%rbp),%rax
add    $0x4,%rax
mov    %rax,-0x1b8(%rbp)
mov    -0x1b8(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x1bc(%rbp)
lea    -0xf0(%rbp),%rax
mov    %rax,-0x1c8(%rbp)
mov    -0x1c8(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x1cc(%rbp)
mov    -0x1cc(%rbp),%eax
mov    %eax,-0x1d0(%rbp)
mov    -0x1bc(%rbp),%eax
mov    %eax,-0x1d4(%rbp)
mov    -0x1d4(%rbp),%eax
imul   -0x1ac(%rbp),%eax
mov    %eax,-0x1d8(%rbp)
mov    -0x1d0(%rbp),%eax
imul   -0x1ac(%rbp),%eax
mov    %eax,-0x1dc(%rbp)
mov    -0x1dc(%rbp),%eax
cmp    -0x1d8(%rbp),%eax
jg     157f <ieee_p_2592010699_sub_7372912886822346862_503743352+0x42f>
jmp    1743 <ieee_p_2592010699_sub_7372912886822346862_503743352+0x5f3>
jmp    1584 <ieee_p_2592010699_sub_7372912886822346862_503743352+0x434>
mov    -0x150(%rbp),%rax
add    $0x38,%rax
mov    %rax,-0x100(%rbp)
mov    -0x100(%rbp),%rax
mov    (%rax),%rax
mov    %rax,-0x110(%rbp)
lea    -0xf0(%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    -0xf0(%rbp),%rax
mov    %rax,-0x118(%rbp)
mov    -0x118(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x108(%rbp)
lea    -0xf0(%rbp),%rax
add    $0x4,%rax
mov    %rax,-0x138(%rbp)
mov    -0x138(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x11c(%rbp)
lea    -0xf0(%rbp),%rax
add    $0x8,%rax
mov    %rax,-0x148(%rbp)
mov    -0x148(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x124(%rbp)
mov    -0x18(%rbp),%rax
mov    %rax,-0x160(%rbp)
mov    -0x160(%rbp),%rax
mov    %rax,-0x168(%rbp)
mov    -0x108(%rbp),%ecx
mov    -0x168(%rbp),%rax
mov    %ecx,(%rax)
mov    -0x160(%rbp),%rax
add    $0x4,%rax
mov    %rax,-0x168(%rbp)
mov    -0x11c(%rbp),%ecx
mov    -0x168(%rbp),%rax
mov    %ecx,(%rax)
mov    -0x160(%rbp),%rax
add    $0x8,%rax
mov    %rax,-0x168(%rbp)
mov    -0x124(%rbp),%ecx
mov    -0x168(%rbp),%rax
mov    %ecx,(%rax)
mov    -0x11c(%rbp),%eax
sub    -0x108(%rbp),%eax
mov    %eax,-0x128(%rbp)
mov    -0x128(%rbp),%eax
imul   -0x124(%rbp),%eax
mov    %eax,-0x120(%rbp)
mov    -0x120(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x120(%rbp)
mov    -0x160(%rbp),%rax
add    $0xc,%rax
mov    %rax,-0x168(%rbp)
mov    -0x120(%rbp),%ecx
mov    -0x168(%rbp),%rax
mov    %ecx,(%rax)
mov    -0xf8(%rbp),%rax
mov    %rax,-0x8(%rbp)
jmp    193c <ieee_p_2592010699_sub_7372912886822346862_503743352+0x7ec>
mov    -0x20(%rbp),%rcx
mov    -0x190(%rbp),%rax
mov    %rcx,(%rax)
jmp    14ab <ieee_p_2592010699_sub_7372912886822346862_503743352+0x35b>
mov    -0x20(%rbp),%rax
mov    %rax,-0x1e8(%rbp)
lea    -0xe0(%rbp),%rax
mov    %rax,-0x1f0(%rbp)
mov    -0x1f0(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x1f4(%rbp)
lea    -0xe0(%rbp),%rax
add    $0x8,%rax
mov    %rax,-0x200(%rbp)
mov    -0x200(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x204(%rbp)
mov    -0x1d0(%rbp),%eax
sub    -0x1f4(%rbp),%eax
mov    %eax,-0x208(%rbp)
mov    -0x208(%rbp),%eax
imul   -0x204(%rbp),%eax
mov    %eax,-0x158(%rbp)
lea    -0xe0(%rbp),%rax
add    $0x4,%rax
mov    %rax,-0x210(%rbp)
mov    -0x210(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x214(%rbp)
mov    -0x1f4(%rbp),%edi
mov    -0x214(%rbp),%esi
mov    -0x204(%rbp),%edx
mov    -0x1d0(%rbp),%ecx
call   1060 <xsi_vhdl_check_range_of_index@plt>
mov    -0x158(%rbp),%eax
shl    $0x0,%eax
mov    %eax,-0x218(%rbp)
mov    -0x218(%rbp),%eax
add    $0x0,%eax
mov    %eax,-0x21c(%rbp)
mov    -0x1e8(%rbp),%rax
mov    -0x21c(%rbp),%ecx
add    %rcx,%rax
mov    %rax,-0x228(%rbp)
mov    -0x228(%rbp),%rax
mov    (%rax),%al
mov    %al,-0x229(%rbp)
mov    -0x150(%rbp),%rax
add    $0x38,%rax
mov    %rax,-0x238(%rbp)
mov    -0x238(%rbp),%rax
mov    (%rax),%rax
mov    %rax,-0x240(%rbp)
lea    -0xf0(%rbp),%rax
mov    %rax,-0x238(%rbp)
mov    -0x238(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x244(%rbp)
lea    -0xf0(%rbp),%rax
add    $0x8,%rax
mov    %rax,-0x250(%rbp)
mov    -0x250(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x254(%rbp)
mov    -0x1d0(%rbp),%eax
sub    -0x244(%rbp),%eax
mov    %eax,-0x258(%rbp)
mov    -0x258(%rbp),%eax
imul   -0x254(%rbp),%eax
mov    %eax,-0x25c(%rbp)
mov    -0x25c(%rbp),%eax
shl    $0x0,%eax
mov    %eax,-0x260(%rbp)
mov    -0x260(%rbp),%eax
add    $0x0,%eax
mov    %eax,-0x264(%rbp)
mov    -0x240(%rbp),%rax
mov    -0x264(%rbp),%ecx
add    %rcx,%rax
mov    %rax,-0x270(%rbp)
mov    -0x229(%rbp),%cl
mov    -0x270(%rbp),%rax
mov    %cl,(%rax)
mov    -0x1d0(%rbp),%eax
cmp    -0x1d4(%rbp),%eax
jne    1914 <ieee_p_2592010699_sub_7372912886822346862_503743352+0x7c4>
jmp    1584 <ieee_p_2592010699_sub_7372912886822346862_503743352+0x434>
jmp    1919 <ieee_p_2592010699_sub_7372912886822346862_503743352+0x7c9>
mov    -0x1d0(%rbp),%eax
add    -0x1ac(%rbp),%eax
mov    %eax,-0x108(%rbp)
mov    -0x108(%rbp),%eax
mov    %eax,-0x1d0(%rbp)
jmp    1542 <ieee_p_2592010699_sub_7372912886822346862_503743352+0x3f2>
mov    -0x8(%rbp),%rax
add    $0x270,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<ieee_p_2592010699_sub_7372912886822346862_503743352>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x38,%rsp
mov    %rdx,0x30(%rsp)
mov    %rsi,0x28(%rsp)
mov    %rdi,%rbp
mov    0xc(%rcx),%ebx
lea    -0x1(%rbx),%eax
mov    %eax,0x1c(%rsp)
mov    %eax,(%rsp)
movabs $0xffffffff00000000,%rax
ff ff ff
mov    %rax,0x4(%rsp)
mov    %ebx,0xc(%rsp)
add    $0xf38,%rbp
mov    %ebx,%edi
call   1040 <alloca@plt>
mov    %rsp,%rdx
mov    %rbp,%rdi
mov    %rax,0x20(%rsp)
mov    %rax,%rsi
call   1030 <xsi_type_set_default_value@plt>
mov    0x8(%rsp),%r14d
mov    (%rsp),%ebp
mov    0x4(%rsp),%r13d
mov    %r13d,0x18(%rsp)
imul   %r14d,%r13d
mov    %ebp,%eax
imul   %r14d,%eax
cmp    %r13d,%eax
jg     1238 <ieee_p_2592010699_sub_7372912886822346862_503743352+0xe8>
lea    (%r14,%rbp,1),%r12d
imul   %r14d,%r12d
mov    %rbx,%rax
mov    %r14d,%ebx
imul   %ebx,%ebx
mov    %ebp,%r15d
not    %r15d
add    %eax,%r15d
nopw   0x0(%rax,%rax,1)
mov    0x1c(%rsp),%edi
xor    %esi,%esi
mov    $0xffffffff,%edx
mov    %ebp,%ecx
call   1060 <xsi_vhdl_check_range_of_index@plt>
mov    %r15d,%eax
mov    0x30(%rsp),%rcx
movzbl (%rcx,%rax,1),%eax
mov    %ebp,%ecx
sub    (%rsp),%ecx
imul   0x8(%rsp),%ecx
mov    0x20(%rsp),%rdx
mov    %al,(%rdx,%rcx,1)
cmp    %ebp,0x18(%rsp)
je     1238 <ieee_p_2592010699_sub_7372912886822346862_503743352+0xe8>
add    %r14d,%ebp
lea    (%r12,%rbx,1),%eax
sub    %r14d,%r15d
cmp    %r13d,%r12d
mov    %eax,%r12d
jle    11f0 <ieee_p_2592010699_sub_7372912886822346862_503743352+0xa0>
mov    0xc(%rsp),%ebp
mov    %ebp,%edi
call   1070 <xsi_get_transient_memory@plt>
mov    %rax,%r15
mov    %rax,%rdi
mov    0x20(%rsp),%rsi
mov    %ebp,%edx
call   1050 <memcpy@plt>
mov    (%rsp),%eax
mov    0x4(%rsp),%ecx
mov    0x8(%rsp),%edx
mov    0x28(%rsp),%rsi
mov    %eax,(%rsi)
mov    %ecx,0x4(%rsi)
mov    %edx,0x8(%rsi)
sub    %eax,%ecx
imul   %edx,%ecx
add    $0x1,%ecx
mov    %ecx,0xc(%rsi)
mov    %r15,%rax
add    $0x38,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
define i8* @ieee_p_2592010699_sub_7372912886822346862_503743352(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 i32
%18 = alloca i8*
%19 = alloca i8*
%20 = alloca i32
%21 = alloca i32
%22 = alloca i32
%23 = alloca i32
%24 = alloca i32
%25 = alloca i8*
%26 = alloca i32
%27 = alloca i32
%28 = alloca i8*
%29 = alloca i8*
%30 = alloca i32
%31 = alloca i32
%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 i8*
%41 = alloca i8*
%42 = alloca i32
%43 = alloca i8*
%44 = alloca i32
%45 = alloca i8*
%46 = alloca i32
%47 = alloca i32
%48 = alloca i32
%49 = alloca i32
%50 = alloca i32
%51 = alloca i8*
%52 = alloca i8*
%53 = alloca i32
%54 = alloca i8*
%55 = alloca i32
%56 = alloca i32
%57 = alloca i8*
%58 = alloca i32
%59 = alloca i32
%60 = alloca i32
%61 = alloca i8*
%62 = alloca i8
%63 = alloca i8*
%64 = alloca i8*
%65 = alloca i32
%66 = alloca i8*
%67 = alloca i32
%68 = alloca i32
%69 = alloca i32
%70 = alloca i32
%71 = alloca i32
%72 = alloca i8*
store i8* %0, i8** %6
store i8* %1, i8** %7
store i8* %2, i8** %8
store i8* %3, i8** %9
br label %73
73: ; preds = %4
%74 = load i8*, i8** %9
%75 = getelementptr inbounds i8, i8* %74, i64 12
store i8* %75, i8** %15
%76 = load i8*, i8** %15
%77 = bitcast i8* %76 to i32*
%78 = load i32, i32* %77
store i32 %78, i32* %16
%79 = load i32, i32* %16
%80 = sub i32 %79, 1
store i32 %80, i32* %17
%81 = getelementptr inbounds [16 x i8], [16 x i8]* %12, i64 0, i64 0
%82 = getelementptr inbounds i8, i8* %81, i64 0
store i8* %82, i8** %18
%83 = load i8*, i8** %18
%84 = getelementptr inbounds i8, i8* %83, i64 0
store i8* %84, i8** %19
%85 = load i32, i32* %17
%86 = load i8*, i8** %19
%87 = bitcast i8* %86 to i32*
store i32 %85, i32* %87
%88 = load i8*, i8** %18
%89 = getelementptr inbounds i8, i8* %88, i64 4
store i8* %89, i8** %19
%90 = load i8*, i8** %19
%91 = bitcast i8* %90 to i32*
store i32 0, i32* %91
%92 = load i8*, i8** %18
%93 = getelementptr inbounds i8, i8* %92, i64 8
store i8* %93, i8** %19
%94 = load i8*, i8** %19
%95 = bitcast i8* %94 to i32*
store i32 -1, i32* %95
%96 = load i32, i32* %17
%97 = sub nsw i32 0, %96
store i32 %97, i32* %20
%98 = load i32, i32* %20
%99 = mul nsw i32 %98, -1
store i32 %99, i32* %21
%100 = load i32, i32* %21
%101 = add i32 %100, 1
store i32 %101, i32* %21
%102 = load i8*, i8** %18
%103 = getelementptr inbounds i8, i8* %102, i64 12
store i8* %103, i8** %19
%104 = load i32, i32* %21
%105 = load i8*, i8** %19
%106 = bitcast i8* %105 to i32*
store i32 %104, i32* %106
%107 = load i8*, i8** %9
%108 = getelementptr inbounds i8, i8* %107, i64 12
store i8* %108, i8** %19
%109 = load i8*, i8** %19
%110 = bitcast i8* %109 to i32*
%111 = load i32, i32* %110
store i32 %111, i32* %21
%112 = load i32, i32* %21
%113 = sub i32 %112, 1
store i32 %113, i32* %22
%114 = load i32, i32* %22
%115 = sub nsw i32 0, %114
store i32 %115, i32* %23
%116 = load i32, i32* %23
%117 = mul nsw i32 %116, -1
store i32 %117, i32* %24
%118 = load i32, i32* %24
%119 = add i32 %118, 1
store i32 %119, i32* %24
%120 = load i32, i32* %24
%121 = mul i32 %120, 1
store i32 %121, i32* %24
%122 = load i8*, i8** %9
%123 = getelementptr inbounds i8, i8* %122, i64 12
store i8* %123, i8** %25
%124 = load i8*, i8** %25
%125 = bitcast i8* %124 to i32*
%126 = load i32, i32* %125
store i32 %126, i32* %26
%127 = load i32, i32* %26
%128 = sub i32 %127, 1
store i32 %128, i32* %27
%129 = getelementptr inbounds [16 x i8], [16 x i8]* %13, i64 0, i64 0
%130 = getelementptr inbounds i8, i8* %129, i64 0
store i8* %130, i8** %28
%131 = load i8*, i8** %28
%132 = getelementptr inbounds i8, i8* %131, i64 0
store i8* %132, i8** %29
%133 = load i32, i32* %27
%134 = load i8*, i8** %29
%135 = bitcast i8* %134 to i32*
store i32 %133, i32* %135
%136 = load i8*, i8** %28
%137 = getelementptr inbounds i8, i8* %136, i64 4
store i8* %137, i8** %29
%138 = load i8*, i8** %29
%139 = bitcast i8* %138 to i32*
store i32 0, i32* %139
%140 = load i8*, i8** %28
%141 = getelementptr inbounds i8, i8* %140, i64 8
store i8* %141, i8** %29
%142 = load i8*, i8** %29
%143 = bitcast i8* %142 to i32*
store i32 -1, i32* %143
%144 = load i32, i32* %27
%145 = sub nsw i32 0, %144
store i32 %145, i32* %30
%146 = load i32, i32* %30
%147 = mul nsw i32 %146, -1
store i32 %147, i32* %31
%148 = load i32, i32* %31
%149 = add i32 %148, 1
store i32 %149, i32* %31
%150 = load i8*, i8** %28
%151 = getelementptr inbounds i8, i8* %150, i64 12
store i8* %151, i8** %29
%152 = load i32, i32* %31
%153 = load i8*, i8** %29
%154 = bitcast i8* %153 to i32*
store i32 %152, i32* %154
%155 = getelementptr inbounds [128 x i8], [128 x i8]* %10, i64 0, i64 0
%156 = getelementptr inbounds i8, i8* %155, i64 4
store i8* %156, i8** %29
%157 = load i8*, i8** %6
%158 = getelementptr inbounds i8, i8* %157, i64 3896
store i8* %158, i8** %32
%159 = load i8*, i8** %29
%160 = getelementptr inbounds i8, i8* %159, i64 88
store i8* %160, i8** %33
%161 = load i8*, i8** %32
%162 = load i8*, i8** %33
%163 = bitcast i8* %162 to i8**
store i8* %161, i8** %163
%164 = load i32, i32* %24
%165 = call i64 @alloca(i32 %164)
%166 = inttoptr i64 %165 to i8*
store i8* %166, i8** %34
%167 = load i8*, i8** %29
%168 = getelementptr inbounds i8, i8* %167, i64 56
store i8* %168, i8** %35
%169 = load i8*, i8** %34
%170 = load i8*, i8** %35
%171 = bitcast i8* %170 to i8**
store i8* %169, i8** %171
%172 = load i8*, i8** %32
%173 = load i8*, i8** %34
%174 = getelementptr inbounds [16 x i8], [16 x i8]* %13, i64 0, i64 0
%175 = call i32 @xsi_type_set_default_value(i8* %172, i8* %173, i8* %174)
%176 = load i8*, i8** %29
%177 = getelementptr inbounds i8, i8* %176, i64 64
store i8* %177, i8** %36
%178 = getelementptr inbounds [16 x i8], [16 x i8]* %13, i64 0, i64 0
%179 = load i8*, i8** %36
%180 = bitcast i8* %179 to i8**
store i8* %178, i8** %180
%181 = load i8*, i8** %29
%182 = getelementptr inbounds i8, i8* %181, i64 80
store i8* %182, i8** %37
%183 = load i32, i32* %24
%184 = load i8*, i8** %37
%185 = bitcast i8* %184 to i32*
store i32 %183, i32* %185
%186 = getelementptr inbounds [24 x i8], [24 x i8]* %11, i64 0, i64 0
%187 = getelementptr inbounds i8, i8* %186, i64 4
store i8* %187, i8** %38
%188 = load i8*, i8** %8
%189 = icmp ne i8* %188, null
%190 = zext i1 %189 to i32
%191 = trunc i32 %190 to i8
store i8 %191, i8* %39
%192 = load i8, i8* %39
%193 = zext i8 %192 to i32
%194 = icmp eq i32 %193, 1
br i1 %194, label %195, label %196
195: ; preds = %73
br label %298
196: ; preds = %73
br label %197
197: ; preds = %298, %196
%198 = getelementptr inbounds [24 x i8], [24 x i8]* %11, i64 0, i64 0
%199 = getelementptr inbounds i8, i8* %198, i64 12
store i8* %199, i8** %40
%200 = load i8*, i8** %9
%201 = load i8*, i8** %40
%202 = bitcast i8* %201 to i8**
store i8* %200, i8** %202
%203 = getelementptr inbounds [16 x i8], [16 x i8]* %13, i64 0, i64 0
%204 = getelementptr inbounds i8, i8* %203, i64 8
store i8* %204, i8** %41
%205 = load i8*, i8** %41
%206 = bitcast i8* %205 to i32*
%207 = load i32, i32* %206
store i32 %207, i32* %42
%208 = getelementptr inbounds [16 x i8], [16 x i8]* %13, i64 0, i64 0
%209 = getelementptr inbounds i8, i8* %208, i64 4
store i8* %209, i8** %43
%210 = load i8*, i8** %43
%211 = bitcast i8* %210 to i32*
%212 = load i32, i32* %211
store i32 %212, i32* %44
%213 = getelementptr inbounds [16 x i8], [16 x i8]* %13, i64 0, i64 0
%214 = getelementptr inbounds i8, i8* %213, i64 0
store i8* %214, i8** %45
%215 = load i8*, i8** %45
%216 = bitcast i8* %215 to i32*
%217 = load i32, i32* %216
store i32 %217, i32* %46
%218 = load i32, i32* %46
store i32 %218, i32* %47
%219 = load i32, i32* %44
store i32 %219, i32* %48
br label %220
220: ; preds = %378, %197
%221 = load i32, i32* %48
%222 = load i32, i32* %42
%223 = mul nsw i32 %221, %222
store i32 %223, i32* %49
%224 = load i32, i32* %47
%225 = load i32, i32* %42
%226 = mul nsw i32 %224, %225
store i32 %226, i32* %50
%227 = load i32, i32* %50
%228 = load i32, i32* %49
%229 = icmp sle i32 %227, %228
br i1 %229, label %230, label %231
230: ; preds = %220
br label %302
231: ; preds = %220
br label %232
232: ; preds = %376, %231
%233 = load i8*, i8** %29
%234 = getelementptr inbounds i8, i8* %233, i64 56
store i8* %234, i8** %15
%235 = load i8*, i8** %15
%236 = bitcast i8* %235 to i8**
%237 = load i8*, i8** %236
store i8* %237, i8** %18
%238 = getelementptr inbounds [16 x i8], [16 x i8]* %13, i64 0, i64 0
%239 = getelementptr inbounds i8, i8* %238, i64 12
store i8* %239, i8** %15
%240 = load i8*, i8** %15
%241 = bitcast i8* %240 to i32*
%242 = load i32, i32* %241
store i32 %242, i32* %16
%243 = load i32, i32* %16
%244 = mul i32 %243, 1
store i32 %244, i32* %16
%245 = load i32, i32* %16
%246 = call i8* @xsi_get_transient_memory(i32 %245)
store i8* %246, i8** %14
%247 = load i8*, i8** %14
%248 = load i8*, i8** %18
%249 = load i32, i32* %16
%250 = call i32 @memcpy(i8* %247, i8* %248, i32 %249)
%251 = getelementptr inbounds [16 x i8], [16 x i8]* %13, i64 0, i64 0
%252 = getelementptr inbounds i8, i8* %251, i64 0
store i8* %252, i8** %19
%253 = load i8*, i8** %19
%254 = bitcast i8* %253 to i32*
%255 = load i32, i32* %254
store i32 %255, i32* %17
%256 = getelementptr inbounds [16 x i8], [16 x i8]* %13, i64 0, i64 0
%257 = getelementptr inbounds i8, i8* %256, i64 4
store i8* %257, i8** %25
%258 = load i8*, i8** %25
%259 = bitcast i8* %258 to i32*
%260 = load i32, i32* %259
store i32 %260, i32* %20
%261 = getelementptr inbounds [16 x i8], [16 x i8]* %13, i64 0, i64 0
%262 = getelementptr inbounds i8, i8* %261, i64 8
store i8* %262, i8** %28
%263 = load i8*, i8** %28
%264 = bitcast i8* %263 to i32*
%265 = load i32, i32* %264
store i32 %265, i32* %22
%266 = load i8*, i8** %7
%267 = getelementptr inbounds i8, i8* %266, i64 0
store i8* %267, i8** %32
%268 = load i8*, i8** %32
%269 = getelementptr inbounds i8, i8* %268, i64 0
store i8* %269, i8** %33
%270 = load i32, i32* %17
%271 = load i8*, i8** %33
%272 = bitcast i8* %271 to i32*
store i32 %270, i32* %272
%273 = load i8*, i8** %32
%274 = getelementptr inbounds i8, i8* %273, i64 4
store i8* %274, i8** %33
%275 = load i32, i32* %20
%276 = load i8*, i8** %33
%277 = bitcast i8* %276 to i32*
store i32 %275, i32* %277
%278 = load i8*, i8** %32
%279 = getelementptr inbounds i8, i8* %278, i64 8
store i8* %279, i8** %33
%280 = load i32, i32* %22
%281 = load i8*, i8** %33
%282 = bitcast i8* %281 to i32*
store i32 %280, i32* %282
%283 = load i32, i32* %20
%284 = load i32, i32* %17
%285 = sub nsw i32 %283, %284
store i32 %285, i32* %23
%286 = load i32, i32* %23
%287 = load i32, i32* %22
%288 = mul nsw i32 %286, %287
store i32 %288, i32* %21
%289 = load i32, i32* %21
%290 = add i32 %289, 1
store i32 %290, i32* %21
%291 = load i8*, i8** %32
%292 = getelementptr inbounds i8, i8* %291, i64 12
store i8* %292, i8** %33
%293 = load i32, i32* %21
%294 = load i8*, i8** %33
%295 = bitcast i8* %294 to i32*
store i32 %293, i32* %295
br label %296
296: ; preds = %232
%297 = load i8*, i8** %14
store i8* %297, i8** %5
br label %384
298: ; preds = %195
%299 = load i8*, i8** %8
%300 = load i8*, i8** %38
%301 = bitcast i8* %300 to i8**
store i8* %299, i8** %301
br label %197
302: ; preds = %230
%303 = load i8*, i8** %8
%304 = getelementptr inbounds i8, i8* %303, i64 0
store i8* %304, i8** %51
%305 = getelementptr inbounds [16 x i8], [16 x i8]* %12, i64 0, i64 0
%306 = getelementptr inbounds i8, i8* %305, i64 0
store i8* %306, i8** %52
%307 = load i8*, i8** %52
%308 = bitcast i8* %307 to i32*
%309 = load i32, i32* %308
store i32 %309, i32* %53
%310 = getelementptr inbounds [16 x i8], [16 x i8]* %12, i64 0, i64 0
%311 = getelementptr inbounds i8, i8* %310, i64 8
store i8* %311, i8** %54
%312 = load i8*, i8** %54
%313 = bitcast i8* %312 to i32*
%314 = load i32, i32* %313
store i32 %314, i32* %55
%315 = load i32, i32* %47
%316 = load i32, i32* %53
%317 = sub nsw i32 %315, %316
store i32 %317, i32* %56
%318 = load i32, i32* %56
%319 = load i32, i32* %55
%320 = mul nsw i32 %318, %319
store i32 %320, i32* %31
%321 = getelementptr inbounds [16 x i8], [16 x i8]* %12, i64 0, i64 0
%322 = getelementptr inbounds i8, i8* %321, i64 4
store i8* %322, i8** %57
%323 = load i8*, i8** %57
%324 = bitcast i8* %323 to i32*
%325 = load i32, i32* %324
store i32 %325, i32* %58
%326 = load i32, i32* %53
%327 = load i32, i32* %58
%328 = load i32, i32* %55
%329 = load i32, i32* %47
%330 = call i32 @xsi_vhdl_check_range_of_index(i32 %326, i32 %327, i32 %328, i32 %329)
%331 = load i32, i32* %31
%332 = mul i32 1, %331
store i32 %332, i32* %59
%333 = load i32, i32* %59
%334 = add i32 0, %333
store i32 %334, i32* %60
%335 = load i8*, i8** %51
%336 = load i32, i32* %60
%337 = zext i32 %336 to i64
%338 = getelementptr inbounds i8, i8* %335, i64 %337
store i8* %338, i8** %61
%339 = load i8*, i8** %61
%340 = load i8, i8* %339
store i8 %340, i8* %62
%341 = load i8*, i8** %29
%342 = getelementptr inbounds i8, i8* %341, i64 56
store i8* %342, i8** %63
%343 = load i8*, i8** %63
%344 = bitcast i8* %343 to i8**
%345 = load i8*, i8** %344
store i8* %345, i8** %64
%346 = getelementptr inbounds [16 x i8], [16 x i8]* %13, i64 0, i64 0
%347 = getelementptr inbounds i8, i8* %346, i64 0
store i8* %347, i8** %63
%348 = load i8*, i8** %63
%349 = bitcast i8* %348 to i32*
%350 = load i32, i32* %349
store i32 %350, i32* %65
%351 = getelementptr inbounds [16 x i8], [16 x i8]* %13, i64 0, i64 0
%352 = getelementptr inbounds i8, i8* %351, i64 8
store i8* %352, i8** %66
%353 = load i8*, i8** %66
%354 = bitcast i8* %353 to i32*
%355 = load i32, i32* %354
store i32 %355, i32* %67
%356 = load i32, i32* %47
%357 = load i32, i32* %65
%358 = sub nsw i32 %356, %357
store i32 %358, i32* %68
%359 = load i32, i32* %68
%360 = load i32, i32* %67
%361 = mul nsw i32 %359, %360
store i32 %361, i32* %69
%362 = load i32, i32* %69
%363 = mul i32 1, %362
store i32 %363, i32* %70
%364 = load i32, i32* %70
%365 = add i32 0, %364
store i32 %365, i32* %71
%366 = load i8*, i8** %64
%367 = load i32, i32* %71
%368 = zext i32 %367 to i64
%369 = getelementptr inbounds i8, i8* %366, i64 %368
store i8* %369, i8** %72
%370 = load i8, i8* %62
%371 = load i8*, i8** %72
store i8 %370, i8* %371
br label %372
372: ; preds = %302
%373 = load i32, i32* %47
%374 = load i32, i32* %48
%375 = icmp eq i32 %373, %374
br i1 %375, label %376, label %377
376: ; preds = %372
br label %232
377: ; preds = %372
br label %378
378: ; preds = %377
%379 = load i32, i32* %47
%380 = load i32, i32* %42
%381 = add nsw i32 %379, %380
store i32 %381, i32* %17
%382 = load i32, i32* %17
store i32 %382, i32* %47
br label %220
383: ; No predecessors!
br label %384
384: ; preds = %383, %296
%385 = load i8*, i8** %5
ret i8* %385
}

LLVM IR (-O2):
define i8* @ieee_p_2592010699_sub_7372912886822346862_503743352(i8* %0, i8* nocapture writeonly %1, i8* nocapture %2, i8* nocapture %3) {
%5 = alloca [16 x i8]
%6 = getelementptr inbounds [16 x i8], [16 x i8]* %5, i64 0, i64 0
%7 = getelementptr inbounds i8, i8* %3, i64 12
%8 = bitcast i8* %7 to i32*
%9 = load i32, i32* %8
%10 = add i32 %9, -1
%11 = bitcast [16 x i8]* %5 to i32*
store i32 %10, i32* %11
%12 = getelementptr inbounds [16 x i8], [16 x i8]* %5, i64 0, i64 4
%13 = bitcast i8* %12 to i32*
store i32 0, i32* %13
%14 = getelementptr inbounds [16 x i8], [16 x i8]* %5, i64 0, i64 8
%15 = bitcast i8* %14 to i32*
store i32 -1, i32* %15
%16 = getelementptr inbounds [16 x i8], [16 x i8]* %5, i64 0, i64 12
%17 = bitcast i8* %16 to i32*
store i32 %9, i32* %17
%18 = getelementptr inbounds i8, i8* %0, i64 3896
%19 = tail call i64 @alloca(i32 %9)
%20 = inttoptr i64 %19 to i8*
%21 = call i32 @xsi_type_set_default_value(i8* %18, i8* %20, i8* %6)
%22 = load i32, i32* %15
%23 = load i32, i32* %13
%24 = load i32, i32* %11
%25 = mul nsw i32 %23, %22
%26 = mul nsw i32 %24, %22
%27 = icmp sgt i32 %26, %25
br i1 %27, label %28, label %45
28: ; preds = %45, %4
%29 = load i32, i32* %17
%30 = call i8* @xsi_get_transient_memory(i32 %29)
%31 = call i32 @memcpy(i8* %30, i8* %20, i32 %29)
%32 = load i32, i32* %11
%33 = load i32, i32* %13
%34 = load i32, i32* %15
%35 = bitcast i8* %1 to i32*
store i32 %32, i32* %35
%36 = getelementptr inbounds i8, i8* %1, i64 4
%37 = bitcast i8* %36 to i32*
store i32 %33, i32* %37
%38 = getelementptr inbounds i8, i8* %1, i64 8
%39 = bitcast i8* %38 to i32*
store i32 %34, i32* %39
%40 = sub nsw i32 %33, %32
%41 = mul nsw i32 %40, %34
%42 = add i32 %41, 1
%43 = getelementptr inbounds i8, i8* %1, i64 12
%44 = bitcast i8* %43 to i32*
store i32 %42, i32* %44
ret i8* %30
45: ; preds = %4, %45
%46 = phi i32 [ %59, %45 ], [ %24, %4 ]
%47 = sub i32 %10, %46
%48 = call i32 @xsi_vhdl_check_range_of_index(i32 %10, i32 0, i32 -1, i32 %46)
%49 = zext i32 %47 to i64
%50 = getelementptr inbounds i8, i8* %2, i64 %49
%51 = load i8, i8* %50
%52 = load i32, i32* %11
%53 = load i32, i32* %15
%54 = sub nsw i32 %46, %52
%55 = mul nsw i32 %54, %53
%56 = zext i32 %55 to i64
%57 = getelementptr inbounds i8, i8* %20, i64 %56
store i8 %51, i8* %57
%58 = icmp eq i32 %46, %23
%59 = add nsw i32 %46, %22
%60 = mul nsw i32 %59, %22
%61 = icmp sgt i32 %60, %25
%62 = select i1 %58, i1 true, i1 %61
br i1 %62, label %28, label %45
}