#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 */
unsigned int get_index(unsigned int, unsigned int, unsigned int const);
void multiply_symbolic(const float alpha, const unsigned int N,
                       unsigned int A_M_lower, unsigned int A_M_upper,
                       unsigned int A_N_lower, unsigned int A_N_upper,
                       float (*A)[4][4], unsigned int B_M_lower,
                       unsigned int B_M_upper, unsigned int B_N_lower,
                       unsigned int B_N_upper, float (*B)[4][4],
                       const float beta, unsigned int C_M_lower,
                       unsigned int C_M_upper, unsigned int C_N_lower,
                       unsigned int C_N_upper, float (*C)[4][4],
                       unsigned int *stream_index, unsigned int *stream_A,
                       unsigned int *stream_B, unsigned int *stream_C) {
  unsigned int i, j;
  if (A_M_upper - A_M_lower == 1) {
    stream_A[*stream_index] = get_index(A_M_lower, A_N_lower, N);
    stream_B[*stream_index] = get_index(B_M_lower, B_N_lower, N);
    stream_C[*stream_index] = get_index(C_M_lower, C_N_lower, N);
    *stream_index += 1;
  } else {
    multiply_symbolic(alpha, N, A_M_lower + (A_M_upper - A_M_lower) / 2 * 0,
                      A_M_lower + (A_M_upper - A_M_lower) / 2 * 1,
                      A_N_lower + (A_N_upper - A_N_lower) / 2 * 0,
                      A_N_lower + (A_N_upper - A_N_lower) / 2 * 1, A,
                      B_M_lower + (B_M_upper - B_M_lower) / 2 * 0,
                      B_M_lower + (B_M_upper - B_M_lower) / 2 * 1,
                      B_N_lower + (B_N_upper - B_N_lower) / 2 * 0,
                      B_N_lower + (B_N_upper - B_N_lower) / 2 * 1, B, beta,
                      C_M_lower + (C_M_upper - C_M_lower) / 2 * 0,
                      C_M_lower + (C_M_upper - C_M_lower) / 2 * 1,
                      C_N_lower + (C_N_upper - C_N_lower) / 2 * 0,
                      C_N_lower + (C_N_upper - C_N_lower) / 2 * 1, C,
                      stream_index, stream_A, stream_B, stream_C);
    multiply_symbolic(alpha, N, A_M_lower + (A_M_upper - A_M_lower) / 2 * 0,
                      A_M_lower + (A_M_upper - A_M_lower) / 2 * 1,
                      A_N_lower + (A_N_upper - A_N_lower) / 2 * 1,
                      A_N_lower + (A_N_upper - A_N_lower) / 2 * 2, A,
                      B_M_lower + (B_M_upper - B_M_lower) / 2 * 1,
                      B_M_lower + (B_M_upper - B_M_lower) / 2 * 2,
                      B_N_lower + (B_N_upper - B_N_lower) / 2 * 0,
                      B_N_lower + (B_N_upper - B_N_lower) / 2 * 1, B, beta,
                      C_M_lower + (C_M_upper - C_M_lower) / 2 * 0,
                      C_M_lower + (C_M_upper - C_M_lower) / 2 * 1,
                      C_N_lower + (C_N_upper - C_N_lower) / 2 * 0,
                      C_N_lower + (C_N_upper - C_N_lower) / 2 * 1, C,
                      stream_index, stream_A, stream_B, stream_C);
    multiply_symbolic(alpha, N, A_M_lower + (A_M_upper - A_M_lower) / 2 * 0,
                      A_M_lower + (A_M_upper - A_M_lower) / 2 * 1,
                      A_N_lower + (A_N_upper - A_N_lower) / 2 * 0,
                      A_N_lower + (A_N_upper - A_N_lower) / 2 * 1, A,
                      B_M_lower + (B_M_upper - B_M_lower) / 2 * 0,
                      B_M_lower + (B_M_upper - B_M_lower) / 2 * 1,
                      B_N_lower + (B_N_upper - B_N_lower) / 2 * 1,
                      B_N_lower + (B_N_upper - B_N_lower) / 2 * 2, B, beta,
                      C_M_lower + (C_M_upper - C_M_lower) / 2 * 0,
                      C_M_lower + (C_M_upper - C_M_lower) / 2 * 1,
                      C_N_lower + (C_N_upper - C_N_lower) / 2 * 1,
                      C_N_lower + (C_N_upper - C_N_lower) / 2 * 2, C,
                      stream_index, stream_A, stream_B, stream_C);
    multiply_symbolic(alpha, N, A_M_lower + (A_M_upper - A_M_lower) / 2 * 0,
                      A_M_lower + (A_M_upper - A_M_lower) / 2 * 1,
                      A_N_lower + (A_N_upper - A_N_lower) / 2 * 1,
                      A_N_lower + (A_N_upper - A_N_lower) / 2 * 2, A,
                      B_M_lower + (B_M_upper - B_M_lower) / 2 * 1,
                      B_M_lower + (B_M_upper - B_M_lower) / 2 * 2,
                      B_N_lower + (B_N_upper - B_N_lower) / 2 * 1,
                      B_N_lower + (B_N_upper - B_N_lower) / 2 * 2, B, beta,
                      C_M_lower + (C_M_upper - C_M_lower) / 2 * 0,
                      C_M_lower + (C_M_upper - C_M_lower) / 2 * 1,
                      C_N_lower + (C_N_upper - C_N_lower) / 2 * 1,
                      C_N_lower + (C_N_upper - C_N_lower) / 2 * 2, C,
                      stream_index, stream_A, stream_B, stream_C);
    multiply_symbolic(alpha, N, A_M_lower + (A_M_upper - A_M_lower) / 2 * 1,
                      A_M_lower + (A_M_upper - A_M_lower) / 2 * 2,
                      A_N_lower + (A_N_upper - A_N_lower) / 2 * 0,
                      A_N_lower + (A_N_upper - A_N_lower) / 2 * 1, A,
                      B_M_lower + (B_M_upper - B_M_lower) / 2 * 0,
                      B_M_lower + (B_M_upper - B_M_lower) / 2 * 1,
                      B_N_lower + (B_N_upper - B_N_lower) / 2 * 0,
                      B_N_lower + (B_N_upper - B_N_lower) / 2 * 1, B, beta,
                      C_M_lower + (C_M_upper - C_M_lower) / 2 * 1,
                      C_M_lower + (C_M_upper - C_M_lower) / 2 * 2,
                      C_N_lower + (C_N_upper - C_N_lower) / 2 * 0,
                      C_N_lower + (C_N_upper - C_N_lower) / 2 * 1, C,
                      stream_index, stream_A, stream_B, stream_C);
    multiply_symbolic(alpha, N, A_M_lower + (A_M_upper - A_M_lower) / 2 * 1,
                      A_M_lower + (A_M_upper - A_M_lower) / 2 * 2,
                      A_N_lower + (A_N_upper - A_N_lower) / 2 * 1,
                      A_N_lower + (A_N_upper - A_N_lower) / 2 * 2, A,
                      B_M_lower + (B_M_upper - B_M_lower) / 2 * 1,
                      B_M_lower + (B_M_upper - B_M_lower) / 2 * 2,
                      B_N_lower + (B_N_upper - B_N_lower) / 2 * 0,
                      B_N_lower + (B_N_upper - B_N_lower) / 2 * 1, B, beta,
                      C_M_lower + (C_M_upper - C_M_lower) / 2 * 1,
                      C_M_lower + (C_M_upper - C_M_lower) / 2 * 2,
                      C_N_lower + (C_N_upper - C_N_lower) / 2 * 0,
                      C_N_lower + (C_N_upper - C_N_lower) / 2 * 1, C,
                      stream_index, stream_A, stream_B, stream_C);
    multiply_symbolic(alpha, N, A_M_lower + (A_M_upper - A_M_lower) / 2 * 1,
                      A_M_lower + (A_M_upper - A_M_lower) / 2 * 2,
                      A_N_lower + (A_N_upper - A_N_lower) / 2 * 0,
                      A_N_lower + (A_N_upper - A_N_lower) / 2 * 1, A,
                      B_M_lower + (B_M_upper - B_M_lower) / 2 * 0,
                      B_M_lower + (B_M_upper - B_M_lower) / 2 * 1,
                      B_N_lower + (B_N_upper - B_N_lower) / 2 * 1,
                      B_N_lower + (B_N_upper - B_N_lower) / 2 * 2, B, beta,
                      C_M_lower + (C_M_upper - C_M_lower) / 2 * 1,
                      C_M_lower + (C_M_upper - C_M_lower) / 2 * 2,
                      C_N_lower + (C_N_upper - C_N_lower) / 2 * 1,
                      C_N_lower + (C_N_upper - C_N_lower) / 2 * 2, C,
                      stream_index, stream_A, stream_B, stream_C);
    multiply_symbolic(alpha, N, A_M_lower + (A_M_upper - A_M_lower) / 2 * 1,
                      A_M_lower + (A_M_upper - A_M_lower) / 2 * 2,
                      A_N_lower + (A_N_upper - A_N_lower) / 2 * 1,
                      A_N_lower + (A_N_upper - A_N_lower) / 2 * 2, A,
                      B_M_lower + (B_M_upper - B_M_lower) / 2 * 1,
                      B_M_lower + (B_M_upper - B_M_lower) / 2 * 2,
                      B_N_lower + (B_N_upper - B_N_lower) / 2 * 1,
                      B_N_lower + (B_N_upper - B_N_lower) / 2 * 2, B, beta,
                      C_M_lower + (C_M_upper - C_M_lower) / 2 * 1,
                      C_M_lower + (C_M_upper - C_M_lower) / 2 * 2,
                      C_N_lower + (C_N_upper - C_N_lower) / 2 * 1,
                      C_N_lower + (C_N_upper - C_N_lower) / 2 * 2, C,
                      stream_index, stream_A, stream_B, stream_C);
  }
}


