#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*/ free(unsigned char *);
int /*<<< orphan*/ print_emc_profile(unsigned char *, int);
int /*<<< orphan*/ print_pre_dive(unsigned char *, int);
int /*<<< orphan*/ printf(char *, ...);
unsigned char *read_block(int *, unsigned int, unsigned int);
void print_emc(const unsigned char *p) {
  printf(
      "Dive Date       Time     BT    Depth Temp Pre Ptr  Pro Ptr  End Ptr\n");
  printf(
      "%4d %04d-%02d-%02d %02d:%02d:%02d %2d:%02d %5.1f %3dF %08x %08x %08x\n",
      ((unsigned int)(p + 86)[0] + ((p + 86)[1] << 8)), *(p + 5) + 2000,
      *(p + 4), *(p + 3), *(p + 2), *(p + 1), *p,
      ((unsigned int)(p + 256 + 48)[0] + ((p + 256 + 48)[1] << 8)) / 60,
      ((unsigned int)(p + 256 + 48)[0] + ((p + 256 + 48)[1] << 8)) % 60,
      ((unsigned int)(p + 256 + 50)[0] + ((p + 256 + 50)[1] << 8)) / 4.0,
      *(p + 256 + 37),
      ((unsigned int)(p + 30)[0] + ((p + 30)[1] << 8) + ((p + 30)[2] << 16) +
       ((p + 30)[3] << 24)),
      ((unsigned int)(p + 6)[0] + ((p + 6)[1] << 8) + ((p + 6)[2] << 16) +
       ((p + 6)[3] << 24)),
      ((unsigned int)(p + 256)[0] + ((p + 256)[1] << 8) + ((p + 256)[2] << 16) +
       ((p + 256)[3] << 24)));
  unsigned char *profile;
  int size;
  profile = read_block(&size,
                       ((unsigned int)(p + 30)[0] + ((p + 30)[1] << 8) +
                        ((p + 30)[2] << 16) + ((p + 30)[3] << 24)),
                       ((unsigned int)(p + 6)[0] + ((p + 6)[1] << 8) +
                        ((p + 6)[2] << 16) + ((p + 6)[3] << 24)));
  print_pre_dive(profile, size);
  free(profile);
  profile = read_block(&size,
                       ((unsigned int)(p + 6)[0] + ((p + 6)[1] << 8) +
                        ((p + 6)[2] << 16) + ((p + 6)[3] << 24)),
                       ((unsigned int)(p + 256)[0] + ((p + 256)[1] << 8) +
                        ((p + 256)[2] << 16) + ((p + 256)[3] << 24)));
  print_emc_profile(profile, size);
  free(profile);
}


