#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*/ CalcLineVec(float *, float *, float *, float *);
int /*<<< orphan*/ CalcNormalize(float *);
int /*<<< orphan*/ CalcOutProduct(float *, float *, float *);
int /*<<< orphan*/ CalcVec(float *, float *, float *);
int /*<<< orphan*/ Calc_3dMat4Multi14(float *, float **, float *);
int /*<<< orphan*/ Calc_3dMat4Multi44(float **, float **, float **);
int /*<<< orphan*/ Calc_3dMat4TranAxis(float *, float *, float *, float *,
                                       float **);
int /*<<< orphan*/ Calc_3dMat4TranAxisInv(float *, float *, float *, float *,
                                          float **);
void npt_move_vertex(float p1[3], float p2[3], float p3[3], float cp_side1_1[3],
                     float cp_side1_2[3], float cp_side2_1[3],
                     float cp_side2_2[3], float cp_side3_1[3],
                     float cp_side3_2[3], float cp_center[3], float p1_n[3],
                     float p2_n[3], float p3_n[3], float cp_side1_1_n[3],
                     float cp_side1_2_n[3], float cp_side2_1_n[3],
                     float cp_side2_2_n[3], float cp_side3_1_n[3],
                     float cp_side3_2_n[3], float cp_center_n[3]) {
  float len12, vec13[3];
  float x_axis[3], y_axis[3], z_axis[3];
  float x_axis_n[3], y_axis_n[3], z_axis_n[3];
  int i;
  CalcLineVec(p1, p2, x_axis, &len12);
  CalcVec(p1, p3, vec13);
  CalcOutProduct(x_axis, vec13, z_axis);
  CalcNormalize(z_axis);
  CalcOutProduct(z_axis, x_axis, y_axis);
  CalcLineVec(p1_n, p2_n, x_axis_n, &len12);
  CalcVec(p1_n, p3_n, vec13);
  CalcOutProduct(x_axis_n, vec13, z_axis_n);
  CalcNormalize(z_axis_n);
  CalcOutProduct(z_axis_n, x_axis_n, y_axis_n);
  float change_mat[4][4];
  float change_mat_n[4][4];
  float change_mat_all[4][4];
  Calc_3dMat4TranAxis(p1, x_axis, y_axis, z_axis, change_mat);
  Calc_3dMat4TranAxisInv(p1_n, x_axis_n, y_axis_n, z_axis_n, change_mat_n);
  Calc_3dMat4Multi44(change_mat, change_mat_n, change_mat_all);
  float pnts_in[7][4], pnts_out[7][4];
  pnts_in[0][0] = cp_side1_1[0];
  pnts_in[0][1] = cp_side1_1[1];
  pnts_in[0][2] = cp_side1_1[2];
  pnts_in[0][3] = 1.0;
  pnts_in[1][0] = cp_side1_2[0];
  pnts_in[1][1] = cp_side1_2[1];
  pnts_in[1][2] = cp_side1_2[2];
  pnts_in[1][3] = 1.0;
  pnts_in[2][0] = cp_side2_1[0];
  pnts_in[2][1] = cp_side2_1[1];
  pnts_in[2][2] = cp_side2_1[2];
  pnts_in[2][3] = 1.0;
  pnts_in[3][0] = cp_side2_2[0];
  pnts_in[3][1] = cp_side2_2[1];
  pnts_in[3][2] = cp_side2_2[2];
  pnts_in[3][3] = 1.0;
  pnts_in[4][0] = cp_side3_1[0];
  pnts_in[4][1] = cp_side3_1[1];
  pnts_in[4][2] = cp_side3_1[2];
  pnts_in[4][3] = 1.0;
  pnts_in[5][0] = cp_side3_2[0];
  pnts_in[5][1] = cp_side3_2[1];
  pnts_in[5][2] = cp_side3_2[2];
  pnts_in[5][3] = 1.0;
  pnts_in[6][0] = cp_center[0];
  pnts_in[6][1] = cp_center[1];
  pnts_in[6][2] = cp_center[2];
  pnts_in[6][3] = 1.0;
  for (i = 0; i < 7; i++) {
    Calc_3dMat4Multi14(pnts_in[i], change_mat_all, pnts_out[i]);
  }
  cp_side1_1_n[0] = pnts_out[0][0];
  cp_side1_1_n[1] = pnts_out[0][1];
  cp_side1_1_n[2] = pnts_out[0][2];
  cp_side1_2_n[0] = pnts_out[1][0];
  cp_side1_2_n[1] = pnts_out[1][1];
  cp_side1_2_n[2] = pnts_out[1][2];
  cp_side2_1_n[0] = pnts_out[2][0];
  cp_side2_1_n[1] = pnts_out[2][1];
  cp_side2_1_n[2] = pnts_out[2][2];
  cp_side2_2_n[0] = pnts_out[3][0];
  cp_side2_2_n[1] = pnts_out[3][1];
  cp_side2_2_n[2] = pnts_out[3][2];
  cp_side3_1_n[0] = pnts_out[4][0];
  cp_side3_1_n[1] = pnts_out[4][1];
  cp_side3_1_n[2] = pnts_out[4][2];
  cp_side3_2_n[0] = pnts_out[5][0];
  cp_side3_2_n[1] = pnts_out[5][1];
  cp_side3_2_n[2] = pnts_out[5][2];
  cp_center_n[0] = pnts_out[6][0];
  cp_center_n[1] = pnts_out[6][1];
  cp_center_n[2] = pnts_out[6][2];
}