x86 assembly (clang, -O0):
<multiply_symbolic>:
push   %rbp
mov    %rsp,%rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x1e8,%rsp
mov    0x78(%rbp),%rax
mov    0x70(%rbp),%rax
mov    0x68(%rbp),%rax
mov    0x60(%rbp),%rax
mov    0x58(%rbp),%rax
mov    0x50(%rbp),%eax
mov    0x48(%rbp),%eax
mov    0x40(%rbp),%eax
mov    0x38(%rbp),%eax
mov    0x30(%rbp),%rax
mov    0x28(%rbp),%eax
mov    0x20(%rbp),%eax
mov    0x18(%rbp),%eax
mov    0x10(%rbp),%eax
movss  %xmm0,-0x2c(%rbp)
mov    %edi,-0x30(%rbp)
mov    %esi,-0x34(%rbp)
mov    %edx,-0x38(%rbp)
mov    %ecx,-0x3c(%rbp)
mov    %r8d,-0x40(%rbp)
mov    %r9,-0x48(%rbp)
movss  %xmm1,-0x4c(%rbp)
mov    -0x38(%rbp),%eax
sub    -0x34(%rbp),%eax
cmp    $0x1,%eax
jne    11f8 <multiply_symbolic+0xd8>
mov    -0x34(%rbp),%edi
mov    -0x3c(%rbp),%esi
mov    -0x30(%rbp),%edx
call   1040 <get_index@plt>
mov    %eax,%edx
mov    0x68(%rbp),%rax
mov    0x60(%rbp),%rcx
mov    (%rcx),%ecx
mov    %edx,(%rax,%rcx,4)
mov    0x10(%rbp),%edi
mov    0x20(%rbp),%esi
mov    -0x30(%rbp),%edx
call   1040 <get_index@plt>
mov    %eax,%edx
mov    0x70(%rbp),%rax
mov    0x60(%rbp),%rcx
mov    (%rcx),%ecx
mov    %edx,(%rax,%rcx,4)
mov    0x38(%rbp),%edi
mov    0x48(%rbp),%esi
mov    -0x30(%rbp),%edx
call   1040 <get_index@plt>
mov    %eax,%edx
mov    0x78(%rbp),%rax
mov    0x60(%rbp),%rcx
mov    (%rcx),%ecx
mov    %edx,(%rax,%rcx,4)
mov    0x60(%rbp),%rax
mov    (%rax),%ecx
add    $0x1,%ecx
mov    %ecx,(%rax)
jmp    1f66 <multiply_symbolic+0xe46>
movss  -0x2c(%rbp),%xmm0
mov    -0x30(%rbp),%edi
mov    -0x34(%rbp),%esi
mov    -0x38(%rbp),%eax
sub    -0x34(%rbp),%eax
shr    $0x1,%eax
imul   $0x0,%eax,%eax
add    %eax,%esi
mov    -0x34(%rbp),%edx
mov    -0x38(%rbp),%eax
sub    -0x34(%rbp),%eax
shr    $0x1,%eax
shl    $0x0,%eax
add    %eax,%edx
mov    -0x3c(%rbp),%ecx
mov    -0x40(%rbp),%eax
sub    -0x3c(%rbp),%eax
shr    $0x1,%eax
imul   $0x0,%eax,%eax
add    %eax,%ecx
mov    -0x3c(%rbp),%r8d
mov    -0x40(%rbp),%eax
sub    -0x3c(%rbp),%eax
shr    $0x1,%eax
shl    $0x0,%eax
add    %eax,%r8d
mov    -0x48(%rbp),%r9
mov    0x10(%rbp),%eax
mov    0x18(%rbp),%r10d
sub    0x10(%rbp),%r10d
shr    $0x1,%r10d
imul   $0x0,%r10d,%r10d
add    %r10d,%eax
mov    %eax,-0x198(%rbp)
mov    0x10(%rbp),%eax
mov    0x18(%rbp),%r10d
sub    0x10(%rbp),%r10d
shr    $0x1,%r10d
shl    $0x0,%r10d
add    %r10d,%eax
mov    %eax,-0x194(%rbp)
mov    0x20(%rbp),%eax
mov    0x28(%rbp),%r10d
sub    0x20(%rbp),%r10d
shr    $0x1,%r10d
imul   $0x0,%r10d,%r10d
add    %r10d,%eax
mov    %eax,-0x190(%rbp)
mov    0x20(%rbp),%eax
mov    0x28(%rbp),%r10d
sub    0x20(%rbp),%r10d
shr    $0x1,%r10d
shl    $0x0,%r10d
add    %r10d,%eax
mov    %eax,-0x18c(%rbp)
mov    0x30(%rbp),%rax
mov    %rax,-0x188(%rbp)
movss  -0x4c(%rbp),%xmm1
mov    0x38(%rbp),%eax
mov    0x40(%rbp),%r10d
sub    0x38(%rbp),%r10d
shr    $0x1,%r10d
imul   $0x0,%r10d,%r10d
add    %r10d,%eax
mov    %eax,-0x17c(%rbp)
mov    0x38(%rbp),%r13d
mov    0x40(%rbp),%eax
sub    0x38(%rbp),%eax
shr    $0x1,%eax
shl    $0x0,%eax
add    %eax,%r13d
mov    0x48(%rbp),%r12d
mov    0x50(%rbp),%eax
sub    0x48(%rbp),%eax
shr    $0x1,%eax
imul   $0x0,%eax,%eax
add    %eax,%r12d
mov    0x48(%rbp),%r15d
mov    0x50(%rbp),%eax
sub    0x48(%rbp),%eax
shr    $0x1,%eax
shl    $0x0,%eax
add    %eax,%r15d
mov    0x58(%rbp),%r14
mov    0x60(%rbp),%rbx
mov    0x68(%rbp),%r11
mov    0x70(%rbp),%r10
mov    0x78(%rbp),%rax
mov    %rax,-0x178(%rbp)
mov    -0x198(%rbp),%eax
mov    %eax,(%rsp)
mov    -0x194(%rbp),%eax
mov    %eax,0x8(%rsp)
mov    -0x190(%rbp),%eax
mov    %eax,0x10(%rsp)
mov    -0x18c(%rbp),%eax
mov    %eax,0x18(%rsp)
mov    -0x188(%rbp),%rax
mov    %rax,0x20(%rsp)
mov    -0x17c(%rbp),%eax
mov    %eax,0x28(%rsp)
mov    -0x178(%rbp),%rax
mov    %r13d,0x30(%rsp)
mov    %r12d,0x38(%rsp)
mov    %r15d,0x40(%rsp)
mov    %r14,0x48(%rsp)
mov    %rbx,0x50(%rsp)
mov    %r11,0x58(%rsp)
mov    %r10,0x60(%rsp)
mov    %rax,0x68(%rsp)
call   1030 <multiply_symbolic@plt>
movss  -0x2c(%rbp),%xmm0
mov    -0x30(%rbp),%edi
mov    -0x34(%rbp),%esi
mov    -0x38(%rbp),%eax
sub    -0x34(%rbp),%eax
shr    $0x1,%eax
imul   $0x0,%eax,%eax
add    %eax,%esi
mov    -0x34(%rbp),%edx
mov    -0x38(%rbp),%eax
sub    -0x34(%rbp),%eax
shr    $0x1,%eax
shl    $0x0,%eax
add    %eax,%edx
mov    -0x3c(%rbp),%ecx
mov    -0x40(%rbp),%eax
sub    -0x3c(%rbp),%eax
shr    $0x1,%eax
shl    $0x0,%eax
add    %eax,%ecx
mov    -0x3c(%rbp),%r8d
mov    -0x40(%rbp),%eax
sub    -0x3c(%rbp),%eax
shr    $0x1,%eax
shl    $0x1,%eax
add    %eax,%r8d
mov    -0x48(%rbp),%r9
mov    0x10(%rbp),%eax
mov    0x18(%rbp),%r10d
sub    0x10(%rbp),%r10d
shr    $0x1,%r10d
shl    $0x0,%r10d
add    %r10d,%eax
mov    %eax,-0x170(%rbp)
mov    0x10(%rbp),%eax
mov    0x18(%rbp),%r10d
sub    0x10(%rbp),%r10d
shr    $0x1,%r10d
shl    $0x1,%r10d
add    %r10d,%eax
mov    %eax,-0x16c(%rbp)
mov    0x20(%rbp),%eax
mov    0x28(%rbp),%r10d
sub    0x20(%rbp),%r10d
shr    $0x1,%r10d
imul   $0x0,%r10d,%r10d
add    %r10d,%eax
mov    %eax,-0x168(%rbp)
mov    0x20(%rbp),%eax
mov    0x28(%rbp),%r10d
sub    0x20(%rbp),%r10d
shr    $0x1,%r10d
shl    $0x0,%r10d
add    %r10d,%eax
mov    %eax,-0x164(%rbp)
mov    0x30(%rbp),%rax
mov    %rax,-0x160(%rbp)
movss  -0x4c(%rbp),%xmm1
mov    0x38(%rbp),%eax
mov    0x40(%rbp),%r10d
sub    0x38(%rbp),%r10d
shr    $0x1,%r10d
imul   $0x0,%r10d,%r10d
add    %r10d,%eax
mov    %eax,-0x154(%rbp)
mov    0x38(%rbp),%r13d
mov    0x40(%rbp),%eax
sub    0x38(%rbp),%eax
shr    $0x1,%eax
shl    $0x0,%eax
add    %eax,%r13d
mov    0x48(%rbp),%r12d
mov    0x50(%rbp),%eax
sub    0x48(%rbp),%eax
shr    $0x1,%eax
imul   $0x0,%eax,%eax
add    %eax,%r12d
mov    0x48(%rbp),%r15d
mov    0x50(%rbp),%eax
sub    0x48(%rbp),%eax
shr    $0x1,%eax
shl    $0x0,%eax
add    %eax,%r15d
mov    0x58(%rbp),%r14
mov    0x60(%rbp),%rbx
mov    0x68(%rbp),%r11
mov    0x70(%rbp),%r10
mov    0x78(%rbp),%rax
mov    %rax,-0x150(%rbp)
mov    -0x170(%rbp),%eax
mov    %eax,(%rsp)
mov    -0x16c(%rbp),%eax
mov    %eax,0x8(%rsp)
mov    -0x168(%rbp),%eax
mov    %eax,0x10(%rsp)
mov    -0x164(%rbp),%eax
mov    %eax,0x18(%rsp)
mov    -0x160(%rbp),%rax
mov    %rax,0x20(%rsp)
mov    -0x154(%rbp),%eax
mov    %eax,0x28(%rsp)
mov    -0x150(%rbp),%rax
mov    %r13d,0x30(%rsp)
mov    %r12d,0x38(%rsp)
mov    %r15d,0x40(%rsp)
mov    %r14,0x48(%rsp)
mov    %rbx,0x50(%rsp)
mov    %r11,0x58(%rsp)
mov    %r10,0x60(%rsp)
mov    %rax,0x68(%rsp)
call   1030 <multiply_symbolic@plt>
movss  -0x2c(%rbp),%xmm0
mov    -0x30(%rbp),%edi
mov    -0x34(%rbp),%esi
mov    -0x38(%rbp),%eax
sub    -0x34(%rbp),%eax
shr    $0x1,%eax
imul   $0x0,%eax,%eax
add    %eax,%esi
mov    -0x34(%rbp),%edx
mov    -0x38(%rbp),%eax
sub    -0x34(%rbp),%eax
shr    $0x1,%eax
shl    $0x0,%eax
add    %eax,%edx
mov    -0x3c(%rbp),%ecx
mov    -0x40(%rbp),%eax
sub    -0x3c(%rbp),%eax
shr    $0x1,%eax
imul   $0x0,%eax,%eax
add    %eax,%ecx
mov    -0x3c(%rbp),%r8d
mov    -0x40(%rbp),%eax
sub    -0x3c(%rbp),%eax
shr    $0x1,%eax
shl    $0x0,%eax
add    %eax,%r8d
mov    -0x48(%rbp),%r9
mov    0x10(%rbp),%eax
mov    0x18(%rbp),%r10d
sub    0x10(%rbp),%r10d
shr    $0x1,%r10d
imul   $0x0,%r10d,%r10d
add    %r10d,%eax
mov    %eax,-0x148(%rbp)
mov    0x10(%rbp),%eax
mov    0x18(%rbp),%r10d
sub    0x10(%rbp),%r10d
shr    $0x1,%r10d
shl    $0x0,%r10d
add    %r10d,%eax
mov    %eax,-0x144(%rbp)
mov    0x20(%rbp),%eax
mov    0x28(%rbp),%r10d
sub    0x20(%rbp),%r10d
shr    $0x1,%r10d
shl    $0x0,%r10d
add    %r10d,%eax
mov    %eax,-0x140(%rbp)
mov    0x20(%rbp),%eax
mov    0x28(%rbp),%r10d
sub    0x20(%rbp),%r10d
shr    $0x1,%r10d
shl    $0x1,%r10d
add    %r10d,%eax
mov    %eax,-0x13c(%rbp)
mov    0x30(%rbp),%rax
mov    %rax,-0x138(%rbp)
movss  -0x4c(%rbp),%xmm1
mov    0x38(%rbp),%eax
mov    0x40(%rbp),%r10d
sub    0x38(%rbp),%r10d
shr    $0x1,%r10d
imul   $0x0,%r10d,%r10d
add    %r10d,%eax
mov    %eax,-0x12c(%rbp)
mov    0x38(%rbp),%r13d
mov    0x40(%rbp),%eax
sub    0x38(%rbp),%eax
shr    $0x1,%eax
shl    $0x0,%eax
add    %eax,%r13d
mov    0x48(%rbp),%r12d
mov    0x50(%rbp),%eax
sub    0x48(%rbp),%eax
shr    $0x1,%eax
shl    $0x0,%eax
add    %eax,%r12d
mov    0x48(%rbp),%r15d
mov    0x50(%rbp),%eax
sub    0x48(%rbp),%eax
shr    $0x1,%eax
shl    $0x1,%eax
add    %eax,%r15d
mov    0x58(%rbp),%r14
mov    0x60(%rbp),%rbx
mov    0x68(%rbp),%r11
mov    0x70(%rbp),%r10
mov    0x78(%rbp),%rax
mov    %rax,-0x128(%rbp)
mov    -0x148(%rbp),%eax
mov    %eax,(%rsp)
mov    -0x144(%rbp),%eax
mov    %eax,0x8(%rsp)
mov    -0x140(%rbp),%eax
mov    %eax,0x10(%rsp)
mov    -0x13c(%rbp),%eax
mov    %eax,0x18(%rsp)
mov    -0x138(%rbp),%rax
mov    %rax,0x20(%rsp)
mov    -0x12c(%rbp),%eax
mov    %eax,0x28(%rsp)
mov    -0x128(%rbp),%rax
mov    %r13d,0x30(%rsp)
mov    %r12d,0x38(%rsp)
mov    %r15d,0x40(%rsp)
mov    %r14,0x48(%rsp)
mov    %rbx,0x50(%rsp)
mov    %r11,0x58(%rsp)
mov    %r10,0x60(%rsp)
mov    %rax,0x68(%rsp)
call   1030 <multiply_symbolic@plt>
movss  -0x2c(%rbp),%xmm0
mov    -0x30(%rbp),%edi
mov    -0x34(%rbp),%esi
mov    -0x38(%rbp),%eax
sub    -0x34(%rbp),%eax
shr    $0x1,%eax
imul   $0x0,%eax,%eax
add    %eax,%esi
mov    -0x34(%rbp),%edx
mov    -0x38(%rbp),%eax
sub    -0x34(%rbp),%eax
shr    $0x1,%eax
shl    $0x0,%eax
add    %eax,%edx
mov    -0x3c(%rbp),%ecx
mov    -0x40(%rbp),%eax
sub    -0x3c(%rbp),%eax
shr    $0x1,%eax
shl    $0x0,%eax
add    %eax,%ecx
mov    -0x3c(%rbp),%r8d
mov    -0x40(%rbp),%eax
sub    -0x3c(%rbp),%eax
shr    $0x1,%eax
shl    $0x1,%eax
add    %eax,%r8d
mov    -0x48(%rbp),%r9
mov    0x10(%rbp),%eax
mov    0x18(%rbp),%r10d
sub    0x10(%rbp),%r10d
shr    $0x1,%r10d
shl    $0x0,%r10d
add    %r10d,%eax
mov    %eax,-0x120(%rbp)
mov    0x10(%rbp),%eax
mov    0x18(%rbp),%r10d
sub    0x10(%rbp),%r10d
shr    $0x1,%r10d
shl    $0x1,%r10d
add    %r10d,%eax
mov    %eax,-0x11c(%rbp)
mov    0x20(%rbp),%eax
mov    0x28(%rbp),%r10d
sub    0x20(%rbp),%r10d
shr    $0x1,%r10d
shl    $0x0,%r10d
add    %r10d,%eax
mov    %eax,-0x118(%rbp)
mov    0x20(%rbp),%eax
mov    0x28(%rbp),%r10d
sub    0x20(%rbp),%r10d
shr    $0x1,%r10d
shl    $0x1,%r10d
add    %r10d,%eax
mov    %eax,-0x114(%rbp)
mov    0x30(%rbp),%rax
mov    %rax,-0x110(%rbp)
movss  -0x4c(%rbp),%xmm1
mov    0x38(%rbp),%eax
mov    0x40(%rbp),%r10d
sub    0x38(%rbp),%r10d
shr    $0x1,%r10d
imul   $0x0,%r10d,%r10d
add    %r10d,%eax
mov    %eax,-0x104(%rbp)
mov    0x38(%rbp),%r13d
mov    0x40(%rbp),%eax
sub    0x38(%rbp),%eax
shr    $0x1,%eax
shl    $0x0,%eax
add    %eax,%r13d
mov    0x48(%rbp),%r12d
mov    0x50(%rbp),%eax
sub    0x48(%rbp),%eax
shr    $0x1,%eax
shl    $0x0,%eax
add    %eax,%r12d
mov    0x48(%rbp),%r15d
mov    0x50(%rbp),%eax
sub    0x48(%rbp),%eax
shr    $0x1,%eax
shl    $0x1,%eax
add    %eax,%r15d
mov    0x58(%rbp),%r14
mov    0x60(%rbp),%rbx
mov    0x68(%rbp),%r11
mov    0x70(%rbp),%r10
mov    0x78(%rbp),%rax
mov    %rax,-0x100(%rbp)
mov    -0x120(%rbp),%eax
mov    %eax,(%rsp)
mov    -0x11c(%rbp),%eax
mov    %eax,0x8(%rsp)
mov    -0x118(%rbp),%eax
mov    %eax,0x10(%rsp)
mov    -0x114(%rbp),%eax
mov    %eax,0x18(%rsp)
mov    -0x110(%rbp),%rax
mov    %rax,0x20(%rsp)
mov    -0x104(%rbp),%eax
mov    %eax,0x28(%rsp)
mov    -0x100(%rbp),%rax
mov    %r13d,0x30(%rsp)
mov    %r12d,0x38(%rsp)
mov    %r15d,0x40(%rsp)
mov    %r14,0x48(%rsp)
mov    %rbx,0x50(%rsp)
mov    %r11,0x58(%rsp)
mov    %r10,0x60(%rsp)
mov    %rax,0x68(%rsp)
call   1030 <multiply_symbolic@plt>
movss  -0x2c(%rbp),%xmm0
mov    -0x30(%rbp),%edi
mov    -0x34(%rbp),%esi
mov    -0x38(%rbp),%eax
sub    -0x34(%rbp),%eax
shr    $0x1,%eax
shl    $0x0,%eax
add    %eax,%esi
mov    -0x34(%rbp),%edx
mov    -0x38(%rbp),%eax
sub    -0x34(%rbp),%eax
shr    $0x1,%eax
shl    $0x1,%eax
add    %eax,%edx
mov    -0x3c(%rbp),%ecx
mov    -0x40(%rbp),%eax
sub    -0x3c(%rbp),%eax
shr    $0x1,%eax
imul   $0x0,%eax,%eax
add    %eax,%ecx
mov    -0x3c(%rbp),%r8d
mov    -0x40(%rbp),%eax
sub    -0x3c(%rbp),%eax
shr    $0x1,%eax
shl    $0x0,%eax
add    %eax,%r8d
mov    -0x48(%rbp),%r9
mov    0x10(%rbp),%eax
mov    0x18(%rbp),%r10d
sub    0x10(%rbp),%r10d
shr    $0x1,%r10d
imul   $0x0,%r10d,%r10d
add    %r10d,%eax
mov    %eax,-0xf8(%rbp)
mov    0x10(%rbp),%eax
mov    0x18(%rbp),%r10d
sub    0x10(%rbp),%r10d
shr    $0x1,%r10d
shl    $0x0,%r10d
add    %r10d,%eax
mov    %eax,-0xf4(%rbp)
mov    0x20(%rbp),%eax
mov    0x28(%rbp),%r10d
sub    0x20(%rbp),%r10d
shr    $0x1,%r10d
imul   $0x0,%r10d,%r10d
add    %r10d,%eax
mov    %eax,-0xf0(%rbp)
mov    0x20(%rbp),%eax
mov    0x28(%rbp),%r10d
sub    0x20(%rbp),%r10d
shr    $0x1,%r10d
shl    $0x0,%r10d
add    %r10d,%eax
mov    %eax,-0xec(%rbp)
mov    0x30(%rbp),%rax
mov    %rax,-0xe8(%rbp)
movss  -0x4c(%rbp),%xmm1
mov    0x38(%rbp),%eax
mov    0x40(%rbp),%r10d
sub    0x38(%rbp),%r10d
shr    $0x1,%r10d
shl    $0x0,%r10d
add    %r10d,%eax
mov    %eax,-0xdc(%rbp)
mov    0x38(%rbp),%r13d
mov    0x40(%rbp),%eax
sub    0x38(%rbp),%eax
shr    $0x1,%eax
shl    $0x1,%eax
add    %eax,%r13d
mov    0x48(%rbp),%r12d
mov    0x50(%rbp),%eax
sub    0x48(%rbp),%eax
shr    $0x1,%eax
imul   $0x0,%eax,%eax
add    %eax,%r12d
mov    0x48(%rbp),%r15d
mov    0x50(%rbp),%eax
sub    0x48(%rbp),%eax
shr    $0x1,%eax
shl    $0x0,%eax
add    %eax,%r15d
mov    0x58(%rbp),%r14
mov    0x60(%rbp),%rbx
mov    0x68(%rbp),%r11
mov    0x70(%rbp),%r10
mov    0x78(%rbp),%rax
mov    %rax,-0xd8(%rbp)
mov    -0xf8(%rbp),%eax
mov    %eax,(%rsp)
mov    -0xf4(%rbp),%eax
mov    %eax,0x8(%rsp)
mov    -0xf0(%rbp),%eax
mov    %eax,0x10(%rsp)
mov    -0xec(%rbp),%eax
mov    %eax,0x18(%rsp)
mov    -0xe8(%rbp),%rax
mov    %rax,0x20(%rsp)
mov    -0xdc(%rbp),%eax
mov    %eax,0x28(%rsp)
mov    -0xd8(%rbp),%rax
mov    %r13d,0x30(%rsp)
mov    %r12d,0x38(%rsp)
mov    %r15d,0x40(%rsp)
mov    %r14,0x48(%rsp)
mov    %rbx,0x50(%rsp)
mov    %r11,0x58(%rsp)
mov    %r10,0x60(%rsp)
mov    %rax,0x68(%rsp)
call   1030 <multiply_symbolic@plt>
movss  -0x2c(%rbp),%xmm0
mov    -0x30(%rbp),%edi
mov    -0x34(%rbp),%esi
mov    -0x38(%rbp),%eax
sub    -0x34(%rbp),%eax
shr    $0x1,%eax
shl    $0x0,%eax
add    %eax,%esi
mov    -0x34(%rbp),%edx
mov    -0x38(%rbp),%eax
sub    -0x34(%rbp),%eax
shr    $0x1,%eax
shl    $0x1,%eax
add    %eax,%edx
mov    -0x3c(%rbp),%ecx
mov    -0x40(%rbp),%eax
sub    -0x3c(%rbp),%eax
shr    $0x1,%eax
shl    $0x0,%eax
add    %eax,%ecx
mov    -0x3c(%rbp),%r8d
mov    -0x40(%rbp),%eax
sub    -0x3c(%rbp),%eax
shr    $0x1,%eax
shl    $0x1,%eax
add    %eax,%r8d
mov    -0x48(%rbp),%r9
mov    0x10(%rbp),%eax
mov    0x18(%rbp),%r10d
sub    0x10(%rbp),%r10d
shr    $0x1,%r10d
shl    $0x0,%r10d
add    %r10d,%eax
mov    %eax,-0xd0(%rbp)
mov    0x10(%rbp),%eax
mov    0x18(%rbp),%r10d
sub    0x10(%rbp),%r10d
shr    $0x1,%r10d
shl    $0x1,%r10d
add    %r10d,%eax
mov    %eax,-0xcc(%rbp)
mov    0x20(%rbp),%eax
mov    0x28(%rbp),%r10d
sub    0x20(%rbp),%r10d
shr    $0x1,%r10d
imul   $0x0,%r10d,%r10d
add    %r10d,%eax
mov    %eax,-0xc8(%rbp)
mov    0x20(%rbp),%eax
mov    0x28(%rbp),%r10d
sub    0x20(%rbp),%r10d
shr    $0x1,%r10d
shl    $0x0,%r10d
add    %r10d,%eax
mov    %eax,-0xc4(%rbp)
mov    0x30(%rbp),%rax
mov    %rax,-0xc0(%rbp)
movss  -0x4c(%rbp),%xmm1
mov    0x38(%rbp),%eax
mov    0x40(%rbp),%r10d
sub    0x38(%rbp),%r10d
shr    $0x1,%r10d
shl    $0x0,%r10d
add    %r10d,%eax
mov    %eax,-0xb4(%rbp)
mov    0x38(%rbp),%r13d
mov    0x40(%rbp),%eax
sub    0x38(%rbp),%eax
shr    $0x1,%eax
shl    $0x1,%eax
add    %eax,%r13d
mov    0x48(%rbp),%r12d
mov    0x50(%rbp),%eax
sub    0x48(%rbp),%eax
shr    $0x1,%eax
imul   $0x0,%eax,%eax
add    %eax,%r12d
mov    0x48(%rbp),%r15d
mov    0x50(%rbp),%eax
sub    0x48(%rbp),%eax
shr    $0x1,%eax
shl    $0x0,%eax
add    %eax,%r15d
mov    0x58(%rbp),%r14
mov    0x60(%rbp),%rbx
mov    0x68(%rbp),%r11
mov    0x70(%rbp),%r10
mov    0x78(%rbp),%rax
mov    %rax,-0xb0(%rbp)
mov    -0xd0(%rbp),%eax
mov    %eax,(%rsp)
mov    -0xcc(%rbp),%eax
mov    %eax,0x8(%rsp)
mov    -0xc8(%rbp),%eax
mov    %eax,0x10(%rsp)
mov    -0xc4(%rbp),%eax
mov    %eax,0x18(%rsp)
mov    -0xc0(%rbp),%rax
mov    %rax,0x20(%rsp)
mov    -0xb4(%rbp),%eax
mov    %eax,0x28(%rsp)
mov    -0xb0(%rbp),%rax
mov    %r13d,0x30(%rsp)
mov    %r12d,0x38(%rsp)
mov    %r15d,0x40(%rsp)
mov    %r14,0x48(%rsp)
mov    %rbx,0x50(%rsp)
mov    %r11,0x58(%rsp)
mov    %r10,0x60(%rsp)
mov    %rax,0x68(%rsp)
call   1030 <multiply_symbolic@plt>
movss  -0x2c(%rbp),%xmm0
mov    -0x30(%rbp),%edi
mov    -0x34(%rbp),%esi
mov    -0x38(%rbp),%eax
sub    -0x34(%rbp),%eax
shr    $0x1,%eax
shl    $0x0,%eax
add    %eax,%esi
mov    -0x34(%rbp),%edx
mov    -0x38(%rbp),%eax
sub    -0x34(%rbp),%eax
shr    $0x1,%eax
shl    $0x1,%eax
add    %eax,%edx
mov    -0x3c(%rbp),%ecx
mov    -0x40(%rbp),%eax
sub    -0x3c(%rbp),%eax
shr    $0x1,%eax
imul   $0x0,%eax,%eax
add    %eax,%ecx
mov    -0x3c(%rbp),%r8d
mov    -0x40(%rbp),%eax
sub    -0x3c(%rbp),%eax
shr    $0x1,%eax
shl    $0x0,%eax
add    %eax,%r8d
mov    -0x48(%rbp),%r9
mov    0x10(%rbp),%eax
mov    0x18(%rbp),%r10d
sub    0x10(%rbp),%r10d
shr    $0x1,%r10d
imul   $0x0,%r10d,%r10d
add    %r10d,%eax
mov    %eax,-0xa8(%rbp)
mov    0x10(%rbp),%eax
mov    0x18(%rbp),%r10d
sub    0x10(%rbp),%r10d
shr    $0x1,%r10d
shl    $0x0,%r10d
add    %r10d,%eax
mov    %eax,-0xa4(%rbp)
mov    0x20(%rbp),%eax
mov    0x28(%rbp),%r10d
sub    0x20(%rbp),%r10d
shr    $0x1,%r10d
shl    $0x0,%r10d
add    %r10d,%eax
mov    %eax,-0xa0(%rbp)
mov    0x20(%rbp),%eax
mov    0x28(%rbp),%r10d
sub    0x20(%rbp),%r10d
shr    $0x1,%r10d
shl    $0x1,%r10d
add    %r10d,%eax
mov    %eax,-0x9c(%rbp)
mov    0x30(%rbp),%rax
mov    %rax,-0x98(%rbp)
movss  -0x4c(%rbp),%xmm1
mov    0x38(%rbp),%eax
mov    0x40(%rbp),%r10d
sub    0x38(%rbp),%r10d
shr    $0x1,%r10d
shl    $0x0,%r10d
add    %r10d,%eax
mov    %eax,-0x8c(%rbp)
mov    0x38(%rbp),%r13d
mov    0x40(%rbp),%eax
sub    0x38(%rbp),%eax
shr    $0x1,%eax
shl    $0x1,%eax
add    %eax,%r13d
mov    0x48(%rbp),%r12d
mov    0x50(%rbp),%eax
sub    0x48(%rbp),%eax
shr    $0x1,%eax
shl    $0x0,%eax
add    %eax,%r12d
mov    0x48(%rbp),%r15d
mov    0x50(%rbp),%eax
sub    0x48(%rbp),%eax
shr    $0x1,%eax
shl    $0x1,%eax
add    %eax,%r15d
mov    0x58(%rbp),%r14
mov    0x60(%rbp),%rbx
mov    0x68(%rbp),%r11
mov    0x70(%rbp),%r10
mov    0x78(%rbp),%rax
mov    %rax,-0x88(%rbp)
mov    -0xa8(%rbp),%eax
mov    %eax,(%rsp)
mov    -0xa4(%rbp),%eax
mov    %eax,0x8(%rsp)
mov    -0xa0(%rbp),%eax
mov    %eax,0x10(%rsp)
mov    -0x9c(%rbp),%eax
mov    %eax,0x18(%rsp)
mov    -0x98(%rbp),%rax
mov    %rax,0x20(%rsp)
mov    -0x8c(%rbp),%eax
mov    %eax,0x28(%rsp)
mov    -0x88(%rbp),%rax
mov    %r13d,0x30(%rsp)
mov    %r12d,0x38(%rsp)
mov    %r15d,0x40(%rsp)
mov    %r14,0x48(%rsp)
mov    %rbx,0x50(%rsp)
mov    %r11,0x58(%rsp)
mov    %r10,0x60(%rsp)
mov    %rax,0x68(%rsp)
call   1030 <multiply_symbolic@plt>
movss  -0x2c(%rbp),%xmm0
mov    -0x30(%rbp),%edi
mov    -0x34(%rbp),%esi
mov    -0x38(%rbp),%eax
sub    -0x34(%rbp),%eax
shr    $0x1,%eax
shl    $0x0,%eax
add    %eax,%esi
mov    -0x34(%rbp),%edx
mov    -0x38(%rbp),%eax
sub    -0x34(%rbp),%eax
shr    $0x1,%eax
shl    $0x1,%eax
add    %eax,%edx
mov    -0x3c(%rbp),%ecx
mov    -0x40(%rbp),%eax
sub    -0x3c(%rbp),%eax
shr    $0x1,%eax
shl    $0x0,%eax
add    %eax,%ecx
mov    -0x3c(%rbp),%r8d
mov    -0x40(%rbp),%eax
sub    -0x3c(%rbp),%eax
shr    $0x1,%eax
shl    $0x1,%eax
add    %eax,%r8d
mov    -0x48(%rbp),%r9
mov    0x10(%rbp),%eax
mov    0x18(%rbp),%r10d
sub    0x10(%rbp),%r10d
shr    $0x1,%r10d
shl    $0x0,%r10d
add    %r10d,%eax
mov    %eax,-0x80(%rbp)
mov    0x10(%rbp),%eax
mov    0x18(%rbp),%r10d
sub    0x10(%rbp),%r10d
shr    $0x1,%r10d
shl    $0x1,%r10d
add    %r10d,%eax
mov    %eax,-0x7c(%rbp)
mov    0x20(%rbp),%eax
mov    0x28(%rbp),%r10d
sub    0x20(%rbp),%r10d
shr    $0x1,%r10d
shl    $0x0,%r10d
add    %r10d,%eax
mov    %eax,-0x78(%rbp)
mov    0x20(%rbp),%eax
mov    0x28(%rbp),%r10d
sub    0x20(%rbp),%r10d
shr    $0x1,%r10d
shl    $0x1,%r10d
add    %r10d,%eax
mov    %eax,-0x74(%rbp)
mov    0x30(%rbp),%rax
mov    %rax,-0x70(%rbp)
movss  -0x4c(%rbp),%xmm1
mov    0x38(%rbp),%eax
mov    0x40(%rbp),%r10d
sub    0x38(%rbp),%r10d
shr    $0x1,%r10d
shl    $0x0,%r10d
add    %r10d,%eax
mov    %eax,-0x64(%rbp)
mov    0x38(%rbp),%r13d
mov    0x40(%rbp),%eax
sub    0x38(%rbp),%eax
shr    $0x1,%eax
shl    $0x1,%eax
add    %eax,%r13d
mov    0x48(%rbp),%r12d
mov    0x50(%rbp),%eax
sub    0x48(%rbp),%eax
shr    $0x1,%eax
shl    $0x0,%eax
add    %eax,%r12d
mov    0x48(%rbp),%r15d
mov    0x50(%rbp),%eax
sub    0x48(%rbp),%eax
shr    $0x1,%eax
shl    $0x1,%eax
add    %eax,%r15d
mov    0x58(%rbp),%r14
mov    0x60(%rbp),%rbx
mov    0x68(%rbp),%r11
mov    0x70(%rbp),%r10
mov    0x78(%rbp),%rax
mov    %rax,-0x60(%rbp)
mov    -0x80(%rbp),%eax
mov    %eax,(%rsp)
mov    -0x7c(%rbp),%eax
mov    %eax,0x8(%rsp)
mov    -0x78(%rbp),%eax
mov    %eax,0x10(%rsp)
mov    -0x74(%rbp),%eax
mov    %eax,0x18(%rsp)
mov    -0x70(%rbp),%rax
mov    %rax,0x20(%rsp)
mov    -0x64(%rbp),%eax
mov    %eax,0x28(%rsp)
mov    -0x60(%rbp),%rax
mov    %r13d,0x30(%rsp)
mov    %r12d,0x38(%rsp)
mov    %r15d,0x40(%rsp)
mov    %r14,0x48(%rsp)
mov    %rbx,0x50(%rsp)
mov    %r11,0x58(%rsp)
mov    %r10,0x60(%rsp)
mov    %rax,0x68(%rsp)
call   1030 <multiply_symbolic@plt>
add    $0x1e8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

