#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*/ printf(char *, ...);
void print_emc(const unsigned char *p) {
  static int count = 0;
  if ((count % 25) == 0)
    printf("  #   Dive Date       Time     BT    Depth Temp Pre Ptr  Pro Ptr  "
           "End Ptr\n");
  printf("[%3d] %4d %04d-%02d-%02d %02d:%02d:%02d %2d:%02d %5.1f %3dF %08x "
         "%08x %08x\n",
         count, ((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)));
  count++;
}


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)
mov    0x2f01(%rip),%eax
mov    $0x19,%ecx
cltd
idiv   %ecx
cmp    $0x0,%edx
jne    114a <print_emc+0x3a>
lea    0xec5(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
mov    0x2edc(%rip),%esi
mov    -0x30(%rbp),%rax
movzwl 0x56(%rax),%edx
movzbl 0x5(%rax),%ecx
add    $0x7d0,%ecx
movzbl 0x4(%rax),%r8d
movzbl 0x3(%rax),%r9d
movzbl 0x2(%rax),%edi
mov    %edi,-0x38(%rbp)
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  0xe4e(%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),%edi
mov    -0x30(%rbp),%rax
movzbl 0x101(%rax),%eax
shl    $0x8,%eax
add    %eax,%edi
mov    -0x30(%rbp),%rax
movzbl 0x102(%rax),%eax
shl    $0x10,%eax
add    %eax,%edi
mov    -0x30(%rbp),%rax
movzbl 0x103(%rax),%eax
shl    $0x18,%eax
add    %eax,%edi
mov    -0x38(%rbp),%eax
mov    %edi,-0x34(%rbp)
lea    0xde4(%rip),%rdi
mov    %eax,(%rsp)
mov    -0x34(%rbp),%eax
mov    %r13d,0x8(%rsp)
mov    %r12d,0x10(%rsp)
mov    %r15d,0x18(%rsp)
mov    %r14d,0x20(%rsp)
mov    %ebx,0x28(%rsp)
mov    %r11d,0x30(%rsp)
mov    %r10d,0x38(%rsp)
mov    %eax,0x40(%rsp)
mov    $0x1,%al
call   1030 <printf@plt>
mov    0x2d84(%rip),%eax
add    $0x1,%eax
mov    %eax,0x2d7b(%rip)
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
push   %rax
mov    %rdi,%rbx
mov    0x2f00(%rip),%esi
imul   $0xc28f5c29,%esi,%eax
add    $0x51eb851,%eax
cmp    $0xa3d70a2,%eax
ja     1158 <print_emc+0x38>
lea    0xf07(%rip),%rdi
call   1030 <puts@plt>
mov    0x2edc(%rip),%esi
movzwl 0x56(%rbx),%edx
movzbl 0x5(%rbx),%ecx
add    $0x7d0,%ecx
movzbl 0x4(%rbx),%r8d
movzbl 0x3(%rbx),%r9d
movzbl 0x2(%rbx),%eax
mov    %rax,(%rsp)
movzbl 0x1(%rbx),%r11d
movzbl (%rbx),%r14d
movzwl 0x130(%rbx),%r12d
mov    $0x88888889,%r15d
imul   %r12,%r15
shr    $0x25,%r15
imul   $0x3c,%r15d,%eax
sub    %eax,%r12d
movzwl 0x132(%rbx),%eax
cvtsi2sd %eax,%xmm0
mulsd  0xe4f(%rip),%xmm0
movzbl 0x125(%rbx),%r13d
mov    0x6(%rbx),%ebp
mov    0x1e(%rbx),%r10d
mov    0x100(%rbx),%ebx
sub    $0x8,%rsp
lea    0xe37(%rip),%rdi
mov    $0x1,%al
push   %rbx
push   %rbp
push   %r10
push   %r13
push   %r12
push   %r15
push   %r14
push   %r11
push   0x48(%rsp)
call   1040 <printf@plt>
add    $0x50,%rsp
addl   $0x1,0x2e3f(%rip)
add    $0x8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
@print_emc.count = internal global i32 0
@.str = [75 x i8] c" # Dive Date Time BT Depth Temp Pre Ptr Pro Ptr End Ptr\0A\00"
@.str.1 = [76 x i8] c"[%3d] %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*
store i8* %0, i8** %2
%3 = load i32, i32* @print_emc.count
%4 = srem i32 %3, 25
%5 = icmp eq i32 %4, 0
br i1 %5, label %6, label %8
6: ; preds = %1
%7 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([75 x i8], [75 x i8]* @.str, i64 0, i64 0))
br label %8
8: ; preds = %6, %1
%9 = load i32, i32* @print_emc.count
%10 = load i8*, i8** %2
%11 = getelementptr inbounds i8, i8* %10, i64 86
%12 = getelementptr inbounds i8, i8* %11, i64 0
%13 = load i8, i8* %12
%14 = zext i8 %13 to i32
%15 = load i8*, i8** %2
%16 = getelementptr inbounds i8, i8* %15, i64 86
%17 = getelementptr inbounds i8, i8* %16, i64 1
%18 = load i8, i8* %17
%19 = zext i8 %18 to i32
%20 = shl i32 %19, 8
%21 = add i32 %14, %20
%22 = load i8*, i8** %2
%23 = getelementptr inbounds i8, i8* %22, i64 5
%24 = load i8, i8* %23
%25 = zext i8 %24 to i32
%26 = add nsw i32 %25, 2000
%27 = load i8*, i8** %2
%28 = getelementptr inbounds i8, i8* %27, i64 4
%29 = load i8, i8* %28
%30 = zext i8 %29 to i32
%31 = load i8*, i8** %2
%32 = getelementptr inbounds i8, i8* %31, i64 3
%33 = load i8, i8* %32
%34 = zext i8 %33 to i32
%35 = load i8*, i8** %2
%36 = getelementptr inbounds i8, i8* %35, i64 2
%37 = load i8, i8* %36
%38 = zext i8 %37 to i32
%39 = load i8*, i8** %2
%40 = getelementptr inbounds i8, i8* %39, i64 1
%41 = load i8, i8* %40
%42 = zext i8 %41 to i32
%43 = load i8*, i8** %2
%44 = load i8, i8* %43
%45 = zext i8 %44 to i32
%46 = load i8*, i8** %2
%47 = getelementptr inbounds i8, i8* %46, i64 256
%48 = getelementptr inbounds i8, i8* %47, i64 48
%49 = getelementptr inbounds i8, i8* %48, i64 0
%50 = load i8, i8* %49
%51 = zext i8 %50 to i32
%52 = load i8*, i8** %2
%53 = getelementptr inbounds i8, i8* %52, i64 256
%54 = getelementptr inbounds i8, i8* %53, i64 48
%55 = getelementptr inbounds i8, i8* %54, i64 1
%56 = load i8, i8* %55
%57 = zext i8 %56 to i32
%58 = shl i32 %57, 8
%59 = add i32 %51, %58
%60 = udiv i32 %59, 60
%61 = load i8*, i8** %2
%62 = getelementptr inbounds i8, i8* %61, i64 256
%63 = getelementptr inbounds i8, i8* %62, i64 48
%64 = getelementptr inbounds i8, i8* %63, i64 0
%65 = load i8, i8* %64
%66 = zext i8 %65 to i32
%67 = load i8*, i8** %2
%68 = getelementptr inbounds i8, i8* %67, i64 256
%69 = getelementptr inbounds i8, i8* %68, i64 48
%70 = getelementptr inbounds i8, i8* %69, i64 1
%71 = load i8, i8* %70
%72 = zext i8 %71 to i32
%73 = shl i32 %72, 8
%74 = add i32 %66, %73
%75 = urem i32 %74, 60
%76 = load i8*, i8** %2
%77 = getelementptr inbounds i8, i8* %76, i64 256
%78 = getelementptr inbounds i8, i8* %77, i64 50
%79 = getelementptr inbounds i8, i8* %78, i64 0
%80 = load i8, i8* %79
%81 = zext i8 %80 to i32
%82 = load i8*, i8** %2
%83 = getelementptr inbounds i8, i8* %82, i64 256
%84 = getelementptr inbounds i8, i8* %83, i64 50
%85 = getelementptr inbounds i8, i8* %84, i64 1
%86 = load i8, i8* %85
%87 = zext i8 %86 to i32
%88 = shl i32 %87, 8
%89 = add i32 %81, %88
%90 = uitofp i32 %89 to double
%91 = fdiv double %90, 4.000000e+00
%92 = load i8*, i8** %2
%93 = getelementptr inbounds i8, i8* %92, i64 256
%94 = getelementptr inbounds i8, i8* %93, i64 37
%95 = load i8, i8* %94
%96 = zext i8 %95 to i32
%97 = load i8*, i8** %2
%98 = getelementptr inbounds i8, i8* %97, i64 30
%99 = getelementptr inbounds i8, i8* %98, i64 0
%100 = load i8, i8* %99
%101 = zext i8 %100 to i32
%102 = load i8*, i8** %2
%103 = getelementptr inbounds i8, i8* %102, i64 30
%104 = getelementptr inbounds i8, i8* %103, i64 1
%105 = load i8, i8* %104
%106 = zext i8 %105 to i32
%107 = shl i32 %106, 8
%108 = add i32 %101, %107
%109 = load i8*, i8** %2
%110 = getelementptr inbounds i8, i8* %109, i64 30
%111 = getelementptr inbounds i8, i8* %110, i64 2
%112 = load i8, i8* %111
%113 = zext i8 %112 to i32
%114 = shl i32 %113, 16
%115 = add i32 %108, %114
%116 = load i8*, i8** %2
%117 = getelementptr inbounds i8, i8* %116, i64 30
%118 = getelementptr inbounds i8, i8* %117, i64 3
%119 = load i8, i8* %118
%120 = zext i8 %119 to i32
%121 = shl i32 %120, 24
%122 = add i32 %115, %121
%123 = load i8*, i8** %2
%124 = getelementptr inbounds i8, i8* %123, i64 6
%125 = getelementptr inbounds i8, i8* %124, i64 0
%126 = load i8, i8* %125
%127 = zext i8 %126 to i32
%128 = load i8*, i8** %2
%129 = getelementptr inbounds i8, i8* %128, i64 6
%130 = getelementptr inbounds i8, i8* %129, i64 1
%131 = load i8, i8* %130
%132 = zext i8 %131 to i32
%133 = shl i32 %132, 8
%134 = add i32 %127, %133
%135 = load i8*, i8** %2
%136 = getelementptr inbounds i8, i8* %135, i64 6
%137 = getelementptr inbounds i8, i8* %136, i64 2
%138 = load i8, i8* %137
%139 = zext i8 %138 to i32
%140 = shl i32 %139, 16
%141 = add i32 %134, %140
%142 = load i8*, i8** %2
%143 = getelementptr inbounds i8, i8* %142, i64 6
%144 = getelementptr inbounds i8, i8* %143, i64 3
%145 = load i8, i8* %144
%146 = zext i8 %145 to i32
%147 = shl i32 %146, 24
%148 = add i32 %141, %147
%149 = load i8*, i8** %2
%150 = getelementptr inbounds i8, i8* %149, i64 256
%151 = getelementptr inbounds i8, i8* %150, i64 0
%152 = load i8, i8* %151
%153 = zext i8 %152 to i32
%154 = load i8*, i8** %2
%155 = getelementptr inbounds i8, i8* %154, i64 256
%156 = getelementptr inbounds i8, i8* %155, i64 1
%157 = load i8, i8* %156
%158 = zext i8 %157 to i32
%159 = shl i32 %158, 8
%160 = add i32 %153, %159
%161 = load i8*, i8** %2
%162 = getelementptr inbounds i8, i8* %161, i64 256
%163 = getelementptr inbounds i8, i8* %162, i64 2
%164 = load i8, i8* %163
%165 = zext i8 %164 to i32
%166 = shl i32 %165, 16
%167 = add i32 %160, %166
%168 = load i8*, i8** %2
%169 = getelementptr inbounds i8, i8* %168, i64 256
%170 = getelementptr inbounds i8, i8* %169, i64 3
%171 = load i8, i8* %170
%172 = zext i8 %171 to i32
%173 = shl i32 %172, 24
%174 = add i32 %167, %173
%175 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([76 x i8], [76 x i8]* @.str.1, i64 0, i64 0), i32 %9, i32 %21, i32 %26, i32 %30, i32 %34, i32 %38, i32 %42, i32 %45, i32 %60, i32 %75, double %91, i32 %96, i32 %122, i32 %148, i32 %174)
%176 = load i32, i32* @print_emc.count
%177 = add nsw i32 %176, 1
store i32 %177, i32* @print_emc.count
ret void
}