x86 assembly (clang, -O0):
<print_emc>:
push   %rbp
mov    %rsp,%rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x58,%rsp
mov    %rdi,-0x30(%rbp)
lea    0xe9c(%rip),%rdi
xor    %eax,%eax
call   1040 <printf@plt>
mov    -0x30(%rbp),%rax
movzwl 0x56(%rax),%esi
movzbl 0x5(%rax),%edx
add    $0x7d0,%edx
movzbl 0x4(%rax),%ecx
movzbl 0x3(%rax),%r8d
movzbl 0x2(%rax),%r9d
movzbl 0x1(%rax),%r13d
movzbl (%rax),%r12d
movzwl 0x130(%rax),%r14d
mov    %r14d,%edi
mov    $0x88888889,%r10d
imul   %r10,%rdi
shr    $0x25,%rdi
mov    %edi,%r15d
imul   $0x3c,%r15d,%edi
sub    %edi,%r14d
movzwl 0x132(%rax),%eax
cvtsi2sd %eax,%xmm0
movsd  0xe2e(%rip),%xmm1
divsd  %xmm1,%xmm0
mov    -0x30(%rbp),%rax
movzbl 0x125(%rax),%ebx
mov    -0x30(%rbp),%rax
movzbl 0x1e(%rax),%r11d
mov    -0x30(%rbp),%rax
movzbl 0x1f(%rax),%eax
shl    $0x8,%eax
add    %eax,%r11d
mov    -0x30(%rbp),%rax
movzbl 0x20(%rax),%eax
shl    $0x10,%eax
add    %eax,%r11d
mov    -0x30(%rbp),%rax
movzbl 0x21(%rax),%eax
shl    $0x18,%eax
add    %eax,%r11d
mov    -0x30(%rbp),%rax
movzbl 0x6(%rax),%r10d
mov    -0x30(%rbp),%rax
movzbl 0x7(%rax),%eax
shl    $0x8,%eax
add    %eax,%r10d
mov    -0x30(%rbp),%rax
movzbl 0x8(%rax),%eax
shl    $0x10,%eax
add    %eax,%r10d
mov    -0x30(%rbp),%rax
movzbl 0x9(%rax),%eax
shl    $0x18,%eax
add    %eax,%r10d
mov    -0x30(%rbp),%rax
movzbl 0x100(%rax),%eax
mov    -0x30(%rbp),%rdi
movzbl 0x101(%rdi),%edi
shl    $0x8,%edi
add    %edi,%eax
mov    -0x30(%rbp),%rdi
movzbl 0x102(%rdi),%edi
shl    $0x10,%edi
add    %edi,%eax
mov    -0x30(%rbp),%rdi
movzbl 0x103(%rdi),%edi
shl    $0x18,%edi
add    %edi,%eax
lea    0xdc4(%rip),%rdi
mov    %r13d,(%rsp)
mov    %r12d,0x8(%rsp)
mov    %r15d,0x10(%rsp)
mov    %r14d,0x18(%rsp)
mov    %ebx,0x20(%rsp)
mov    %r11d,0x28(%rsp)
mov    %r10d,0x30(%rsp)
mov    %eax,0x38(%rsp)
mov    $0x1,%al
call   1040 <printf@plt>
mov    -0x30(%rbp),%rax
movzbl 0x1e(%rax),%esi
mov    -0x30(%rbp),%rax
movzbl 0x1f(%rax),%eax
shl    $0x8,%eax
add    %eax,%esi
mov    -0x30(%rbp),%rax
movzbl 0x20(%rax),%eax
shl    $0x10,%eax
add    %eax,%esi
mov    -0x30(%rbp),%rax
movzbl 0x21(%rax),%eax
shl    $0x18,%eax
add    %eax,%esi
mov    -0x30(%rbp),%rax
movzbl 0x6(%rax),%edx
mov    -0x30(%rbp),%rax
movzbl 0x7(%rax),%eax
shl    $0x8,%eax
add    %eax,%edx
mov    -0x30(%rbp),%rax
movzbl 0x8(%rax),%eax
shl    $0x10,%eax
add    %eax,%edx
mov    -0x30(%rbp),%rax
movzbl 0x9(%rax),%eax
shl    $0x18,%eax
add    %eax,%edx
lea    -0x3c(%rbp),%rdi
call   1070 <read_block@plt>
mov    %rax,-0x38(%rbp)
mov    -0x38(%rbp),%rdi
mov    -0x3c(%rbp),%esi
call   1050 <print_pre_dive@plt>
mov    -0x38(%rbp),%rdi
call   1030 <free@plt>
mov    -0x30(%rbp),%rax
movzbl 0x6(%rax),%esi
mov    -0x30(%rbp),%rax
movzbl 0x7(%rax),%eax
shl    $0x8,%eax
add    %eax,%esi
mov    -0x30(%rbp),%rax
movzbl 0x8(%rax),%eax
shl    $0x10,%eax
add    %eax,%esi
mov    -0x30(%rbp),%rax
movzbl 0x9(%rax),%eax
shl    $0x18,%eax
add    %eax,%esi
mov    -0x30(%rbp),%rax
movzbl 0x100(%rax),%edx
mov    -0x30(%rbp),%rax
movzbl 0x101(%rax),%eax
shl    $0x8,%eax
add    %eax,%edx
mov    -0x30(%rbp),%rax
movzbl 0x102(%rax),%eax
shl    $0x10,%eax
add    %eax,%edx
mov    -0x30(%rbp),%rax
movzbl 0x103(%rax),%eax
shl    $0x18,%eax
add    %eax,%edx
lea    -0x3c(%rbp),%rdi
call   1070 <read_block@plt>
mov    %rax,-0x38(%rbp)
mov    -0x38(%rbp),%rdi
mov    -0x3c(%rbp),%esi
call   1060 <print_emc_profile@plt>
mov    -0x38(%rbp),%rdi
call   1030 <free@plt>
add    $0x58,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

