#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 */
long double qual_delta(double *, int, int, int, int, double);
int func_xyz(double *vertex, int v, int v1, int v2, int v3, double dx[3],
             double delta, double ds, int n) {
  long double h = ds * 1e-6;
  long double q1, q2, f1, f2;
  int i, j;
  for (i = 0; i < 3; i++) {
    vertex[3 * v + i] += h;
    q1 = qual_delta(vertex, v, v1, v2, v3, delta);
    vertex[3 * v + i] -= h;
    for (f1 = 1.0, j = 0; j < n; j++)
      f1 /= q1;
    vertex[3 * v + i] -= h;
    q2 = qual_delta(vertex, v, v1, v2, v3, delta);
    vertex[3 * v + i] += h;
    for (f2 = 1.0, j = 0; j < n; j++)
      f2 /= q2;
    dx[i] = (f1 - f2) / (2.0 * h);
  }
  return 0;
}


x86 assembly (clang, -O0):
<func_xyz>:
push   %rbp
mov    %rsp,%rbp
sub    $0xa0,%rsp
mov    0x10(%rbp),%eax
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %edx,-0x10(%rbp)
mov    %ecx,-0x14(%rbp)
mov    %r8d,-0x18(%rbp)
mov    %r9,-0x20(%rbp)
movsd  %xmm0,-0x28(%rbp)
movsd  %xmm1,-0x30(%rbp)
movsd  -0x30(%rbp),%xmm0
movsd  0xeb6(%rip),%xmm1
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
fldl   -0x90(%rbp)
fstpt  -0x40(%rbp)
movl   $0x0,-0x84(%rbp)
cmpl   $0x3,-0x84(%rbp)
jge    12f5 <func_xyz+0x1e5>
fldt   -0x40(%rbp)
mov    -0x8(%rbp),%rax
mov    -0xc(%rbp),%edx
mov    %edx,%ecx
lea    (%rcx,%rcx,2),%ecx
mov    -0x84(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
fldl   (%rax,%rcx,8)
faddp  %st,%st(1)
fstpl  (%rax,%rcx,8)
mov    -0x8(%rbp),%rdi
mov    -0xc(%rbp),%esi
mov    -0x10(%rbp),%edx
mov    -0x14(%rbp),%ecx
mov    -0x18(%rbp),%r8d
movsd  -0x28(%rbp),%xmm0
call   1030 <qual_delta@plt>
fstpt  -0x50(%rbp)
fldt   -0x40(%rbp)
mov    -0x8(%rbp),%rax
mov    -0xc(%rbp),%edx
mov    %edx,%ecx
lea    (%rcx,%rcx,2),%ecx
mov    -0x84(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
fldl   (%rax,%rcx,8)
fsubp  %st,%st(1)
fstpl  (%rax,%rcx,8)
fld1
fstpt  -0x70(%rbp)
movl   $0x0,-0x88(%rbp)
mov    -0x88(%rbp),%eax
cmp    0x10(%rbp),%eax
jge    1215 <func_xyz+0x105>
fldt   -0x50(%rbp)
fldt   -0x70(%rbp)
fdivp  %st,%st(1)
fstpt  -0x70(%rbp)
mov    -0x88(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x88(%rbp)
jmp    11e7 <func_xyz+0xd7>
fldt   -0x40(%rbp)
mov    -0x8(%rbp),%rax
mov    -0xc(%rbp),%edx
mov    %edx,%ecx
lea    (%rcx,%rcx,2),%ecx
mov    -0x84(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
fldl   (%rax,%rcx,8)
fsubp  %st,%st(1)
fstpl  (%rax,%rcx,8)
mov    -0x8(%rbp),%rdi
mov    -0xc(%rbp),%esi
mov    -0x10(%rbp),%edx
mov    -0x14(%rbp),%ecx
mov    -0x18(%rbp),%r8d
movsd  -0x28(%rbp),%xmm0
call   1030 <qual_delta@plt>
fstpt  -0x60(%rbp)
fldt   -0x40(%rbp)
mov    -0x8(%rbp),%rax
mov    -0xc(%rbp),%edx
mov    %edx,%ecx
lea    (%rcx,%rcx,2),%ecx
mov    -0x84(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
fldl   (%rax,%rcx,8)
faddp  %st,%st(1)
fstpl  (%rax,%rcx,8)
fld1
fstpt  -0x80(%rbp)
movl   $0x0,-0x88(%rbp)
mov    -0x88(%rbp),%eax
cmp    0x10(%rbp),%eax
jge    12b4 <func_xyz+0x1a4>
fldt   -0x60(%rbp)
fldt   -0x80(%rbp)
fdivp  %st,%st(1)
fstpt  -0x80(%rbp)
mov    -0x88(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x88(%rbp)
jmp    1286 <func_xyz+0x176>
fldt   -0x70(%rbp)
fldt   -0x80(%rbp)
fsubrp %st,%st(1)
fldt   -0x40(%rbp)
fadd   %st,%st(0)
fdivrp %st,%st(1)
fstpl  -0x98(%rbp)
movsd  -0x98(%rbp),%xmm0
ff
mov    -0x20(%rbp),%rax
movslq -0x84(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x84(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x84(%rbp)
jmp    1169 <func_xyz+0x59>
xor    %eax,%eax
add    $0xa0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<func_xyz>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x88,%rsp
movsd  %xmm0,0x30(%rsp)
mov    %r9,0x40(%rsp)
mov    %r8d,0x14(%rsp)
mov    %ecx,%r12d
mov    %edx,%r13d
mov    %esi,%ebx
mov    %rdi,%rbp
mulsd  0xebc(%rip),%xmm1
mov    0xc0(%rsp),%ecx
movsd  %xmm1,0x58(%rsp)
fldl   0x58(%rsp)
lea    (%rbx,%rbx,2),%eax
fld    %st(0)
fstpt  0x18(%rsp)
fadd   %st,%st(0)
fstpt  0x70(%rsp)
cltq
mov    %rax,0x38(%rsp)
lea    -0x1(%rcx),%eax
mov    %eax,0x10(%rsp)
mov    %ecx,%eax
and    $0x3,%eax
mov    %eax,0x8(%rsp)
mov    %ecx,%eax
and    $0xfffffffc,%eax
mov    %eax,0xc(%rsp)
xor    %r14d,%r14d
fld1
fstpt  0x24(%rsp)
fldz
fstpt  0x64(%rsp)
jmp    11c7 <func_xyz+0xb7>
cs nopw 0x0(%rax,%rax,1)
nop
fstp   %st(2)
fstp   %st(1)
fldt   0x7c(%rsp)
fsubp  %st,%st(1)
fldt   0x70(%rsp)
fdivrp %st,%st(1)
mov    0x40(%rsp),%rax
fstpl  (%rax,%r14,8)
add    $0x1,%r14
cmp    $0x3,%r14
je     1330 <func_xyz+0x220>
mov    0x38(%rsp),%rax
lea    (%r14,%rax,1),%r15
fldt   0x18(%rsp)
faddl  0x0(%rbp,%r15,8)
fstpl  0x0(%rbp,%r15,8)
mov    %rbp,%rdi
mov    %ebx,%esi
mov    %r13d,%edx
mov    %r12d,%ecx
mov    0x14(%rsp),%r8d
movsd  0x30(%rsp),%xmm0
call   1030 <qual_delta@plt>
fldt   0x18(%rsp)
fsubrl 0x0(%rbp,%r15,8)
fstpl  0x50(%rsp)
fldt   0x24(%rsp)
mov    0xc0(%rsp),%eax
test   %eax,%eax
fldz
jle    126b <func_xyz+0x15b>
fstp   %st(0)
fstp   %st(0)
fldt   0x64(%rsp)
fldt   0x24(%rsp)
cmpl   $0x3,0x10(%rsp)
jb     1251 <func_xyz+0x141>
fstp   %st(0)
fstp   %st(0)
fld1
mov    0xc(%rsp),%eax
fldz
cs nopw 0x0(%rax,%rax,1)
fstp   %st(0)
fdiv   %st(1),%st
fdiv   %st(1),%st
fdiv   %st(1),%st
fdiv   %st(1),%st
fld    %st(0)
add    $0xfffffffc,%eax
jne    1240 <func_xyz+0x130>
cmpl   $0x0,0x8(%rsp)
je     126b <func_xyz+0x15b>
fstp   %st(1)
mov    0x8(%rsp),%eax
fldz
fstp   %st(0)
fdiv   %st(1),%st
add    $0xffffffff,%eax
fldz
jne    1260 <func_xyz+0x150>
fstp   %st(2)
fstp   %st(1)
fstpt  0x7c(%rsp)
movsd  0x50(%rsp),%xmm0
movsd  %xmm0,0x48(%rsp)
fldt   0x18(%rsp)
fsubrl 0x48(%rsp)
fstpl  0x0(%rbp,%r15,8)
mov    %rbp,%rdi
mov    %ebx,%esi
mov    %r13d,%edx
mov    %r12d,%ecx
mov    0x14(%rsp),%r8d
movsd  0x30(%rsp),%xmm0
call   1030 <qual_delta@plt>
fldt   0x18(%rsp)
faddl  0x0(%rbp,%r15,8)
fstpl  0x0(%rbp,%r15,8)
fldt   0x24(%rsp)
mov    0xc0(%rsp),%eax
test   %eax,%eax
fldz
jle    11a0 <func_xyz+0x90>
fstp   %st(1)
fstp   %st(0)
fld1
fldz
cmpl   $0x3,0x10(%rsp)
jb     1303 <func_xyz+0x1f3>
fstp   %st(0)
fstp   %st(0)
fld1
mov    0xc(%rsp),%eax
fldz
fxch   %st(1)
nopw   0x0(%rax,%rax,1)
fstp   %st(1)
fdiv   %st(1),%st
fdiv   %st(1),%st
fdiv   %st(1),%st
fdiv   %st(1),%st
fld    %st(0)
add    $0xfffffffc,%eax
fxch   %st(1)
jne    12f0 <func_xyz+0x1e0>
mov    0xc0(%rsp),%eax
test   $0x3,%al
fxch   %st(1)
je     11a0 <func_xyz+0x90>
fstp   %st(1)
mov    0x8(%rsp),%eax
fldz
nopl   0x0(%rax)
fstp   %st(0)
fdiv   %st(1),%st
add    $0xffffffff,%eax
fldz
jne    1320 <func_xyz+0x210>
jmp    11a0 <func_xyz+0x90>
xor    %eax,%eax
add    $0x88,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
define i32 @func_xyz(double* %0, i32 %1, i32 %2, i32 %3, i32 %4, double* %5, double %6, double %7, i32 %8) {
%10 = alloca double*
%11 = alloca i32
%12 = alloca i32
%13 = alloca i32
%14 = alloca i32
%15 = alloca double*
%16 = alloca double
%17 = alloca double
%18 = alloca i32
%19 = alloca x86_fp80
%20 = alloca x86_fp80
%21 = alloca x86_fp80
%22 = alloca x86_fp80
%23 = alloca x86_fp80
%24 = alloca i32
%25 = alloca i32
store double* %0, double** %10
store i32 %1, i32* %11
store i32 %2, i32* %12
store i32 %3, i32* %13
store i32 %4, i32* %14
store double* %5, double** %15
store double %6, double* %16
store double %7, double* %17
store i32 %8, i32* %18
%26 = load double, double* %17
%27 = fmul double %26, 0x3EB0C6F7A0B5ED8D
%28 = fpext double %27 to x86_fp80
store x86_fp80 %28, x86_fp80* %19
store i32 0, i32* %24
br label %29
29: ; preds = %130, %9
%30 = load i32, i32* %24
%31 = icmp slt i32 %30, 3
br i1 %31, label %32, label %133
32: ; preds = %29
%33 = load x86_fp80, x86_fp80* %19
%34 = load double*, double** %10
%35 = load i32, i32* %11
%36 = mul nsw i32 3, %35
%37 = load i32, i32* %24
%38 = add nsw i32 %36, %37
%39 = sext i32 %38 to i64
%40 = getelementptr inbounds double, double* %34, i64 %39
%41 = load double, double* %40
%42 = fpext double %41 to x86_fp80
%43 = fadd x86_fp80 %42, %33
%44 = fptrunc x86_fp80 %43 to double
store double %44, double* %40
%45 = load double*, double** %10
%46 = load i32, i32* %11
%47 = load i32, i32* %12
%48 = load i32, i32* %13
%49 = load i32, i32* %14
%50 = load double, double* %16
%51 = call x86_fp80 @qual_delta(double* %45, i32 %46, i32 %47, i32 %48, i32 %49, double %50)
store x86_fp80 %51, x86_fp80* %20
%52 = load x86_fp80, x86_fp80* %19
%53 = load double*, double** %10
%54 = load i32, i32* %11
%55 = mul nsw i32 3, %54
%56 = load i32, i32* %24
%57 = add nsw i32 %55, %56
%58 = sext i32 %57 to i64
%59 = getelementptr inbounds double, double* %53, i64 %58
%60 = load double, double* %59
%61 = fpext double %60 to x86_fp80
%62 = fsub x86_fp80 %61, %52
%63 = fptrunc x86_fp80 %62 to double
store double %63, double* %59
store x86_fp80 0xK3FFF8000000000000000, x86_fp80* %22
store i32 0, i32* %25
br label %64
64: ; preds = %72, %32
%65 = load i32, i32* %25
%66 = load i32, i32* %18
%67 = icmp slt i32 %65, %66
br i1 %67, label %68, label %75
68: ; preds = %64
%69 = load x86_fp80, x86_fp80* %20
%70 = load x86_fp80, x86_fp80* %22
%71 = fdiv x86_fp80 %70, %69
store x86_fp80 %71, x86_fp80* %22
br label %72
72: ; preds = %68
%73 = load i32, i32* %25
%74 = add nsw i32 %73, 1
store i32 %74, i32* %25
br label %64
75: ; preds = %64
%76 = load x86_fp80, x86_fp80* %19
%77 = load double*, double** %10
%78 = load i32, i32* %11
%79 = mul nsw i32 3, %78
%80 = load i32, i32* %24
%81 = add nsw i32 %79, %80
%82 = sext i32 %81 to i64
%83 = getelementptr inbounds double, double* %77, i64 %82
%84 = load double, double* %83
%85 = fpext double %84 to x86_fp80
%86 = fsub x86_fp80 %85, %76
%87 = fptrunc x86_fp80 %86 to double
store double %87, double* %83
%88 = load double*, double** %10
%89 = load i32, i32* %11
%90 = load i32, i32* %12
%91 = load i32, i32* %13
%92 = load i32, i32* %14
%93 = load double, double* %16
%94 = call x86_fp80 @qual_delta(double* %88, i32 %89, i32 %90, i32 %91, i32 %92, double %93)
store x86_fp80 %94, x86_fp80* %21
%95 = load x86_fp80, x86_fp80* %19
%96 = load double*, double** %10
%97 = load i32, i32* %11
%98 = mul nsw i32 3, %97
%99 = load i32, i32* %24
%100 = add nsw i32 %98, %99
%101 = sext i32 %100 to i64
%102 = getelementptr inbounds double, double* %96, i64 %101
%103 = load double, double* %102
%104 = fpext double %103 to x86_fp80
%105 = fadd x86_fp80 %104, %95
%106 = fptrunc x86_fp80 %105 to double
store double %106, double* %102
store x86_fp80 0xK3FFF8000000000000000, x86_fp80* %23
store i32 0, i32* %25
br label %107
107: ; preds = %115, %75
%108 = load i32, i32* %25
%109 = load i32, i32* %18
%110 = icmp slt i32 %108, %109
br i1 %110, label %111, label %118
111: ; preds = %107
%112 = load x86_fp80, x86_fp80* %21
%113 = load x86_fp80, x86_fp80* %23
%114 = fdiv x86_fp80 %113, %112
store x86_fp80 %114, x86_fp80* %23
br label %115
115: ; preds = %111
%116 = load i32, i32* %25
%117 = add nsw i32 %116, 1
store i32 %117, i32* %25
br label %107
118: ; preds = %107
%119 = load x86_fp80, x86_fp80* %22
%120 = load x86_fp80, x86_fp80* %23
%121 = fsub x86_fp80 %119, %120
%122 = load x86_fp80, x86_fp80* %19
%123 = fmul x86_fp80 0xK40008000000000000000, %122
%124 = fdiv x86_fp80 %121, %123
%125 = fptrunc x86_fp80 %124 to double
%126 = load double*, double** %15
%127 = load i32, i32* %24
%128 = sext i32 %127 to i64
%129 = getelementptr inbounds double, double* %126, i64 %128
store double %125, double* %129
br label %130
130: ; preds = %118
%131 = load i32, i32* %24
%132 = add nsw i32 %131, 1
store i32 %132, i32* %24
br label %29
133: ; preds = %29
ret i32 0
}

LLVM IR (-O2):
define i32 @func_xyz(double* %0, i32 %1, i32 %2, i32 %3, i32 %4, double* nocapture writeonly %5, double %6, double %7, i32 %8) {
%10 = fmul double %7, 0x3EB0C6F7A0B5ED8D
%11 = fpext double %10 to x86_fp80
%12 = mul nsw i32 %1, 3
%13 = icmp sgt i32 %8, 0
%14 = fmul x86_fp80 %11, 0xK40008000000000000000
%15 = sext i32 %12 to i64
%16 = add i32 %8, -1
%17 = and i32 %8, 3
%18 = icmp ult i32 %16, 3
%19 = and i32 %8, -4
%20 = icmp eq i32 %17, 0
%21 = and i32 %8, 3
%22 = icmp ult i32 %16, 3
%23 = and i32 %8, -4
%24 = icmp eq i32 %21, 0
br label %25
25: ; preds = %9, %86
%26 = phi i64 [ 0, %9 ], [ %92, %86 ]
%27 = add nsw i64 %26, %15
%28 = getelementptr inbounds double, double* %0, i64 %27
%29 = load double, double* %28
%30 = fpext double %29 to x86_fp80
%31 = fadd x86_fp80 %11, %30
%32 = fptrunc x86_fp80 %31 to double
store double %32, double* %28
%33 = tail call x86_fp80 @qual_delta(double* %0, i32 %1, i32 %2, i32 %3, i32 %4, double %6)
%34 = load double, double* %28
%35 = fpext double %34 to x86_fp80
%36 = fsub x86_fp80 %35, %11
%37 = fptrunc x86_fp80 %36 to double
br i1 %13, label %38, label %57
38: ; preds = %25
br i1 %18, label %48, label %39
39: ; preds = %38, %39
%40 = phi x86_fp80 [ %45, %39 ], [ 0xK3FFF8000000000000000, %38 ]
%41 = phi i32 [ %46, %39 ], [ 0, %38 ]
%42 = fdiv x86_fp80 %40, %33
%43 = fdiv x86_fp80 %42, %33
%44 = fdiv x86_fp80 %43, %33
%45 = fdiv x86_fp80 %44, %33
%46 = add i32 %41, 4
%47 = icmp eq i32 %46, %19
br i1 %47, label %48, label %39
48: ; preds = %39, %38
%49 = phi x86_fp80 [ undef, %38 ], [ %45, %39 ]
%50 = phi x86_fp80 [ 0xK3FFF8000000000000000, %38 ], [ %45, %39 ]
br i1 %20, label %57, label %51
51: ; preds = %48, %51
%52 = phi x86_fp80 [ %54, %51 ], [ %50, %48 ]
%53 = phi i32 [ %55, %51 ], [ 0, %48 ]
%54 = fdiv x86_fp80 %52, %33
%55 = add i32 %53, 1
%56 = icmp eq i32 %55, %17
br i1 %56, label %57, label %51
57: ; preds = %48, %51, %25
%58 = phi x86_fp80 [ 0xK3FFF8000000000000000, %25 ], [ %49, %48 ], [ %54, %51 ]
%59 = fpext double %37 to x86_fp80
%60 = fsub x86_fp80 %59, %11
%61 = fptrunc x86_fp80 %60 to double
store double %61, double* %28
%62 = tail call x86_fp80 @qual_delta(double* %0, i32 %1, i32 %2, i32 %3, i32 %4, double %6)
%63 = load double, double* %28
%64 = fpext double %63 to x86_fp80
%65 = fadd x86_fp80 %11, %64
%66 = fptrunc x86_fp80 %65 to double
store double %66, double* %28
br i1 %13, label %67, label %86
67: ; preds = %57
br i1 %22, label %77, label %68
68: ; preds = %67, %68
%69 = phi x86_fp80 [ %74, %68 ], [ 0xK3FFF8000000000000000, %67 ]
%70 = phi i32 [ %75, %68 ], [ 0, %67 ]
%71 = fdiv x86_fp80 %69, %62
%72 = fdiv x86_fp80 %71, %62
%73 = fdiv x86_fp80 %72, %62
%74 = fdiv x86_fp80 %73, %62
%75 = add i32 %70, 4
%76 = icmp eq i32 %75, %23
br i1 %76, label %77, label %68
77: ; preds = %68, %67
%78 = phi x86_fp80 [ undef, %67 ], [ %74, %68 ]
%79 = phi x86_fp80 [ 0xK3FFF8000000000000000, %67 ], [ %74, %68 ]
br i1 %24, label %86, label %80
80: ; preds = %77, %80
%81 = phi x86_fp80 [ %83, %80 ], [ %79, %77 ]
%82 = phi i32 [ %84, %80 ], [ 0, %77 ]
%83 = fdiv x86_fp80 %81, %62
%84 = add i32 %82, 1
%85 = icmp eq i32 %84, %21
br i1 %85, label %86, label %80
86: ; preds = %77, %80, %57
%87 = phi x86_fp80 [ 0xK3FFF8000000000000000, %57 ], [ %78, %77 ], [ %83, %80 ]
%88 = fsub x86_fp80 %58, %87
%89 = fdiv x86_fp80 %88, %14
%90 = fptrunc x86_fp80 %89 to double
%91 = getelementptr inbounds double, double* %5, i64 %26
store double %90, double* %91
%92 = add nuw nsw i64 %26, 1
%93 = icmp eq i64 %92, 3
br i1 %93, label %94, label %25
94: ; preds = %86
ret i32 0
}