LLVM IR (-O2):
@print_emc.count = internal unnamed_addr global i32 0
@.str.1 = [76 x i8] c"[%3d] %4d %04d-%02d-%02d %02d:%02d:%02d %2d:%02d %5.1f %3dF %08x %08x %08x\0A\00"
@str = [74 x i8] c" # Dive Date Time BT Depth Temp Pre Ptr Pro Ptr End Ptr\00"
define void @print_emc(i8* %0) {
%2 = load i32, i32* @print_emc.count
%3 = srem i32 %2, 25
%4 = icmp eq i32 %3, 0
br i1 %4, label %5, label %8
5: ; preds = %1
%6 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([74 x i8], [74 x i8]* @str, i64 0, i64 0))
%7 = load i32, i32* @print_emc.count
br label %8
8: ; preds = %5, %1
%9 = phi i32 [ %7, %5 ], [ %2, %1 ]
%10 = getelementptr inbounds i8, i8* %0, i64 86
%11 = load i8, i8* %10
%12 = zext i8 %11 to i32
%13 = getelementptr inbounds i8, i8* %0, i64 87
%14 = load i8, i8* %13
%15 = zext i8 %14 to i32
%16 = shl nuw nsw i32 %15, 8
%17 = or i32 %16, %12
%18 = getelementptr inbounds i8, i8* %0, i64 5
%19 = load i8, i8* %18
%20 = zext i8 %19 to i32
%21 = add nuw nsw i32 %20, 2000
%22 = getelementptr inbounds i8, i8* %0, i64 4
%23 = load i8, i8* %22
%24 = zext i8 %23 to i32
%25 = getelementptr inbounds i8, i8* %0, i64 3
%26 = load i8, i8* %25
%27 = zext i8 %26 to i32
%28 = getelementptr inbounds i8, i8* %0, i64 2
%29 = load i8, i8* %28
%30 = zext i8 %29 to i32
%31 = getelementptr inbounds i8, i8* %0, i64 1
%32 = load i8, i8* %31
%33 = zext i8 %32 to i32
%34 = load i8, i8* %0
%35 = zext i8 %34 to i32
%36 = getelementptr inbounds i8, i8* %0, i64 256
%37 = getelementptr inbounds i8, i8* %0, i64 304
%38 = load i8, i8* %37
%39 = zext i8 %38 to i32
%40 = getelementptr inbounds i8, i8* %0, i64 305
%41 = load i8, i8* %40
%42 = zext i8 %41 to i32
%43 = shl nuw nsw i32 %42, 8
%44 = or i32 %43, %39
%45 = udiv i32 %44, 60
%46 = urem i32 %44, 60
%47 = getelementptr inbounds i8, i8* %0, i64 306
%48 = load i8, i8* %47
%49 = zext i8 %48 to i32
%50 = getelementptr inbounds i8, i8* %0, i64 307
%51 = load i8, i8* %50
%52 = zext i8 %51 to i32
%53 = shl nuw nsw i32 %52, 8
%54 = or i32 %53, %49
%55 = uitofp i32 %54 to double
%56 = fmul double %55, 2.500000e-01
%57 = getelementptr inbounds i8, i8* %0, i64 293
%58 = load i8, i8* %57
%59 = zext i8 %58 to i32
%60 = getelementptr inbounds i8, i8* %0, i64 30
%61 = load i8, i8* %60
%62 = zext i8 %61 to i32
%63 = getelementptr inbounds i8, i8* %0, i64 31
%64 = load i8, i8* %63
%65 = zext i8 %64 to i32
%66 = shl nuw nsw i32 %65, 8
%67 = or i32 %66, %62
%68 = getelementptr inbounds i8, i8* %0, i64 32
%69 = load i8, i8* %68
%70 = zext i8 %69 to i32
%71 = shl nuw nsw i32 %70, 16
%72 = or i32 %67, %71
%73 = getelementptr inbounds i8, i8* %0, i64 33
%74 = load i8, i8* %73
%75 = zext i8 %74 to i32
%76 = shl nuw i32 %75, 24
%77 = or i32 %72, %76
%78 = getelementptr inbounds i8, i8* %0, i64 6
%79 = load i8, i8* %78
%80 = zext i8 %79 to i32
%81 = getelementptr inbounds i8, i8* %0, i64 7
%82 = load i8, i8* %81
%83 = zext i8 %82 to i32
%84 = shl nuw nsw i32 %83, 8
%85 = or i32 %84, %80
%86 = getelementptr inbounds i8, i8* %0, i64 8
%87 = load i8, i8* %86
%88 = zext i8 %87 to i32
%89 = shl nuw nsw i32 %88, 16
%90 = or i32 %85, %89
%91 = getelementptr inbounds i8, i8* %0, i64 9
%92 = load i8, i8* %91
%93 = zext i8 %92 to i32
%94 = shl nuw i32 %93, 24
%95 = or i32 %90, %94
%96 = load i8, i8* %36
%97 = zext i8 %96 to i32
%98 = getelementptr inbounds i8, i8* %0, i64 257
%99 = load i8, i8* %98
%100 = zext i8 %99 to i32
%101 = shl nuw nsw i32 %100, 8
%102 = or i32 %101, %97
%103 = getelementptr inbounds i8, i8* %0, i64 258
%104 = load i8, i8* %103
%105 = zext i8 %104 to i32
%106 = shl nuw nsw i32 %105, 16
%107 = or i32 %102, %106
%108 = getelementptr inbounds i8, i8* %0, i64 259
%109 = load i8, i8* %108
%110 = zext i8 %109 to i32
%111 = shl nuw i32 %110, 24
%112 = or i32 %107, %111
%113 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([76 x i8], [76 x i8]* @.str.1, i64 0, i64 0), i32 %9, i32 %17, i32 %21, i32 %24, i32 %27, i32 %30, i32 %33, i32 %35, i32 %45, i32 %46, double %56, i32 %59, i32 %77, i32 %95, i32 %112)
%114 = load i32, i32* @print_emc.count
%115 = add nsw i32 %114, 1
store i32 %115, i32* @print_emc.count
ret void
}