#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__ malloc(int);
int /*<<< orphan*/ memcpy(int *, int *, int);
int *load_mats(int *num_nucs, long n_isotopes, int *max_num_nucs) {
  *max_num_nucs = 0;
  int num_mats = 12;
  for (int m = 0; m < num_mats; m++) {
    if (num_nucs[m] > *max_num_nucs)
      *max_num_nucs = num_nucs[m];
  }
  int *mats = (int *)malloc(num_mats * (*max_num_nucs) * sizeof(int));
  int mats0_Sml[] = {58, 59, 60, 61, 40, 42, 43, 44, 45, 46, 1,  2,
                     3,  7,  8,  9,  10, 29, 57, 47, 48, 0,  62, 15,
                     33, 34, 52, 53, 54, 55, 56, 18, 23, 41};
  int mats0_Lrg[321] = {58, 59, 60, 61, 40, 42, 43, 44, 45, 46, 1,  2,
                        3,  7,  8,  9,  10, 29, 57, 47, 48, 0,  62, 15,
                        33, 34, 52, 53, 54, 55, 56, 18, 23, 41};
  for (int i = 0; i < 321 - 34; i++)
    mats0_Lrg[34 + i] = 68 + i;
  int mats1[] = {63, 64, 65, 66, 67};
  int mats2[] = {24, 41, 4, 5};
  int mats3[] = {24, 41, 4, 5};
  int mats4[] = {19, 20, 21, 22, 35, 36, 37, 38, 39, 25, 27, 28, 29, 30,
                 31, 32, 26, 49, 50, 51, 11, 12, 13, 14, 6,  16, 17};
  int mats5[] = {24, 41, 4,  5,  19, 20, 21, 22, 35, 36, 37,
                 38, 39, 25, 49, 50, 51, 11, 12, 13, 14};
  int mats6[] = {24, 41, 4,  5,  19, 20, 21, 22, 35, 36, 37,
                 38, 39, 25, 49, 50, 51, 11, 12, 13, 14};
  int mats7[] = {24, 41, 4,  5,  19, 20, 21, 22, 35, 36, 37,
                 38, 39, 25, 49, 50, 51, 11, 12, 13, 14};
  int mats8[] = {24, 41, 4,  5,  19, 20, 21, 22, 35, 36, 37,
                 38, 39, 25, 49, 50, 51, 11, 12, 13, 14};
  int mats9[] = {24, 41, 4,  5,  19, 20, 21, 22, 35, 36, 37,
                 38, 39, 25, 49, 50, 51, 11, 12, 13, 14};
  int mats10[] = {24, 41, 4, 5, 63, 64, 65, 66, 67};
  int mats11[] = {24, 41, 4, 5, 63, 64, 65, 66, 67};
  if (n_isotopes == 68)
    memcpy(mats, mats0_Sml, num_nucs[0] * sizeof(int));
  else
    memcpy(mats, mats0_Lrg, num_nucs[0] * sizeof(int));
  memcpy(mats + *max_num_nucs * 1, mats1, num_nucs[1] * sizeof(int));
  memcpy(mats + *max_num_nucs * 2, mats2, num_nucs[2] * sizeof(int));
  memcpy(mats + *max_num_nucs * 3, mats3, num_nucs[3] * sizeof(int));
  memcpy(mats + *max_num_nucs * 4, mats4, num_nucs[4] * sizeof(int));
  memcpy(mats + *max_num_nucs * 5, mats5, num_nucs[5] * sizeof(int));
  memcpy(mats + *max_num_nucs * 6, mats6, num_nucs[6] * sizeof(int));
  memcpy(mats + *max_num_nucs * 7, mats7, num_nucs[7] * sizeof(int));
  memcpy(mats + *max_num_nucs * 8, mats8, num_nucs[8] * sizeof(int));
  memcpy(mats + *max_num_nucs * 9, mats9, num_nucs[9] * sizeof(int));
  memcpy(mats + *max_num_nucs * 10, mats10, num_nucs[10] * sizeof(int));
  memcpy(mats + *max_num_nucs * 11, mats11, num_nucs[11] * sizeof(int));
  return mats;
}