x86 assembly (clang, -O0):
<npt_move_vertex>:
push   %rbp
mov    %rsp,%rbp
sub    $0x230,%rsp
mov    0x78(%rbp),%rax
mov    0x70(%rbp),%rax
mov    0x68(%rbp),%rax
mov    0x60(%rbp),%rax
mov    0x58(%rbp),%rax
mov    0x50(%rbp),%rax
mov    0x48(%rbp),%rax
mov    0x40(%rbp),%rax
mov    0x38(%rbp),%rax
mov    0x30(%rbp),%rax
mov    0x28(%rbp),%rax
mov    0x20(%rbp),%rax
mov    0x18(%rbp),%rax
mov    0x10(%rbp),%rax
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
mov    %r8,-0x28(%rbp)
mov    %r9,-0x30(%rbp)
mov    -0x8(%rbp),%rdi
mov    -0x10(%rbp),%rsi
lea    -0x4c(%rbp),%rdx
lea    -0x34(%rbp),%rcx
call   1080 <CalcLineVec@plt>
mov    -0x8(%rbp),%rdi
mov    -0x18(%rbp),%rsi
lea    -0x40(%rbp),%rdx
call   10a0 <CalcVec@plt>
lea    -0x4c(%rbp),%rdi
lea    -0x40(%rbp),%rsi
lea    -0x64(%rbp),%rdx
call   1090 <CalcOutProduct@plt>
lea    -0x64(%rbp),%rdi
call   1070 <CalcNormalize@plt>
lea    -0x64(%rbp),%rdi
lea    -0x4c(%rbp),%rsi
lea    -0x58(%rbp),%rdx
call   1090 <CalcOutProduct@plt>
mov    0x30(%rbp),%rdi
mov    0x38(%rbp),%rsi
lea    -0x70(%rbp),%rdx
lea    -0x34(%rbp),%rcx
call   1080 <CalcLineVec@plt>
mov    0x30(%rbp),%rdi
mov    0x40(%rbp),%rsi
lea    -0x40(%rbp),%rdx
call   10a0 <CalcVec@plt>
lea    -0x70(%rbp),%rdi
lea    -0x40(%rbp),%rsi
lea    -0x88(%rbp),%rdx
call   1090 <CalcOutProduct@plt>
lea    -0x88(%rbp),%rdi
call   1070 <CalcNormalize@plt>
lea    -0x88(%rbp),%rdi
lea    -0x70(%rbp),%rsi
lea    -0x7c(%rbp),%rdx
call   1090 <CalcOutProduct@plt>
mov    -0x8(%rbp),%rdi
lea    -0x4c(%rbp),%rsi
lea    -0x58(%rbp),%rdx
lea    -0x64(%rbp),%rcx
lea    -0xd0(%rbp),%r8
call   1030 <Calc_3dMat4TranAxis@plt>
mov    0x30(%rbp),%rdi
lea    -0x70(%rbp),%rsi
lea    -0x7c(%rbp),%rdx
lea    -0x88(%rbp),%rcx
lea    -0x110(%rbp),%r8
call   1050 <Calc_3dMat4TranAxisInv@plt>
lea    -0xd0(%rbp),%rdi
lea    -0x110(%rbp),%rsi
lea    -0x150(%rbp),%rdx
call   1040 <Calc_3dMat4Multi44@plt>
mov    -0x20(%rbp),%rax
movss  (%rax),%xmm0
movss  %xmm0,-0x1c0(%rbp)
ff
mov    -0x20(%rbp),%rax
movss  0x4(%rax),%xmm0
movss  %xmm0,-0x1bc(%rbp)
ff
mov    -0x20(%rbp),%rax
movss  0x8(%rax),%xmm0
movss  %xmm0,-0x1b8(%rbp)
ff
movss  0xceb(%rip),%xmm0
movss  %xmm0,-0x1b4(%rbp)
ff
mov    -0x28(%rbp),%rax
movss  (%rax),%xmm0
movss  %xmm0,-0x1b0(%rbp)
ff
mov    -0x28(%rbp),%rax
movss  0x4(%rax),%xmm0
movss  %xmm0,-0x1ac(%rbp)
ff
mov    -0x28(%rbp),%rax
movss  0x8(%rax),%xmm0
movss  %xmm0,-0x1a8(%rbp)
ff
movss  0xca9(%rip),%xmm0
movss  %xmm0,-0x1a4(%rbp)
ff
mov    -0x30(%rbp),%rax
movss  (%rax),%xmm0
movss  %xmm0,-0x1a0(%rbp)
ff
mov    -0x30(%rbp),%rax
movss  0x4(%rax),%xmm0
movss  %xmm0,-0x19c(%rbp)
ff
mov    -0x30(%rbp),%rax
movss  0x8(%rax),%xmm0
movss  %xmm0,-0x198(%rbp)
ff
movss  0xc67(%rip),%xmm0
movss  %xmm0,-0x194(%rbp)
ff
mov    0x10(%rbp),%rax
movss  (%rax),%xmm0
movss  %xmm0,-0x190(%rbp)
ff
mov    0x10(%rbp),%rax
movss  0x4(%rax),%xmm0
movss  %xmm0,-0x18c(%rbp)
ff
mov    0x10(%rbp),%rax
movss  0x8(%rax),%xmm0
movss  %xmm0,-0x188(%rbp)
ff
movss  0xc25(%rip),%xmm0
movss  %xmm0,-0x184(%rbp)
ff
mov    0x18(%rbp),%rax
movss  (%rax),%xmm0
movss  %xmm0,-0x180(%rbp)
ff
mov    0x18(%rbp),%rax
movss  0x4(%rax),%xmm0
movss  %xmm0,-0x17c(%rbp)
ff
mov    0x18(%rbp),%rax
movss  0x8(%rax),%xmm0
movss  %xmm0,-0x178(%rbp)
ff
movss  0xbe3(%rip),%xmm0
movss  %xmm0,-0x174(%rbp)
ff
mov    0x20(%rbp),%rax
movss  (%rax),%xmm0
movss  %xmm0,-0x170(%rbp)
ff
mov    0x20(%rbp),%rax
movss  0x4(%rax),%xmm0
movss  %xmm0,-0x16c(%rbp)
ff
mov    0x20(%rbp),%rax
movss  0x8(%rax),%xmm0
movss  %xmm0,-0x168(%rbp)
ff
movss  0xba1(%rip),%xmm0
movss  %xmm0,-0x164(%rbp)
ff
mov    0x28(%rbp),%rax
movss  (%rax),%xmm0
movss  %xmm0,-0x160(%rbp)
ff
mov    0x28(%rbp),%rax
movss  0x4(%rax),%xmm0
movss  %xmm0,-0x15c(%rbp)
ff
mov    0x28(%rbp),%rax
movss  0x8(%rax),%xmm0
movss  %xmm0,-0x158(%rbp)
ff
movss  0xb5f(%rip),%xmm0
movss  %xmm0,-0x154(%rbp)
ff
movl   $0x0,-0x8c(%rbp)
cmpl   $0x7,-0x8c(%rbp)
jge    150a <npt_move_vertex+0x38a>
movslq -0x8c(%rbp),%rax
lea    -0x1c0(%rbp),%rdi
shl    $0x4,%rax
add    %rax,%rdi
lea    -0x150(%rbp),%rsi
movslq -0x8c(%rbp),%rax
lea    -0x230(%rbp),%rdx
shl    $0x4,%rax
add    %rax,%rdx
call   1060 <Calc_3dMat4Multi14@plt>
mov    -0x8c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8c(%rbp)
jmp    14b3 <npt_move_vertex+0x333>
movss  -0x230(%rbp),%xmm0
ff
mov    0x48(%rbp),%rax
movss  %xmm0,(%rax)
movss  -0x22c(%rbp),%xmm0
ff
mov    0x48(%rbp),%rax
movss  %xmm0,0x4(%rax)
movss  -0x228(%rbp),%xmm0
ff
mov    0x48(%rbp),%rax
movss  %xmm0,0x8(%rax)
movss  -0x220(%rbp),%xmm0
ff
mov    0x50(%rbp),%rax
movss  %xmm0,(%rax)
movss  -0x21c(%rbp),%xmm0
ff
mov    0x50(%rbp),%rax
movss  %xmm0,0x4(%rax)
movss  -0x218(%rbp),%xmm0
ff
mov    0x50(%rbp),%rax
movss  %xmm0,0x8(%rax)
movss  -0x210(%rbp),%xmm0
ff
mov    0x58(%rbp),%rax
movss  %xmm0,(%rax)
movss  -0x20c(%rbp),%xmm0
ff
mov    0x58(%rbp),%rax
movss  %xmm0,0x4(%rax)
movss  -0x208(%rbp),%xmm0
ff
mov    0x58(%rbp),%rax
movss  %xmm0,0x8(%rax)
movss  -0x200(%rbp),%xmm0
ff
mov    0x60(%rbp),%rax
movss  %xmm0,(%rax)
movss  -0x1fc(%rbp),%xmm0
ff
mov    0x60(%rbp),%rax
movss  %xmm0,0x4(%rax)
movss  -0x1f8(%rbp),%xmm0
ff
mov    0x60(%rbp),%rax
movss  %xmm0,0x8(%rax)
movss  -0x1f0(%rbp),%xmm0
ff
mov    0x68(%rbp),%rax
movss  %xmm0,(%rax)
movss  -0x1ec(%rbp),%xmm0
ff
mov    0x68(%rbp),%rax
movss  %xmm0,0x4(%rax)
movss  -0x1e8(%rbp),%xmm0
ff
mov    0x68(%rbp),%rax
movss  %xmm0,0x8(%rax)
movss  -0x1e0(%rbp),%xmm0
ff
mov    0x70(%rbp),%rax
movss  %xmm0,(%rax)
movss  -0x1dc(%rbp),%xmm0
ff
mov    0x70(%rbp),%rax
movss  %xmm0,0x4(%rax)
movss  -0x1d8(%rbp),%xmm0
ff
mov    0x70(%rbp),%rax
movss  %xmm0,0x8(%rax)
movss  -0x1d0(%rbp),%xmm0
ff
mov    0x78(%rbp),%rax
movss  %xmm0,(%rax)
movss  -0x1cc(%rbp),%xmm0
ff
mov    0x78(%rbp),%rax
movss  %xmm0,0x4(%rax)
movss  -0x1c8(%rbp),%xmm0
ff
mov    0x78(%rbp),%rax
movss  %xmm0,0x8(%rax)
add    $0x230,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<npt_move_vertex>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x228,%rsp
mov    %r9,0x100(%rsp)
mov    %r8,0xf8(%rsp)
mov    %rcx,0xf0(%rsp)
mov    %rdx,%r14
mov    %rdi,%r13
mov    0x280(%rsp),%r15
lea    0x118(%rsp),%rbx
lea    0xc(%rsp),%rcx
mov    %rbx,%rdx
call   1080 <CalcLineVec@plt>
lea    0x154(%rsp),%r12
mov    %r13,%rdi
mov    %r14,%rsi
mov    %r12,%rdx
call   10a0 <CalcVec@plt>
lea    0x10c(%rsp),%rbp
mov    %rbx,%rdi
mov    %r12,%rsi
mov    %rbp,%rdx
call   1090 <CalcOutProduct@plt>
mov    %rbp,%rdi
call   1070 <CalcNormalize@plt>
lea    0x148(%rsp),%rdx
mov    %rbp,%rdi
mov    %rbx,%rsi
mov    %rdx,%rbx
call   1090 <CalcOutProduct@plt>
lea    0x13c(%rsp),%r14
mov    %r15,%rdi
mov    0x288(%rsp),%rsi
mov    %r14,%rdx
lea    0xc(%rsp),%rcx
call   1080 <CalcLineVec@plt>
mov    %r15,%rdi
mov    0x290(%rsp),%rsi
mov    %r12,%rdx
call   10a0 <CalcVec@plt>
lea    0x124(%rsp),%r15
mov    %r14,%rdi
mov    %r12,%rsi
mov    %r15,%rdx
call   1090 <CalcOutProduct@plt>
mov    %r15,%rdi
call   1070 <CalcNormalize@plt>
lea    0x130(%rsp),%rbp
mov    %r15,%rdi
mov    %r14,%rsi
mov    %rbp,%rdx
call   1090 <CalcOutProduct@plt>
lea    0x1e0(%rsp),%r12
mov    %r13,%rdi
lea    0x118(%rsp),%rsi
mov    %rbx,%rdx
lea    0x10c(%rsp),%rcx
mov    %r12,%r8
call   1030 <Calc_3dMat4TranAxis@plt>
lea    0x1a0(%rsp),%rbx
mov    0x280(%rsp),%rdi
mov    %r14,%rsi
mov    %rbp,%rdx
mov    %r15,%rcx
mov    %rbx,%r8
call   1050 <Calc_3dMat4TranAxisInv@plt>
lea    0x160(%rsp),%r15
mov    %r12,%rdi
mov    %rbx,%rsi
mov    %r15,%rdx
call   1040 <Calc_3dMat4Multi44@plt>
mov    0xf0(%rsp),%rax
movss  (%rax),%xmm0
movss  %xmm0,0x10(%rsp)
movss  0x4(%rax),%xmm0
movss  %xmm0,0x14(%rsp)
movss  0x8(%rax),%xmm0
movss  %xmm0,0x18(%rsp)
movl   $0x3f800000,0x1c(%rsp)
3f
mov    0xf8(%rsp),%rax
movss  (%rax),%xmm0
movss  %xmm0,0x20(%rsp)
movss  0x4(%rax),%xmm0
movss  %xmm0,0x24(%rsp)
movss  0x8(%rax),%xmm0
movss  %xmm0,0x28(%rsp)
movl   $0x3f800000,0x2c(%rsp)
3f
mov    0x100(%rsp),%rax
movss  (%rax),%xmm0
lea    0x30(%rsp),%rbx
movss  %xmm0,0x30(%rsp)
movss  0x4(%rax),%xmm0
movss  %xmm0,0x34(%rsp)
movss  0x8(%rax),%xmm0
movss  %xmm0,0x38(%rsp)
movl   $0x3f800000,0x3c(%rsp)
3f
mov    0x260(%rsp),%rax
movss  (%rax),%xmm0
lea    0x40(%rsp),%r14
movss  %xmm0,0x40(%rsp)
movss  0x4(%rax),%xmm0
movss  %xmm0,0x44(%rsp)
movss  0x8(%rax),%xmm0
movss  %xmm0,0x48(%rsp)
movl   $0x3f800000,0x4c(%rsp)
3f
mov    0x268(%rsp),%rax
movss  (%rax),%xmm0
lea    0x50(%rsp),%r13
movss  %xmm0,0x50(%rsp)
movss  0x4(%rax),%xmm0
movss  %xmm0,0x54(%rsp)
movss  0x8(%rax),%xmm0
movss  %xmm0,0x58(%rsp)
movl   $0x3f800000,0x5c(%rsp)
3f
mov    0x270(%rsp),%rax
movss  (%rax),%xmm0
lea    0x60(%rsp),%rbp
movss  %xmm0,0x60(%rsp)
movss  0x4(%rax),%xmm0
movss  %xmm0,0x64(%rsp)
movss  0x8(%rax),%xmm0
movss  %xmm0,0x68(%rsp)
movl   $0x3f800000,0x6c(%rsp)
3f
mov    0x278(%rsp),%rax
movss  (%rax),%xmm0
lea    0x70(%rsp),%r12
movss  %xmm0,0x70(%rsp)
movss  0x4(%rax),%xmm0
movss  %xmm0,0x74(%rsp)
movss  0x8(%rax),%xmm0
movss  %xmm0,0x78(%rsp)
movl   $0x3f800000,0x7c(%rsp)
3f
lea    0x10(%rsp),%rdi
lea    0x80(%rsp),%rdx
mov    %r15,%rsi
call   1060 <Calc_3dMat4Multi14@plt>
lea    0x90(%rsp),%rdx
lea    0x20(%rsp),%rdi
mov    %r15,%rsi
call   1060 <Calc_3dMat4Multi14@plt>
lea    0xa0(%rsp),%rdx
mov    %rbx,%rdi
mov    %r15,%rsi
call   1060 <Calc_3dMat4Multi14@plt>
lea    0xb0(%rsp),%rdx
mov    %r14,%rdi
mov    %r15,%rsi
call   1060 <Calc_3dMat4Multi14@plt>
lea    0xc0(%rsp),%rdx
mov    %r13,%rdi
mov    %r15,%rsi
call   1060 <Calc_3dMat4Multi14@plt>
lea    0xd0(%rsp),%rdx
mov    %rbp,%rdi
mov    %r15,%rsi
call   1060 <Calc_3dMat4Multi14@plt>
lea    0xe0(%rsp),%rdx
mov    %r12,%rdi
mov    %r15,%rsi
call   1060 <Calc_3dMat4Multi14@plt>
movss  0x80(%rsp),%xmm0
mov    0x298(%rsp),%rax
movss  %xmm0,(%rax)
movss  0x84(%rsp),%xmm0
movss  %xmm0,0x4(%rax)
movss  0x88(%rsp),%xmm0
movss  %xmm0,0x8(%rax)
movss  0x90(%rsp),%xmm0
mov    0x2a0(%rsp),%rax
movss  %xmm0,(%rax)
movss  0x94(%rsp),%xmm0
movss  %xmm0,0x4(%rax)
movss  0x98(%rsp),%xmm0
movss  %xmm0,0x8(%rax)
movss  0xa0(%rsp),%xmm0
mov    0x2a8(%rsp),%rax
movss  %xmm0,(%rax)
movss  0xa4(%rsp),%xmm0
movss  %xmm0,0x4(%rax)
movss  0xa8(%rsp),%xmm0
movss  %xmm0,0x8(%rax)
movss  0xb0(%rsp),%xmm0
mov    0x2b0(%rsp),%rax
movss  %xmm0,(%rax)
movss  0xb4(%rsp),%xmm0
movss  %xmm0,0x4(%rax)
movss  0xb8(%rsp),%xmm0
movss  %xmm0,0x8(%rax)
movss  0xc0(%rsp),%xmm0
mov    0x2b8(%rsp),%rax
movss  %xmm0,(%rax)
movss  0xc4(%rsp),%xmm0
movss  %xmm0,0x4(%rax)
movss  0xc8(%rsp),%xmm0
movss  %xmm0,0x8(%rax)
movss  0xd0(%rsp),%xmm0
mov    0x2c0(%rsp),%rax
movss  %xmm0,(%rax)
movss  0xd4(%rsp),%xmm0
movss  %xmm0,0x4(%rax)
movss  0xd8(%rsp),%xmm0
movss  %xmm0,0x8(%rax)
movss  0xe0(%rsp),%xmm0
mov    0x2c8(%rsp),%rax
movss  %xmm0,(%rax)
movss  0xe4(%rsp),%xmm0
movss  %xmm0,0x4(%rax)
movss  0xe8(%rsp),%xmm0
movss  %xmm0,0x8(%rax)
add    $0x228,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

