#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 /*<<< orphan*/ exit(int);
int /*<<< orphan*/ fclose(int /*<<< orphan*/ *);
int /*<<< orphan*/ *fopen(char const *, char *);
int /*<<< orphan*/ fprintf(int /*<<< orphan*/ *, char *, ...);
unsigned char *jpeg_load(char const *, int *, int *, int *);
scalar_t__ malloc(int);
int /*<<< orphan*/ printf(char *);
void write_array(const char *filename, const char *jpegfile) {
  FILE *fp;
  unsigned char *img;
  int width;
  int height;
  int compos;
  int i, j;
  int ival;
  int idx;
  float *data;
  float fval;
  float intensity;
  fp = fopen(filename, "w");
  if (!fp)
    exit(-1);
  img = jpeg_load(jpegfile, &width, &height, &compos);
  if (img == NULL) {
    printf("can't load jpeg file.\n");
    exit(-1);
  }
  data = (float *)malloc(sizeof(float) * width * height * 3);
  if (!data) {
    printf("muda muda muda!\n");
    exit(-1);
  }
  for (i = 0; i < width * height; i++) {
    idx = 3 * i;
    switch (compos) {
    case 1:
      data[idx + 0] = (float)(*img++) / (256.0f);
      data[idx + 1] = data[idx + 0];
      data[idx + 2] = data[idx + 1];
      break;
    case 2:
      data[idx + 0] = (float)(*img++) / (256.0f);
      data[idx + 1] = (float)(*img++) / (256.0f);
      data[idx + 2] = data[idx + 1];
      break;
    case 3:
      data[idx + 0] = (float)(*img++) / (256.0f);
      data[idx + 1] = (float)(*img++) / (256.0f);
      data[idx + 2] = (float)(*img++) / (256.0f);
      break;
    }
  }
  for (j = height - 1; j >= 0; j--) {
    for (i = 0; i < width; i++) {
      intensity = (0.265074126 * (&data[3 * (j * width + i)])[0] +
                   0.670114631 * (&data[3 * (j * width + i)])[1] +
                   0.064811243 * (&data[3 * (j * width + i)])[2]);
      fprintf(fp, "%f ", intensity);
    }
    fprintf(fp, "\n");
  }
  fclose(fp);
}