x86 assembly (clang, -O2):
<multiply_symbolic>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x88,%rsp
mov    %r9,%rax
mov    %r8d,%ebp
mov    %ecx,%r10d
mov    %edi,%r8d
mov    0xf8(%rsp),%r11d
mov    0xe8(%rsp),%edi
mov    0xd0(%rsp),%ebx
mov    0xc0(%rsp),%r9d
sub    %esi,%edx
cmp    $0x1,%edx
jne    1179 <multiply_symbolic+0x59>
mov    %esi,%r15d
mov    %r10d,%esi
mov    %r9d,%ebp
mov    %ebx,%r14d
mov    %edi,%r12d
mov    %r11d,%r13d
jmp    169b <multiply_symbolic+0x57b>
mov    0x100(%rsp),%ecx
mov    %rcx,0x38(%rsp)
mov    0xf0(%rsp),%ecx
mov    %rcx,0x48(%rsp)
mov    0xd8(%rsp),%ecx
mov    %rcx,0x30(%rsp)
mov    0xc8(%rsp),%ecx
mov    %rcx,0x28(%rsp)
mov    %esi,%ecx
mov    %rax,0x40(%rsp)
mov    %ebp,0x14(%rsp)
mov    %rdi,%rax
mov    %r8d,0x10(%rsp)
movss  %xmm1,0xc(%rsp)
movss  %xmm0,0x8(%rsp)
nopl   0x0(%rax,%rax,1)
mov    %r9,0x58(%rsp)
mov    %edx,0x18(%rsp)
mov    %r8d,%edi
mov    %edx,%r15d
shr    %r15d
add    %ecx,%r15d
mov    0x14(%rsp),%edx
sub    %r10d,%edx
mov    %edx,0x14(%rsp)
mov    %ecx,%esi
mov    %ecx,0x1c(%rsp)
mov    %edx,%ecx
shr    %ecx
add    %r10d,%ecx
mov    %ecx,%r8d
mov    %ecx,0x20(%rsp)
mov    0x28(%rsp),%r12
sub    %r9d,%r12d
mov    %r12,0x28(%rsp)
shr    %r12d
add    %r9d,%r12d
mov    0x30(%rsp),%rcx
sub    %ebx,%ecx
mov    %rcx,0x30(%rsp)
shr    %ecx
add    %ebx,%ecx
mov    %rcx,0x60(%rsp)
mov    0x48(%rsp),%rcx
sub    %eax,%ecx
mov    %rcx,0x48(%rsp)
mov    %ecx,%edx
shr    %edx
add    %eax,%edx
mov    %rdx,%rbp
mov    %rdx,0x50(%rsp)
mov    0x38(%rsp),%r13
mov    %r11,0x80(%rsp)
sub    %r11d,%r13d
mov    %r13,0x38(%rsp)
shr    %r13d
add    %r11d,%r13d
movss  0x8(%rsp),%xmm0
mov    %rbx,%r14
mov    %rbx,0x70(%rsp)
mov    %r15d,%edx
mov    %r10d,%ecx
mov    %rax,%rbx
mov    %rax,0x78(%rsp)
mov    0x40(%rsp),%r9
movss  0xc(%rsp),%xmm1
mov    0x128(%rsp),%rax
push   %rax
mov    0x128(%rsp),%rax
push   %rax
mov    0x128(%rsp),%rax
push   %rax
mov    0x128(%rsp),%rax
push   %rax
mov    0x128(%rsp),%rax
push   %rax
push   %r13
push   %r11
push   %rbp
push   %rbx
mov    0x128(%rsp),%rax
push   %rax
push   0xb0(%rsp)
push   %r14
push   %r12
mov    0xc0(%rsp),%rbp
push   %rbp
mov    %r10d,%ebx
mov    %r10d,0x94(%rsp)
call   1030 <multiply_symbolic@plt>
add    $0x70,%rsp
mov    0x14(%rsp),%eax
and    $0xfffffffe,%eax
add    %ebx,%eax
mov    %eax,%r8d
mov    %eax,0x14(%rsp)
mov    0x28(%rsp),%rax
and    $0xfffffffe,%eax
add    %ebp,%eax
mov    %rax,0x28(%rsp)
mov    %r12,%r10
mov    %r12,0x68(%rsp)
movss  0x8(%rsp),%xmm0
mov    0x10(%rsp),%edi
mov    0x1c(%rsp),%esi
mov    %r15d,%edx
mov    0x20(%rsp),%r14d
mov    %r14d,%ecx
mov    0x40(%rsp),%r9
movss  0xc(%rsp),%xmm1
push   0x128(%rsp)
push   0x128(%rsp)
push   0x128(%rsp)
push   0x128(%rsp)
push   0x128(%rsp)
push   %r13
mov    0xb0(%rsp),%rbp
push   %rbp
push   0x88(%rsp)
push   0xb8(%rsp)
push   0x128(%rsp)
mov    0xb0(%rsp),%r12
push   %r12
mov    0xc8(%rsp),%rbx
push   %rbx
push   %rax
push   %r10
call   1030 <multiply_symbolic@plt>
add    $0x70,%rsp
mov    0x30(%rsp),%rax
and    $0xfffffffe,%eax
add    %ebx,%eax
mov    %rax,%r10
mov    %rax,0x30(%rsp)
mov    0x38(%rsp),%rax
and    $0xfffffffe,%eax
add    %ebp,%eax
mov    %rax,0x38(%rsp)
movss  0x8(%rsp),%xmm0
mov    0x10(%rsp),%edi
mov    0x1c(%rsp),%esi
mov    %r15d,%edx
mov    0x24(%rsp),%ecx
mov    %r14d,%r8d
mov    0x40(%rsp),%rbp
mov    %rbp,%r9
movss  0xc(%rsp),%xmm1
push   0x128(%rsp)
push   0x128(%rsp)
push   0x128(%rsp)
push   0x128(%rsp)
push   0x128(%rsp)
push   %rax
push   %r13
mov    0x88(%rsp),%rbx
push   %rbx
push   0xb8(%rsp)
push   0x128(%rsp)
push   %r10
push   %r12
mov    %r12,%r14
mov    0xc8(%rsp),%r12
push   %r12
push   0xc0(%rsp)
call   1030 <multiply_symbolic@plt>
add    $0x70,%rsp
movss  0x8(%rsp),%xmm0
mov    0x10(%rsp),%edi
mov    0x1c(%rsp),%esi
mov    %r15d,%edx
mov    0x20(%rsp),%ecx
mov    0x14(%rsp),%r8d
mov    %rbp,%r9
movss  0xc(%rsp),%xmm1
push   0x128(%rsp)
push   0x128(%rsp)
push   0x128(%rsp)
push   0x128(%rsp)
push   0x128(%rsp)
push   0x60(%rsp)
push   %r13
push   %rbx
mov    0xb8(%rsp),%rbx
push   %rbx
push   0x128(%rsp)
push   0x80(%rsp)
push   %r14
push   0x88(%rsp)
push   %r12
call   1030 <multiply_symbolic@plt>
add    $0x70,%rsp
andl   $0xfffffffe,0x18(%rsp)
mov    0x1c(%rsp),%eax
add    %eax,0x18(%rsp)
mov    0x48(%rsp),%rbp
and    $0xfffffffe,%ebp
add    %ebx,%ebp
mov    %rbp,%rax
mov    %rbp,0x48(%rsp)
movss  0x8(%rsp),%xmm0
mov    0x10(%rsp),%edi
mov    %r15d,%esi
mov    0x18(%rsp),%edx
mov    0x24(%rsp),%ecx
mov    0x20(%rsp),%r14d
mov    %r14d,%r8d
mov    0x40(%rsp),%rbp
mov    %rbp,%r9
movss  0xc(%rsp),%xmm1
mov    0x128(%rsp),%rbx
push   %rbx
mov    0x128(%rsp),%rbx
push   %rbx
mov    0x128(%rsp),%rbx
push   %rbx
mov    0x128(%rsp),%rbx
push   %rbx
mov    0x128(%rsp),%rbx
push   %rbx
push   %r13
mov    0xb0(%rsp),%r12
push   %r12
push   %rax
push   0x90(%rsp)
mov    0x128(%rsp),%rax
push   %rax
mov    0xb0(%rsp),%rbx
push   %rbx
push   0xc8(%rsp)
push   0xc8(%rsp)
push   0xc0(%rsp)
call   1030 <multiply_symbolic@plt>
add    $0x70,%rsp
movss  0x8(%rsp),%xmm0
mov    0x10(%rsp),%edi
mov    %r15d,%esi
mov    0x18(%rsp),%edx
mov    %r14d,%ecx
mov    0x14(%rsp),%r8d
mov    %rbp,%r9
movss  0xc(%rsp),%xmm1
push   0x128(%rsp)
push   0x128(%rsp)
push   0x128(%rsp)
push   0x128(%rsp)
push   0x128(%rsp)
push   %r13
push   %r12
mov    0x80(%rsp),%r12
push   %r12
push   0x90(%rsp)
push   0x128(%rsp)
push   %rbx
push   0xc8(%rsp)
push   0x88(%rsp)
mov    0xd0(%rsp),%rbp
push   %rbp
call   1030 <multiply_symbolic@plt>
add    $0x70,%rsp
movss  0x8(%rsp),%xmm0
mov    0x10(%rsp),%edi
mov    %r15d,%esi
mov    0x18(%rsp),%edx
mov    0x24(%rsp),%ecx
mov    %r14d,%r8d
mov    0x40(%rsp),%r9
movss  0xc(%rsp),%xmm1
push   0x128(%rsp)
push   0x128(%rsp)
push   0x128(%rsp)
push   0x128(%rsp)
push   0x128(%rsp)
push   0x60(%rsp)
push   %r13
push   %r12
mov    0x90(%rsp),%r12
push   %r12
push   0x128(%rsp)
push   0x80(%rsp)
push   %rbx
push   %rbp
push   0xc0(%rsp)
call   1030 <multiply_symbolic@plt>
mov    %r14d,%esi
mov    0x88(%rsp),%edx
mov    0x80(%rsp),%r8d
add    $0x70,%rsp
sub    %r15d,%edx
mov    %r13d,%r11d
mov    %r12,%rax
mov    %rbx,%r14
mov    %rbp,%r9
mov    %esi,%r10d
mov    %r15d,%ecx
cmp    $0x1,%edx
jne    11d0 <multiply_symbolic+0xb0>
mov    %r15d,%edi
mov    %r8d,%r15d
mov    %r8d,%edx
call   1040 <get_index@plt>
mov    0x110(%rsp),%rbx
mov    (%rbx),%ecx
mov    0x118(%rsp),%rdx
mov    %eax,(%rdx,%rcx,4)
mov    %ebp,%edi
mov    %r14d,%esi
mov    %r15d,%edx
call   1040 <get_index@plt>
mov    (%rbx),%ecx
mov    0x120(%rsp),%rdx
mov    %eax,(%rdx,%rcx,4)
mov    %r12d,%edi
mov    %r13d,%esi
mov    %r15d,%edx
call   1040 <get_index@plt>
mov    (%rbx),%ecx
mov    0x128(%rsp),%rdx
mov    %eax,(%rdx,%rcx,4)
addl   $0x1,(%rbx)
add    $0x88,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
define void @multiply_symbolic(float %0, i32 %1, i32 %2, i32 %3, i32 %4, i32 %5, [4 x [4 x float]]* %6, i32 %7, i32 %8, i32 %9, i32 %10, [4 x [4 x float]]* %11, float %12, i32 %13, i32 %14, i32 %15, i32 %16, [4 x [4 x float]]* %17, i32* %18, i32* %19, i32* %20, i32* %21) {
%23 = alloca float
%24 = alloca i32
%25 = alloca i32
%26 = alloca i32
%27 = alloca i32
%28 = alloca i32
%29 = alloca [4 x [4 x float]]*
%30 = alloca i32
%31 = alloca i32
%32 = alloca i32
%33 = alloca i32
%34 = alloca [4 x [4 x float]]*
%35 = alloca float
%36 = alloca i32
%37 = alloca i32
%38 = alloca i32
%39 = alloca i32
%40 = alloca [4 x [4 x float]]*
%41 = alloca i32*
%42 = alloca i32*
%43 = alloca i32*
%44 = alloca i32*
%45 = alloca i32
%46 = alloca i32
store float %0, float* %23
store i32 %1, i32* %24
store i32 %2, i32* %25
store i32 %3, i32* %26
store i32 %4, i32* %27
store i32 %5, i32* %28
store [4 x [4 x float]]* %6, [4 x [4 x float]]** %29
store i32 %7, i32* %30
store i32 %8, i32* %31
store i32 %9, i32* %32
store i32 %10, i32* %33
store [4 x [4 x float]]* %11, [4 x [4 x float]]** %34
store float %12, float* %35
store i32 %13, i32* %36
store i32 %14, i32* %37
store i32 %15, i32* %38
store i32 %16, i32* %39
store [4 x [4 x float]]* %17, [4 x [4 x float]]** %40
store i32* %18, i32** %41
store i32* %19, i32** %42
store i32* %20, i32** %43
store i32* %21, i32** %44
%47 = load i32, i32* %26
%48 = load i32, i32* %25
%49 = sub i32 %47, %48
%50 = icmp eq i32 %49, 1
br i1 %50, label %51, label %82
51: ; preds = %22
%52 = load i32, i32* %25
%53 = load i32, i32* %27
%54 = load i32, i32* %24
%55 = call i32 @get_index(i32 %52, i32 %53, i32 %54)
%56 = load i32*, i32** %42
%57 = load i32*, i32** %41
%58 = load i32, i32* %57
%59 = zext i32 %58 to i64
%60 = getelementptr inbounds i32, i32* %56, i64 %59
store i32 %55, i32* %60
%61 = load i32, i32* %30
%62 = load i32, i32* %32
%63 = load i32, i32* %24
%64 = call i32 @get_index(i32 %61, i32 %62, i32 %63)
%65 = load i32*, i32** %43
%66 = load i32*, i32** %41
%67 = load i32, i32* %66
%68 = zext i32 %67 to i64
%69 = getelementptr inbounds i32, i32* %65, i64 %68
store i32 %64, i32* %69
%70 = load i32, i32* %36
%71 = load i32, i32* %38
%72 = load i32, i32* %24
%73 = call i32 @get_index(i32 %70, i32 %71, i32 %72)
%74 = load i32*, i32** %44
%75 = load i32*, i32** %41
%76 = load i32, i32* %75
%77 = zext i32 %76 to i64
%78 = getelementptr inbounds i32, i32* %74, i64 %77
store i32 %73, i32* %78
%79 = load i32*, i32** %41
%80 = load i32, i32* %79
%81 = add i32 %80, 1
store i32 %81, i32* %79
br label %835
82: ; preds = %22
%83 = load float, float* %23
%84 = load i32, i32* %24
%85 = load i32, i32* %25
%86 = load i32, i32* %26
%87 = load i32, i32* %25
%88 = sub i32 %86, %87
%89 = udiv i32 %88, 2
%90 = mul i32 %89, 0
%91 = add i32 %85, %90
%92 = load i32, i32* %25
%93 = load i32, i32* %26
%94 = load i32, i32* %25
%95 = sub i32 %93, %94
%96 = udiv i32 %95, 2
%97 = mul i32 %96, 1
%98 = add i32 %92, %97
%99 = load i32, i32* %27
%100 = load i32, i32* %28
%101 = load i32, i32* %27
%102 = sub i32 %100, %101
%103 = udiv i32 %102, 2
%104 = mul i32 %103, 0
%105 = add i32 %99, %104
%106 = load i32, i32* %27
%107 = load i32, i32* %28
%108 = load i32, i32* %27
%109 = sub i32 %107, %108
%110 = udiv i32 %109, 2
%111 = mul i32 %110, 1
%112 = add i32 %106, %111
%113 = load [4 x [4 x float]]*, [4 x [4 x float]]** %29
%114 = load i32, i32* %30
%115 = load i32, i32* %31
%116 = load i32, i32* %30
%117 = sub i32 %115, %116
%118 = udiv i32 %117, 2
%119 = mul i32 %118, 0
%120 = add i32 %114, %119
%121 = load i32, i32* %30
%122 = load i32, i32* %31
%123 = load i32, i32* %30
%124 = sub i32 %122, %123
%125 = udiv i32 %124, 2
%126 = mul i32 %125, 1
%127 = add i32 %121, %126
%128 = load i32, i32* %32
%129 = load i32, i32* %33
%130 = load i32, i32* %32
%131 = sub i32 %129, %130
%132 = udiv i32 %131, 2
%133 = mul i32 %132, 0
%134 = add i32 %128, %133
%135 = load i32, i32* %32
%136 = load i32, i32* %33
%137 = load i32, i32* %32
%138 = sub i32 %136, %137
%139 = udiv i32 %138, 2
%140 = mul i32 %139, 1
%141 = add i32 %135, %140
%142 = load [4 x [4 x float]]*, [4 x [4 x float]]** %34
%143 = load float, float* %35
%144 = load i32, i32* %36
%145 = load i32, i32* %37
%146 = load i32, i32* %36
%147 = sub i32 %145, %146
%148 = udiv i32 %147, 2
%149 = mul i32 %148, 0
%150 = add i32 %144, %149
%151 = load i32, i32* %36
%152 = load i32, i32* %37
%153 = load i32, i32* %36
%154 = sub i32 %152, %153
%155 = udiv i32 %154, 2
%156 = mul i32 %155, 1
%157 = add i32 %151, %156
%158 = load i32, i32* %38
%159 = load i32, i32* %39
%160 = load i32, i32* %38
%161 = sub i32 %159, %160
%162 = udiv i32 %161, 2
%163 = mul i32 %162, 0
%164 = add i32 %158, %163
%165 = load i32, i32* %38
%166 = load i32, i32* %39
%167 = load i32, i32* %38
%168 = sub i32 %166, %167
%169 = udiv i32 %168, 2
%170 = mul i32 %169, 1
%171 = add i32 %165, %170
%172 = load [4 x [4 x float]]*, [4 x [4 x float]]** %40
%173 = load i32*, i32** %41
%174 = load i32*, i32** %42
%175 = load i32*, i32** %43
%176 = load i32*, i32** %44
%177 = load float, float* %23
%178 = load i32, i32* %24
%179 = load i32, i32* %25
%180 = load i32, i32* %26
%181 = load i32, i32* %25
%182 = sub i32 %180, %181
%183 = udiv i32 %182, 2
%184 = mul i32 %183, 0
%185 = add i32 %179, %184
%186 = load i32, i32* %25
%187 = load i32, i32* %26
%188 = load i32, i32* %25
%189 = sub i32 %187, %188
%190 = udiv i32 %189, 2
%191 = mul i32 %190, 1
%192 = add i32 %186, %191
%193 = load i32, i32* %27
%194 = load i32, i32* %28
%195 = load i32, i32* %27
%196 = sub i32 %194, %195
%197 = udiv i32 %196, 2
%198 = mul i32 %197, 1
%199 = add i32 %193, %198
%200 = load i32, i32* %27
%201 = load i32, i32* %28
%202 = load i32, i32* %27
%203 = sub i32 %201, %202
%204 = udiv i32 %203, 2
%205 = mul i32 %204, 2
%206 = add i32 %200, %205
%207 = load [4 x [4 x float]]*, [4 x [4 x float]]** %29
%208 = load i32, i32* %30
%209 = load i32, i32* %31
%210 = load i32, i32* %30
%211 = sub i32 %209, %210
%212 = udiv i32 %211, 2
%213 = mul i32 %212, 1
%214 = add i32 %208, %213
%215 = load i32, i32* %30
%216 = load i32, i32* %31
%217 = load i32, i32* %30
%218 = sub i32 %216, %217
%219 = udiv i32 %218, 2
%220 = mul i32 %219, 2
%221 = add i32 %215, %220
%222 = load i32, i32* %32
%223 = load i32, i32* %33
%224 = load i32, i32* %32
%225 = sub i32 %223, %224
%226 = udiv i32 %225, 2
%227 = mul i32 %226, 0
%228 = add i32 %222, %227
%229 = load i32, i32* %32
%230 = load i32, i32* %33
%231 = load i32, i32* %32
%232 = sub i32 %230, %231
%233 = udiv i32 %232, 2
%234 = mul i32 %233, 1
%235 = add i32 %229, %234
%236 = load [4 x [4 x float]]*, [4 x [4 x float]]** %34
%237 = load float, float* %35
%238 = load i32, i32* %36
%239 = load i32, i32* %37
%240 = load i32, i32* %36
%241 = sub i32 %239, %240
%242 = udiv i32 %241, 2
%243 = mul i32 %242, 0
%244 = add i32 %238, %243
%245 = load i32, i32* %36
%246 = load i32, i32* %37
%247 = load i32, i32* %36
%248 = sub i32 %246, %247
%249 = udiv i32 %248, 2
%250 = mul i32 %249, 1
%251 = add i32 %245, %250
%252 = load i32, i32* %38
%253 = load i32, i32* %39
%254 = load i32, i32* %38
%255 = sub i32 %253, %254
%256 = udiv i32 %255, 2
%257 = mul i32 %256, 0
%258 = add i32 %252, %257
%259 = load i32, i32* %38
%260 = load i32, i32* %39
%261 = load i32, i32* %38
%262 = sub i32 %260, %261
%263 = udiv i32 %262, 2
%264 = mul i32 %263, 1
%265 = add i32 %259, %264
%266 = load [4 x [4 x float]]*, [4 x [4 x float]]** %40
%267 = load i32*, i32** %41
%268 = load i32*, i32** %42
%269 = load i32*, i32** %43
%270 = load i32*, i32** %44
%271 = load float, float* %23
%272 = load i32, i32* %24
%273 = load i32, i32* %25
%274 = load i32, i32* %26
%275 = load i32, i32* %25
%276 = sub i32 %274, %275
%277 = udiv i32 %276, 2
%278 = mul i32 %277, 0
%279 = add i32 %273, %278
%280 = load i32, i32* %25
%281 = load i32, i32* %26
%282 = load i32, i32* %25
%283 = sub i32 %281, %282
%284 = udiv i32 %283, 2
%285 = mul i32 %284, 1
%286 = add i32 %280, %285
%287 = load i32, i32* %27
%288 = load i32, i32* %28
%289 = load i32, i32* %27
%290 = sub i32 %288, %289
%291 = udiv i32 %290, 2
%292 = mul i32 %291, 0
%293 = add i32 %287, %292
%294 = load i32, i32* %27
%295 = load i32, i32* %28
%296 = load i32, i32* %27
%297 = sub i32 %295, %296
%298 = udiv i32 %297, 2
%299 = mul i32 %298, 1
%300 = add i32 %294, %299
%301 = load [4 x [4 x float]]*, [4 x [4 x float]]** %29
%302 = load i32, i32* %30
%303 = load i32, i32* %31
%304 = load i32, i32* %30
%305 = sub i32 %303, %304
%306 = udiv i32 %305, 2
%307 = mul i32 %306, 0
%308 = add i32 %302, %307
%309 = load i32, i32* %30
%310 = load i32, i32* %31
%311 = load i32, i32* %30
%312 = sub i32 %310, %311
%313 = udiv i32 %312, 2
%314 = mul i32 %313, 1
%315 = add i32 %309, %314
%316 = load i32, i32* %32
%317 = load i32, i32* %33
%318 = load i32, i32* %32
%319 = sub i32 %317, %318
%320 = udiv i32 %319, 2
%321 = mul i32 %320, 1
%322 = add i32 %316, %321
%323 = load i32, i32* %32
%324 = load i32, i32* %33
%325 = load i32, i32* %32
%326 = sub i32 %324, %325
%327 = udiv i32 %326, 2
%328 = mul i32 %327, 2
%329 = add i32 %323, %328
%330 = load [4 x [4 x float]]*, [4 x [4 x float]]** %34
%331 = load float, float* %35
%332 = load i32, i32* %36
%333 = load i32, i32* %37
%334 = load i32, i32* %36
%335 = sub i32 %333, %334
%336 = udiv i32 %335, 2
%337 = mul i32 %336, 0
%338 = add i32 %332, %337
%339 = load i32, i32* %36
%340 = load i32, i32* %37
%341 = load i32, i32* %36
%342 = sub i32 %340, %341
%343 = udiv i32 %342, 2
%344 = mul i32 %343, 1
%345 = add i32 %339, %344
%346 = load i32, i32* %38
%347 = load i32, i32* %39
%348 = load i32, i32* %38
%349 = sub i32 %347, %348
%350 = udiv i32 %349, 2
%351 = mul i32 %350, 1
%352 = add i32 %346, %351
%353 = load i32, i32* %38
%354 = load i32, i32* %39
%355 = load i32, i32* %38
%356 = sub i32 %354, %355
%357 = udiv i32 %356, 2
%358 = mul i32 %357, 2
%359 = add i32 %353, %358
%360 = load [4 x [4 x float]]*, [4 x [4 x float]]** %40
%361 = load i32*, i32** %41
%362 = load i32*, i32** %42
%363 = load i32*, i32** %43
%364 = load i32*, i32** %44
%365 = load float, float* %23
%366 = load i32, i32* %24
%367 = load i32, i32* %25
%368 = load i32, i32* %26
%369 = load i32, i32* %25
%370 = sub i32 %368, %369
%371 = udiv i32 %370, 2
%372 = mul i32 %371, 0
%373 = add i32 %367, %372
%374 = load i32, i32* %25
%375 = load i32, i32* %26
%376 = load i32, i32* %25
%377 = sub i32 %375, %376
%378 = udiv i32 %377, 2
%379 = mul i32 %378, 1
%380 = add i32 %374, %379
%381 = load i32, i32* %27
%382 = load i32, i32* %28
%383 = load i32, i32* %27
%384 = sub i32 %382, %383
%385 = udiv i32 %384, 2
%386 = mul i32 %385, 1
%387 = add i32 %381, %386
%388 = load i32, i32* %27
%389 = load i32, i32* %28
%390 = load i32, i32* %27
%391 = sub i32 %389, %390
%392 = udiv i32 %391, 2
%393 = mul i32 %392, 2
%394 = add i32 %388, %393
%395 = load [4 x [4 x float]]*, [4 x [4 x float]]** %29
%396 = load i32, i32* %30
%397 = load i32, i32* %31
%398 = load i32, i32* %30
%399 = sub i32 %397, %398
%400 = udiv i32 %399, 2
%401 = mul i32 %400, 1
%402 = add i32 %396, %401
%403 = load i32, i32* %30
%404 = load i32, i32* %31
%405 = load i32, i32* %30
%406 = sub i32 %404, %405
%407 = udiv i32 %406, 2
%408 = mul i32 %407, 2
%409 = add i32 %403, %408
%410 = load i32, i32* %32
%411 = load i32, i32* %33
%412 = load i32, i32* %32
%413 = sub i32 %411, %412
%414 = udiv i32 %413, 2
%415 = mul i32 %414, 1
%416 = add i32 %410, %415
%417 = load i32, i32* %32
%418 = load i32, i32* %33
%419 = load i32, i32* %32
%420 = sub i32 %418, %419
%421 = udiv i32 %420, 2
%422 = mul i32 %421, 2
%423 = add i32 %417, %422
%424 = load [4 x [4 x float]]*, [4 x [4 x float]]** %34
%425 = load float, float* %35
%426 = load i32, i32* %36
%427 = load i32, i32* %37
%428 = load i32, i32* %36
%429 = sub i32 %427, %428
%430 = udiv i32 %429, 2
%431 = mul i32 %430, 0
%432 = add i32 %426, %431
%433 = load i32, i32* %36
%434 = load i32, i32* %37
%435 = load i32, i32* %36
%436 = sub i32 %434, %435
%437 = udiv i32 %436, 2
%438 = mul i32 %437, 1
%439 = add i32 %433, %438
%440 = load i32, i32* %38
%441 = load i32, i32* %39
%442 = load i32, i32* %38
%443 = sub i32 %441, %442
%444 = udiv i32 %443, 2
%445 = mul i32 %444, 1
%446 = add i32 %440, %445
%447 = load i32, i32* %38
%448 = load i32, i32* %39
%449 = load i32, i32* %38
%450 = sub i32 %448, %449
%451 = udiv i32 %450, 2
%452 = mul i32 %451, 2
%453 = add i32 %447, %452
%454 = load [4 x [4 x float]]*, [4 x [4 x float]]** %40
%455 = load i32*, i32** %41
%456 = load i32*, i32** %42
%457 = load i32*, i32** %43
%458 = load i32*, i32** %44
%459 = load float, float* %23
%460 = load i32, i32* %24
%461 = load i32, i32* %25
%462 = load i32, i32* %26
%463 = load i32, i32* %25
%464 = sub i32 %462, %463
%465 = udiv i32 %464, 2
%466 = mul i32 %465, 1
%467 = add i32 %461, %466
%468 = load i32, i32* %25
%469 = load i32, i32* %26
%470 = load i32, i32* %25
%471 = sub i32 %469, %470
%472 = udiv i32 %471, 2
%473 = mul i32 %472, 2
%474 = add i32 %468, %473
%475 = load i32, i32* %27
%476 = load i32, i32* %28
%477 = load i32, i32* %27
%478 = sub i32 %476, %477
%479 = udiv i32 %478, 2
%480 = mul i32 %479, 0
%481 = add i32 %475, %480
%482 = load i32, i32* %27
%483 = load i32, i32* %28
%484 = load i32, i32* %27
%485 = sub i32 %483, %484
%486 = udiv i32 %485, 2
%487 = mul i32 %486, 1
%488 = add i32 %482, %487
%489 = load [4 x [4 x float]]*, [4 x [4 x float]]** %29
%490 = load i32, i32* %30
%491 = load i32, i32* %31
%492 = load i32, i32* %30
%493 = sub i32 %491, %492
%494 = udiv i32 %493, 2
%495 = mul i32 %494, 0
%496 = add i32 %490, %495
%497 = load i32, i32* %30
%498 = load i32, i32* %31
%499 = load i32, i32* %30
%500 = sub i32 %498, %499
%501 = udiv i32 %500, 2
%502 = mul i32 %501, 1
%503 = add i32 %497, %502
%504 = load i32, i32* %32
%505 = load i32, i32* %33
%506 = load i32, i32* %32
%507 = sub i32 %505, %506
%508 = udiv i32 %507, 2
%509 = mul i32 %508, 0
%510 = add i32 %504, %509
%511 = load i32, i32* %32
%512 = load i32, i32* %33
%513 = load i32, i32* %32
%514 = sub i32 %512, %513
%515 = udiv i32 %514, 2
%516 = mul i32 %515, 1
%517 = add i32 %511, %516
%518 = load [4 x [4 x float]]*, [4 x [4 x float]]** %34
%519 = load float, float* %35
%520 = load i32, i32* %36
%521 = load i32, i32* %37
%522 = load i32, i32* %36
%523 = sub i32 %521, %522
%524 = udiv i32 %523, 2
%525 = mul i32 %524, 1
%526 = add i32 %520, %525
%527 = load i32, i32* %36
%528 = load i32, i32* %37
%529 = load i32, i32* %36
%530 = sub i32 %528, %529
%531 = udiv i32 %530, 2
%532 = mul i32 %531, 2
%533 = add i32 %527, %532
%534 = load i32, i32* %38
%535 = load i32, i32* %39
%536 = load i32, i32* %38
%537 = sub i32 %535, %536
%538 = udiv i32 %537, 2
%539 = mul i32 %538, 0
%540 = add i32 %534, %539
%541 = load i32, i32* %38
%542 = load i32, i32* %39
%543 = load i32, i32* %38
%544 = sub i32 %542, %543
%545 = udiv i32 %544, 2
%546 = mul i32 %545, 1
%547 = add i32 %541, %546
%548 = load [4 x [4 x float]]*, [4 x [4 x float]]** %40
%549 = load i32*, i32** %41
%550 = load i32*, i32** %42
%551 = load i32*, i32** %43
%552 = load i32*, i32** %44
%553 = load float, float* %23
%554 = load i32, i32* %24
%555 = load i32, i32* %25
%556 = load i32, i32* %26
%557 = load i32, i32* %25
%558 = sub i32 %556, %557
%559 = udiv i32 %558, 2
%560 = mul i32 %559, 1
%561 = add i32 %555, %560
%562 = load i32, i32* %25
%563 = load i32, i32* %26
%564 = load i32, i32* %25
%565 = sub i32 %563, %564
%566 = udiv i32 %565, 2
%567 = mul i32 %566, 2
%568 = add i32 %562, %567
%569 = load i32, i32* %27
%570 = load i32, i32* %28
%571 = load i32, i32* %27
%572 = sub i32 %570, %571
%573 = udiv i32 %572, 2
%574 = mul i32 %573, 1
%575 = add i32 %569, %574
%576 = load i32, i32* %27
%577 = load i32, i32* %28
%578 = load i32, i32* %27
%579 = sub i32 %577, %578
%580 = udiv i32 %579, 2
%581 = mul i32 %580, 2
%582 = add i32 %576, %581
%583 = load [4 x [4 x float]]*, [4 x [4 x float]]** %29
%584 = load i32, i32* %30
%585 = load i32, i32* %31
%586 = load i32, i32* %30
%587 = sub i32 %585, %586
%588 = udiv i32 %587, 2
%589 = mul i32 %588, 1
%590 = add i32 %584, %589
%591 = load i32, i32* %30
%592 = load i32, i32* %31
%593 = load i32, i32* %30
%594 = sub i32 %592, %593
%595 = udiv i32 %594, 2
%596 = mul i32 %595, 2
%597 = add i32 %591, %596
%598 = load i32, i32* %32
%599 = load i32, i32* %33
%600 = load i32, i32* %32
%601 = sub i32 %599, %600
%602 = udiv i32 %601, 2
%603 = mul i32 %602, 0
%604 = add i32 %598, %603
%605 = load i32, i32* %32
%606 = load i32, i32* %33
%607 = load i32, i32* %32
%608 = sub i32 %606, %607
%609 = udiv i32 %608, 2
%610 = mul i32 %609, 1
%611 = add i32 %605, %610
%612 = load [4 x [4 x float]]*, [4 x [4 x float]]** %34
%613 = load float, float* %35
%614 = load i32, i32* %36
%615 = load i32, i32* %37
%616 = load i32, i32* %36
%617 = sub i32 %615, %616
%618 = udiv i32 %617, 2
%619 = mul i32 %618, 1
%620 = add i32 %614, %619
%621 = load i32, i32* %36
%622 = load i32, i32* %37
%623 = load i32, i32* %36
%624 = sub i32 %622, %623
%625 = udiv i32 %624, 2
%626 = mul i32 %625, 2
%627 = add i32 %621, %626
%628 = load i32, i32* %38
%629 = load i32, i32* %39
%630 = load i32, i32* %38
%631 = sub i32 %629, %630
%632 = udiv i32 %631, 2
%633 = mul i32 %632, 0
%634 = add i32 %628, %633
%635 = load i32, i32* %38
%636 = load i32, i32* %39
%637 = load i32, i32* %38
%638 = sub i32 %636, %637
%639 = udiv i32 %638, 2
%640 = mul i32 %639, 1
%641 = add i32 %635, %640
%642 = load [4 x [4 x float]]*, [4 x [4 x float]]** %40
%643 = load i32*, i32** %41
%644 = load i32*, i32** %42
%645 = load i32*, i32** %43
%646 = load i32*, i32** %44
%647 = load float, float* %23
%648 = load i32, i32* %24
%649 = load i32, i32* %25
%650 = load i32, i32* %26
%651 = load i32, i32* %25
%652 = sub i32 %650, %651
%653 = udiv i32 %652, 2
%654 = mul i32 %653, 1
%655 = add i32 %649, %654
%656 = load i32, i32* %25
%657 = load i32, i32* %26
%658 = load i32, i32* %25
%659 = sub i32 %657, %658
%660 = udiv i32 %659, 2
%661 = mul i32 %660, 2
%662 = add i32 %656, %661
%663 = load i32, i32* %27
%664 = load i32, i32* %28
%665 = load i32, i32* %27
%666 = sub i32 %664, %665
%667 = udiv i32 %666, 2
%668 = mul i32 %667, 0
%669 = add i32 %663, %668
%670 = load i32, i32* %27
%671 = load i32, i32* %28
%672 = load i32, i32* %27
%673 = sub i32 %671, %672
%674 = udiv i32 %673, 2
%675 = mul i32 %674, 1
%676 = add i32 %670, %675
%677 = load [4 x [4 x float]]*, [4 x [4 x float]]** %29
%678 = load i32, i32* %30
%679 = load i32, i32* %31
%680 = load i32, i32* %30
%681 = sub i32 %679, %680
%682 = udiv i32 %681, 2
%683 = mul i32 %682, 0
%684 = add i32 %678, %683
%685 = load i32, i32* %30
%686 = load i32, i32* %31
%687 = load i32, i32* %30
%688 = sub i32 %686, %687
%689 = udiv i32 %688, 2
%690 = mul i32 %689, 1
%691 = add i32 %685, %690
%692 = load i32, i32* %32
%693 = load i32, i32* %33
%694 = load i32, i32* %32
%695 = sub i32 %693, %694
%696 = udiv i32 %695, 2
%697 = mul i32 %696, 1
%698 = add i32 %692, %697
%699 = load i32, i32* %32
%700 = load i32, i32* %33
%701 = load i32, i32* %32
%702 = sub i32 %700, %701
%703 = udiv i32 %702, 2
%704 = mul i32 %703, 2
%705 = add i32 %699, %704
%706 = load [4 x [4 x float]]*, [4 x [4 x float]]** %34
%707 = load float, float* %35
%708 = load i32, i32* %36
%709 = load i32, i32* %37
%710 = load i32, i32* %36
%711 = sub i32 %709, %710
%712 = udiv i32 %711, 2
%713 = mul i32 %712, 1
%714 = add i32 %708, %713
%715 = load i32, i32* %36
%716 = load i32, i32* %37
%717 = load i32, i32* %36
%718 = sub i32 %716, %717
%719 = udiv i32 %718, 2
%720 = mul i32 %719, 2
%721 = add i32 %715, %720
%722 = load i32, i32* %38
%723 = load i32, i32* %39
%724 = load i32, i32* %38
%725 = sub i32 %723, %724
%726 = udiv i32 %725, 2
%727 = mul i32 %726, 1
%728 = add i32 %722, %727
%729 = load i32, i32* %38
%730 = load i32, i32* %39
%731 = load i32, i32* %38
%732 = sub i32 %730, %731
%733 = udiv i32 %732, 2
%734 = mul i32 %733, 2
%735 = add i32 %729, %734
%736 = load [4 x [4 x float]]*, [4 x [4 x float]]** %40
%737 = load i32*, i32** %41
%738 = load i32*, i32** %42
%739 = load i32*, i32** %43
%740 = load i32*, i32** %44
%741 = load float, float* %23
%742 = load i32, i32* %24
%743 = load i32, i32* %25
%744 = load i32, i32* %26
%745 = load i32, i32* %25
%746 = sub i32 %744, %745
%747 = udiv i32 %746, 2
%748 = mul i32 %747, 1
%749 = add i32 %743, %748
%750 = load i32, i32* %25
%751 = load i32, i32* %26
%752 = load i32, i32* %25
%753 = sub i32 %751, %752
%754 = udiv i32 %753, 2
%755 = mul i32 %754, 2
%756 = add i32 %750, %755
%757 = load i32, i32* %27
%758 = load i32, i32* %28
%759 = load i32, i32* %27
%760 = sub i32 %758, %759
%761 = udiv i32 %760, 2
%762 = mul i32 %761, 1
%763 = add i32 %757, %762
%764 = load i32, i32* %27
%765 = load i32, i32* %28
%766 = load i32, i32* %27
%767 = sub i32 %765, %766
%768 = udiv i32 %767, 2
%769 = mul i32 %768, 2
%770 = add i32 %764, %769
%771 = load [4 x [4 x float]]*, [4 x [4 x float]]** %29
%772 = load i32, i32* %30
%773 = load i32, i32* %31
%774 = load i32, i32* %30
%775 = sub i32 %773, %774
%776 = udiv i32 %775, 2
%777 = mul i32 %776, 1
%778 = add i32 %772, %777
%779 = load i32, i32* %30
%780 = load i32, i32* %31
%781 = load i32, i32* %30
%782 = sub i32 %780, %781
%783 = udiv i32 %782, 2
%784 = mul i32 %783, 2
%785 = add i32 %779, %784
%786 = load i32, i32* %32
%787 = load i32, i32* %33
%788 = load i32, i32* %32
%789 = sub i32 %787, %788
%790 = udiv i32 %789, 2
%791 = mul i32 %790, 1
%792 = add i32 %786, %791
%793 = load i32, i32* %32
%794 = load i32, i32* %33
%795 = load i32, i32* %32
%796 = sub i32 %794, %795
%797 = udiv i32 %796, 2
%798 = mul i32 %797, 2
%799 = add i32 %793, %798
%800 = load [4 x [4 x float]]*, [4 x [4 x float]]** %34
%801 = load float, float* %35
%802 = load i32, i32* %36
%803 = load i32, i32* %37
%804 = load i32, i32* %36
%805 = sub i32 %803, %804
%806 = udiv i32 %805, 2
%807 = mul i32 %806, 1
%808 = add i32 %802, %807
%809 = load i32, i32* %36
%810 = load i32, i32* %37
%811 = load i32, i32* %36
%812 = sub i32 %810, %811
%813 = udiv i32 %812, 2
%814 = mul i32 %813, 2
%815 = add i32 %809, %814
%816 = load i32, i32* %38
%817 = load i32, i32* %39
%818 = load i32, i32* %38
%819 = sub i32 %817, %818
%820 = udiv i32 %819, 2
%821 = mul i32 %820, 1
%822 = add i32 %816, %821
%823 = load i32, i32* %38
%824 = load i32, i32* %39
%825 = load i32, i32* %38
%826 = sub i32 %824, %825
%827 = udiv i32 %826, 2
%828 = mul i32 %827, 2
%829 = add i32 %823, %828
%830 = load [4 x [4 x float]]*, [4 x [4 x float]]** %40
%831 = load i32*, i32** %41
%832 = load i32*, i32** %42
%833 = load i32*, i32** %43
%834 = load i32*, i32** %44
br label %835
835: ; preds = %82, %51
ret void
}