LLVM IR (-O2):
define void @npt_move_vertex(float* %0, float* %1, float* %2, float* nocapture %3, float* nocapture %4, float* nocapture %5, float* nocapture %6, float* nocapture %7, float* nocapture %8, float* nocapture %9, float* %10, float* %11, float* %12, float* nocapture writeonly %13, float* nocapture writeonly %14, float* nocapture writeonly %15, float* nocapture writeonly %16, float* nocapture writeonly %17, float* nocapture writeonly %18, float* nocapture writeonly %19) {
%21 = alloca float
%22 = alloca [3 x float]
%23 = alloca [3 x float]
%24 = alloca [3 x float]
%25 = alloca [3 x float]
%26 = alloca [3 x float]
%27 = alloca [3 x float]
%28 = alloca [3 x float]
%29 = alloca [4 x [4 x float]]
%30 = alloca [4 x [4 x float]]
%31 = alloca [4 x [4 x float]]
%32 = alloca [7 x [4 x float]]
%33 = alloca [7 x [4 x float]]
%34 = bitcast float* %21 to i8*
%35 = bitcast [3 x float]* %22 to i8*
%36 = bitcast [3 x float]* %23 to i8*
%37 = bitcast [3 x float]* %24 to i8*
%38 = bitcast [3 x float]* %25 to i8*
%39 = bitcast [3 x float]* %26 to i8*
%40 = bitcast [3 x float]* %27 to i8*
%41 = bitcast [3 x float]* %28 to i8*
%42 = getelementptr inbounds [3 x float], [3 x float]* %23, i64 0, i64 0
%43 = call i32 @CalcLineVec(float* %0, float* %1, float* %42, float* %21)
%44 = getelementptr inbounds [3 x float], [3 x float]* %22, i64 0, i64 0
%45 = call i32 @CalcVec(float* %0, float* %2, float* %44)
%46 = getelementptr inbounds [3 x float], [3 x float]* %25, i64 0, i64 0
%47 = call i32 @CalcOutProduct(float* %42, float* %44, float* %46)
%48 = call i32 @CalcNormalize(float* %46)
%49 = getelementptr inbounds [3 x float], [3 x float]* %24, i64 0, i64 0
%50 = call i32 @CalcOutProduct(float* %46, float* %42, float* %49)
%51 = getelementptr inbounds [3 x float], [3 x float]* %26, i64 0, i64 0
%52 = call i32 @CalcLineVec(float* %10, float* %11, float* %51, float* %21)
%53 = call i32 @CalcVec(float* %10, float* %12, float* %44)
%54 = getelementptr inbounds [3 x float], [3 x float]* %28, i64 0, i64 0
%55 = call i32 @CalcOutProduct(float* %51, float* %44, float* %54)
%56 = call i32 @CalcNormalize(float* %54)
%57 = getelementptr inbounds [3 x float], [3 x float]* %27, i64 0, i64 0
%58 = call i32 @CalcOutProduct(float* %54, float* %51, float* %57)
%59 = bitcast [4 x [4 x float]]* %29 to i8*
%60 = bitcast [4 x [4 x float]]* %30 to i8*
%61 = bitcast [4 x [4 x float]]* %31 to i8*
%62 = bitcast [4 x [4 x float]]* %29 to float**
%63 = call i32 @Calc_3dMat4TranAxis(float* %0, float* %42, float* %49, float* %46, float** %62)
%64 = bitcast [4 x [4 x float]]* %30 to float**
%65 = call i32 @Calc_3dMat4TranAxisInv(float* %10, float* %51, float* %57, float* %54, float** %64)
%66 = bitcast [4 x [4 x float]]* %31 to float**
%67 = call i32 @Calc_3dMat4Multi44(float** %62, float** %64, float** %66)
%68 = bitcast [7 x [4 x float]]* %32 to i8*
%69 = bitcast [7 x [4 x float]]* %33 to i8*
%70 = load float, float* %3
%71 = getelementptr inbounds [7 x [4 x float]], [7 x [4 x float]]* %32, i64 0, i64 0, i64 0
store float %70, float* %71
%72 = getelementptr inbounds float, float* %3, i64 1
%73 = load float, float* %72
%74 = getelementptr inbounds [7 x [4 x float]], [7 x [4 x float]]* %32, i64 0, i64 0, i64 1
store float %73, float* %74
%75 = getelementptr inbounds float, float* %3, i64 2
%76 = load float, float* %75
%77 = getelementptr inbounds [7 x [4 x float]], [7 x [4 x float]]* %32, i64 0, i64 0, i64 2
store float %76, float* %77
%78 = getelementptr inbounds [7 x [4 x float]], [7 x [4 x float]]* %32, i64 0, i64 0, i64 3
store float 1.000000e+00, float* %78
%79 = load float, float* %4
%80 = getelementptr inbounds [7 x [4 x float]], [7 x [4 x float]]* %32, i64 0, i64 1, i64 0
store float %79, float* %80
%81 = getelementptr inbounds float, float* %4, i64 1
%82 = load float, float* %81
%83 = getelementptr inbounds [7 x [4 x float]], [7 x [4 x float]]* %32, i64 0, i64 1, i64 1
store float %82, float* %83
%84 = getelementptr inbounds float, float* %4, i64 2
%85 = load float, float* %84
%86 = getelementptr inbounds [7 x [4 x float]], [7 x [4 x float]]* %32, i64 0, i64 1, i64 2
store float %85, float* %86
%87 = getelementptr inbounds [7 x [4 x float]], [7 x [4 x float]]* %32, i64 0, i64 1, i64 3
store float 1.000000e+00, float* %87
%88 = load float, float* %5
%89 = getelementptr inbounds [7 x [4 x float]], [7 x [4 x float]]* %32, i64 0, i64 2, i64 0
store float %88, float* %89
%90 = getelementptr inbounds float, float* %5, i64 1
%91 = load float, float* %90
%92 = getelementptr inbounds [7 x [4 x float]], [7 x [4 x float]]* %32, i64 0, i64 2, i64 1
store float %91, float* %92
%93 = getelementptr inbounds float, float* %5, i64 2
%94 = load float, float* %93
%95 = getelementptr inbounds [7 x [4 x float]], [7 x [4 x float]]* %32, i64 0, i64 2, i64 2
store float %94, float* %95
%96 = getelementptr inbounds [7 x [4 x float]], [7 x [4 x float]]* %32, i64 0, i64 2, i64 3
store float 1.000000e+00, float* %96
%97 = load float, float* %6
%98 = getelementptr inbounds [7 x [4 x float]], [7 x [4 x float]]* %32, i64 0, i64 3, i64 0
store float %97, float* %98
%99 = getelementptr inbounds float, float* %6, i64 1
%100 = load float, float* %99
%101 = getelementptr inbounds [7 x [4 x float]], [7 x [4 x float]]* %32, i64 0, i64 3, i64 1
store float %100, float* %101
%102 = getelementptr inbounds float, float* %6, i64 2
%103 = load float, float* %102
%104 = getelementptr inbounds [7 x [4 x float]], [7 x [4 x float]]* %32, i64 0, i64 3, i64 2
store float %103, float* %104
%105 = getelementptr inbounds [7 x [4 x float]], [7 x [4 x float]]* %32, i64 0, i64 3, i64 3
store float 1.000000e+00, float* %105
%106 = load float, float* %7
%107 = getelementptr inbounds [7 x [4 x float]], [7 x [4 x float]]* %32, i64 0, i64 4, i64 0
store float %106, float* %107
%108 = getelementptr inbounds float, float* %7, i64 1
%109 = load float, float* %108
%110 = getelementptr inbounds [7 x [4 x float]], [7 x [4 x float]]* %32, i64 0, i64 4, i64 1
store float %109, float* %110
%111 = getelementptr inbounds float, float* %7, i64 2
%112 = load float, float* %111
%113 = getelementptr inbounds [7 x [4 x float]], [7 x [4 x float]]* %32, i64 0, i64 4, i64 2
store float %112, float* %113
%114 = getelementptr inbounds [7 x [4 x float]], [7 x [4 x float]]* %32, i64 0, i64 4, i64 3
store float 1.000000e+00, float* %114
%115 = load float, float* %8
%116 = getelementptr inbounds [7 x [4 x float]], [7 x [4 x float]]* %32, i64 0, i64 5, i64 0
store float %115, float* %116
%117 = getelementptr inbounds float, float* %8, i64 1
%118 = load float, float* %117
%119 = getelementptr inbounds [7 x [4 x float]], [7 x [4 x float]]* %32, i64 0, i64 5, i64 1
store float %118, float* %119
%120 = getelementptr inbounds float, float* %8, i64 2
%121 = load float, float* %120
%122 = getelementptr inbounds [7 x [4 x float]], [7 x [4 x float]]* %32, i64 0, i64 5, i64 2
store float %121, float* %122
%123 = getelementptr inbounds [7 x [4 x float]], [7 x [4 x float]]* %32, i64 0, i64 5, i64 3
store float 1.000000e+00, float* %123
%124 = load float, float* %9
%125 = getelementptr inbounds [7 x [4 x float]], [7 x [4 x float]]* %32, i64 0, i64 6, i64 0
store float %124, float* %125
%126 = getelementptr inbounds float, float* %9, i64 1
%127 = load float, float* %126
%128 = getelementptr inbounds [7 x [4 x float]], [7 x [4 x float]]* %32, i64 0, i64 6, i64 1
store float %127, float* %128
%129 = getelementptr inbounds float, float* %9, i64 2
%130 = load float, float* %129
%131 = getelementptr inbounds [7 x [4 x float]], [7 x [4 x float]]* %32, i64 0, i64 6, i64 2
store float %130, float* %131
%132 = getelementptr inbounds [7 x [4 x float]], [7 x [4 x float]]* %32, i64 0, i64 6, i64 3
store float 1.000000e+00, float* %132
%133 = getelementptr inbounds [7 x [4 x float]], [7 x [4 x float]]* %33, i64 0, i64 0, i64 0
%134 = call i32 @Calc_3dMat4Multi14(float* %71, float** %66, float* %133)
%135 = getelementptr inbounds [7 x [4 x float]], [7 x [4 x float]]* %33, i64 0, i64 1, i64 0
%136 = call i32 @Calc_3dMat4Multi14(float* %80, float** %66, float* %135)
%137 = getelementptr inbounds [7 x [4 x float]], [7 x [4 x float]]* %33, i64 0, i64 2, i64 0
%138 = call i32 @Calc_3dMat4Multi14(float* %89, float** %66, float* %137)
%139 = getelementptr inbounds [7 x [4 x float]], [7 x [4 x float]]* %33, i64 0, i64 3, i64 0
%140 = call i32 @Calc_3dMat4Multi14(float* %98, float** %66, float* %139)
%141 = getelementptr inbounds [7 x [4 x float]], [7 x [4 x float]]* %33, i64 0, i64 4, i64 0
%142 = call i32 @Calc_3dMat4Multi14(float* %107, float** %66, float* %141)
%143 = getelementptr inbounds [7 x [4 x float]], [7 x [4 x float]]* %33, i64 0, i64 5, i64 0
%144 = call i32 @Calc_3dMat4Multi14(float* %116, float** %66, float* %143)
%145 = getelementptr inbounds [7 x [4 x float]], [7 x [4 x float]]* %33, i64 0, i64 6, i64 0
%146 = call i32 @Calc_3dMat4Multi14(float* %125, float** %66, float* %145)
%147 = load float, float* %133
store float %147, float* %13
%148 = getelementptr inbounds [7 x [4 x float]], [7 x [4 x float]]* %33, i64 0, i64 0, i64 1
%149 = load float, float* %148
%150 = getelementptr inbounds float, float* %13, i64 1
store float %149, float* %150
%151 = getelementptr inbounds [7 x [4 x float]], [7 x [4 x float]]* %33, i64 0, i64 0, i64 2
%152 = load float, float* %151
%153 = getelementptr inbounds float, float* %13, i64 2
store float %152, float* %153
%154 = load float, float* %135
store float %154, float* %14
%155 = getelementptr inbounds [7 x [4 x float]], [7 x [4 x float]]* %33, i64 0, i64 1, i64 1
%156 = load float, float* %155
%157 = getelementptr inbounds float, float* %14, i64 1
store float %156, float* %157
%158 = getelementptr inbounds [7 x [4 x float]], [7 x [4 x float]]* %33, i64 0, i64 1, i64 2
%159 = load float, float* %158
%160 = getelementptr inbounds float, float* %14, i64 2
store float %159, float* %160
%161 = load float, float* %137
store float %161, float* %15
%162 = getelementptr inbounds [7 x [4 x float]], [7 x [4 x float]]* %33, i64 0, i64 2, i64 1
%163 = load float, float* %162
%164 = getelementptr inbounds float, float* %15, i64 1
store float %163, float* %164
%165 = getelementptr inbounds [7 x [4 x float]], [7 x [4 x float]]* %33, i64 0, i64 2, i64 2
%166 = load float, float* %165
%167 = getelementptr inbounds float, float* %15, i64 2
store float %166, float* %167
%168 = load float, float* %139
store float %168, float* %16
%169 = getelementptr inbounds [7 x [4 x float]], [7 x [4 x float]]* %33, i64 0, i64 3, i64 1
%170 = load float, float* %169
%171 = getelementptr inbounds float, float* %16, i64 1
store float %170, float* %171
%172 = getelementptr inbounds [7 x [4 x float]], [7 x [4 x float]]* %33, i64 0, i64 3, i64 2
%173 = load float, float* %172
%174 = getelementptr inbounds float, float* %16, i64 2
store float %173, float* %174
%175 = load float, float* %141
store float %175, float* %17
%176 = getelementptr inbounds [7 x [4 x float]], [7 x [4 x float]]* %33, i64 0, i64 4, i64 1
%177 = load float, float* %176
%178 = getelementptr inbounds float, float* %17, i64 1
store float %177, float* %178
%179 = getelementptr inbounds [7 x [4 x float]], [7 x [4 x float]]* %33, i64 0, i64 4, i64 2
%180 = load float, float* %179
%181 = getelementptr inbounds float, float* %17, i64 2
store float %180, float* %181
%182 = load float, float* %143
store float %182, float* %18
%183 = getelementptr inbounds [7 x [4 x float]], [7 x [4 x float]]* %33, i64 0, i64 5, i64 1
%184 = load float, float* %183
%185 = getelementptr inbounds float, float* %18, i64 1
store float %184, float* %185
%186 = getelementptr inbounds [7 x [4 x float]], [7 x [4 x float]]* %33, i64 0, i64 5, i64 2
%187 = load float, float* %186
%188 = getelementptr inbounds float, float* %18, i64 2
store float %187, float* %188
%189 = load float, float* %145
store float %189, float* %19
%190 = getelementptr inbounds [7 x [4 x float]], [7 x [4 x float]]* %33, i64 0, i64 6, i64 1
%191 = load float, float* %190
%192 = getelementptr inbounds float, float* %19, i64 1
store float %191, float* %192
%193 = getelementptr inbounds [7 x [4 x float]], [7 x [4 x float]]* %33, i64 0, i64 6, i64 2
%194 = load float, float* %193
%195 = getelementptr inbounds float, float* %19, i64 2
store float %194, float* %195
ret void
}