#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 */
int /*<<< orphan*/ exit(int /*<<< orphan*/);
int /*<<< orphan*/ fgets(char *, int, int /*<<< orphan*/);
int /*<<< orphan*/ printf(char *, ...);
int /*<<< orphan*/ sscanf(char *, char *, ...);
int /*<<< orphan*/ stdin;
void initLineModel(int *line_num, int *loop_num, int line_mode[26],
                   double inter_coord[10][26][26][3]) {
  int i, j, k;
  char buf[256];
  int hno, vno;
  double dist1, dist2;
  hno = 7;
  vno = 9;
  *loop_num = 5;
  dist1 = 40.0;
  dist2 = 100.0;
  printf("Number of horizontal lines (%d): ", hno);
  fgets(buf, 256, stdin);
  sscanf(buf, "%d", &hno);
  printf("Number of vertical lines (%d): ", vno);
  fgets(buf, 256, stdin);
  sscanf(buf, "%d", &vno);
  if (hno + vno > 26) {
    printf("too many lines!!\n");
    exit(0);
  }
  printf("Number of iteration (%d): ", *loop_num);
  fgets(buf, 256, stdin);
  sscanf(buf, "%d", loop_num);
  if (*loop_num > 10) {
    printf("too many iteration!!\n");
    exit(0);
  }
  printf("Distance among lines (%f): ", dist1);
  fgets(buf, 256, stdin);
  sscanf(buf, "%lf", &dist1);
  printf("Distance to move (%f): ", dist2);
  fgets(buf, 256, stdin);
  sscanf(buf, "%lf", &dist2);
  *line_num = hno + vno;
  for (i = 0; i < hno; i++)
    line_mode[i] = 0;
  for (i = 0; i < vno; i++)
    line_mode[i + hno] = 1;
  for (k = 0; k < 10; k++) {
    for (i = 0; i < 26; i++) {
      for (j = 0; j < 26; j++) {
        inter_coord[k][j][i][0] = -10000.0;
        inter_coord[k][j][i][1] = -10000.0;
        inter_coord[k][j][i][2] = -10000.0;
      }
    }
  }
  for (k = 0; k < *loop_num; k++) {
    for (j = 0; j < hno; j++) {
      for (i = 0; i < vno; i++) {
        inter_coord[k][j][i + hno][0] = dist1 * i;
        inter_coord[k][j][i + hno][1] = dist1 * j;
        inter_coord[k][j][i + hno][2] = dist2 * k;
      }
    }
  }
}


