#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 */
struct image_data {
  int dummy;
};

/* Variables and functions */
int /*<<< orphan*/ image_data_set(struct image_data *, unsigned short,
                                  unsigned char);
int /*<<< orphan*/ printf(char *, unsigned char);
void parse_edlf(unsigned char *start, int bytes, struct image_data *idata) {
  unsigned char *s = start;
  unsigned char *end = start + bytes;
  unsigned short cci = 0;
  if (*s++ != 0x0a)
    return;
  while (1) {
    unsigned char tag, data;
    if ((s - start + 1) % 5 == 0)
      s++;
    if (s >= end)
      return;
    tag = *s++;
    if ((s - start + 1) % 5 == 0)
      s++;
    if (s >= end)
      return;
    data = *s++;
    switch (tag) {
    case 0x07:
      return;
    case 0xaa:
      cci = (cci & 0xff) | (((unsigned short)data) << 8);
      break;
    case 0xa5:
      cci = (cci & 0xff00) | data;
      break;
    case 0x5a:
      image_data_set(idata, cci, data);
      cci += 1;
      break;
    case 0x55:
      if (data != 0x07) {
        printf("Invalid NULL data byte 0x%02x\n", data);
        return;
      }
      cci += 1;
      break;
    default:
      printf("Illegal tag 0x%02x\n", tag);
      return;
    }
  }
}


