#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 */
typedef int /*<<< orphan*/ FILE;

/* Variables and functions */
int fwrite(void *, int, int, int /*<<< orphan*/ *);
int write_AVS_binary(FILE *fp, void *grd, int dim, char type) {
  int written, nmemb = dim * dim * dim, i, data_size;
  double *dgrid = NULL;
  float *fgrid = NULL;
  if (type == 'd') {
    dgrid = (double *)grd;
    for (i = 0; i < nmemb; i++)
      dgrid[i] /= 332.;
    data_size = sizeof(double);
  } else {
    fgrid = (float *)grd;
    for (i = 0; i < nmemb; i++)
      fgrid[i] /= 332.;
    data_size = sizeof(float);
  }
  written = fwrite(grd, data_size, nmemb, fp);
  return ((written == nmemb) ? 1 : 0);
}


x86 assembly (clang, -O0):
<write_AVS_binary>:
push   %rbp
mov    %rsp,%rbp
sub    $0x40,%rsp
mov    %cl,%al
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %edx,-0x14(%rbp)
mov    %al,-0x15(%rbp)
mov    -0x14(%rbp),%eax
imul   -0x14(%rbp),%eax
imul   -0x14(%rbp),%eax
mov    %eax,-0x20(%rbp)
movq   $0x0,-0x30(%rbp)
movq   $0x0,-0x38(%rbp)
movsbl -0x15(%rbp),%eax
cmp    $0x64,%eax
jne    11a6 <write_AVS_binary+0x96>
mov    -0x10(%rbp),%rax
mov    %rax,-0x30(%rbp)
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x20(%rbp),%eax
jge    119a <write_AVS_binary+0x8a>
mov    -0x30(%rbp),%rax
movslq -0x24(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  0xe7d(%rip),%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    1162 <write_AVS_binary+0x52>
movl   $0x8,-0x28(%rbp)
jmp    11fc <write_AVS_binary+0xec>
mov    -0x10(%rbp),%rax
mov    %rax,-0x38(%rbp)
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x20(%rbp),%eax
jge    11f5 <write_AVS_binary+0xe5>
mov    -0x38(%rbp),%rax
movslq -0x24(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0xe26(%rip),%xmm1
divsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    11b5 <write_AVS_binary+0xa5>
movl   $0x4,-0x28(%rbp)
mov    -0x10(%rbp),%rdi
mov    -0x28(%rbp),%esi
mov    -0x20(%rbp),%edx
mov    -0x8(%rbp),%rcx
call   1030 <fwrite@plt>
mov    %eax,-0x1c(%rbp)
mov    -0x1c(%rbp),%edx
mov    -0x20(%rbp),%esi
xor    %eax,%eax
mov    $0x1,%ecx
cmp    %esi,%edx
cmove  %ecx,%eax
add    $0x40,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<write_AVS_binary>:
push   %rbp
push   %r14
push   %rbx
mov    %ecx,%ebx
mov    %rsi,%rax
mov    %rdi,%rcx
mov    %edx,%r14d
imul   %edx,%r14d
imul   %edx,%r14d
cmp    $0x64,%bl
jne    114a <write_AVS_binary+0x3a>
mov    $0x8,%esi
test   %r14d,%r14d
jle    12b7 <write_AVS_binary+0x1a7>
mov    %r14d,%edx
cmp    $0x1,%r14d
jne    116c <write_AVS_binary+0x5c>
xor    %edi,%edi
jmp    11e9 <write_AVS_binary+0xd9>
mov    $0x4,%esi
test   %r14d,%r14d
jle    12b7 <write_AVS_binary+0x1a7>
mov    %r14d,%edx
cmp    $0x4,%r14d
jae    121c <write_AVS_binary+0x10c>
xor    %edi,%edi
jmp    128c <write_AVS_binary+0x17c>
mov    %edx,%edi
and    $0xfffffffe,%edi
lea    -0x2(%rdi),%rbp
mov    %rbp,%r8
shr    %r8
add    $0x1,%r8
test   %rbp,%rbp
je     12d1 <write_AVS_binary+0x1c1>
mov    %r8,%rbp
and    $0xfffffffffffffffe,%rbp
xor    %ebx,%ebx
movapd 0xe77(%rip),%xmm0
nopl   0x0(%rax)
movupd (%rax,%rbx,8),%xmm1
movupd 0x10(%rax,%rbx,8),%xmm2
divpd  %xmm0,%xmm1
movupd %xmm1,(%rax,%rbx,8)
divpd  %xmm0,%xmm2
movupd %xmm2,0x10(%rax,%rbx,8)
add    $0x4,%rbx
add    $0xfffffffffffffffe,%rbp
jne    11a0 <write_AVS_binary+0x90>
test   $0x1,%r8b
je     11e0 <write_AVS_binary+0xd0>
movupd (%rax,%rbx,8),%xmm0
divpd  0xe35(%rip),%xmm0
movupd %xmm0,(%rax,%rbx,8)
cmp    %rdx,%rdi
je     12b7 <write_AVS_binary+0x1a7>
movsd  0xe37(%rip),%xmm0
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movsd  (%rax,%rdi,8),%xmm1
divsd  %xmm0,%xmm1
movsd  %xmm1,(%rax,%rdi,8)
add    $0x1,%rdi
cmp    %rdi,%rdx
jne    1200 <write_AVS_binary+0xf0>
jmp    12b7 <write_AVS_binary+0x1a7>
mov    %edx,%edi
and    $0xfffffffc,%edi
lea    -0x4(%rdi),%rbp
mov    %rbp,%r8
shr    $0x2,%r8
add    $0x1,%r8
test   %rbp,%rbp
je     12e2 <write_AVS_binary+0x1d2>
mov    %r8,%rbp
and    $0xfffffffffffffffe,%rbp
xor    %ebx,%ebx
movaps 0xdb7(%rip),%xmm0
nopl   0x0(%rax)
movups (%rax,%rbx,4),%xmm1
movups 0x10(%rax,%rbx,4),%xmm2
divps  %xmm0,%xmm1
movups %xmm1,(%rax,%rbx,4)
divps  %xmm0,%xmm2
movups %xmm2,0x10(%rax,%rbx,4)
add    $0x8,%rbx
add    $0xfffffffffffffffe,%rbp
jne    1250 <write_AVS_binary+0x140>
test   $0x1,%r8b
je     1287 <write_AVS_binary+0x177>
movups (%rax,%rbx,4),%xmm0
divps  0xd7d(%rip),%xmm0
movups %xmm0,(%rax,%rbx,4)
cmp    %rdx,%rdi
je     12b7 <write_AVS_binary+0x1a7>
movss  0xd8c(%rip),%xmm0
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movss  (%rax,%rdi,4),%xmm1
divss  %xmm0,%xmm1
movss  %xmm1,(%rax,%rdi,4)
add    $0x1,%rdi
cmp    %rdi,%rdx
jne    12a0 <write_AVS_binary+0x190>
mov    %rax,%rdi
mov    %r14d,%edx
call   1030 <fwrite@plt>
xor    %ecx,%ecx
cmp    %r14d,%eax
sete   %cl
mov    %ecx,%eax
pop    %rbx
pop    %r14
pop    %rbp
ret
xor    %ebx,%ebx
test   $0x1,%r8b
jne    11ce <write_AVS_binary+0xbe>
jmp    11e0 <write_AVS_binary+0xd0>
xor    %ebx,%ebx
test   $0x1,%r8b
jne    1278 <write_AVS_binary+0x168>
jmp    1287 <write_AVS_binary+0x177>

LLVM IR (-O0):
define i32 @write_AVS_binary(i32* %0, i8* %1, i32 %2, i8 signext %3) {
%5 = alloca i32*
%6 = alloca i8*
%7 = alloca i32
%8 = alloca i8
%9 = alloca i32
%10 = alloca i32
%11 = alloca i32
%12 = alloca i32
%13 = alloca double*
%14 = alloca float*
store i32* %0, i32** %5
store i8* %1, i8** %6
store i32 %2, i32* %7
store i8 %3, i8* %8
%15 = load i32, i32* %7
%16 = load i32, i32* %7
%17 = mul nsw i32 %15, %16
%18 = load i32, i32* %7
%19 = mul nsw i32 %17, %18
store i32 %19, i32* %10
store double* null, double** %13
store float* null, float** %14
%20 = load i8, i8* %8
%21 = sext i8 %20 to i32
%22 = icmp eq i32 %21, 100
br i1 %22, label %23, label %41
23: ; preds = %4
%24 = load i8*, i8** %6
%25 = bitcast i8* %24 to double*
store double* %25, double** %13
store i32 0, i32* %11
br label %26
26: ; preds = %37, %23
%27 = load i32, i32* %11
%28 = load i32, i32* %10
%29 = icmp slt i32 %27, %28
br i1 %29, label %30, label %40
30: ; preds = %26
%31 = load double*, double** %13
%32 = load i32, i32* %11
%33 = sext i32 %32 to i64
%34 = getelementptr inbounds double, double* %31, i64 %33
%35 = load double, double* %34
%36 = fdiv double %35, 3.320000e+02
store double %36, double* %34
br label %37
37: ; preds = %30
%38 = load i32, i32* %11
%39 = add nsw i32 %38, 1
store i32 %39, i32* %11
br label %26
40: ; preds = %26
store i32 8, i32* %12
br label %61
41: ; preds = %4
%42 = load i8*, i8** %6
%43 = bitcast i8* %42 to float*
store float* %43, float** %14
store i32 0, i32* %11
br label %44
44: ; preds = %57, %41
%45 = load i32, i32* %11
%46 = load i32, i32* %10
%47 = icmp slt i32 %45, %46
br i1 %47, label %48, label %60
48: ; preds = %44
%49 = load float*, float** %14
%50 = load i32, i32* %11
%51 = sext i32 %50 to i64
%52 = getelementptr inbounds float, float* %49, i64 %51
%53 = load float, float* %52
%54 = fpext float %53 to double
%55 = fdiv double %54, 3.320000e+02
%56 = fptrunc double %55 to float
store float %56, float* %52
br label %57
57: ; preds = %48
%58 = load i32, i32* %11
%59 = add nsw i32 %58, 1
store i32 %59, i32* %11
br label %44
60: ; preds = %44
store i32 4, i32* %12
br label %61
61: ; preds = %60, %40
%62 = load i8*, i8** %6
%63 = load i32, i32* %12
%64 = load i32, i32* %10
%65 = load i32*, i32** %5
%66 = call i32 @fwrite(i8* %62, i32 %63, i32 %64, i32* %65)
store i32 %66, i32* %9
%67 = load i32, i32* %9
%68 = load i32, i32* %10
%69 = icmp eq i32 %67, %68
%70 = zext i1 %69 to i64
%71 = select i1 %69, i32 1, i32 0
ret i32 %71
}

LLVM IR (-O2):
define i32 @write_AVS_binary(i32* nocapture %0, i8* nocapture %1, i32 %2, i8 signext %3) {
%5 = mul nsw i32 %2, %2
%6 = mul i32 %5, %2
%7 = icmp eq i8 %3, 100
br i1 %7, label %8, label %60
8: ; preds = %4
%9 = bitcast i8* %1 to double*
%10 = icmp sgt i32 %6, 0
br i1 %10, label %11, label %112
11: ; preds = %8
%12 = zext i32 %6 to i64
%13 = icmp eq i32 %6, 1
br i1 %13, label %51, label %14
14: ; preds = %11
%15 = and i64 %12, 4294967294
%16 = add nsw i64 %15, -2
%17 = lshr exact i64 %16, 1
%18 = add nuw i64 %17, 1
%19 = and i64 %18, 1
%20 = icmp eq i64 %16, 0
br i1 %20, label %40, label %21
21: ; preds = %14
%22 = and i64 %18, -2
br label %23
23: ; preds = %23, %21
%24 = phi i64 [ 0, %21 ], [ %37, %23 ]
%25 = phi i64 [ 0, %21 ], [ %38, %23 ]
%26 = getelementptr inbounds double, double* %9, i64 %24
%27 = bitcast double* %26 to <2 x double>*
%28 = load <2 x double>, <2 x double>* %27
%29 = fdiv <2 x double> %28, <double 3.320000e+02, double 3.320000e+02>
%30 = bitcast double* %26 to <2 x double>*
store <2 x double> %29, <2 x double>* %30
%31 = or i64 %24, 2
%32 = getelementptr inbounds double, double* %9, i64 %31
%33 = bitcast double* %32 to <2 x double>*
%34 = load <2 x double>, <2 x double>* %33
%35 = fdiv <2 x double> %34, <double 3.320000e+02, double 3.320000e+02>
%36 = bitcast double* %32 to <2 x double>*
store <2 x double> %35, <2 x double>* %36
%37 = add nuw i64 %24, 4
%38 = add nuw i64 %25, 2
%39 = icmp eq i64 %38, %22
br i1 %39, label %40, label %23
40: ; preds = %23, %14
%41 = phi i64 [ 0, %14 ], [ %37, %23 ]
%42 = icmp eq i64 %19, 0
br i1 %42, label %49, label %43
43: ; preds = %40
%44 = getelementptr inbounds double, double* %9, i64 %41
%45 = bitcast double* %44 to <2 x double>*
%46 = load <2 x double>, <2 x double>* %45
%47 = fdiv <2 x double> %46, <double 3.320000e+02, double 3.320000e+02>
%48 = bitcast double* %44 to <2 x double>*
store <2 x double> %47, <2 x double>* %48
br label %49
49: ; preds = %40, %43
%50 = icmp eq i64 %15, %12
br i1 %50, label %112, label %51
51: ; preds = %11, %49
%52 = phi i64 [ 0, %11 ], [ %15, %49 ]
br label %53
53: ; preds = %51, %53
%54 = phi i64 [ %58, %53 ], [ %52, %51 ]
%55 = getelementptr inbounds double, double* %9, i64 %54
%56 = load double, double* %55
%57 = fdiv double %56, 3.320000e+02
store double %57, double* %55
%58 = add nuw nsw i64 %54, 1
%59 = icmp eq i64 %58, %12
br i1 %59, label %112, label %53
60: ; preds = %4
%61 = bitcast i8* %1 to float*
%62 = icmp sgt i32 %6, 0
br i1 %62, label %63, label %112
63: ; preds = %60
%64 = zext i32 %6 to i64
%65 = icmp ult i32 %6, 4
br i1 %65, label %103, label %66
66: ; preds = %63
%67 = and i64 %64, 4294967292
%68 = add nsw i64 %67, -4
%69 = lshr exact i64 %68, 2
%70 = add nuw nsw i64 %69, 1
%71 = and i64 %70, 1
%72 = icmp eq i64 %68, 0
br i1 %72, label %92, label %73
73: ; preds = %66
%74 = and i64 %70, 9223372036854775806
br label %75
75: ; preds = %75, %73
%76 = phi i64 [ 0, %73 ], [ %89, %75 ]
%77 = phi i64 [ 0, %73 ], [ %90, %75 ]
%78 = getelementptr inbounds float, float* %61, i64 %76
%79 = bitcast float* %78 to <4 x float>*
%80 = load <4 x float>, <4 x float>* %79
%81 = fdiv <4 x float> %80, <float 3.320000e+02, float 3.320000e+02, float 3.320000e+02, float 3.320000e+02>
%82 = bitcast float* %78 to <4 x float>*
store <4 x float> %81, <4 x float>* %82
%83 = or i64 %76, 4
%84 = getelementptr inbounds float, float* %61, i64 %83
%85 = bitcast float* %84 to <4 x float>*
%86 = load <4 x float>, <4 x float>* %85
%87 = fdiv <4 x float> %86, <float 3.320000e+02, float 3.320000e+02, float 3.320000e+02, float 3.320000e+02>
%88 = bitcast float* %84 to <4 x float>*
store <4 x float> %87, <4 x float>* %88
%89 = add nuw i64 %76, 8
%90 = add i64 %77, 2
%91 = icmp eq i64 %90, %74
br i1 %91, label %92, label %75
92: ; preds = %75, %66
%93 = phi i64 [ 0, %66 ], [ %89, %75 ]
%94 = icmp eq i64 %71, 0
br i1 %94, label %101, label %95
95: ; preds = %92
%96 = getelementptr inbounds float, float* %61, i64 %93
%97 = bitcast float* %96 to <4 x float>*
%98 = load <4 x float>, <4 x float>* %97
%99 = fdiv <4 x float> %98, <float 3.320000e+02, float 3.320000e+02, float 3.320000e+02, float 3.320000e+02>
%100 = bitcast float* %96 to <4 x float>*
store <4 x float> %99, <4 x float>* %100
br label %101
101: ; preds = %92, %95
%102 = icmp eq i64 %67, %64
br i1 %102, label %112, label %103
103: ; preds = %63, %101
%104 = phi i64 [ 0, %63 ], [ %67, %101 ]
br label %105
105: ; preds = %103, %105
%106 = phi i64 [ %110, %105 ], [ %104, %103 ]
%107 = getelementptr inbounds float, float* %61, i64 %106
%108 = load float, float* %107
%109 = fdiv float %108, 3.320000e+02
store float %109, float* %107
%110 = add nuw nsw i64 %106, 1
%111 = icmp eq i64 %110, %64
br i1 %111, label %112, label %105
112: ; preds = %105, %53, %101, %49, %60, %8
%113 = phi i32 [ 8, %8 ], [ 4, %60 ], [ 8, %49 ], [ 4, %101 ], [ 8, %53 ], [ 4, %105 ]
%114 = tail call i32 @fwrite(i8* %1, i32 %113, i32 %6, i32* %0)
%115 = icmp eq i32 %114, %6
%116 = zext i1 %115 to i32
ret i32 %116
}