x86 assembly (clang, -O0):
<initLineModel>:
push   %rbp
mov    %rsp,%rbp
sub    $0x150,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
movl   $0x7,-0x134(%rbp)
movl   $0x9,-0x138(%rbp)
mov    -0x10(%rbp),%rax
movl   $0x5,(%rax)
movsd  0xe87(%rip),%xmm0
movsd  %xmm0,-0x140(%rbp)
ff
movsd  0xe6f(%rip),%xmm0
movsd  %xmm0,-0x148(%rbp)
ff
mov    -0x134(%rbp),%esi
lea    0xe72(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    -0x130(%rbp),%rdi
mov    0x2e2d(%rip),%rax
mov    (%rax),%edx
mov    $0x100,%esi
call   1040 <fgets@plt>
lea    -0x130(%rbp),%rdi
lea    0xe65(%rip),%rsi
lea    -0x134(%rbp),%rdx
mov    $0x0,%al
call   1050 <sscanf@plt>
mov    -0x138(%rbp),%esi
lea    0xe4d(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    -0x130(%rbp),%rdi
mov    0x2de3(%rip),%rax
mov    (%rax),%edx
mov    $0x100,%esi
call   1040 <fgets@plt>
lea    -0x130(%rbp),%rdi
lea    0xe1b(%rip),%rsi
lea    -0x138(%rbp),%rdx
mov    $0x0,%al
call   1050 <sscanf@plt>
mov    -0x134(%rbp),%eax
add    -0x138(%rbp),%eax
cmp    $0x1a,%eax
jle    1257 <initLineModel+0x117>
lea    0xe14(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
xor    %edi,%edi
call   1060 <exit@plt>
mov    -0x10(%rbp),%rax
mov    (%rax),%esi
lea    0xe0b(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    -0x130(%rbp),%rdi
mov    0x2d6f(%rip),%rax
mov    (%rax),%edx
mov    $0x100,%esi
call   1040 <fgets@plt>
lea    -0x130(%rbp),%rdi
mov    -0x10(%rbp),%rdx
lea    0xda3(%rip),%rsi
mov    $0x0,%al
call   1050 <sscanf@plt>
mov    -0x10(%rbp),%rax
cmpl   $0xa,(%rax)
jle    12c0 <initLineModel+0x180>
lea    0xdd8(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
xor    %edi,%edi
call   1060 <exit@plt>
movsd  -0x140(%rbp),%xmm0
ff
lea    0xdd1(%rip),%rdi
mov    $0x1,%al
call   1030 <printf@plt>
lea    -0x130(%rbp),%rdi
mov    0x2d04(%rip),%rax
mov    (%rax),%edx
mov    $0x100,%esi
call   1040 <fgets@plt>
lea    -0x130(%rbp),%rdi
lea    0xdbe(%rip),%rsi
lea    -0x140(%rbp),%rdx
mov    $0x0,%al
call   1050 <sscanf@plt>
movsd  -0x148(%rbp),%xmm0
ff
lea    0xda5(%rip),%rdi
mov    $0x1,%al
call   1030 <printf@plt>
lea    -0x130(%rbp),%rdi
mov    0x2cb8(%rip),%rax
mov    (%rax),%edx
mov    $0x100,%esi
call   1040 <fgets@plt>
lea    -0x130(%rbp),%rdi
lea    0xd72(%rip),%rsi
lea    -0x148(%rbp),%rdx
mov    $0x0,%al
call   1050 <sscanf@plt>
mov    -0x134(%rbp),%ecx
add    -0x138(%rbp),%ecx
mov    -0x8(%rbp),%rax
mov    %ecx,(%rax)
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x134(%rbp),%eax
jge    139d <initLineModel+0x25d>
mov    -0x18(%rbp),%rax
movslq -0x24(%rbp),%rcx
movl   $0x0,(%rax,%rcx,4)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    1371 <initLineModel+0x231>
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x138(%rbp),%eax
jge    13d8 <initLineModel+0x298>
mov    -0x18(%rbp),%rax
mov    -0x24(%rbp),%ecx
add    -0x134(%rbp),%ecx
movslq %ecx,%rcx
movl   $0x1,(%rax,%rcx,4)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    13a4 <initLineModel+0x264>
movl   $0x0,-0x2c(%rbp)
cmpl   $0xa,-0x2c(%rbp)
jge    14e6 <initLineModel+0x3a6>
movl   $0x0,-0x24(%rbp)
cmpl   $0x1a,-0x24(%rbp)
jge    14d3 <initLineModel+0x393>
movl   $0x0,-0x28(%rbp)
cmpl   $0x1a,-0x28(%rbp)
jge    14c0 <initLineModel+0x380>
mov    -0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
imul   $0x3f60,%rcx,%rcx
add    %rcx,%rax
movslq -0x28(%rbp),%rcx
imul   $0x270,%rcx,%rcx
add    %rcx,%rax
movslq -0x24(%rbp),%rcx
imul   $0x18,%rcx,%rcx
add    %rcx,%rax
movsd  0xbd2(%rip),%xmm0
movsd  %xmm0,(%rax)
mov    -0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
imul   $0x3f60,%rcx,%rcx
add    %rcx,%rax
movslq -0x28(%rbp),%rcx
imul   $0x270,%rcx,%rcx
add    %rcx,%rax
movslq -0x24(%rbp),%rcx
imul   $0x18,%rcx,%rcx
add    %rcx,%rax
movsd  0xb9b(%rip),%xmm0
movsd  %xmm0,0x8(%rax)
mov    -0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
imul   $0x3f60,%rcx,%rcx
add    %rcx,%rax
movslq -0x28(%rbp),%rcx
imul   $0x270,%rcx,%rcx
add    %rcx,%rax
movslq -0x24(%rbp),%rcx
imul   $0x18,%rcx,%rcx
add    %rcx,%rax
movsd  0xb63(%rip),%xmm0
movsd  %xmm0,0x10(%rax)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    1401 <initLineModel+0x2c1>
jmp    14c5 <initLineModel+0x385>
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    13f0 <initLineModel+0x2b0>
jmp    14d8 <initLineModel+0x398>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    13df <initLineModel+0x29f>
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
mov    -0x10(%rbp),%rcx
cmp    (%rcx),%eax
jge    1636 <initLineModel+0x4f6>
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x134(%rbp),%eax
jge    1623 <initLineModel+0x4e3>
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x138(%rbp),%eax
jge    1610 <initLineModel+0x4d0>
movsd  -0x140(%rbp),%xmm0
ff
cvtsi2sdl -0x24(%rbp),%xmm1
mulsd  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
imul   $0x3f60,%rcx,%rcx
add    %rcx,%rax
movslq -0x28(%rbp),%rcx
imul   $0x270,%rcx,%rcx
add    %rcx,%rax
mov    -0x24(%rbp),%ecx
add    -0x134(%rbp),%ecx
movslq %ecx,%rcx
imul   $0x18,%rcx,%rcx
add    %rcx,%rax
movsd  %xmm0,(%rax)
movsd  -0x140(%rbp),%xmm0
ff
cvtsi2sdl -0x28(%rbp),%xmm1
mulsd  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
imul   $0x3f60,%rcx,%rcx
add    %rcx,%rax
movslq -0x28(%rbp),%rcx
imul   $0x270,%rcx,%rcx
add    %rcx,%rax
mov    -0x24(%rbp),%ecx
add    -0x134(%rbp),%ecx
movslq %ecx,%rcx
imul   $0x18,%rcx,%rcx
add    %rcx,%rax
movsd  %xmm0,0x8(%rax)
movsd  -0x148(%rbp),%xmm0
ff
cvtsi2sdl -0x2c(%rbp),%xmm1
mulsd  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
imul   $0x3f60,%rcx,%rcx
add    %rcx,%rax
movslq -0x28(%rbp),%rcx
imul   $0x270,%rcx,%rcx
add    %rcx,%rax
mov    -0x24(%rbp),%ecx
add    -0x134(%rbp),%ecx
movslq %ecx,%rcx
imul   $0x18,%rcx,%rcx
add    %rcx,%rax
movsd  %xmm0,0x10(%rax)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    1519 <initLineModel+0x3d9>
jmp    1615 <initLineModel+0x4d5>
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    1503 <initLineModel+0x3c3>
jmp    1628 <initLineModel+0x4e8>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    14ed <initLineModel+0x3ad>
add    $0x150,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<initLineModel>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x138,%rsp
mov    %rcx,%r15
mov    %rdx,0x28(%rsp)
mov    %rsi,%r14
mov    %rdi,%rbx
movl   $0x7,0x4(%rsp)
movl   $0x9,(%rsp)
movl   $0x5,(%rsi)
movabs $0x4044000000000000,%rax
mov    %rax,0x10(%rsp)
movabs $0x4059000000000000,%rax
mov    %rax,0x8(%rsp)
lea    0xea7(%rip),%rdi
mov    $0x7,%esi
xor    %eax,%eax
call   1040 <printf@plt>
mov    0x2e1c(%rip),%r12
mov    (%r12),%edx
lea    0x30(%rsp),%r13
mov    %r13,%rdi
mov    $0x100,%esi
call   1060 <fgets@plt>
lea    0xe99(%rip),%rbp
lea    0x4(%rsp),%rdx
mov    %r13,%rdi
mov    %rbp,%rsi
xor    %eax,%eax
call   1070 <sscanf@plt>
lea    0xe83(%rip),%rdi
mov    $0x9,%esi
xor    %eax,%eax
call   1040 <printf@plt>
mov    (%r12),%edx
mov    %r13,%rdi
mov    $0x100,%esi
call   1060 <fgets@plt>
mov    %rsp,%rdx
mov    %r13,%rdi
mov    %rbp,%rsi
xor    %eax,%eax
call   1070 <sscanf@plt>
mov    (%rsp),%eax
add    0x4(%rsp),%eax
cmp    $0x1b,%eax
jge    16af <initLineModel+0x54f>
mov    %rbx,0x20(%rsp)
mov    (%r14),%esi
lea    0xe57(%rip),%rdi
xor    %eax,%eax
call   1040 <printf@plt>
mov    (%r12),%edx
lea    0x30(%rsp),%rbp
mov    %rbp,%rdi
mov    $0x100,%esi
call   1060 <fgets@plt>
lea    0xe10(%rip),%rsi
mov    %rbp,%rdi
mov    %r14,%rdx
xor    %eax,%eax
call   1070 <sscanf@plt>
mov    %r14,0x18(%rsp)
cmpl   $0xb,(%r14)
jge    16b8 <initLineModel+0x558>
lea    0xe2b(%rip),%rdi
movsd  0xd63(%rip),%xmm0
mov    $0x1,%al
call   1040 <printf@plt>
mov    (%r12),%edx
lea    0x30(%rsp),%r13
mov    %r13,%rdi
mov    $0x100,%esi
call   1060 <fgets@plt>
lea    0xe1b(%rip),%rbp
lea    0x10(%rsp),%rdx
mov    %r13,%rdi
mov    %rbp,%rsi
xor    %eax,%eax
call   1070 <sscanf@plt>
lea    0xe06(%rip),%rdi
movsd  0xd26(%rip),%xmm0
mov    $0x1,%al
call   1040 <printf@plt>
mov    (%r12),%edx
mov    %r13,%rdi
mov    $0x100,%esi
call   1060 <fgets@plt>
lea    0x8(%rsp),%rdx
mov    %r13,%rdi
mov    %rbp,%rsi
xor    %eax,%eax
call   1070 <sscanf@plt>
movslq 0x4(%rsp),%r12
mov    (%rsp),%ebx
lea    (%rbx,%r12,1),%eax
mov    %r12d,%r13d
mov    0x20(%rsp),%rcx
mov    %eax,(%rcx)
test   %r12,%r12
mov    0x28(%rsp),%rbp
jle    133e <initLineModel+0x1de>
lea    0x0(,%r13,4),%rdx
mov    %rbp,%rdi
xor    %esi,%esi
call   1050 <memset@plt>
test   %ebx,%ebx
mov    0x18(%rsp),%r8
jle    1440 <initLineModel+0x2e0>
cmp    $0x8,%ebx
jae    1357 <initLineModel+0x1f7>
xor    %eax,%eax
jmp    1417 <initLineModel+0x2b7>
mov    %ebx,%eax
and    $0xfffffff8,%eax
lea    -0x8(%rax),%rsi
mov    %rsi,%rdx
shr    $0x3,%rdx
add    $0x1,%rdx
mov    %edx,%ecx
and    $0x3,%ecx
cmp    $0x18,%rsi
jae    137a <initLineModel+0x21a>
xor    %esi,%esi
jmp    13d1 <initLineModel+0x271>
and    $0xfffffffffffffffc,%rdx
lea    0x70(,%r12,4),%rdi
add    %rbp,%rdi
xor    %esi,%esi
movaps 0xc7e(%rip),%xmm0
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movups %xmm0,-0x70(%rdi,%rsi,4)
movups %xmm0,-0x60(%rdi,%rsi,4)
movups %xmm0,-0x50(%rdi,%rsi,4)
movups %xmm0,-0x40(%rdi,%rsi,4)
movups %xmm0,-0x30(%rdi,%rsi,4)
movups %xmm0,-0x20(%rdi,%rsi,4)
movups %xmm0,-0x10(%rdi,%rsi,4)
movups %xmm0,(%rdi,%rsi,4)
add    $0x20,%rsi
add    $0xfffffffffffffffc,%rdx
jne    13a0 <initLineModel+0x240>
test   %rcx,%rcx
je     1412 <initLineModel+0x2b2>
add    %r12,%rsi
lea    0x10(,%rsi,4),%rdx
add    %rbp,%rdx
shl    $0x5,%rcx
xor    %esi,%esi
movaps 0xc1f(%rip),%xmm0
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movups %xmm0,-0x10(%rdx,%rsi,1)
movups %xmm0,(%rdx,%rsi,1)
add    $0x20,%rsi
cmp    %rsi,%rcx
jne    1400 <initLineModel+0x2a0>
cmp    %rbx,%rax
je     1440 <initLineModel+0x2e0>
lea    0x0(,%r12,4),%rcx
add    %rbp,%rcx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movl   $0x1,(%rcx,%rax,4)
add    $0x1,%rax
cmp    %rax,%rbx
jne    1430 <initLineModel+0x2d0>
lea    0x280(%r15),%rax
xor    %ecx,%ecx
movapd 0xbcf(%rip),%xmm0
movabs $0xc0c3880000000000,%rdx
88 c3 c0
nopl   0x0(%rax,%rax,1)
mov    %rax,%rsi
xor    %edi,%edi
cs nopw 0x0(%rax,%rax,1)
nop
xor    %ebp,%ebp
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movupd %xmm0,-0x280(%rsi,%rbp,1)
ff ff
mov    %rdx,-0x270(%rsi,%rbp,1)
ff
movupd %xmm0,-0x10(%rsi,%rbp,1)
mov    %rdx,(%rsi,%rbp,1)
add    $0x4e0,%rbp
cmp    $0x3f60,%rbp
jne    1480 <initLineModel+0x320>
add    $0x1,%rdi
add    $0x18,%rsi
cmp    $0x1a,%rdi
jne    1470 <initLineModel+0x310>
add    $0x1,%rcx
add    $0x3f60,%rax
cmp    $0xa,%rcx
jne    1460 <initLineModel+0x300>
mov    (%r8),%r8d
test   %r8d,%r8d
jle    169d <initLineModel+0x53d>
movsd  0x10(%rsp),%xmm12
movsd  0x8(%rsp),%xmm8
mov    %r12d,%r14d
mov    %ebx,%r11d
and    $0xfffffffc,%r11d
movapd %xmm12,%xmm14
unpcklpd %xmm12,%xmm14
lea    (%r12,%r12,2),%rax
lea    (%r15,%rax,8),%r9
add    $0x30,%r9
lea    0x0(,%rbx,8),%rax
and    $0xffffffffffffffe0,%rax
lea    (%rax,%rax,2),%rdi
add    $0x10,%r15
xor    %r10d,%r10d
movdqa 0xb0d(%rip),%xmm9
movdqa 0xb14(%rip),%xmm10
movdqa 0xb1b(%rip),%xmm11
jmp    155b <initLineModel+0x3fb>
nopw   0x0(%rax,%rax,1)
add    $0x1,%r10
add    $0x3f60,%r9
add    $0x3f60,%r15
cmp    %r8,%r10
je     169d <initLineModel+0x53d>
test   %r13d,%r13d
jle    1540 <initLineModel+0x3e0>
xorps  %xmm13,%xmm13
cvtsi2sd %r10d,%xmm13
mulsd  %xmm8,%xmm13
movapd %xmm13,%xmm7
unpcklpd %xmm13,%xmm7
mov    %r15,%rbp
mov    %r9,%rsi
xor    %eax,%eax
jmp    15a7 <initLineModel+0x447>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
add    $0x1,%rax
add    $0x270,%rsi
add    $0x270,%rbp
cmp    %r14,%rax
je     1540 <initLineModel+0x3e0>
test   %ebx,%ebx
jle    1590 <initLineModel+0x430>
xorps  %xmm2,%xmm2
cvtsi2sd %eax,%xmm2
mulsd  %xmm12,%xmm2
cmp    $0x4,%ebx
jae    15d0 <initLineModel+0x470>
xor    %edx,%edx
jmp    1658 <initLineModel+0x4f8>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movapd %xmm2,%xmm3
unpcklpd %xmm2,%xmm3
xor    %edx,%edx
movdqa %xmm9,%xmm5
nop
movdqa %xmm5,%xmm4
paddd  %xmm10,%xmm4
cvtdq2pd %xmm5,%xmm0
cvtdq2pd %xmm4,%xmm4
mulpd  %xmm14,%xmm0
mulpd  %xmm14,%xmm4
movapd %xmm0,%xmm6
unpcklpd %xmm3,%xmm6
movsd  %xmm7,%xmm0
movapd %xmm3,%xmm1
unpckhpd %xmm7,%xmm1
movupd %xmm1,-0x10(%rsi,%rdx,1)
movupd %xmm0,-0x20(%rsi,%rdx,1)
movupd %xmm6,-0x30(%rsi,%rdx,1)
movapd %xmm4,%xmm0
unpcklpd %xmm3,%xmm0
movsd  %xmm7,%xmm4
movupd %xmm1,0x20(%rsi,%rdx,1)
movupd %xmm4,0x10(%rsi,%rdx,1)
movupd %xmm0,(%rsi,%rdx,1)
paddd  %xmm11,%xmm5
add    $0x60,%rdx
cmp    %rdx,%rdi
jne    15e0 <initLineModel+0x480>
mov    %r11,%rdx
cmp    %rbx,%r11
je     1590 <initLineModel+0x430>
lea    (%r12,%rdx,1),%rcx
lea    (%rcx,%rcx,2),%rcx
lea    0x0(,%rcx,8),%rcx
add    %rbp,%rcx
nopl   0x0(%rax,%rax,1)
xorps  %xmm0,%xmm0
cvtsi2sd %edx,%xmm0
mulsd  %xmm12,%xmm0
movsd  %xmm0,-0x10(%rcx)
movsd  %xmm2,-0x8(%rcx)
movsd  %xmm13,(%rcx)
add    $0x1,%rdx
add    $0x18,%rcx
cmp    %rdx,%rbx
jne    1670 <initLineModel+0x510>
jmp    1590 <initLineModel+0x430>
add    $0x138,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
lea    0xa57(%rip),%rdi
jmp    16bf <initLineModel+0x55f>
lea    0xa39(%rip),%rdi
call   1030 <puts@plt>
xor    %edi,%edi
call   1080 <exit@plt>

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

LLVM IR (-O2):
@.str = [34 x i8] c"Number of horizontal lines (%d): \00"
@stdin = global i32 0
@.str.1 = [3 x i8] c"%d\00"
@.str.2 = [32 x i8] c"Number of vertical lines (%d): \00"
@.str.4 = [27 x i8] c"Number of iteration (%d): \00"
@.str.6 = [28 x i8] c"Distance among lines (%f): \00"
@.str.7 = [4 x i8] c"%lf\00"
@.str.8 = [24 x i8] c"Distance to move (%f): \00"
@str = [21 x i8] c"too many iteration!!\00"
@str.9 = [17 x i8] c"too many lines!!\00"
define void @initLineModel(i32* nocapture writeonly %0, i32* %1, i32* nocapture writeonly %2, [26 x [26 x [3 x double]]]* nocapture writeonly %3) {
%5 = bitcast i32* %2 to i8*
%6 = alloca [256 x i8]
%7 = alloca i32
%8 = alloca i32
%9 = alloca double
%10 = alloca double
%11 = getelementptr inbounds [256 x i8], [256 x i8]* %6, i64 0, i64 0
%12 = bitcast i32* %7 to i8*
%13 = bitcast i32* %8 to i8*
%14 = bitcast double* %9 to i8*
%15 = bitcast double* %10 to i8*
store i32 7, i32* %7
store i32 9, i32* %8
store i32 5, i32* %1
store double 4.000000e+01, double* %9
store double 1.000000e+02, double* %10
%16 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([34 x i8], [34 x i8]* @.str, i64 0, i64 0), i32 7)
%17 = load i32, i32* @stdin
%18 = call i32 @fgets(i8* %11, i32 256, i32 %17)
%19 = call i32 (i8*, i8*, ...) @sscanf(i8* %11, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.1, i64 0, i64 0), i32* %7)
%20 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([32 x i8], [32 x i8]* @.str.2, i64 0, i64 0), i32 9)
%21 = load i32, i32* @stdin
%22 = call i32 @fgets(i8* %11, i32 256, i32 %21)
%23 = call i32 (i8*, i8*, ...) @sscanf(i8* %11, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.1, i64 0, i64 0), i32* %8)
%24 = load i32, i32* %7
%25 = load i32, i32* %8
%26 = add nsw i32 %25, %24
%27 = icmp sgt i32 %26, 26
br i1 %27, label %28, label %31
28: ; preds = %4
%29 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([17 x i8], [17 x i8]* @str.9, i64 0, i64 0))
%30 = call i32 @exit(i32 0)
unreachable
31: ; preds = %4
%32 = load i32, i32* %1
%33 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([27 x i8], [27 x i8]* @.str.4, i64 0, i64 0), i32 %32)
%34 = load i32, i32* @stdin
%35 = call i32 @fgets(i8* %11, i32 256, i32 %34)
%36 = call i32 (i8*, i8*, ...) @sscanf(i8* %11, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.1, i64 0, i64 0), i32* %1)
%37 = load i32, i32* %1
%38 = icmp sgt i32 %37, 10
br i1 %38, label %39, label %42
39: ; preds = %31
%40 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([21 x i8], [21 x i8]* @str, i64 0, i64 0))
%41 = call i32 @exit(i32 0)
unreachable
42: ; preds = %31
%43 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([28 x i8], [28 x i8]* @.str.6, i64 0, i64 0), double 4.000000e+01)
%44 = load i32, i32* @stdin
%45 = call i32 @fgets(i8* %11, i32 256, i32 %44)
%46 = call i32 (i8*, i8*, ...) @sscanf(i8* %11, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.7, i64 0, i64 0), double* %9)
%47 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([24 x i8], [24 x i8]* @.str.8, i64 0, i64 0), double 1.000000e+02)
%48 = load i32, i32* @stdin
%49 = call i32 @fgets(i8* %11, i32 256, i32 %48)
%50 = call i32 (i8*, i8*, ...) @sscanf(i8* %11, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.7, i64 0, i64 0), double* %10)
%51 = load i32, i32* %7
%52 = load i32, i32* %8
%53 = add nsw i32 %52, %51
store i32 %53, i32* %0
%54 = icmp sgt i32 %51, 0
br i1 %54, label %55, label %58
55: ; preds = %42
%56 = zext i32 %51 to i64
%57 = shl nuw nsw i64 %56, 2
br label %58
58: ; preds = %55, %42
%59 = icmp sgt i32 %52, 0
br i1 %59, label %60, label %126
60: ; preds = %58
%61 = sext i32 %51 to i64
%62 = zext i32 %52 to i64
%63 = icmp ult i32 %52, 8
br i1 %63, label %118, label %64
64: ; preds = %60
%65 = and i64 %62, 4294967288
%66 = add nsw i64 %65, -8
%67 = lshr exact i64 %66, 3
%68 = add nuw nsw i64 %67, 1
%69 = and i64 %68, 3
%70 = icmp ult i64 %66, 24
br i1 %70, label %102, label %71
71: ; preds = %64
%72 = and i64 %68, 4611686018427387900
br label %73
73: ; preds = %73, %71
%74 = phi i64 [ 0, %71 ], [ %99, %73 ]
%75 = phi i64 [ 0, %71 ], [ %100, %73 ]
%76 = add nsw i64 %74, %61
%77 = getelementptr inbounds i32, i32* %2, i64 %76
%78 = bitcast i32* %77 to <4 x i32>*
store <4 x i32> <i32 1, i32 1, i32 1, i32 1>, <4 x i32>* %78
%79 = getelementptr inbounds i32, i32* %77, i64 4
%80 = bitcast i32* %79 to <4 x i32>*
store <4 x i32> <i32 1, i32 1, i32 1, i32 1>, <4 x i32>* %80
%81 = or i64 %74, 8
%82 = add nsw i64 %81, %61
%83 = getelementptr inbounds i32, i32* %2, i64 %82
%84 = bitcast i32* %83 to <4 x i32>*
store <4 x i32> <i32 1, i32 1, i32 1, i32 1>, <4 x i32>* %84
%85 = getelementptr inbounds i32, i32* %83, i64 4
%86 = bitcast i32* %85 to <4 x i32>*
store <4 x i32> <i32 1, i32 1, i32 1, i32 1>, <4 x i32>* %86
%87 = or i64 %74, 16
%88 = add nsw i64 %87, %61
%89 = getelementptr inbounds i32, i32* %2, i64 %88
%90 = bitcast i32* %89 to <4 x i32>*
store <4 x i32> <i32 1, i32 1, i32 1, i32 1>, <4 x i32>* %90
%91 = getelementptr inbounds i32, i32* %89, i64 4
%92 = bitcast i32* %91 to <4 x i32>*
store <4 x i32> <i32 1, i32 1, i32 1, i32 1>, <4 x i32>* %92
%93 = or i64 %74, 24
%94 = add nsw i64 %93, %61
%95 = getelementptr inbounds i32, i32* %2, i64 %94
%96 = bitcast i32* %95 to <4 x i32>*
store <4 x i32> <i32 1, i32 1, i32 1, i32 1>, <4 x i32>* %96
%97 = getelementptr inbounds i32, i32* %95, i64 4
%98 = bitcast i32* %97 to <4 x i32>*
store <4 x i32> <i32 1, i32 1, i32 1, i32 1>, <4 x i32>* %98
%99 = add nuw i64 %74, 32
%100 = add i64 %75, 4
%101 = icmp eq i64 %100, %72
br i1 %101, label %102, label %73
102: ; preds = %73, %64
%103 = phi i64 [ 0, %64 ], [ %99, %73 ]
%104 = icmp eq i64 %69, 0
br i1 %104, label %116, label %105
105: ; preds = %102, %105
%106 = phi i64 [ %113, %105 ], [ %103, %102 ]
%107 = phi i64 [ %114, %105 ], [ 0, %102 ]
%108 = add nsw i64 %106, %61
%109 = getelementptr inbounds i32, i32* %2, i64 %108
%110 = bitcast i32* %109 to <4 x i32>*
store <4 x i32> <i32 1, i32 1, i32 1, i32 1>, <4 x i32>* %110
%111 = getelementptr inbounds i32, i32* %109, i64 4
%112 = bitcast i32* %111 to <4 x i32>*
store <4 x i32> <i32 1, i32 1, i32 1, i32 1>, <4 x i32>* %112
%113 = add nuw i64 %106, 8
%114 = add i64 %107, 1
%115 = icmp eq i64 %114, %69
br i1 %115, label %116, label %105
116: ; preds = %105, %102
%117 = icmp eq i64 %65, %62
br i1 %117, label %126, label %118
118: ; preds = %60, %116
%119 = phi i64 [ 0, %60 ], [ %65, %116 ]
br label %120
120: ; preds = %118, %120
%121 = phi i64 [ %124, %120 ], [ %119, %118 ]
%122 = add nsw i64 %121, %61
%123 = getelementptr inbounds i32, i32* %2, i64 %122
store i32 1, i32* %123
%124 = add nuw nsw i64 %121, 1
%125 = icmp eq i64 %124, %62
br i1 %125, label %126, label %120
126: ; preds = %120, %116, %58
br label %127
127: ; preds = %126, %162
%128 = phi i64 [ %163, %162 ], [ 0, %126 ]
br label %146
129: ; preds = %162
%130 = load i32, i32* %1
%131 = icmp sgt i32 %130, 0
br i1 %131, label %132, label %228
132: ; preds = %129
%133 = load double, double* %9
%134 = load double, double* %10
%135 = sext i32 %51 to i64
%136 = zext i32 %130 to i64
%137 = zext i32 %51 to i64
%138 = zext i32 %52 to i64
%139 = icmp ult i32 %52, 4
%140 = and i64 %138, 4294967292
%141 = insertelement <2 x double> poison, double %133, i64 0
%142 = shufflevector <2 x double> %141, <2 x double> poison, <2 x i32> zeroinitializer
%143 = insertelement <2 x double> poison, double %133, i64 0
%144 = shufflevector <2 x double> %143, <2 x double> poison, <2 x i32> zeroinitializer
%145 = icmp eq i64 %140, %138
br label %165
146: ; preds = %127, %159
%147 = phi i64 [ 0, %127 ], [ %160, %159 ]
br label %148
148: ; preds = %148, %146
%149 = phi i64 [ 0, %146 ], [ %157, %148 ]
%150 = getelementptr inbounds [26 x [26 x [3 x double]]], [26 x [26 x [3 x double]]]* %3, i64 %128, i64 %149, i64 %147, i64 0
%151 = bitcast double* %150 to <2 x double>*
store <2 x double> <double -1.000000e+04, double -1.000000e+04>, <2 x double>* %151
%152 = getelementptr inbounds [26 x [26 x [3 x double]]], [26 x [26 x [3 x double]]]* %3, i64 %128, i64 %149, i64 %147, i64 2
store double -1.000000e+04, double* %152
%153 = or i64 %149, 1
%154 = getelementptr inbounds [26 x [26 x [3 x double]]], [26 x [26 x [3 x double]]]* %3, i64 %128, i64 %153, i64 %147, i64 0
%155 = bitcast double* %154 to <2 x double>*
store <2 x double> <double -1.000000e+04, double -1.000000e+04>, <2 x double>* %155
%156 = getelementptr inbounds [26 x [26 x [3 x double]]], [26 x [26 x [3 x double]]]* %3, i64 %128, i64 %153, i64 %147, i64 2
store double -1.000000e+04, double* %156
%157 = add nuw nsw i64 %149, 2
%158 = icmp eq i64 %157, 26
br i1 %158, label %159, label %148
159: ; preds = %148
%160 = add nuw nsw i64 %147, 1
%161 = icmp eq i64 %160, 26
br i1 %161, label %162, label %146
162: ; preds = %159
%163 = add nuw nsw i64 %128, 1
%164 = icmp eq i64 %163, 10
br i1 %164, label %129, label %127
165: ; preds = %132, %225
%166 = phi i64 [ 0, %132 ], [ %226, %225 ]
br i1 %54, label %167, label %225
167: ; preds = %165
%168 = trunc i64 %166 to i32
%169 = sitofp i32 %168 to double
%170 = fmul double %134, %169
%171 = insertelement <2 x double> poison, double %170, i64 0
%172 = insertelement <2 x double> poison, double %170, i64 0
%173 = shufflevector <2 x double> %171, <2 x double> poison, <4 x i32> <i32 0, i32 0, i32 undef, i32 undef>
%174 = shufflevector <2 x double> %172, <2 x double> poison, <4 x i32> <i32 0, i32 0, i32 undef, i32 undef>
br label %175
175: ; preds = %167, %222
%176 = phi i64 [ 0, %167 ], [ %223, %222 ]
br i1 %59, label %177, label %222
177: ; preds = %175
%178 = trunc i64 %176 to i32
%179 = sitofp i32 %178 to double
%180 = fmul double %133, %179
br i1 %139, label %209, label %181
181: ; preds = %177
%182 = insertelement <2 x double> poison, double %180, i64 0
%183 = shufflevector <2 x double> %182, <2 x double> poison, <2 x i32> zeroinitializer
%184 = insertelement <2 x double> poison, double %180, i64 0
%185 = shufflevector <2 x double> %184, <2 x double> poison, <2 x i32> zeroinitializer
br label %186
186: ; preds = %186, %181
%187 = phi i64 [ 0, %181 ], [ %205, %186 ]
%188 = phi <2 x i32> [ <i32 0, i32 1>, %181 ], [ %206, %186 ]
%189 = or i64 %187, 2
%190 = add <2 x i32> %188, <i32 2, i32 2>
%191 = sitofp <2 x i32> %188 to <2 x double>
%192 = sitofp <2 x i32> %190 to <2 x double>
%193 = fmul <2 x double> %142, %191
%194 = fmul <2 x double> %144, %192
%195 = add nsw i64 %187, %135
%196 = add nsw i64 %189, %135
%197 = getelementptr inbounds [26 x [26 x [3 x double]]], [26 x [26 x [3 x double]]]* %3, i64 %166, i64 %176, i64 %195, i64 0
%198 = bitcast double* %197 to <6 x double>*
%199 = getelementptr inbounds [26 x [26 x [3 x double]]], [26 x [26 x [3 x double]]]* %3, i64 %166, i64 %176, i64 %196, i64 0
%200 = bitcast double* %199 to <6 x double>*
%201 = shufflevector <2 x double> %193, <2 x double> %183, <4 x i32> <i32 0, i32 1, i32 2, i32 3>
%202 = shufflevector <4 x double> %201, <4 x double> %173, <6 x i32> <i32 0, i32 2, i32 4, i32 1, i32 3, i32 5>
store <6 x double> %202, <6 x double>* %198
%203 = shufflevector <2 x double> %194, <2 x double> %185, <4 x i32> <i32 0, i32 1, i32 2, i32 3>
%204 = shufflevector <4 x double> %203, <4 x double> %174, <6 x i32> <i32 0, i32 2, i32 4, i32 1, i32 3, i32 5>
store <6 x double> %204, <6 x double>* %200
%205 = add nuw i64 %187, 4
%206 = add <2 x i32> %188, <i32 4, i32 4>
%207 = icmp eq i64 %205, %140
br i1 %207, label %208, label %186
208: ; preds = %186
br i1 %145, label %222, label %209
209: ; preds = %177, %208
%210 = phi i64 [ 0, %177 ], [ %140, %208 ]
br label %211
211: ; preds = %209, %211
%212 = phi i64 [ %220, %211 ], [ %210, %209 ]
%213 = trunc i64 %212 to i32
%214 = sitofp i32 %213 to double
%215 = fmul double %133, %214
%216 = add nsw i64 %212, %135
%217 = getelementptr inbounds [26 x [26 x [3 x double]]], [26 x [26 x [3 x double]]]* %3, i64 %166, i64 %176, i64 %216, i64 0
store double %215, double* %217
%218 = getelementptr inbounds [26 x [26 x [3 x double]]], [26 x [26 x [3 x double]]]* %3, i64 %166, i64 %176, i64 %216, i64 1
store double %180, double* %218
%219 = getelementptr inbounds [26 x [26 x [3 x double]]], [26 x [26 x [3 x double]]]* %3, i64 %166, i64 %176, i64 %216, i64 2
store double %170, double* %219
%220 = add nuw nsw i64 %212, 1
%221 = icmp eq i64 %220, %138
br i1 %221, label %222, label %211
222: ; preds = %211, %208, %175
%223 = add nuw nsw i64 %176, 1
%224 = icmp eq i64 %223, %137
br i1 %224, label %225, label %175
225: ; preds = %222, %165
%226 = add nuw nsw i64 %166, 1
%227 = icmp eq i64 %226, %136
br i1 %227, label %228, label %165
228: ; preds = %225, %129
ret void
}