x86 assembly (clang, -O0):
<parse_edlf>:
push   %rbp
mov    %rsp,%rbp
sub    $0x30,%rsp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %rdx,-0x18(%rbp)
mov    -0x8(%rbp),%rax
mov    %rax,-0x20(%rbp)
mov    -0x8(%rbp),%rax
movslq -0xc(%rbp),%rcx
add    %rcx,%rax
mov    %rax,-0x28(%rbp)
movw   $0x0,-0x2a(%rbp)
mov    -0x20(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x20(%rbp)
movzbl (%rax),%eax
cmp    $0xa,%eax
je     1170 <parse_edlf+0x50>
jmp    1329 <parse_edlf+0x209>
jmp    1175 <parse_edlf+0x55>
mov    -0x20(%rbp),%rax
mov    -0x8(%rbp),%rcx
sub    %rcx,%rax
add    $0x1,%rax
mov    $0x5,%ecx
cqto
idiv   %rcx
cmp    $0x0,%rdx
jne    11a4 <parse_edlf+0x84>
mov    -0x20(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x20(%rbp)
mov    -0x20(%rbp),%rax
cmp    -0x28(%rbp),%rax
jb     11b7 <parse_edlf+0x97>
jmp    1329 <parse_edlf+0x209>
mov    -0x20(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x20(%rbp)
mov    (%rax),%al
mov    %al,-0x2b(%rbp)
mov    -0x20(%rbp),%rax
mov    -0x8(%rbp),%rcx
sub    %rcx,%rax
add    $0x1,%rax
mov    $0x5,%ecx
cqto
idiv   %rcx
cmp    $0x0,%rdx
jne    11fa <parse_edlf+0xda>
mov    -0x20(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x20(%rbp)
mov    -0x20(%rbp),%rax
cmp    -0x28(%rbp),%rax
jb     120d <parse_edlf+0xed>
jmp    1329 <parse_edlf+0x209>
mov    -0x20(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x20(%rbp)
mov    (%rax),%al
mov    %al,-0x2c(%rbp)
movzbl -0x2b(%rbp),%eax
mov    %eax,-0x30(%rbp)
sub    $0x7,%eax
je     127e <parse_edlf+0x15e>
jmp    1236 <parse_edlf+0x116>
mov    -0x30(%rbp),%eax
sub    $0x55,%eax
je     12dd <parse_edlf+0x1bd>
jmp    1247 <parse_edlf+0x127>
mov    -0x30(%rbp),%eax
sub    $0x5a,%eax
je     12b9 <parse_edlf+0x199>
jmp    1258 <parse_edlf+0x138>
mov    -0x30(%rbp),%eax
sub    $0xa5,%eax
je     12a1 <parse_edlf+0x181>
jmp    126b <parse_edlf+0x14b>
mov    -0x30(%rbp),%eax
sub    $0xaa,%eax
je     1283 <parse_edlf+0x163>
jmp    130f <parse_edlf+0x1ef>
jmp    1329 <parse_edlf+0x209>
movzwl -0x2a(%rbp),%eax
and    $0xff,%eax
movzbl -0x2c(%rbp),%ecx
movzwl %cx,%ecx
shl    $0x8,%ecx
or     %ecx,%eax
mov    %ax,-0x2a(%rbp)
jmp    1324 <parse_edlf+0x204>
movzwl -0x2a(%rbp),%eax
and    $0xff00,%eax
movzbl -0x2c(%rbp),%ecx
or     %ecx,%eax
mov    %ax,-0x2a(%rbp)
jmp    1324 <parse_edlf+0x204>
mov    -0x18(%rbp),%rdi
mov    -0x2a(%rbp),%ax
movzwl %ax,%esi
movzbl -0x2c(%rbp),%edx
call   1040 <image_data_set@plt>
movzwl -0x2a(%rbp),%eax
add    $0x1,%eax
mov    %ax,-0x2a(%rbp)
jmp    1324 <parse_edlf+0x204>
movzbl -0x2c(%rbp),%eax
cmp    $0x7,%eax
je     12ff <parse_edlf+0x1df>
lea    0xd0f(%rip),%rdi
movzbl -0x2c(%rbp),%esi
call   1030 <printf@plt>
jmp    1329 <parse_edlf+0x209>
movzwl -0x2a(%rbp),%eax
add    $0x1,%eax
mov    %ax,-0x2a(%rbp)
jmp    1324 <parse_edlf+0x204>
lea    0xd09(%rip),%rdi
movzbl -0x2b(%rbp),%esi
call   1030 <printf@plt>
jmp    1329 <parse_edlf+0x209>
jmp    1175 <parse_edlf+0x55>
add    $0x30,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<parse_edlf>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
push   %rax
cmpb   $0xa,(%rdi)
jne    1296 <parse_edlf+0x176>
mov    %rdx,%r13
movslq %esi,%rbx
add    %rdi,%rbx
mov    $0x1,%ebp
sub    %rdi,%rbp
lea    0x1(%rdi),%rax
lea    (%rdi,%rbp,1),%rcx
add    $0x1,%rcx
movabs $0xcccccccccccccccd,%rdx
cc cc cc
imul   %rdx,%rcx
movabs $0x1999999999999999,%rsi
99 99 19
add    %rsi,%rcx
add    $0x2,%rdi
movabs $0x3333333333333333,%r15
33 33 33
cmp    %r15,%rcx
cmovae %rax,%rdi
cmp    %rbx,%rdi
jae    1296 <parse_edlf+0x176>
xor    %r14d,%r14d
jmp    11a0 <parse_edlf+0x80>
nop
add    $0x1,%r12
mov    %r12,%rdi
cmp    %rbx,%r12
jae    1296 <parse_edlf+0x176>
lea    (%rdi,%rbp,1),%rax
add    $0x1,%rax
imul   %rdx,%rax
add    %rsi,%rax
cmp    %r15,%rax
jb     11d0 <parse_edlf+0xb0>
lea    0x1(%rdi),%r12
cmp    %rbx,%r12
jb     11dd <parse_edlf+0xbd>
jmp    1296 <parse_edlf+0x176>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
lea    0x2(%rdi),%r12
cmp    %rbx,%r12
jae    1296 <parse_edlf+0x176>
movzbl (%rdi),%ecx
movzbl (%r12),%eax
cmp    $0x6,%cl
jle    1230 <parse_edlf+0x110>
cmp    $0x55,%cl
je     1250 <parse_edlf+0x130>
cmp    $0x5a,%cl
jne    1291 <parse_edlf+0x171>
movzwl %r14w,%esi
movzwl %ax,%edx
mov    %r13,%rdi
call   1040 <image_data_set@plt>
movabs $0x1999999999999999,%rsi
99 99 19
movabs $0xcccccccccccccccd,%rdx
cc cc cc
add    $0x1,%r14d
jmp    1270 <parse_edlf+0x150>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
cmp    $0xa5,%cl
je     1260 <parse_edlf+0x140>
cmp    $0xaa,%cl
jne    12b1 <parse_edlf+0x191>
movzbl %r14b,%ecx
movzwl %ax,%r14d
shl    $0x8,%r14d
or     %ecx,%r14d
jmp    1270 <parse_edlf+0x150>
nopl   0x0(%rax,%rax,1)
cmp    $0x7,%al
jne    12a5 <parse_edlf+0x185>
add    $0x1,%r14d
jmp    1270 <parse_edlf+0x150>
nopw   0x0(%rax,%rax,1)
and    $0xffffff00,%r14d
movzwl %ax,%eax
or     %r14d,%eax
mov    %eax,%r14d
lea    (%r12,%rbp,1),%rax
add    $0x1,%rax
imul   %rdx,%rax
add    %rsi,%rax
cmp    %r15,%rax
jae    1190 <parse_edlf+0x70>
add    $0x2,%r12
jmp    1194 <parse_edlf+0x74>
cmp    $0x7,%cl
jne    12b1 <parse_edlf+0x191>
add    $0x8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
movzwl %ax,%esi
lea    0xd51(%rip),%rdi
jmp    12bb <parse_edlf+0x19b>
movzbl %cl,%esi
lea    0xd64(%rip),%rdi
add    $0x8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
jmp    1030 <printf@plt>

LLVM IR (-O0):
%struct.image_data = type { i32 }
@.str = [31 x i8] c"Invalid NULL data byte 0x%02x\0A\00"
@.str.1 = [20 x i8] c"Illegal tag 0x%02x\0A\00"
define void @parse_edlf(i8* %0, i32 %1, %struct.image_data* %2) {
%4 = alloca i8*
%5 = alloca i32
%6 = alloca %struct.image_data*
%7 = alloca i8*
%8 = alloca i8*
%9 = alloca i16
%10 = alloca i8
%11 = alloca i8
store i8* %0, i8** %4
store i32 %1, i32* %5
store %struct.image_data* %2, %struct.image_data** %6
%12 = load i8*, i8** %4
store i8* %12, i8** %7
%13 = load i8*, i8** %4
%14 = load i32, i32* %5
%15 = sext i32 %14 to i64
%16 = getelementptr inbounds i8, i8* %13, i64 %15
store i8* %16, i8** %8
store i16 0, i16* %9
%17 = load i8*, i8** %7
%18 = getelementptr inbounds i8, i8* %17, i32 1
store i8* %18, i8** %7
%19 = load i8, i8* %17
%20 = zext i8 %19 to i32
%21 = icmp ne i32 %20, 10
br i1 %21, label %22, label %23
22: ; preds = %3
br label %111
23: ; preds = %3
br label %24
24: ; preds = %23, %110
%25 = load i8*, i8** %7
%26 = load i8*, i8** %4
%27 = ptrtoint i8* %25 to i64
%28 = ptrtoint i8* %26 to i64
%29 = sub i64 %27, %28
%30 = add nsw i64 %29, 1
%31 = srem i64 %30, 5
%32 = icmp eq i64 %31, 0
br i1 %32, label %33, label %36
33: ; preds = %24
%34 = load i8*, i8** %7
%35 = getelementptr inbounds i8, i8* %34, i32 1
store i8* %35, i8** %7
br label %36
36: ; preds = %33, %24
%37 = load i8*, i8** %7
%38 = load i8*, i8** %8
%39 = icmp uge i8* %37, %38
br i1 %39, label %40, label %41
40: ; preds = %36
br label %111
41: ; preds = %36
%42 = load i8*, i8** %7
%43 = getelementptr inbounds i8, i8* %42, i32 1
store i8* %43, i8** %7
%44 = load i8, i8* %42
store i8 %44, i8* %10
%45 = load i8*, i8** %7
%46 = load i8*, i8** %4
%47 = ptrtoint i8* %45 to i64
%48 = ptrtoint i8* %46 to i64
%49 = sub i64 %47, %48
%50 = add nsw i64 %49, 1
%51 = srem i64 %50, 5
%52 = icmp eq i64 %51, 0
br i1 %52, label %53, label %56
53: ; preds = %41
%54 = load i8*, i8** %7
%55 = getelementptr inbounds i8, i8* %54, i32 1
store i8* %55, i8** %7
br label %56
56: ; preds = %53, %41
%57 = load i8*, i8** %7
%58 = load i8*, i8** %8
%59 = icmp uge i8* %57, %58
br i1 %59, label %60, label %61
60: ; preds = %56
br label %111
61: ; preds = %56
%62 = load i8*, i8** %7
%63 = getelementptr inbounds i8, i8* %62, i32 1
store i8* %63, i8** %7
%64 = load i8, i8* %62
store i8 %64, i8* %11
%65 = load i8, i8* %10
%66 = zext i8 %65 to i32
switch i32 %66, label %107 [
i32 7, label %67
i32 170, label %68
i32 165, label %78
i32 90, label %86
i32 85, label %95
]
67: ; preds = %61
br label %111
68: ; preds = %61
%69 = load i16, i16* %9
%70 = zext i16 %69 to i32
%71 = and i32 %70, 255
%72 = load i8, i8* %11
%73 = zext i8 %72 to i16
%74 = zext i16 %73 to i32
%75 = shl i32 %74, 8
%76 = or i32 %71, %75
%77 = trunc i32 %76 to i16
store i16 %77, i16* %9
br label %110
78: ; preds = %61
%79 = load i16, i16* %9
%80 = zext i16 %79 to i32
%81 = and i32 %80, 65280
%82 = load i8, i8* %11
%83 = zext i8 %82 to i32
%84 = or i32 %81, %83
%85 = trunc i32 %84 to i16
store i16 %85, i16* %9
br label %110
86: ; preds = %61
%87 = load %struct.image_data*, %struct.image_data** %6
%88 = load i16, i16* %9
%89 = load i8, i8* %11
%90 = call i32 @image_data_set(%struct.image_data* %87, i16 zeroext %88, i8 zeroext %89)
%91 = load i16, i16* %9
%92 = zext i16 %91 to i32
%93 = add nsw i32 %92, 1
%94 = trunc i32 %93 to i16
store i16 %94, i16* %9
br label %110
95: ; preds = %61
%96 = load i8, i8* %11
%97 = zext i8 %96 to i32
%98 = icmp ne i32 %97, 7
br i1 %98, label %99, label %102
99: ; preds = %95
%100 = load i8, i8* %11
%101 = call i32 @printf(i8* getelementptr inbounds ([31 x i8], [31 x i8]* @.str, i64 0, i64 0), i8 zeroext %100)
br label %111
102: ; preds = %95
%103 = load i16, i16* %9
%104 = zext i16 %103 to i32
%105 = add nsw i32 %104, 1
%106 = trunc i32 %105 to i16
store i16 %106, i16* %9
br label %110
107: ; preds = %61
%108 = load i8, i8* %10
%109 = call i32 @printf(i8* getelementptr inbounds ([20 x i8], [20 x i8]* @.str.1, i64 0, i64 0), i8 zeroext %108)
br label %111
110: ; preds = %102, %86, %78, %68
br label %24
111: ; preds = %107, %99, %67, %60, %40, %22
ret void
}

LLVM IR (-O2):
%struct.image_data = type { i32 }
@.str = [31 x i8] c"Invalid NULL data byte 0x%02x\0A\00"
@.str.1 = [20 x i8] c"Illegal tag 0x%02x\0A\00"
define void @parse_edlf(i8* %0, i32 %1, %struct.image_data* %2) {
%4 = sext i32 %1 to i64
%5 = getelementptr inbounds i8, i8* %0, i64 %4
%6 = load i8, i8* %0
%7 = icmp eq i8 %6, 10
br i1 %7, label %8, label %63
8: ; preds = %3
%9 = ptrtoint i8* %0 to i64
%10 = sub i64 1, %9
%11 = getelementptr inbounds i8, i8* %0, i64 1
%12 = ptrtoint i8* %11 to i64
%13 = add i64 %10, %12
%14 = srem i64 %13, 5
%15 = icmp eq i64 %14, 0
%16 = getelementptr inbounds i8, i8* %0, i64 2
%17 = select i1 %15, i8* %16, i8* %11
%18 = icmp ult i8* %17, %5
br i1 %18, label %19, label %63
19: ; preds = %8, %53
%20 = phi i8* [ %61, %53 ], [ %17, %8 ]
%21 = phi i16 [ %54, %53 ], [ 0, %8 ]
%22 = getelementptr inbounds i8, i8* %20, i64 1
%23 = load i8, i8* %20
%24 = ptrtoint i8* %22 to i64
%25 = add i64 %10, %24
%26 = srem i64 %25, 5
%27 = icmp eq i64 %26, 0
%28 = getelementptr inbounds i8, i8* %20, i64 2
%29 = select i1 %27, i8* %28, i8* %22
%30 = icmp ult i8* %29, %5
br i1 %30, label %31, label %63
31: ; preds = %19
%32 = load i8, i8* %29
switch i8 %23, label %51 [
i8 7, label %63
i8 -86, label %33
i8 -91, label %38
i8 90, label %42
i8 85, label %45
]
33: ; preds = %31
%34 = and i16 %21, 255
%35 = zext i8 %32 to i16
%36 = shl nuw i16 %35, 8
%37 = or i16 %36, %34
br label %53
38: ; preds = %31
%39 = and i16 %21, -256
%40 = zext i8 %32 to i16
%41 = or i16 %39, %40
br label %53
42: ; preds = %31
%43 = tail call i32 @image_data_set(%struct.image_data* %2, i16 zeroext %21, i8 zeroext %32)
%44 = add i16 %21, 1
br label %53
45: ; preds = %31
%46 = icmp eq i8 %32, 7
br i1 %46, label %49, label %47
47: ; preds = %45
%48 = tail call i32 @printf(i8* getelementptr inbounds ([31 x i8], [31 x i8]* @.str, i64 0, i64 0), i8 zeroext %32)
br label %63
49: ; preds = %45
%50 = add i16 %21, 1
br label %53
51: ; preds = %31
%52 = tail call i32 @printf(i8* getelementptr inbounds ([20 x i8], [20 x i8]* @.str.1, i64 0, i64 0), i8 zeroext %23)
br label %63
53: ; preds = %33, %38, %42, %49
%54 = phi i16 [ %50, %49 ], [ %44, %42 ], [ %41, %38 ], [ %37, %33 ]
%55 = getelementptr inbounds i8, i8* %29, i64 1
%56 = ptrtoint i8* %55 to i64
%57 = add i64 %10, %56
%58 = srem i64 %57, 5
%59 = icmp eq i64 %58, 0
%60 = getelementptr inbounds i8, i8* %29, i64 2
%61 = select i1 %59, i8* %60, i8* %55
%62 = icmp ult i8* %61, %5
br i1 %62, label %19, label %63
63: ; preds = %53, %19, %31, %8, %47, %51, %3
ret void
}