x86 assembly (clang, -O0):
<write_array>:
push   %rbp
mov    %rsp,%rbp
sub    $0x60,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    -0x8(%rbp),%rdi
lea    0xe91(%rip),%rsi
call   1080 <fopen@plt>
mov    %rax,-0x18(%rbp)
cmpq   $0x0,-0x18(%rbp)
jne    11a9 <write_array+0x39>
mov    $0xffffffff,%edi
call   1090 <exit@plt>
mov    -0x10(%rbp),%rdi
lea    -0x24(%rbp),%rsi
lea    -0x28(%rbp),%rdx
lea    -0x2c(%rbp),%rcx
call   1070 <jpeg_load@plt>
mov    %rax,-0x20(%rbp)
cmpq   $0x0,-0x20(%rbp)
jne    11e3 <write_array+0x73>
lea    0xe4a(%rip),%rdi
call   1040 <printf@plt>
mov    $0xffffffff,%edi
call   1090 <exit@plt>
movslq -0x24(%rbp),%rax
shl    $0x2,%rax
movslq -0x28(%rbp),%rcx
imul   %rcx,%rax
imul   $0x3,%rax,%rax
mov    %eax,%edi
call   1060 <malloc@plt>
mov    %rax,-0x48(%rbp)
cmpq   $0x0,-0x48(%rbp)
jne    1223 <write_array+0xb3>
lea    0xe21(%rip),%rdi
call   1040 <printf@plt>
mov    $0xffffffff,%edi
call   1090 <exit@plt>
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
mov    -0x24(%rbp),%ecx
imul   -0x28(%rbp),%ecx
cmp    %ecx,%eax
jge    1428 <write_array+0x2b8>
mov    -0x30(%rbp),%ecx
mov    %ecx,%eax
lea    (%rax,%rax,2),%eax
mov    %eax,-0x3c(%rbp)
mov    -0x2c(%rbp),%eax
mov    %eax,-0x54(%rbp)
sub    $0x1,%eax
je     127d <write_array+0x10d>
jmp    125b <write_array+0xeb>
mov    -0x54(%rbp),%eax
sub    $0x2,%eax
je     12fe <write_array+0x18e>
jmp    126c <write_array+0xfc>
mov    -0x54(%rbp),%eax
sub    $0x3,%eax
je     138a <write_array+0x21a>
jmp    1415 <write_array+0x2a5>
mov    -0x20(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x20(%rbp)
movzbl (%rax),%eax
cvtsi2ss %eax,%xmm0
movss  0xd7d(%rip),%xmm1
divss  %xmm1,%xmm0
mov    -0x48(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x48(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x48(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x48(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x48(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
jmp    1415 <write_array+0x2a5>
mov    -0x20(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x20(%rbp)
movzbl (%rax),%eax
cvtsi2ss %eax,%xmm0
movss  0xcfc(%rip),%xmm1
divss  %xmm1,%xmm0
mov    -0x48(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x20(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x20(%rbp)
movzbl (%rax),%eax
cvtsi2ss %eax,%xmm0
movss  0xccd(%rip),%xmm1
divss  %xmm1,%xmm0
mov    -0x48(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x48(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x48(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
jmp    1415 <write_array+0x2a5>
mov    -0x20(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x20(%rbp)
movzbl (%rax),%eax
cvtsi2ss %eax,%xmm0
movss  0xc70(%rip),%xmm1
divss  %xmm1,%xmm0
mov    -0x48(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x20(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x20(%rbp)
movzbl (%rax),%eax
cvtsi2ss %eax,%xmm0
divss  %xmm1,%xmm0
mov    -0x48(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movss  %xmm0,0x4(%rax,%rcx,4)
mov    -0x20(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x20(%rbp)
movzbl (%rax),%eax
cvtsi2ss %eax,%xmm0
movss  0xc19(%rip),%xmm1
divss  %xmm1,%xmm0
mov    -0x48(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
jmp    141a <write_array+0x2aa>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    122a <write_array+0xba>
mov    -0x28(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x34(%rbp)
cmpl   $0x0,-0x34(%rbp)
jl     1525 <write_array+0x3b5>
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x24(%rbp),%eax
jge    1505 <write_array+0x395>
mov    -0x48(%rbp),%rax
mov    -0x34(%rbp),%ecx
imul   -0x24(%rbp),%ecx
add    -0x30(%rbp),%ecx
imul   $0x3,%ecx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm1
mov    -0x48(%rbp),%rax
mov    -0x34(%rbp),%ecx
imul   -0x24(%rbp),%ecx
add    -0x30(%rbp),%ecx
imul   $0x3,%ecx,%ecx
movslq %ecx,%rcx
movss  0x4(%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm2
movsd  0xb7f(%rip),%xmm0
mulsd  %xmm2,%xmm0
movsd  0xb6b(%rip),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x48(%rbp),%rax
mov    -0x34(%rbp),%ecx
imul   -0x24(%rbp),%ecx
add    -0x30(%rbp),%ecx
imul   $0x3,%ecx,%ecx
movslq %ecx,%rcx
movss  0x8(%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0xb35(%rip),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x50(%rbp)
mov    -0x18(%rbp),%rdi
movss  -0x50(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
lea    0xb56(%rip),%rsi
mov    $0x1,%al
call   1050 <fprintf@plt>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1442 <write_array+0x2d2>
mov    -0x18(%rbp),%rdi
lea    0xb34(%rip),%rsi
mov    $0x0,%al
call   1050 <fprintf@plt>
mov    -0x34(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x34(%rbp)
jmp    1431 <write_array+0x2c1>
mov    -0x18(%rbp),%rdi
call   1030 <fclose@plt>
add    $0x60,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<write_array>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x18,%rsp
mov    %rsi,%rbx
lea    0xe88(%rip),%rsi
call   1090 <fopen@plt>
test   %rax,%rax
je     13c2 <write_array+0x242>
mov    %rax,%r14
lea    0xc(%rsp),%rsi
lea    0x10(%rsp),%rdx
lea    0x14(%rsp),%rcx
mov    %rbx,%rdi
call   1080 <jpeg_load@plt>
test   %rax,%rax
je     13cc <write_array+0x24c>
mov    %rax,%r15
mov    0xc(%rsp),%eax
imul   0x10(%rsp),%eax
shl    $0x2,%eax
lea    (%rax,%rax,2),%edi
call   1070 <malloc@plt>
test   %rax,%rax
je     13d5 <write_array+0x255>
mov    %rax,%rbx
mov    0xc(%rsp),%eax
mov    0x10(%rsp),%r12d
mov    %r12d,%edx
imul   %eax,%edx
test   %edx,%edx
jle    12d7 <write_array+0x157>
mov    0x14(%rsp),%ecx
mov    %edx,%edx
lea    (%rdx,%rdx,2),%rdx
xor    %esi,%esi
movss  0xde9(%rip),%xmm0
jmp    1263 <write_array+0xe3>
nopl   0x0(%rax)
movzbl (%r15),%edi
xorps  %xmm1,%xmm1
cvtsi2ss %edi,%xmm1
mulss  %xmm0,%xmm1
mov    %esi,%edi
movss  %xmm1,(%rbx,%rdi,4)
movzbl 0x1(%r15),%edi
xorps  %xmm1,%xmm1
cvtsi2ss %edi,%xmm1
add    $0x2,%r15
mulss  %xmm0,%xmm1
lea    0x1(%rsi),%edi
movss  %xmm1,(%rbx,%rdi,4)
lea    0x2(%rsi),%edi
movss  %xmm1,(%rbx,%rdi,4)
add    $0x3,%rsi
cmp    %rsi,%rdx
je     12d7 <write_array+0x157>
cmp    $0x3,%ecx
je     1290 <write_array+0x110>
cmp    $0x2,%ecx
je     1220 <write_array+0xa0>
cmp    $0x1,%ecx
jne    125a <write_array+0xda>
movzbl (%r15),%edi
add    $0x1,%r15
xorps  %xmm1,%xmm1
cvtsi2ss %edi,%xmm1
mulss  %xmm0,%xmm1
mov    %esi,%edi
movss  %xmm1,(%rbx,%rdi,4)
jmp    124a <write_array+0xca>
xchg   %ax,%ax
movzbl (%r15),%edi
xorps  %xmm1,%xmm1
cvtsi2ss %edi,%xmm1
mulss  %xmm0,%xmm1
mov    %esi,%edi
movss  %xmm1,(%rbx,%rdi,4)
movzbl 0x1(%r15),%edi
xorps  %xmm1,%xmm1
cvtsi2ss %edi,%xmm1
mulss  %xmm0,%xmm1
lea    0x1(%rsi),%edi
movss  %xmm1,(%rbx,%rdi,4)
movzbl 0x2(%r15),%edi
add    $0x3,%r15
xorps  %xmm1,%xmm1
cvtsi2ss %edi,%xmm1
mulss  %xmm0,%xmm1
jmp    1252 <write_array+0xd2>
test   %r12d,%r12d
jle    13ab <write_array+0x22b>
lea    -0x1(%r12),%r13d
lea    0xd36(%rip),%r15
nopl   0x0(%rax)
test   %eax,%eax
movsd  0xd0e(%rip),%xmm2
movsd  0xd0e(%rip),%xmm3
movsd  0xd0e(%rip),%xmm4
jle    1387 <write_array+0x207>
xor    %ebp,%ebp
xchg   %ax,%ax
imul   %r13d,%eax
add    %ebp,%eax
lea    (%rax,%rax,2),%eax
cltq
movss  (%rbx,%rax,4),%xmm0
movss  0x4(%rbx,%rax,4),%xmm1
cvtss2sd %xmm0,%xmm0
cvtss2sd %xmm1,%xmm1
mulsd  %xmm2,%xmm1
mulsd  %xmm3,%xmm0
addsd  %xmm1,%xmm0
movss  0x8(%rbx,%rax,4),%xmm1
cvtss2sd %xmm1,%xmm1
mulsd  %xmm4,%xmm1
addsd  %xmm0,%xmm1
xorps  %xmm0,%xmm0
cvtsd2ss %xmm1,%xmm0
cvtss2sd %xmm0,%xmm0
mov    %r14,%rdi
mov    %r15,%rsi
mov    $0x1,%al
call   1060 <fprintf@plt>
movsd  0xcac(%rip),%xmm4
movsd  0xc9c(%rip),%xmm3
movsd  0xc8c(%rip),%xmm2
add    $0x1,%ebp
mov    0xc(%rsp),%eax
cmp    %eax,%ebp
jl     1310 <write_array+0x190>
mov    $0xa,%edi
mov    %r14,%rsi
call   1050 <fputc@plt>
cmp    $0x2,%r12d
jl     13ab <write_array+0x22b>
add    $0xffffffff,%r12d
mov    0xc(%rsp),%eax
add    $0xffffffff,%r13d
jmp    12f0 <write_array+0x170>
mov    %r14,%rdi
call   1040 <fclose@plt>
add    $0x18,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
mov    $0xffffffff,%edi
call   10a0 <exit@plt>
lea    0xc63(%rip),%rdi
jmp    13dc <write_array+0x25c>
lea    0xc4a(%rip),%rdi
call   1030 <puts@plt>
mov    $0xffffffff,%edi
call   10a0 <exit@plt>

LLVM IR (-O0):
@.str = [2 x i8] c"w\00"
@.str.1 = [23 x i8] c"can't load jpeg file.\0A\00"
@.str.2 = [17 x i8] c"muda muda muda!\0A\00"
@.str.3 = [4 x i8] c"%f \00"
@.str.4 = [2 x i8] c"\0A\00"
define void @write_array(i8* %0, i8* %1) {
%3 = alloca i8*
%4 = alloca i8*
%5 = alloca i32*
%6 = alloca i8*
%7 = alloca i32
%8 = alloca i32
%9 = alloca i32
%10 = alloca i32
%11 = alloca i32
%12 = alloca i32
%13 = alloca i32
%14 = alloca float*
%15 = alloca float
%16 = alloca float
store i8* %0, i8** %3
store i8* %1, i8** %4
%17 = load i8*, i8** %3
%18 = call i32* @fopen(i8* %17, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str, i64 0, i64 0))
store i32* %18, i32** %5
%19 = load i32*, i32** %5
%20 = icmp ne i32* %19, null
br i1 %20, label %23, label %21
21: ; preds = %2
%22 = call i32 @exit(i32 -1)
unreachable
23: ; preds = %2
%24 = load i8*, i8** %4
%25 = call i8* @jpeg_load(i8* %24, i32* %7, i32* %8, i32* %9)
store i8* %25, i8** %6
%26 = load i8*, i8** %6
%27 = icmp eq i8* %26, null
br i1 %27, label %28, label %31
28: ; preds = %23
%29 = call i32 @printf(i8* getelementptr inbounds ([23 x i8], [23 x i8]* @.str.1, i64 0, i64 0))
%30 = call i32 @exit(i32 -1)
unreachable
31: ; preds = %23
%32 = load i32, i32* %7
%33 = sext i32 %32 to i64
%34 = mul i64 4, %33
%35 = load i32, i32* %8
%36 = sext i32 %35 to i64
%37 = mul i64 %34, %36
%38 = mul i64 %37, 3
%39 = trunc i64 %38 to i32
%40 = call i64 @malloc(i32 %39)
%41 = inttoptr i64 %40 to float*
store float* %41, float** %14
%42 = load float*, float** %14
%43 = icmp ne float* %42, null
br i1 %43, label %47, label %44
44: ; preds = %31
%45 = call i32 @printf(i8* getelementptr inbounds ([17 x i8], [17 x i8]* @.str.2, i64 0, i64 0))
%46 = call i32 @exit(i32 -1)
unreachable
47: ; preds = %31
store i32 0, i32* %10
br label %48
48: ; preds = %155, %47
%49 = load i32, i32* %10
%50 = load i32, i32* %7
%51 = load i32, i32* %8
%52 = mul nsw i32 %50, %51
%53 = icmp slt i32 %49, %52
br i1 %53, label %54, label %158
54: ; preds = %48
%55 = load i32, i32* %10
%56 = mul nsw i32 3, %55
store i32 %56, i32* %13
%57 = load i32, i32* %9
switch i32 %57, label %154 [
i32 1, label %58
i32 2, label %91
i32 3, label %123
]
58: ; preds = %54
%59 = load i8*, i8** %6
%60 = getelementptr inbounds i8, i8* %59, i32 1
store i8* %60, i8** %6
%61 = load i8, i8* %59
%62 = uitofp i8 %61 to float
%63 = fdiv float %62, 2.560000e+02
%64 = load float*, float** %14
%65 = load i32, i32* %13
%66 = add nsw i32 %65, 0
%67 = sext i32 %66 to i64
%68 = getelementptr inbounds float, float* %64, i64 %67
store float %63, float* %68
%69 = load float*, float** %14
%70 = load i32, i32* %13
%71 = add nsw i32 %70, 0
%72 = sext i32 %71 to i64
%73 = getelementptr inbounds float, float* %69, i64 %72
%74 = load float, float* %73
%75 = load float*, float** %14
%76 = load i32, i32* %13
%77 = add nsw i32 %76, 1
%78 = sext i32 %77 to i64
%79 = getelementptr inbounds float, float* %75, i64 %78
store float %74, float* %79
%80 = load float*, float** %14
%81 = load i32, i32* %13
%82 = add nsw i32 %81, 1
%83 = sext i32 %82 to i64
%84 = getelementptr inbounds float, float* %80, i64 %83
%85 = load float, float* %84
%86 = load float*, float** %14
%87 = load i32, i32* %13
%88 = add nsw i32 %87, 2
%89 = sext i32 %88 to i64
%90 = getelementptr inbounds float, float* %86, i64 %89
store float %85, float* %90
br label %154
91: ; preds = %54
%92 = load i8*, i8** %6
%93 = getelementptr inbounds i8, i8* %92, i32 1
store i8* %93, i8** %6
%94 = load i8, i8* %92
%95 = uitofp i8 %94 to float
%96 = fdiv float %95, 2.560000e+02
%97 = load float*, float** %14
%98 = load i32, i32* %13
%99 = add nsw i32 %98, 0
%100 = sext i32 %99 to i64
%101 = getelementptr inbounds float, float* %97, i64 %100
store float %96, float* %101
%102 = load i8*, i8** %6
%103 = getelementptr inbounds i8, i8* %102, i32 1
store i8* %103, i8** %6
%104 = load i8, i8* %102
%105 = uitofp i8 %104 to float
%106 = fdiv float %105, 2.560000e+02
%107 = load float*, float** %14
%108 = load i32, i32* %13
%109 = add nsw i32 %108, 1
%110 = sext i32 %109 to i64
%111 = getelementptr inbounds float, float* %107, i64 %110
store float %106, float* %111
%112 = load float*, float** %14
%113 = load i32, i32* %13
%114 = add nsw i32 %113, 1
%115 = sext i32 %114 to i64
%116 = getelementptr inbounds float, float* %112, i64 %115
%117 = load float, float* %116
%118 = load float*, float** %14
%119 = load i32, i32* %13
%120 = add nsw i32 %119, 2
%121 = sext i32 %120 to i64
%122 = getelementptr inbounds float, float* %118, i64 %121
store float %117, float* %122
br label %154
123: ; preds = %54
%124 = load i8*, i8** %6
%125 = getelementptr inbounds i8, i8* %124, i32 1
store i8* %125, i8** %6
%126 = load i8, i8* %124
%127 = uitofp i8 %126 to float
%128 = fdiv float %127, 2.560000e+02
%129 = load float*, float** %14
%130 = load i32, i32* %13
%131 = add nsw i32 %130, 0
%132 = sext i32 %131 to i64
%133 = getelementptr inbounds float, float* %129, i64 %132
store float %128, float* %133
%134 = load i8*, i8** %6
%135 = getelementptr inbounds i8, i8* %134, i32 1
store i8* %135, i8** %6
%136 = load i8, i8* %134
%137 = uitofp i8 %136 to float
%138 = fdiv float %137, 2.560000e+02
%139 = load float*, float** %14
%140 = load i32, i32* %13
%141 = add nsw i32 %140, 1
%142 = sext i32 %141 to i64
%143 = getelementptr inbounds float, float* %139, i64 %142
store float %138, float* %143
%144 = load i8*, i8** %6
%145 = getelementptr inbounds i8, i8* %144, i32 1
store i8* %145, i8** %6
%146 = load i8, i8* %144
%147 = uitofp i8 %146 to float
%148 = fdiv float %147, 2.560000e+02
%149 = load float*, float** %14
%150 = load i32, i32* %13
%151 = add nsw i32 %150, 2
%152 = sext i32 %151 to i64
%153 = getelementptr inbounds float, float* %149, i64 %152
store float %148, float* %153
br label %154
154: ; preds = %54, %123, %91, %58
br label %155
155: ; preds = %154
%156 = load i32, i32* %10
%157 = add nsw i32 %156, 1
store i32 %157, i32* %10
br label %48
158: ; preds = %48
%159 = load i32, i32* %8
%160 = sub nsw i32 %159, 1
store i32 %160, i32* %11
br label %161
161: ; preds = %220, %158
%162 = load i32, i32* %11
%163 = icmp sge i32 %162, 0
br i1 %163, label %164, label %223
164: ; preds = %161
store i32 0, i32* %10
br label %165
165: ; preds = %214, %164
%166 = load i32, i32* %10
%167 = load i32, i32* %7
%168 = icmp slt i32 %166, %167
br i1 %168, label %169, label %217
169: ; preds = %165
%170 = load float*, float** %14
%171 = load i32, i32* %11
%172 = load i32, i32* %7
%173 = mul nsw i32 %171, %172
%174 = load i32, i32* %10
%175 = add nsw i32 %173, %174
%176 = mul nsw i32 3, %175
%177 = sext i32 %176 to i64
%178 = getelementptr inbounds float, float* %170, i64 %177
%179 = getelementptr inbounds float, float* %178, i64 0
%180 = load float, float* %179
%181 = fpext float %180 to double
%182 = load float*, float** %14
%183 = load i32, i32* %11
%184 = load i32, i32* %7
%185 = mul nsw i32 %183, %184
%186 = load i32, i32* %10
%187 = add nsw i32 %185, %186
%188 = mul nsw i32 3, %187
%189 = sext i32 %188 to i64
%190 = getelementptr inbounds float, float* %182, i64 %189
%191 = getelementptr inbounds float, float* %190, i64 1
%192 = load float, float* %191
%193 = fpext float %192 to double
%194 = fmul double 0x3FE571943D16EA5B, %193
%195 = call double @llvm.fmuladd.f64(double 0x3FD0F6F9778BE3E0, double %181, double %194)
%196 = load float*, float** %14
%197 = load i32, i32* %11
%198 = load i32, i32* %7
%199 = mul nsw i32 %197, %198
%200 = load i32, i32* %10
%201 = add nsw i32 %199, %200
%202 = mul nsw i32 3, %201
%203 = sext i32 %202 to i64
%204 = getelementptr inbounds float, float* %196, i64 %203
%205 = getelementptr inbounds float, float* %204, i64 2
%206 = load float, float* %205
%207 = fpext float %206 to double
%208 = call double @llvm.fmuladd.f64(double 0x3FB0977839191DAB, double %207, double %195)
%209 = fptrunc double %208 to float
store float %209, float* %16
%210 = load i32*, i32** %5
%211 = load float, float* %16
%212 = fpext float %211 to double
%213 = call i32 (i32*, i8*, ...) @fprintf(i32* %210, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.3, i64 0, i64 0), double %212)
br label %214
214: ; preds = %169
%215 = load i32, i32* %10
%216 = add nsw i32 %215, 1
store i32 %216, i32* %10
br label %165
217: ; preds = %165
%218 = load i32*, i32** %5
%219 = call i32 (i32*, i8*, ...) @fprintf(i32* %218, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.4, i64 0, i64 0))
br label %220
220: ; preds = %217
%221 = load i32, i32* %11
%222 = add nsw i32 %221, -1
store i32 %222, i32* %11
br label %161
223: ; preds = %161
%224 = load i32*, i32** %5
%225 = call i32 @fclose(i32* %224)
ret void
}

LLVM IR (-O2):
@.str = [2 x i8] c"w\00"
@.str.3 = [4 x i8] c"%f \00"
@str = [16 x i8] c"muda muda muda!\00"
@str.5 = [22 x i8] c"can't load jpeg file.\00"
define void @write_array(i8* nocapture %0, i8* %1) {
%3 = alloca i32
%4 = alloca i32
%5 = alloca i32
%6 = bitcast i32* %3 to i8*
%7 = bitcast i32* %4 to i8*
%8 = bitcast i32* %5 to i8*
%9 = tail call i32* @fopen(i8* %0, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str, i64 0, i64 0))
%10 = icmp eq i32* %9, null
br i1 %10, label %11, label %13
11: ; preds = %2
%12 = tail call i32 @exit(i32 -1)
unreachable
13: ; preds = %2
%14 = call i8* @jpeg_load(i8* %1, i32* %3, i32* %4, i32* %5)
%15 = icmp eq i8* %14, null
br i1 %15, label %16, label %19
16: ; preds = %13
%17 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([22 x i8], [22 x i8]* @str.5, i64 0, i64 0))
%18 = call i32 @exit(i32 -1)
unreachable
19: ; preds = %13
%20 = load i32, i32* %3
%21 = load i32, i32* %4
%22 = mul i32 %20, 12
%23 = mul i32 %22, %21
%24 = call i64 @malloc(i32 %23)
%25 = inttoptr i64 %24 to float*
%26 = icmp eq i64 %24, 0
br i1 %26, label %35, label %27
27: ; preds = %19
%28 = load i32, i32* %3
%29 = load i32, i32* %4
%30 = mul i32 %29, %28
%31 = icmp sgt i32 %30, 0
br i1 %31, label %32, label %38
32: ; preds = %27
%33 = load i32, i32* %5
%34 = zext i32 %30 to i64
br label %40
35: ; preds = %19
%36 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([16 x i8], [16 x i8]* @str, i64 0, i64 0))
%37 = call i32 @exit(i32 -1)
unreachable
38: ; preds = %93, %27
%39 = icmp sgt i32 %29, 0
br i1 %39, label %97, label %132
40: ; preds = %32, %93
%41 = phi i64 [ 0, %32 ], [ %95, %93 ]
%42 = phi i8* [ %14, %32 ], [ %94, %93 ]
%43 = trunc i64 %41 to i32
%44 = mul nsw i32 %43, 3
switch i32 %33, label %93 [
i32 1, label %45
i32 2, label %55
i32 3, label %69
]
45: ; preds = %40
%46 = getelementptr inbounds i8, i8* %42, i64 1
%47 = load i8, i8* %42
%48 = uitofp i8 %47 to float
%49 = fmul float %48, 3.906250e-03
%50 = zext i32 %44 to i64
%51 = getelementptr inbounds float, float* %25, i64 %50
store float %49, float* %51
%52 = add nuw nsw i32 %44, 1
%53 = zext i32 %52 to i64
%54 = getelementptr inbounds float, float* %25, i64 %53
store float %49, float* %54
br label %87
55: ; preds = %40
%56 = getelementptr inbounds i8, i8* %42, i64 1
%57 = load i8, i8* %42
%58 = uitofp i8 %57 to float
%59 = fmul float %58, 3.906250e-03
%60 = zext i32 %44 to i64
%61 = getelementptr inbounds float, float* %25, i64 %60
store float %59, float* %61
%62 = getelementptr inbounds i8, i8* %42, i64 2
%63 = load i8, i8* %56
%64 = uitofp i8 %63 to float
%65 = fmul float %64, 3.906250e-03
%66 = add nuw nsw i32 %44, 1
%67 = zext i32 %66 to i64
%68 = getelementptr inbounds float, float* %25, i64 %67
store float %65, float* %68
br label %87
69: ; preds = %40
%70 = getelementptr inbounds i8, i8* %42, i64 1
%71 = load i8, i8* %42
%72 = uitofp i8 %71 to float
%73 = fmul float %72, 3.906250e-03
%74 = zext i32 %44 to i64
%75 = getelementptr inbounds float, float* %25, i64 %74
store float %73, float* %75
%76 = getelementptr inbounds i8, i8* %42, i64 2
%77 = load i8, i8* %70
%78 = uitofp i8 %77 to float
%79 = fmul float %78, 3.906250e-03
%80 = add nuw nsw i32 %44, 1
%81 = zext i32 %80 to i64
%82 = getelementptr inbounds float, float* %25, i64 %81
store float %79, float* %82
%83 = getelementptr inbounds i8, i8* %42, i64 3
%84 = load i8, i8* %76
%85 = uitofp i8 %84 to float
%86 = fmul float %85, 3.906250e-03
br label %87
87: ; preds = %69, %55, %45
%88 = phi float [ %49, %45 ], [ %65, %55 ], [ %86, %69 ]
%89 = phi i8* [ %46, %45 ], [ %62, %55 ], [ %83, %69 ]
%90 = add nuw nsw i32 %44, 2
%91 = zext i32 %90 to i64
%92 = getelementptr inbounds float, float* %25, i64 %91
store float %88, float* %92
br label %93
93: ; preds = %87, %40
%94 = phi i8* [ %42, %40 ], [ %89, %87 ]
%95 = add nuw nsw i64 %41, 1
%96 = icmp eq i64 %95, %34
br i1 %96, label %38, label %40
97: ; preds = %38, %130
%98 = phi i32 [ %131, %130 ], [ %28, %38 ]
%99 = phi i32 [ %100, %130 ], [ %29, %38 ]
%100 = add nsw i32 %99, -1
%101 = icmp sgt i32 %98, 0
br i1 %101, label %102, label %127
102: ; preds = %97, %102
%103 = phi i32 [ %125, %102 ], [ %98, %97 ]
%104 = phi i32 [ %124, %102 ], [ 0, %97 ]
%105 = mul nsw i32 %103, %100
%106 = add nsw i32 %105, %104
%107 = mul nsw i32 %106, 3
%108 = sext i32 %107 to i64
%109 = getelementptr inbounds float, float* %25, i64 %108
%110 = load float, float* %109
%111 = fpext float %110 to double
%112 = getelementptr inbounds float, float* %109, i64 1
%113 = load float, float* %112
%114 = fpext float %113 to double
%115 = fmul double %114, 0x3FE571943D16EA5B
%116 = call double @llvm.fmuladd.f64(double %111, double 0x3FD0F6F9778BE3E0, double %115)
%117 = getelementptr inbounds float, float* %109, i64 2
%118 = load float, float* %117
%119 = fpext float %118 to double
%120 = call double @llvm.fmuladd.f64(double %119, double 0x3FB0977839191DAB, double %116)
%121 = fptrunc double %120 to float
%122 = fpext float %121 to double
%123 = call i32 (i32*, i8*, ...) @fprintf(i32* %9, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.3, i64 0, i64 0), double %122)
%124 = add nuw nsw i32 %104, 1
%125 = load i32, i32* %3
%126 = icmp slt i32 %124, %125
br i1 %126, label %102, label %127
127: ; preds = %102, %97
%128 = call i32 @fputc(i32 10, i32* %9)
%129 = icmp sgt i32 %99, 1
br i1 %129, label %130, label %132
130: ; preds = %127
%131 = load i32, i32* %3
br label %97
132: ; preds = %127, %38
%133 = call i32 @fclose(i32* %9)
ret void
}