x86 assembly (clang, -O2):
<print_emc>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x18,%rsp
mov    %rdi,%rbx
lea    0xed6(%rip),%rdi
call   1040 <puts@plt>
movzwl 0x56(%rbx),%esi
movzbl 0x5(%rbx),%edx
add    $0x7d0,%edx
movzbl 0x4(%rbx),%ecx
movzbl 0x3(%rbx),%r8d
movzbl 0x2(%rbx),%r9d
movzbl 0x1(%rbx),%eax
mov    %rax,0x10(%rsp)
movzbl (%rbx),%r11d
movzwl 0x130(%rbx),%r15d
mov    $0x88888889,%r14d
imul   %r15,%r14
shr    $0x25,%r14
imul   $0x3c,%r14d,%eax
sub    %eax,%r15d
movzwl 0x132(%rbx),%eax
cvtsi2sd %eax,%xmm0
mulsd  0xe2a(%rip),%xmm0
movzbl 0x125(%rbx),%r12d
mov    0x6(%rbx),%r13d
mov    0x1e(%rbx),%ebp
mov    0x100(%rbx),%r10d
lea    0xe15(%rip),%rdi
mov    $0x1,%al
push   %r10
push   %r13
push   %rbp
push   %r12
push   %r15
push   %r14
push   %r11
push   0x48(%rsp)
call   1050 <printf@plt>
add    $0x40,%rsp
mov    0x6(%rbx),%edx
mov    0x1e(%rbx),%esi
lea    0xc(%rsp),%r14
mov    %r14,%rdi
call   1080 <read_block@plt>
mov    %rax,%r15
mov    0xc(%rsp),%esi
mov    %rax,%rdi
call   1060 <print_pre_dive@plt>
mov    %r15,%rdi
call   1030 <free@plt>
mov    0x6(%rbx),%esi
mov    0x100(%rbx),%edx
mov    %r14,%rdi
call   1080 <read_block@plt>
mov    %rax,%rbx
mov    0xc(%rsp),%esi
mov    %rax,%rdi
call   1070 <print_emc_profile@plt>
mov    %rbx,%rdi
call   1030 <free@plt>
add    $0x18,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
@.str = [69 x i8] c"Dive Date Time BT Depth Temp Pre Ptr Pro Ptr End Ptr\0A\00"
@.str.1 = [70 x i8] c"%4d %04d-%02d-%02d %02d:%02d:%02d %2d:%02d %5.1f %3dF %08x %08x %08x\0A\00"
define void @print_emc(i8* %0) {
%2 = alloca i8*
%3 = alloca i8*
%4 = alloca i32
store i8* %0, i8** %2
%5 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([69 x i8], [69 x i8]* @.str, i64 0, i64 0))
%6 = load i8*, i8** %2
%7 = getelementptr inbounds i8, i8* %6, i64 86
%8 = getelementptr inbounds i8, i8* %7, i64 0
%9 = load i8, i8* %8
%10 = zext i8 %9 to i32
%11 = load i8*, i8** %2
%12 = getelementptr inbounds i8, i8* %11, i64 86
%13 = getelementptr inbounds i8, i8* %12, i64 1
%14 = load i8, i8* %13
%15 = zext i8 %14 to i32
%16 = shl i32 %15, 8
%17 = add i32 %10, %16
%18 = load i8*, i8** %2
%19 = getelementptr inbounds i8, i8* %18, i64 5
%20 = load i8, i8* %19
%21 = zext i8 %20 to i32
%22 = add nsw i32 %21, 2000
%23 = load i8*, i8** %2
%24 = getelementptr inbounds i8, i8* %23, i64 4
%25 = load i8, i8* %24
%26 = zext i8 %25 to i32
%27 = load i8*, i8** %2
%28 = getelementptr inbounds i8, i8* %27, i64 3
%29 = load i8, i8* %28
%30 = zext i8 %29 to i32
%31 = load i8*, i8** %2
%32 = getelementptr inbounds i8, i8* %31, i64 2
%33 = load i8, i8* %32
%34 = zext i8 %33 to i32
%35 = load i8*, i8** %2
%36 = getelementptr inbounds i8, i8* %35, i64 1
%37 = load i8, i8* %36
%38 = zext i8 %37 to i32
%39 = load i8*, i8** %2
%40 = load i8, i8* %39
%41 = zext i8 %40 to i32
%42 = load i8*, i8** %2
%43 = getelementptr inbounds i8, i8* %42, i64 256
%44 = getelementptr inbounds i8, i8* %43, i64 48
%45 = getelementptr inbounds i8, i8* %44, i64 0
%46 = load i8, i8* %45
%47 = zext i8 %46 to i32
%48 = load i8*, i8** %2
%49 = getelementptr inbounds i8, i8* %48, i64 256
%50 = getelementptr inbounds i8, i8* %49, i64 48
%51 = getelementptr inbounds i8, i8* %50, i64 1
%52 = load i8, i8* %51
%53 = zext i8 %52 to i32
%54 = shl i32 %53, 8
%55 = add i32 %47, %54
%56 = udiv i32 %55, 60
%57 = load i8*, i8** %2
%58 = getelementptr inbounds i8, i8* %57, i64 256
%59 = getelementptr inbounds i8, i8* %58, i64 48
%60 = getelementptr inbounds i8, i8* %59, i64 0
%61 = load i8, i8* %60
%62 = zext i8 %61 to i32
%63 = load i8*, i8** %2
%64 = getelementptr inbounds i8, i8* %63, i64 256
%65 = getelementptr inbounds i8, i8* %64, i64 48
%66 = getelementptr inbounds i8, i8* %65, i64 1
%67 = load i8, i8* %66
%68 = zext i8 %67 to i32
%69 = shl i32 %68, 8
%70 = add i32 %62, %69
%71 = urem i32 %70, 60
%72 = load i8*, i8** %2
%73 = getelementptr inbounds i8, i8* %72, i64 256
%74 = getelementptr inbounds i8, i8* %73, i64 50
%75 = getelementptr inbounds i8, i8* %74, i64 0
%76 = load i8, i8* %75
%77 = zext i8 %76 to i32
%78 = load i8*, i8** %2
%79 = getelementptr inbounds i8, i8* %78, i64 256
%80 = getelementptr inbounds i8, i8* %79, i64 50
%81 = getelementptr inbounds i8, i8* %80, i64 1
%82 = load i8, i8* %81
%83 = zext i8 %82 to i32
%84 = shl i32 %83, 8
%85 = add i32 %77, %84
%86 = uitofp i32 %85 to double
%87 = fdiv double %86, 4.000000e+00
%88 = load i8*, i8** %2
%89 = getelementptr inbounds i8, i8* %88, i64 256
%90 = getelementptr inbounds i8, i8* %89, i64 37
%91 = load i8, i8* %90
%92 = zext i8 %91 to i32
%93 = load i8*, i8** %2
%94 = getelementptr inbounds i8, i8* %93, i64 30
%95 = getelementptr inbounds i8, i8* %94, i64 0
%96 = load i8, i8* %95
%97 = zext i8 %96 to i32
%98 = load i8*, i8** %2
%99 = getelementptr inbounds i8, i8* %98, i64 30
%100 = getelementptr inbounds i8, i8* %99, i64 1
%101 = load i8, i8* %100
%102 = zext i8 %101 to i32
%103 = shl i32 %102, 8
%104 = add i32 %97, %103
%105 = load i8*, i8** %2
%106 = getelementptr inbounds i8, i8* %105, i64 30
%107 = getelementptr inbounds i8, i8* %106, i64 2
%108 = load i8, i8* %107
%109 = zext i8 %108 to i32
%110 = shl i32 %109, 16
%111 = add i32 %104, %110
%112 = load i8*, i8** %2
%113 = getelementptr inbounds i8, i8* %112, i64 30
%114 = getelementptr inbounds i8, i8* %113, i64 3
%115 = load i8, i8* %114
%116 = zext i8 %115 to i32
%117 = shl i32 %116, 24
%118 = add i32 %111, %117
%119 = load i8*, i8** %2
%120 = getelementptr inbounds i8, i8* %119, i64 6
%121 = getelementptr inbounds i8, i8* %120, i64 0
%122 = load i8, i8* %121
%123 = zext i8 %122 to i32
%124 = load i8*, i8** %2
%125 = getelementptr inbounds i8, i8* %124, i64 6
%126 = getelementptr inbounds i8, i8* %125, i64 1
%127 = load i8, i8* %126
%128 = zext i8 %127 to i32
%129 = shl i32 %128, 8
%130 = add i32 %123, %129
%131 = load i8*, i8** %2
%132 = getelementptr inbounds i8, i8* %131, i64 6
%133 = getelementptr inbounds i8, i8* %132, i64 2
%134 = load i8, i8* %133
%135 = zext i8 %134 to i32
%136 = shl i32 %135, 16
%137 = add i32 %130, %136
%138 = load i8*, i8** %2
%139 = getelementptr inbounds i8, i8* %138, i64 6
%140 = getelementptr inbounds i8, i8* %139, i64 3
%141 = load i8, i8* %140
%142 = zext i8 %141 to i32
%143 = shl i32 %142, 24
%144 = add i32 %137, %143
%145 = load i8*, i8** %2
%146 = getelementptr inbounds i8, i8* %145, i64 256
%147 = getelementptr inbounds i8, i8* %146, i64 0
%148 = load i8, i8* %147
%149 = zext i8 %148 to i32
%150 = load i8*, i8** %2
%151 = getelementptr inbounds i8, i8* %150, i64 256
%152 = getelementptr inbounds i8, i8* %151, i64 1
%153 = load i8, i8* %152
%154 = zext i8 %153 to i32
%155 = shl i32 %154, 8
%156 = add i32 %149, %155
%157 = load i8*, i8** %2
%158 = getelementptr inbounds i8, i8* %157, i64 256
%159 = getelementptr inbounds i8, i8* %158, i64 2
%160 = load i8, i8* %159
%161 = zext i8 %160 to i32
%162 = shl i32 %161, 16
%163 = add i32 %156, %162
%164 = load i8*, i8** %2
%165 = getelementptr inbounds i8, i8* %164, i64 256
%166 = getelementptr inbounds i8, i8* %165, i64 3
%167 = load i8, i8* %166
%168 = zext i8 %167 to i32
%169 = shl i32 %168, 24
%170 = add i32 %163, %169
%171 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([70 x i8], [70 x i8]* @.str.1, i64 0, i64 0), i32 %17, i32 %22, i32 %26, i32 %30, i32 %34, i32 %38, i32 %41, i32 %56, i32 %71, double %87, i32 %92, i32 %118, i32 %144, i32 %170)
%172 = load i8*, i8** %2
%173 = getelementptr inbounds i8, i8* %172, i64 30
%174 = getelementptr inbounds i8, i8* %173, i64 0
%175 = load i8, i8* %174
%176 = zext i8 %175 to i32
%177 = load i8*, i8** %2
%178 = getelementptr inbounds i8, i8* %177, i64 30
%179 = getelementptr inbounds i8, i8* %178, i64 1
%180 = load i8, i8* %179
%181 = zext i8 %180 to i32
%182 = shl i32 %181, 8
%183 = add i32 %176, %182
%184 = load i8*, i8** %2
%185 = getelementptr inbounds i8, i8* %184, i64 30
%186 = getelementptr inbounds i8, i8* %185, i64 2
%187 = load i8, i8* %186
%188 = zext i8 %187 to i32
%189 = shl i32 %188, 16
%190 = add i32 %183, %189
%191 = load i8*, i8** %2
%192 = getelementptr inbounds i8, i8* %191, i64 30
%193 = getelementptr inbounds i8, i8* %192, i64 3
%194 = load i8, i8* %193
%195 = zext i8 %194 to i32
%196 = shl i32 %195, 24
%197 = add i32 %190, %196
%198 = load i8*, i8** %2
%199 = getelementptr inbounds i8, i8* %198, i64 6
%200 = getelementptr inbounds i8, i8* %199, i64 0
%201 = load i8, i8* %200
%202 = zext i8 %201 to i32
%203 = load i8*, i8** %2
%204 = getelementptr inbounds i8, i8* %203, i64 6
%205 = getelementptr inbounds i8, i8* %204, i64 1
%206 = load i8, i8* %205
%207 = zext i8 %206 to i32
%208 = shl i32 %207, 8
%209 = add i32 %202, %208
%210 = load i8*, i8** %2
%211 = getelementptr inbounds i8, i8* %210, i64 6
%212 = getelementptr inbounds i8, i8* %211, i64 2
%213 = load i8, i8* %212
%214 = zext i8 %213 to i32
%215 = shl i32 %214, 16
%216 = add i32 %209, %215
%217 = load i8*, i8** %2
%218 = getelementptr inbounds i8, i8* %217, i64 6
%219 = getelementptr inbounds i8, i8* %218, i64 3
%220 = load i8, i8* %219
%221 = zext i8 %220 to i32
%222 = shl i32 %221, 24
%223 = add i32 %216, %222
%224 = call i8* @read_block(i32* %4, i32 %197, i32 %223)
store i8* %224, i8** %3
%225 = load i8*, i8** %3
%226 = load i32, i32* %4
%227 = call i32 @print_pre_dive(i8* %225, i32 %226)
%228 = load i8*, i8** %3
%229 = call i32 @free(i8* %228)
%230 = load i8*, i8** %2
%231 = getelementptr inbounds i8, i8* %230, i64 6
%232 = getelementptr inbounds i8, i8* %231, i64 0
%233 = load i8, i8* %232
%234 = zext i8 %233 to i32
%235 = load i8*, i8** %2
%236 = getelementptr inbounds i8, i8* %235, i64 6
%237 = getelementptr inbounds i8, i8* %236, i64 1
%238 = load i8, i8* %237
%239 = zext i8 %238 to i32
%240 = shl i32 %239, 8
%241 = add i32 %234, %240
%242 = load i8*, i8** %2
%243 = getelementptr inbounds i8, i8* %242, i64 6
%244 = getelementptr inbounds i8, i8* %243, i64 2
%245 = load i8, i8* %244
%246 = zext i8 %245 to i32
%247 = shl i32 %246, 16
%248 = add i32 %241, %247
%249 = load i8*, i8** %2
%250 = getelementptr inbounds i8, i8* %249, i64 6
%251 = getelementptr inbounds i8, i8* %250, i64 3
%252 = load i8, i8* %251
%253 = zext i8 %252 to i32
%254 = shl i32 %253, 24
%255 = add i32 %248, %254
%256 = load i8*, i8** %2
%257 = getelementptr inbounds i8, i8* %256, i64 256
%258 = getelementptr inbounds i8, i8* %257, i64 0
%259 = load i8, i8* %258
%260 = zext i8 %259 to i32
%261 = load i8*, i8** %2
%262 = getelementptr inbounds i8, i8* %261, i64 256
%263 = getelementptr inbounds i8, i8* %262, i64 1
%264 = load i8, i8* %263
%265 = zext i8 %264 to i32
%266 = shl i32 %265, 8
%267 = add i32 %260, %266
%268 = load i8*, i8** %2
%269 = getelementptr inbounds i8, i8* %268, i64 256
%270 = getelementptr inbounds i8, i8* %269, i64 2
%271 = load i8, i8* %270
%272 = zext i8 %271 to i32
%273 = shl i32 %272, 16
%274 = add i32 %267, %273
%275 = load i8*, i8** %2
%276 = getelementptr inbounds i8, i8* %275, i64 256
%277 = getelementptr inbounds i8, i8* %276, i64 3
%278 = load i8, i8* %277
%279 = zext i8 %278 to i32
%280 = shl i32 %279, 24
%281 = add i32 %274, %280
%282 = call i8* @read_block(i32* %4, i32 %255, i32 %281)
store i8* %282, i8** %3
%283 = load i8*, i8** %3
%284 = load i32, i32* %4
%285 = call i32 @print_emc_profile(i8* %283, i32 %284)
%286 = load i8*, i8** %3
%287 = call i32 @free(i8* %286)
ret void
}