LLVM IR (-O2):
define void @multiply_symbolic(float %0, i32 %1, i32 %2, i32 %3, i32 %4, i32 %5, [4 x [4 x float]]* %6, i32 %7, i32 %8, i32 %9, i32 %10, [4 x [4 x float]]* %11, float %12, i32 %13, i32 %14, i32 %15, i32 %16, [4 x [4 x float]]* %17, i32* %18, i32* %19, i32* %20, i32* %21) {
%23 = sub i32 %3, %2
%24 = icmp eq i32 %23, 1
br i1 %24, label %25, label %46
25: ; preds = %46, %22
%26 = phi i32 [ %2, %22 ], [ %60, %46 ]
%27 = phi i32 [ %4, %22 ], [ %63, %46 ]
%28 = phi i32 [ %7, %22 ], [ %66, %46 ]
%29 = phi i32 [ %9, %22 ], [ %69, %46 ]
%30 = phi i32 [ %13, %22 ], [ %72, %46 ]
%31 = phi i32 [ %15, %22 ], [ %75, %46 ]
%32 = tail call i32 @get_index(i32 %26, i32 %27, i32 %1)
%33 = load i32, i32* %18
%34 = zext i32 %33 to i64
%35 = getelementptr inbounds i32, i32* %19, i64 %34
store i32 %32, i32* %35
%36 = tail call i32 @get_index(i32 %28, i32 %29, i32 %1)
%37 = load i32, i32* %18
%38 = zext i32 %37 to i64
%39 = getelementptr inbounds i32, i32* %20, i64 %38
store i32 %36, i32* %39
%40 = tail call i32 @get_index(i32 %30, i32 %31, i32 %1)
%41 = load i32, i32* %18
%42 = zext i32 %41 to i64
%43 = getelementptr inbounds i32, i32* %21, i64 %42
store i32 %40, i32* %43
%44 = load i32, i32* %18
%45 = add i32 %44, 1
store i32 %45, i32* %18
ret void
46: ; preds = %22, %46
%47 = phi i32 [ %88, %46 ], [ %23, %22 ]
%48 = phi i32 [ %83, %46 ], [ %16, %22 ]
%49 = phi i32 [ %75, %46 ], [ %15, %22 ]
%50 = phi i32 [ %87, %46 ], [ %14, %22 ]
%51 = phi i32 [ %72, %46 ], [ %13, %22 ]
%52 = phi i32 [ %81, %46 ], [ %10, %22 ]
%53 = phi i32 [ %69, %46 ], [ %9, %22 ]
%54 = phi i32 [ %79, %46 ], [ %8, %22 ]
%55 = phi i32 [ %66, %46 ], [ %7, %22 ]
%56 = phi i32 [ %77, %46 ], [ %5, %22 ]
%57 = phi i32 [ %63, %46 ], [ %4, %22 ]
%58 = phi i32 [ %60, %46 ], [ %2, %22 ]
%59 = lshr i32 %47, 1
%60 = add i32 %59, %58
%61 = sub i32 %56, %57
%62 = lshr i32 %61, 1
%63 = add i32 %62, %57
%64 = sub i32 %54, %55
%65 = lshr i32 %64, 1
%66 = add i32 %65, %55
%67 = sub i32 %52, %53
%68 = lshr i32 %67, 1
%69 = add i32 %68, %53
%70 = sub i32 %50, %51
%71 = lshr i32 %70, 1
%72 = add i32 %71, %51
%73 = sub i32 %48, %49
%74 = lshr i32 %73, 1
%75 = add i32 %74, %49
tail call void @multiply_symbolic(float %0, i32 %1, i32 %58, i32 %60, i32 %57, i32 %63, [4 x [4 x float]]* %6, i32 %55, i32 %66, i32 %53, i32 %69, [4 x [4 x float]]* %11, float %12, i32 %51, i32 %72, i32 %49, i32 %75, [4 x [4 x float]]* %17, i32* %18, i32* %19, i32* %20, i32* %21)
%76 = and i32 %61, -2
%77 = add i32 %76, %57
%78 = and i32 %64, -2
%79 = add i32 %78, %55
tail call void @multiply_symbolic(float %0, i32 %1, i32 %58, i32 %60, i32 %63, i32 %77, [4 x [4 x float]]* %6, i32 %66, i32 %79, i32 %53, i32 %69, [4 x [4 x float]]* %11, float %12, i32 %51, i32 %72, i32 %49, i32 %75, [4 x [4 x float]]* %17, i32* %18, i32* %19, i32* %20, i32* %21)
%80 = and i32 %67, -2
%81 = add i32 %80, %53
%82 = and i32 %73, -2
%83 = add i32 %82, %49
tail call void @multiply_symbolic(float %0, i32 %1, i32 %58, i32 %60, i32 %57, i32 %63, [4 x [4 x float]]* %6, i32 %55, i32 %66, i32 %69, i32 %81, [4 x [4 x float]]* %11, float %12, i32 %51, i32 %72, i32 %75, i32 %83, [4 x [4 x float]]* %17, i32* %18, i32* %19, i32* %20, i32* %21)
tail call void @multiply_symbolic(float %0, i32 %1, i32 %58, i32 %60, i32 %63, i32 %77, [4 x [4 x float]]* %6, i32 %66, i32 %79, i32 %69, i32 %81, [4 x [4 x float]]* %11, float %12, i32 %51, i32 %72, i32 %75, i32 %83, [4 x [4 x float]]* %17, i32* %18, i32* %19, i32* %20, i32* %21)
%84 = and i32 %47, -2
%85 = add i32 %84, %58
%86 = and i32 %70, -2
%87 = add i32 %86, %51
tail call void @multiply_symbolic(float %0, i32 %1, i32 %60, i32 %85, i32 %57, i32 %63, [4 x [4 x float]]* %6, i32 %55, i32 %66, i32 %53, i32 %69, [4 x [4 x float]]* %11, float %12, i32 %72, i32 %87, i32 %49, i32 %75, [4 x [4 x float]]* %17, i32* %18, i32* %19, i32* %20, i32* %21)
tail call void @multiply_symbolic(float %0, i32 %1, i32 %60, i32 %85, i32 %63, i32 %77, [4 x [4 x float]]* %6, i32 %66, i32 %79, i32 %53, i32 %69, [4 x [4 x float]]* %11, float %12, i32 %72, i32 %87, i32 %49, i32 %75, [4 x [4 x float]]* %17, i32* %18, i32* %19, i32* %20, i32* %21)
tail call void @multiply_symbolic(float %0, i32 %1, i32 %60, i32 %85, i32 %57, i32 %63, [4 x [4 x float]]* %6, i32 %55, i32 %66, i32 %69, i32 %81, [4 x [4 x float]]* %11, float %12, i32 %72, i32 %87, i32 %75, i32 %83, [4 x [4 x float]]* %17, i32* %18, i32* %19, i32* %20, i32* %21)
%88 = sub i32 %85, %60
%89 = icmp eq i32 %88, 1
br i1 %89, label %25, label %46
}