x86 assembly (clang, -O0):
<load_mats>:
push   %rbp
mov    %rsp,%rbp
sub    $0x8b0,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    -0x18(%rbp),%rax
movl   $0x0,(%rax)
movl   $0xc,-0x1c(%rbp)
movl   $0x0,-0x20(%rbp)
mov    -0x20(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    1196 <load_mats+0x76>
mov    -0x8(%rbp),%rax
movslq -0x20(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    -0x18(%rbp),%rcx
cmp    (%rcx),%eax
jle    1183 <load_mats+0x63>
mov    -0x8(%rbp),%rax
movslq -0x20(%rbp),%rcx
mov    (%rax,%rcx,4),%ecx
mov    -0x18(%rbp),%rax
mov    %ecx,(%rax)
jmp    1188 <load_mats+0x68>
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    114f <load_mats+0x2f>
mov    -0x1c(%rbp),%eax
mov    -0x18(%rbp),%rcx
imul   (%rcx),%eax
cltq
shl    $0x2,%rax
mov    %eax,%edi
call   1040 <malloc@plt>
mov    %rax,-0x28(%rbp)
lea    -0xb0(%rbp),%rdi
lea    0xe41(%rip),%rsi
mov    $0x88,%edx
call   1030 <memcpy@plt>
lea    -0x5c0(%rbp),%rdi
lea    0xeb9(%rip),%rsi
mov    $0x504,%edx
call   1030 <memcpy@plt>
movl   $0x0,-0x5c4(%rbp)
cmpl   $0x11f,-0x5c4(%rbp)
jge    122a <load_mats+0x10a>
mov    -0x5c4(%rbp),%ecx
add    $0x44,%ecx
mov    -0x5c4(%rbp),%eax
add    $0x22,%eax
cltq
mov    %ecx,-0x5c0(%rbp,%rax,4)
mov    -0x5c4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x5c4(%rbp)
jmp    11eb <load_mats+0xcb>
mov    0x136f(%rip),%rax
mov    %rax,-0x5e0(%rbp)
mov    0x1369(%rip),%rax
mov    %rax,-0x5d8(%rbp)
mov    0x1364(%rip),%eax
mov    %eax,-0x5d0(%rbp)
mov    0x1617(%rip),%rax
mov    %rax,-0x5f0(%rbp)
mov    0x1611(%rip),%rax
mov    %rax,-0x5e8(%rbp)
mov    0x15fb(%rip),%rax
mov    %rax,-0x600(%rbp)
mov    0x15f5(%rip),%rax
mov    %rax,-0x5f8(%rbp)
lea    -0x670(%rbp),%rdi
lea    0x1328(%rip),%rsi
mov    $0x6c,%edx
call   1030 <memcpy@plt>
lea    -0x6d0(%rbp),%rdi
lea    0x1380(%rip),%rsi
mov    $0x54,%edx
call   1030 <memcpy@plt>
lea    -0x730(%rbp),%rdi
lea    0x13c8(%rip),%rsi
mov    $0x54,%edx
call   1030 <memcpy@plt>
lea    -0x790(%rbp),%rdi
lea    0x1410(%rip),%rsi
mov    $0x54,%edx
call   1030 <memcpy@plt>
lea    -0x7f0(%rbp),%rdi
lea    0x1458(%rip),%rsi
mov    $0x54,%edx
call   1030 <memcpy@plt>
lea    -0x850(%rbp),%rdi
lea    0x14a0(%rip),%rsi
mov    $0x54,%edx
call   1030 <memcpy@plt>
lea    -0x880(%rbp),%rdi
lea    0x14e8(%rip),%rsi
mov    $0x24,%edx
call   1030 <memcpy@plt>
lea    -0x8b0(%rbp),%rdi
lea    0x1500(%rip),%rsi
mov    $0x24,%edx
call   1030 <memcpy@plt>
cmpq   $0x44,-0x10(%rbp)
jne    1377 <load_mats+0x257>
mov    -0x28(%rbp),%rdi
lea    -0xb0(%rbp),%rsi
mov    -0x8(%rbp),%rax
movslq (%rax),%rax
shl    $0x2,%rax
mov    %eax,%edx
call   1030 <memcpy@plt>
jmp    1394 <load_mats+0x274>
mov    -0x28(%rbp),%rdi
lea    -0x5c0(%rbp),%rsi
mov    -0x8(%rbp),%rax
movslq (%rax),%rax
shl    $0x2,%rax
mov    %eax,%edx
call   1030 <memcpy@plt>
mov    -0x28(%rbp),%rdi
mov    -0x18(%rbp),%rax
mov    (%rax),%eax
shl    $0x0,%eax
cltq
shl    $0x2,%rax
add    %rax,%rdi
lea    -0x5e0(%rbp),%rsi
mov    -0x8(%rbp),%rax
movslq 0x4(%rax),%rax
shl    $0x2,%rax
mov    %eax,%edx
call   1030 <memcpy@plt>
mov    -0x28(%rbp),%rdi
mov    -0x18(%rbp),%rax
mov    (%rax),%eax
shl    $0x1,%eax
cltq
shl    $0x2,%rax
add    %rax,%rdi
lea    -0x5f0(%rbp),%rsi
mov    -0x8(%rbp),%rax
movslq 0x8(%rax),%rax
shl    $0x2,%rax
mov    %eax,%edx
call   1030 <memcpy@plt>
mov    -0x28(%rbp),%rdi
mov    -0x18(%rbp),%rax
imul   $0x3,(%rax),%eax
cltq
shl    $0x2,%rax
add    %rax,%rdi
lea    -0x600(%rbp),%rsi
mov    -0x8(%rbp),%rax
movslq 0xc(%rax),%rax
shl    $0x2,%rax
mov    %eax,%edx
call   1030 <memcpy@plt>
mov    -0x28(%rbp),%rdi
mov    -0x18(%rbp),%rax
mov    (%rax),%eax
shl    $0x2,%eax
cltq
shl    $0x2,%rax
add    %rax,%rdi
lea    -0x670(%rbp),%rsi
mov    -0x8(%rbp),%rax
movslq 0x10(%rax),%rax
shl    $0x2,%rax
mov    %eax,%edx
call   1030 <memcpy@plt>
mov    -0x28(%rbp),%rdi
mov    -0x18(%rbp),%rax
imul   $0x5,(%rax),%eax
cltq
shl    $0x2,%rax
add    %rax,%rdi
lea    -0x6d0(%rbp),%rsi
mov    -0x8(%rbp),%rax
movslq 0x14(%rax),%rax
shl    $0x2,%rax
mov    %eax,%edx
call   1030 <memcpy@plt>
mov    -0x28(%rbp),%rdi
mov    -0x18(%rbp),%rax
imul   $0x6,(%rax),%eax
cltq
shl    $0x2,%rax
add    %rax,%rdi
lea    -0x730(%rbp),%rsi
mov    -0x8(%rbp),%rax
movslq 0x18(%rax),%rax
shl    $0x2,%rax
mov    %eax,%edx
call   1030 <memcpy@plt>
mov    -0x28(%rbp),%rdi
mov    -0x18(%rbp),%rax
imul   $0x7,(%rax),%eax
cltq
shl    $0x2,%rax
add    %rax,%rdi
lea    -0x790(%rbp),%rsi
mov    -0x8(%rbp),%rax
movslq 0x1c(%rax),%rax
shl    $0x2,%rax
mov    %eax,%edx
call   1030 <memcpy@plt>
mov    -0x28(%rbp),%rdi
mov    -0x18(%rbp),%rax
mov    (%rax),%eax
shl    $0x3,%eax
cltq
shl    $0x2,%rax
add    %rax,%rdi
lea    -0x7f0(%rbp),%rsi
mov    -0x8(%rbp),%rax
movslq 0x20(%rax),%rax
shl    $0x2,%rax
mov    %eax,%edx
call   1030 <memcpy@plt>
mov    -0x28(%rbp),%rdi
mov    -0x18(%rbp),%rax
imul   $0x9,(%rax),%eax
cltq
shl    $0x2,%rax
add    %rax,%rdi
lea    -0x850(%rbp),%rsi
mov    -0x8(%rbp),%rax
movslq 0x24(%rax),%rax
shl    $0x2,%rax
mov    %eax,%edx
call   1030 <memcpy@plt>
mov    -0x28(%rbp),%rdi
mov    -0x18(%rbp),%rax
imul   $0xa,(%rax),%eax
cltq
shl    $0x2,%rax
add    %rax,%rdi
lea    -0x880(%rbp),%rsi
mov    -0x8(%rbp),%rax
movslq 0x28(%rax),%rax
shl    $0x2,%rax
mov    %eax,%edx
call   1030 <memcpy@plt>
mov    -0x28(%rbp),%rdi
mov    -0x18(%rbp),%rax
imul   $0xb,(%rax),%eax
cltq
shl    $0x2,%rax
add    %rax,%rdi
lea    -0x8b0(%rbp),%rsi
mov    -0x8(%rbp),%rax
movslq 0x2c(%rax),%rax
shl    $0x2,%rax
mov    %eax,%edx
call   1030 <memcpy@plt>
mov    -0x28(%rbp),%rax
add    $0x8b0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<load_mats>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x888,%rsp
mov    %rdx,%rbx
mov    %rdi,%r14
movl   $0x0,(%rdx)
mov    (%rdi),%ecx
xor    %eax,%eax
test   %ecx,%ecx
cmovns %ecx,%eax
mov    %eax,(%rdx)
mov    0x4(%rdi),%ecx
cmp    %eax,%ecx
cmovg  %ecx,%eax
mov    %eax,(%rdx)
mov    0x8(%rdi),%ecx
cmp    %eax,%ecx
cmovg  %ecx,%eax
mov    %eax,(%rdx)
mov    0xc(%rdi),%ecx
cmp    %eax,%ecx
cmovg  %ecx,%eax
mov    %eax,(%rdx)
mov    0x10(%rdi),%ecx
cmp    %eax,%ecx
cmovg  %ecx,%eax
mov    %eax,(%rdx)
mov    0x14(%rdi),%ecx
cmp    %eax,%ecx
cmovg  %ecx,%eax
mov    %eax,(%rdx)
mov    0x18(%rdi),%ecx
cmp    %eax,%ecx
cmovg  %ecx,%eax
mov    %eax,(%rdx)
mov    0x1c(%rdi),%ecx
cmp    %eax,%ecx
cmovg  %ecx,%eax
mov    %eax,(%rdx)
mov    0x20(%rdi),%ecx
cmp    %eax,%ecx
cmovg  %ecx,%eax
mov    %eax,(%rdx)
mov    0x24(%rdi),%ecx
cmp    %eax,%ecx
cmovg  %ecx,%eax
mov    %eax,(%rdx)
mov    0x28(%rdi),%ecx
cmp    %eax,%ecx
cmovg  %ecx,%eax
mov    %eax,(%rdx)
mov    0x2c(%rdi),%ecx
cmp    %eax,%ecx
cmovg  %ecx,%eax
mov    %rsi,%r12
mov    %eax,(%rdx)
shl    $0x4,%eax
lea    (%rax,%rax,2),%edi
call   1040 <malloc@plt>
mov    %rax,%r15
lea    0xeb2(%rip),%rsi
lea    0x2f0(%rsp),%r13
mov    $0x88,%edx
mov    %r13,%rdi
call   1030 <memcpy@plt>
lea    0xf26(%rip),%rsi
lea    0x380(%rsp),%rbp
mov    $0x504,%edx
mov    %rbp,%rdi
call   1030 <memcpy@plt>
movdqa 0xdf9(%rip),%xmm0
mov    $0x2e,%eax
movdqa 0xdfc(%rip),%xmm1
movdqa 0xe04(%rip),%xmm2
movdqa 0xe0c(%rip),%xmm3
movdqa 0xe14(%rip),%xmm4
movdqa 0xe1c(%rip),%xmm5
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movdqa %xmm0,%xmm6
paddd  %xmm1,%xmm6
movdqa %xmm0,%xmm7
paddd  %xmm2,%xmm7
movdqu %xmm6,0x350(%rsp,%rax,4)
movdqu %xmm7,0x360(%rsp,%rax,4)
cmp    $0x13e,%rax
je     1296 <load_mats+0x176>
movdqa %xmm0,%xmm6
paddd  %xmm3,%xmm6
movdqa %xmm0,%xmm7
paddd  %xmm4,%xmm7
movdqu %xmm6,0x370(%rsp,%rax,4)
movdqu %xmm7,0x380(%rsp,%rax,4)
paddd  %xmm5,%xmm0
add    $0x10,%rax
jmp    1240 <load_mats+0x120>
movaps 0xdc3(%rip),%xmm0
movups %xmm0,0x868(%rsp)
movabs $0x16100000160,%rax
mov    %rax,0x878(%rsp)
movl   $0x162,0x880(%rsp)
mov    0x1368(%rip),%eax
mov    %eax,0x10(%rsp)
movaps 0x134d(%rip),%xmm0
movaps %xmm0,(%rsp)
movaps 0xd92(%rip),%xmm0
movaps %xmm0,0x30(%rsp)
movaps %xmm0,0x20(%rsp)
movups 0x13ad(%rip),%xmm0
movups %xmm0,0x2dc(%rsp)
movaps 0x1392(%rip),%xmm0
movaps %xmm0,0x2d0(%rsp)
movaps 0x1373(%rip),%xmm0
movaps %xmm0,0x2c0(%rsp)
movaps 0x1354(%rip),%xmm0
movaps %xmm0,0x2b0(%rsp)
movaps 0x1335(%rip),%xmm0
movaps %xmm0,0x2a0(%rsp)
movaps 0x1316(%rip),%xmm0
movaps %xmm0,0x290(%rsp)
movaps 0x12f7(%rip),%xmm0
movaps %xmm0,0x280(%rsp)
mov    0x13a9(%rip),%eax
mov    %eax,0x270(%rsp)
movaps 0x138b(%rip),%xmm0
movaps %xmm0,0x260(%rsp)
movaps 0x136c(%rip),%xmm1
movaps %xmm1,0x250(%rsp)
movaps 0x134d(%rip),%xmm2
movaps %xmm2,0x240(%rsp)
movaps 0x132e(%rip),%xmm3
movaps %xmm3,0x230(%rsp)
movaps 0x130f(%rip),%xmm4
movaps %xmm4,0x220(%rsp)
mov    %eax,0x210(%rsp)
movaps %xmm0,0x200(%rsp)
movaps %xmm1,0x1f0(%rsp)
movaps %xmm2,0x1e0(%rsp)
movaps %xmm3,0x1d0(%rsp)
movaps %xmm4,0x1c0(%rsp)
mov    %eax,0x1b0(%rsp)
movaps %xmm0,0x1a0(%rsp)
movaps %xmm1,0x190(%rsp)
movaps %xmm2,0x180(%rsp)
movaps %xmm3,0x170(%rsp)
movaps %xmm4,0x160(%rsp)
mov    %eax,0x150(%rsp)
movaps %xmm0,0x140(%rsp)
movaps %xmm1,0x130(%rsp)
movaps %xmm2,0x120(%rsp)
movaps %xmm3,0x110(%rsp)
movaps %xmm4,0x100(%rsp)
mov    %eax,0xf0(%rsp)
movaps %xmm0,0xe0(%rsp)
movaps %xmm1,0xd0(%rsp)
movaps %xmm2,0xc0(%rsp)
movaps %xmm3,0xb0(%rsp)
movaps %xmm4,0xa0(%rsp)
mov    0x12c5(%rip),%eax
mov    %eax,0x90(%rsp)
movaps 0x12a7(%rip),%xmm0
movaps %xmm0,0x80(%rsp)
movaps 0x1288(%rip),%xmm1
movaps %xmm1,0x70(%rsp)
mov    %eax,0x60(%rsp)
movaps %xmm0,0x50(%rsp)
movaps %xmm1,0x40(%rsp)
cmp    $0x44,%r12
cmove  %r13,%rbp
mov    (%r14),%edx
shl    $0x2,%edx
mov    %r15,%rdi
mov    %rbp,%rsi
call   1030 <memcpy@plt>
movslq (%rbx),%rax
lea    (%r15,%rax,4),%rdi
mov    0x4(%r14),%edx
shl    $0x2,%edx
mov    %rsp,%rsi
call   1030 <memcpy@plt>
movslq (%rbx),%rax
lea    (%r15,%rax,8),%rdi
mov    0x8(%r14),%edx
shl    $0x2,%edx
lea    0x30(%rsp),%rsi
call   1030 <memcpy@plt>
movslq (%rbx),%rax
lea    (%rax,%rax,2),%rax
lea    (%r15,%rax,4),%rdi
mov    0xc(%r14),%edx
shl    $0x2,%edx
lea    0x20(%rsp),%rsi
call   1030 <memcpy@plt>
movslq (%rbx),%rdi
shl    $0x4,%rdi
add    %r15,%rdi
mov    0x10(%r14),%edx
shl    $0x2,%edx
lea    0x280(%rsp),%rsi
call   1030 <memcpy@plt>
movslq (%rbx),%rax
lea    (%rax,%rax,4),%rax
lea    (%r15,%rax,4),%rdi
mov    0x14(%r14),%edx
shl    $0x2,%edx
lea    0x220(%rsp),%rsi
call   1030 <memcpy@plt>
movslq (%rbx),%rax
lea    (%rax,%rax,2),%rax
lea    (%r15,%rax,8),%rdi
mov    0x18(%r14),%edx
shl    $0x2,%edx
lea    0x1c0(%rsp),%rsi
call   1030 <memcpy@plt>
movslq (%rbx),%rax
lea    (%rax,%rax,8),%rcx
lea    (%rcx,%rcx,2),%rdi
add    %rax,%rdi
add    %r15,%rdi
mov    0x1c(%r14),%edx
shl    $0x2,%edx
lea    0x160(%rsp),%rsi
call   1030 <memcpy@plt>
movslq (%rbx),%rdi
shl    $0x5,%rdi
add    %r15,%rdi
mov    0x20(%r14),%edx
shl    $0x2,%edx
lea    0x100(%rsp),%rsi
call   1030 <memcpy@plt>
movslq (%rbx),%rax
lea    (%rax,%rax,8),%rax
lea    (%r15,%rax,4),%rdi
mov    0x24(%r14),%edx
shl    $0x2,%edx
lea    0xa0(%rsp),%rsi
call   1030 <memcpy@plt>
movslq (%rbx),%rax
lea    (%rax,%rax,4),%rax
lea    (%r15,%rax,8),%rdi
mov    0x28(%r14),%edx
shl    $0x2,%edx
lea    0x70(%rsp),%rsi
call   1030 <memcpy@plt>
movslq (%rbx),%rax
imul   $0x2c,%rax,%rdi
add    %r15,%rdi
mov    0x2c(%r14),%edx
shl    $0x2,%edx
lea    0x40(%rsp),%rsi
call   1030 <memcpy@plt>
mov    %r15,%rax
add    $0x888,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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