LLVM IR (-O2):
@.str.1 = [70 x i8] c"%4d %04d-%02d-%02d %02d:%02d:%02d %2d:%02d %5.1f %3dF %08x %08x %08x\0A\00"
@str = [68 x i8] c"Dive Date Time BT Depth Temp Pre Ptr Pro Ptr End Ptr\00"
define void @print_emc(i8* %0) {
%2 = alloca i32
%3 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([68 x i8], [68 x i8]* @str, i64 0, i64 0))
%4 = getelementptr inbounds i8, i8* %0, i64 86
%5 = load i8, i8* %4
%6 = zext i8 %5 to i32
%7 = getelementptr inbounds i8, i8* %0, i64 87
%8 = load i8, i8* %7
%9 = zext i8 %8 to i32
%10 = shl nuw nsw i32 %9, 8
%11 = or i32 %10, %6
%12 = getelementptr inbounds i8, i8* %0, i64 5
%13 = load i8, i8* %12
%14 = zext i8 %13 to i32
%15 = add nuw nsw i32 %14, 2000
%16 = getelementptr inbounds i8, i8* %0, i64 4
%17 = load i8, i8* %16
%18 = zext i8 %17 to i32
%19 = getelementptr inbounds i8, i8* %0, i64 3
%20 = load i8, i8* %19
%21 = zext i8 %20 to i32
%22 = getelementptr inbounds i8, i8* %0, i64 2
%23 = load i8, i8* %22
%24 = zext i8 %23 to i32
%25 = getelementptr inbounds i8, i8* %0, i64 1
%26 = load i8, i8* %25
%27 = zext i8 %26 to i32
%28 = load i8, i8* %0
%29 = zext i8 %28 to i32
%30 = getelementptr inbounds i8, i8* %0, i64 256
%31 = getelementptr inbounds i8, i8* %0, i64 304
%32 = load i8, i8* %31
%33 = zext i8 %32 to i32
%34 = getelementptr inbounds i8, i8* %0, i64 305
%35 = load i8, i8* %34
%36 = zext i8 %35 to i32
%37 = shl nuw nsw i32 %36, 8
%38 = or i32 %37, %33
%39 = udiv i32 %38, 60
%40 = urem i32 %38, 60
%41 = getelementptr inbounds i8, i8* %0, i64 306
%42 = load i8, i8* %41
%43 = zext i8 %42 to i32
%44 = getelementptr inbounds i8, i8* %0, i64 307
%45 = load i8, i8* %44
%46 = zext i8 %45 to i32
%47 = shl nuw nsw i32 %46, 8
%48 = or i32 %47, %43
%49 = uitofp i32 %48 to double
%50 = fmul double %49, 2.500000e-01
%51 = getelementptr inbounds i8, i8* %0, i64 293
%52 = load i8, i8* %51
%53 = zext i8 %52 to i32
%54 = getelementptr inbounds i8, i8* %0, i64 30
%55 = load i8, i8* %54
%56 = zext i8 %55 to i32
%57 = getelementptr inbounds i8, i8* %0, i64 31
%58 = load i8, i8* %57
%59 = zext i8 %58 to i32
%60 = shl nuw nsw i32 %59, 8
%61 = or i32 %60, %56
%62 = getelementptr inbounds i8, i8* %0, i64 32
%63 = load i8, i8* %62
%64 = zext i8 %63 to i32
%65 = shl nuw nsw i32 %64, 16
%66 = or i32 %61, %65
%67 = getelementptr inbounds i8, i8* %0, i64 33
%68 = load i8, i8* %67
%69 = zext i8 %68 to i32
%70 = shl nuw i32 %69, 24
%71 = or i32 %66, %70
%72 = getelementptr inbounds i8, i8* %0, i64 6
%73 = load i8, i8* %72
%74 = zext i8 %73 to i32
%75 = getelementptr inbounds i8, i8* %0, i64 7
%76 = load i8, i8* %75
%77 = zext i8 %76 to i32
%78 = shl nuw nsw i32 %77, 8
%79 = or i32 %78, %74
%80 = getelementptr inbounds i8, i8* %0, i64 8
%81 = load i8, i8* %80
%82 = zext i8 %81 to i32
%83 = shl nuw nsw i32 %82, 16
%84 = or i32 %79, %83
%85 = getelementptr inbounds i8, i8* %0, i64 9
%86 = load i8, i8* %85
%87 = zext i8 %86 to i32
%88 = shl nuw i32 %87, 24
%89 = or i32 %84, %88
%90 = load i8, i8* %30
%91 = zext i8 %90 to i32
%92 = getelementptr inbounds i8, i8* %0, i64 257
%93 = load i8, i8* %92
%94 = zext i8 %93 to i32
%95 = shl nuw nsw i32 %94, 8
%96 = or i32 %95, %91
%97 = getelementptr inbounds i8, i8* %0, i64 258
%98 = load i8, i8* %97
%99 = zext i8 %98 to i32
%100 = shl nuw nsw i32 %99, 16
%101 = or i32 %96, %100
%102 = getelementptr inbounds i8, i8* %0, i64 259
%103 = load i8, i8* %102
%104 = zext i8 %103 to i32
%105 = shl nuw i32 %104, 24
%106 = or i32 %101, %105
%107 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([70 x i8], [70 x i8]* @.str.1, i64 0, i64 0), i32 %11, i32 %15, i32 %18, i32 %21, i32 %24, i32 %27, i32 %29, i32 %39, i32 %40, double %50, i32 %53, i32 %71, i32 %89, i32 %106)
%108 = bitcast i32* %2 to i8*
%109 = load i8, i8* %54
%110 = zext i8 %109 to i32
%111 = load i8, i8* %57
%112 = zext i8 %111 to i32
%113 = shl nuw nsw i32 %112, 8
%114 = or i32 %113, %110
%115 = load i8, i8* %62
%116 = zext i8 %115 to i32
%117 = shl nuw nsw i32 %116, 16
%118 = or i32 %114, %117
%119 = load i8, i8* %67
%120 = zext i8 %119 to i32
%121 = shl nuw i32 %120, 24
%122 = or i32 %118, %121
%123 = load i8, i8* %72
%124 = zext i8 %123 to i32
%125 = load i8, i8* %75
%126 = zext i8 %125 to i32
%127 = shl nuw nsw i32 %126, 8
%128 = or i32 %127, %124
%129 = load i8, i8* %80
%130 = zext i8 %129 to i32
%131 = shl nuw nsw i32 %130, 16
%132 = or i32 %128, %131
%133 = load i8, i8* %85
%134 = zext i8 %133 to i32
%135 = shl nuw i32 %134, 24
%136 = or i32 %132, %135
%137 = call i8* @read_block(i32* %2, i32 %122, i32 %136)
%138 = load i32, i32* %2
%139 = call i32 @print_pre_dive(i8* %137, i32 %138)
%140 = call i32 @free(i8* %137)
%141 = load i8, i8* %72
%142 = zext i8 %141 to i32
%143 = load i8, i8* %75
%144 = zext i8 %143 to i32
%145 = shl nuw nsw i32 %144, 8
%146 = or i32 %145, %142
%147 = load i8, i8* %80
%148 = zext i8 %147 to i32
%149 = shl nuw nsw i32 %148, 16
%150 = or i32 %146, %149
%151 = load i8, i8* %85
%152 = zext i8 %151 to i32
%153 = shl nuw i32 %152, 24
%154 = or i32 %150, %153
%155 = load i8, i8* %30
%156 = zext i8 %155 to i32
%157 = load i8, i8* %92
%158 = zext i8 %157 to i32
%159 = shl nuw nsw i32 %158, 8
%160 = or i32 %159, %156
%161 = load i8, i8* %97
%162 = zext i8 %161 to i32
%163 = shl nuw nsw i32 %162, 16
%164 = or i32 %160, %163
%165 = load i8, i8* %102
%166 = zext i8 %165 to i32
%167 = shl nuw i32 %166, 24
%168 = or i32 %164, %167
%169 = call i8* @read_block(i32* %2, i32 %154, i32 %168)
%170 = load i32, i32* %2
%171 = call i32 @print_emc_profile(i8* %169, i32 %170)
%172 = call i32 @free(i8* %169)
ret void
}