#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 uint8_t;

/* Variables and functions */
int DISK_GetByte(unsigned int);
int /*<<< orphan*/ sprintf(char *, char *, ...);
const char *DISK_decodeDisasm(uint8_t *table[256], unsigned int address,
                              int *count, int realLength) {
  static char temporaryBuffer[2048];
  char sprintBuffer[256];
  uint8_t byte = DISK_GetByte(address);
  if (byte > realLength) {
    sprintf(temporaryBuffer, "UNKNOWN OPCODE");
    return temporaryBuffer;
  } else {
    const char *mnemonic = table[byte];
    const char *sPtr = mnemonic;
    char *dPtr = temporaryBuffer;
    int counting = 0;
    int doingDecode = 0;
    if (sPtr == NULL) {
      sprintf(temporaryBuffer, "UNKNOWN OPCODE");
      return temporaryBuffer;
    }
    while (*sPtr) {
      if (!doingDecode) {
        if (*sPtr == '%') {
          doingDecode = 1;
          if (*(sPtr + 1) == '$')
            sPtr++;
        } else {
          *dPtr++ = *sPtr;
        }
      } else {
        char *tPtr = sprintBuffer;
        int negOffs = 1;
        if (*sPtr == '-') {
          sPtr++;
          negOffs = -1;
        }
        int offset = (*sPtr - '0') * negOffs;
        sprintf(sprintBuffer, "%02X", DISK_GetByte(address + offset));
        while (*tPtr) {
          *dPtr++ = *tPtr++;
        }
        doingDecode = 0;
        counting++;
      }
      sPtr++;
    }
    *dPtr = 0;
    *count = counting;
  }
  return temporaryBuffer;
}


x86 assembly (clang, -O0):
<DISK_decodeDisasm>:
push   %rbp
mov    %rsp,%rbp
sub    $0x170,%rsp
mov    %rdi,-0x10(%rbp)
mov    %esi,-0x14(%rbp)
mov    %rdx,-0x20(%rbp)
mov    %ecx,-0x24(%rbp)
mov    -0x14(%rbp),%edi
call   1040 <DISK_GetByte@plt>
mov    %eax,-0x134(%rbp)
mov    -0x134(%rbp),%eax
cmp    -0x24(%rbp),%eax
jle    117b <DISK_decodeDisasm+0x5b>
lea    0x2ee3(%rip),%rdi
lea    0xe9c(%rip),%rsi
mov    $0x0,%al
call   1030 <sprintf@plt>
lea    0x2ece(%rip),%rax
mov    %rax,-0x8(%rbp)
jmp    13ab <DISK_decodeDisasm+0x28b>
mov    -0x10(%rbp),%rax
movslq -0x134(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    %rax,-0x140(%rbp)
mov    -0x140(%rbp),%rax
mov    %rax,-0x148(%rbp)
lea    0x2e9a(%rip),%rax
mov    %rax,-0x150(%rbp)
movl   $0x0,-0x154(%rbp)
movl   $0x0,-0x158(%rbp)
cmpq   $0x0,-0x148(%rbp)
jne    11f4 <DISK_decodeDisasm+0xd4>
lea    0x2e6a(%rip),%rdi
lea    0xe23(%rip),%rsi
mov    $0x0,%al
call   1030 <sprintf@plt>
lea    0x2e55(%rip),%rax
mov    %rax,-0x8(%rbp)
jmp    13ab <DISK_decodeDisasm+0x28b>
jmp    11f9 <DISK_decodeDisasm+0xd9>
mov    -0x148(%rbp),%rax
cmpb   $0x0,(%rax)
je     138a <DISK_decodeDisasm+0x26a>
cmpl   $0x0,-0x158(%rbp)
jne    1283 <DISK_decodeDisasm+0x163>
mov    -0x148(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x25,%eax
jne    125e <DISK_decodeDisasm+0x13e>
movl   $0x1,-0x158(%rbp)
mov    -0x148(%rbp),%rax
movsbl 0x1(%rax),%eax
cmp    $0x24,%eax
jne    1259 <DISK_decodeDisasm+0x139>
mov    -0x148(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x148(%rbp)
jmp    127e <DISK_decodeDisasm+0x15e>
mov    -0x148(%rbp),%rax
mov    (%rax),%cl
mov    -0x150(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x150(%rbp)
mov    %cl,(%rax)
jmp    1373 <DISK_decodeDisasm+0x253>
lea    -0x130(%rbp),%rax
mov    %rax,-0x160(%rbp)
movl   $0x1,-0x164(%rbp)
mov    -0x148(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x2d,%eax
jne    12ca <DISK_decodeDisasm+0x1aa>
mov    -0x148(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x148(%rbp)
movl   $0xffffffff,-0x164(%rbp)
ff ff ff
mov    -0x148(%rbp),%rax
movsbl (%rax),%eax
sub    $0x30,%eax
imul   -0x164(%rbp),%eax
mov    %eax,-0x168(%rbp)
lea    -0x130(%rbp),%rax
mov    %rax,-0x170(%rbp)
mov    -0x14(%rbp),%edi
add    -0x168(%rbp),%edi
call   1040 <DISK_GetByte@plt>
mov    -0x170(%rbp),%rdi
mov    %eax,%edx
lea    0xcff(%rip),%rsi
mov    $0x0,%al
call   1030 <sprintf@plt>
mov    -0x160(%rbp),%rax
cmpb   $0x0,(%rax)
je     135a <DISK_decodeDisasm+0x23a>
mov    -0x160(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x160(%rbp)
mov    (%rax),%cl
mov    -0x150(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x150(%rbp)
mov    %cl,(%rax)
jmp    1317 <DISK_decodeDisasm+0x1f7>
movl   $0x0,-0x158(%rbp)
mov    -0x154(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x154(%rbp)
mov    -0x148(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x148(%rbp)
jmp    11f9 <DISK_decodeDisasm+0xd9>
mov    -0x150(%rbp),%rax
movb   $0x0,(%rax)
mov    -0x154(%rbp),%ecx
mov    -0x20(%rbp),%rax
mov    %ecx,(%rax)
lea    0x2c99(%rip),%rax
mov    %rax,-0x8(%rbp)
mov    -0x8(%rbp),%rax
add    $0x170,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<DISK_decodeDisasm>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x118,%rsp
mov    %ecx,%ebp
mov    %rdx,%r14
mov    %esi,%r12d
mov    %rdi,%rbx
mov    %esi,%edi
call   1040 <DISK_GetByte@plt>
cmp    %ebp,%eax
jg     1235 <DISK_decodeDisasm+0x115>
cltq
mov    (%rbx,%rax,8),%rbp
test   %rbp,%rbp
je     1235 <DISK_decodeDisasm+0x115>
mov    %r14,0x8(%rsp)
mov    0x0(%rbp),%al
test   %al,%al
je     1259 <DISK_decodeDisasm+0x139>
lea    0x2ecf(%rip),%rbx
lea    0x10(%rsp),%r13
xor    %ecx,%ecx
xor    %r14d,%r14d
jmp    1198 <DISK_decodeDisasm+0x78>
nopl   (%rax)
add    %r15,%rbp
add    $0x1,%r14d
xor    %ecx,%ecx
mov    0x1(%rbp),%al
add    $0x1,%rbp
test   %al,%al
je     1263 <DISK_decodeDisasm+0x143>
test   %ecx,%ecx
je     1210 <DISK_decodeDisasm+0xf0>
xor    %r15d,%r15d
cmp    $0x2d,%al
sete   %r15b
movsbl 0x0(%rbp,%r15,1),%edi
mov    $0x30,%ecx
sub    %edi,%ecx
add    $0xffffffd0,%edi
cmp    $0x2d,%al
cmove  %ecx,%edi
add    %r12d,%edi
call   1040 <DISK_GetByte@plt>
mov    %r13,%rdi
lea    0xe43(%rip),%rsi
mov    %eax,%edx
xor    %eax,%eax
call   1030 <sprintf@plt>
mov    0x10(%rsp),%al
test   %al,%al
je     1180 <DISK_decodeDisasm+0x60>
lea    0x11(%rsp),%rcx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    %al,(%rbx)
add    $0x1,%rbx
movzbl (%rcx),%eax
add    $0x1,%rcx
test   %al,%al
jne    11f0 <DISK_decodeDisasm+0xd0>
jmp    1180 <DISK_decodeDisasm+0x60>
cs nopw 0x0(%rax,%rax,1)
cmp    $0x25,%al
jne    122a <DISK_decodeDisasm+0x10a>
cmpb   $0x24,0x1(%rbp)
lea    0x1(%rbp),%rax
cmove  %rax,%rbp
mov    $0x1,%ecx
jmp    1189 <DISK_decodeDisasm+0x69>
mov    %al,(%rbx)
add    $0x1,%rbx
jmp    1187 <DISK_decodeDisasm+0x67>
movabs $0x45444f43504f20,%rax
mov    %rax,0x2e01(%rip)
movabs $0x204e574f4e4b4e55,%rax
57 4e 20
mov    %rax,0x2de9(%rip)
jmp    126e <DISK_decodeDisasm+0x14e>
xor    %r14d,%r14d
lea    0x2ddd(%rip),%rbx
movb   $0x0,(%rbx)
mov    0x8(%rsp),%rax
mov    %r14d,(%rax)
lea    0x2dcb(%rip),%rax
add    $0x118,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
@DISK_decodeDisasm.temporaryBuffer = internal global [2048 x i8] zeroinitializer
@.str = [15 x i8] c"UNKNOWN OPCODE\00"
@.str.1 = [5 x i8] c"%02X\00"
define i8* @DISK_decodeDisasm(i32** %0, i32 %1, i32* %2, i32 %3) {
%5 = alloca i8*
%6 = alloca i32**
%7 = alloca i32
%8 = alloca i32*
%9 = alloca i32
%10 = alloca [256 x i8]
%11 = alloca i32
%12 = alloca i8*
%13 = alloca i8*
%14 = alloca i8*
%15 = alloca i32
%16 = alloca i32
%17 = alloca i8*
%18 = alloca i32
%19 = alloca i32
store i32** %0, i32*** %6
store i32 %1, i32* %7
store i32* %2, i32** %8
store i32 %3, i32* %9
%20 = load i32, i32* %7
%21 = call i32 @DISK_GetByte(i32 %20)
store i32 %21, i32* %11
%22 = load i32, i32* %11
%23 = load i32, i32* %9
%24 = icmp sgt i32 %22, %23
br i1 %24, label %25, label %27
25: ; preds = %4
%26 = call i32 (i8*, i8*, ...) @sprintf(i8* getelementptr inbounds ([2048 x i8], [2048 x i8]* @DISK_decodeDisasm.temporaryBuffer, i64 0, i64 0), i8* getelementptr inbounds ([15 x i8], [15 x i8]* @.str, i64 0, i64 0))
store i8* getelementptr inbounds ([2048 x i8], [2048 x i8]* @DISK_decodeDisasm.temporaryBuffer, i64 0, i64 0), i8** %5
br label %111
27: ; preds = %4
%28 = load i32**, i32*** %6
%29 = load i32, i32* %11
%30 = sext i32 %29 to i64
%31 = getelementptr inbounds i32*, i32** %28, i64 %30
%32 = load i32*, i32** %31
%33 = bitcast i32* %32 to i8*
store i8* %33, i8** %12
%34 = load i8*, i8** %12
store i8* %34, i8** %13
store i8* getelementptr inbounds ([2048 x i8], [2048 x i8]* @DISK_decodeDisasm.temporaryBuffer, i64 0, i64 0), i8** %14
store i32 0, i32* %15
store i32 0, i32* %16
%35 = load i8*, i8** %13
%36 = icmp eq i8* %35, null
br i1 %36, label %37, label %39
37: ; preds = %27
%38 = call i32 (i8*, i8*, ...) @sprintf(i8* getelementptr inbounds ([2048 x i8], [2048 x i8]* @DISK_decodeDisasm.temporaryBuffer, i64 0, i64 0), i8* getelementptr inbounds ([15 x i8], [15 x i8]* @.str, i64 0, i64 0))
store i8* getelementptr inbounds ([2048 x i8], [2048 x i8]* @DISK_decodeDisasm.temporaryBuffer, i64 0, i64 0), i8** %5
br label %111
39: ; preds = %27
br label %40
40: ; preds = %103, %39
%41 = load i8*, i8** %13
%42 = load i8, i8* %41
%43 = icmp ne i8 %42, 0
br i1 %43, label %44, label %106
44: ; preds = %40
%45 = load i32, i32* %16
%46 = icmp ne i32 %45, 0
br i1 %46, label %68, label %47
47: ; preds = %44
%48 = load i8*, i8** %13
%49 = load i8, i8* %48
%50 = sext i8 %49 to i32
%51 = icmp eq i32 %50, 37
br i1 %51, label %52, label %62
52: ; preds = %47
store i32 1, i32* %16
%53 = load i8*, i8** %13
%54 = getelementptr inbounds i8, i8* %53, i64 1
%55 = load i8, i8* %54
%56 = sext i8 %55 to i32
%57 = icmp eq i32 %56, 36
br i1 %57, label %58, label %61
58: ; preds = %52
%59 = load i8*, i8** %13
%60 = getelementptr inbounds i8, i8* %59, i32 1
store i8* %60, i8** %13
br label %61
61: ; preds = %58, %52
br label %67
62: ; preds = %47
%63 = load i8*, i8** %13
%64 = load i8, i8* %63
%65 = load i8*, i8** %14
%66 = getelementptr inbounds i8, i8* %65, i32 1
store i8* %66, i8** %14
store i8 %64, i8* %65
br label %67
67: ; preds = %62, %61
br label %103
68: ; preds = %44
%69 = getelementptr inbounds [256 x i8], [256 x i8]* %10, i64 0, i64 0
store i8* %69, i8** %17
store i32 1, i32* %18
%70 = load i8*, i8** %13
%71 = load i8, i8* %70
%72 = sext i8 %71 to i32
%73 = icmp eq i32 %72, 45
br i1 %73, label %74, label %77
74: ; preds = %68
%75 = load i8*, i8** %13
%76 = getelementptr inbounds i8, i8* %75, i32 1
store i8* %76, i8** %13
store i32 -1, i32* %18
br label %77
77: ; preds = %74, %68
%78 = load i8*, i8** %13
%79 = load i8, i8* %78
%80 = sext i8 %79 to i32
%81 = sub nsw i32 %80, 48
%82 = load i32, i32* %18
%83 = mul nsw i32 %81, %82
store i32 %83, i32* %19
%84 = getelementptr inbounds [256 x i8], [256 x i8]* %10, i64 0, i64 0
%85 = load i32, i32* %7
%86 = load i32, i32* %19
%87 = add i32 %85, %86
%88 = call i32 @DISK_GetByte(i32 %87)
%89 = call i32 (i8*, i8*, ...) @sprintf(i8* %84, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.1, i64 0, i64 0), i32 %88)
br label %90
90: ; preds = %94, %77
%91 = load i8*, i8** %17
%92 = load i8, i8* %91
%93 = icmp ne i8 %92, 0
br i1 %93, label %94, label %100
94: ; preds = %90
%95 = load i8*, i8** %17
%96 = getelementptr inbounds i8, i8* %95, i32 1
store i8* %96, i8** %17
%97 = load i8, i8* %95
%98 = load i8*, i8** %14
%99 = getelementptr inbounds i8, i8* %98, i32 1
store i8* %99, i8** %14
store i8 %97, i8* %98
br label %90
100: ; preds = %90
store i32 0, i32* %16
%101 = load i32, i32* %15
%102 = add nsw i32 %101, 1
store i32 %102, i32* %15
br label %103
103: ; preds = %100, %67
%104 = load i8*, i8** %13
%105 = getelementptr inbounds i8, i8* %104, i32 1
store i8* %105, i8** %13
br label %40
106: ; preds = %40
%107 = load i8*, i8** %14
store i8 0, i8* %107
%108 = load i32, i32* %15
%109 = load i32*, i32** %8
store i32 %108, i32* %109
br label %110
110: ; preds = %106
store i8* getelementptr inbounds ([2048 x i8], [2048 x i8]* @DISK_decodeDisasm.temporaryBuffer, i64 0, i64 0), i8** %5
br label %111
111: ; preds = %110, %37, %25
%112 = load i8*, i8** %5
ret i8* %112
}

LLVM IR (-O2):
@DISK_decodeDisasm.temporaryBuffer = internal global [2048 x i8] zeroinitializer
@.str = [15 x i8] c"UNKNOWN OPCODE\00"
@.str.1 = [5 x i8] c"%02X\00"
define i8* @DISK_decodeDisasm(i32** nocapture %0, i32 %1, i32* nocapture writeonly %2, i32 %3) {
%5 = alloca [256 x i8]
%6 = getelementptr inbounds [256 x i8], [256 x i8]* %5, i64 0, i64 0
%7 = tail call i32 @DISK_GetByte(i32 %1)
%8 = icmp sgt i32 %7, %3
br i1 %8, label %9, label %10
9: ; preds = %4
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 16 dereferenceable(15) getelementptr inbounds ([2048 x i8], [2048 x i8]* @DISK_decodeDisasm.temporaryBuffer, i64 0, i64 0), i8* align 1 dereferenceable(15) getelementptr inbounds ([15 x i8], [15 x i8]* @.str, i64 0, i64 0), i64 15, i1 false)
br label %72
10: ; preds = %4
%11 = sext i32 %7 to i64
%12 = getelementptr inbounds i32*, i32** %0, i64 %11
%13 = bitcast i32** %12 to i8**
%14 = load i8*, i8** %13
%15 = icmp eq i8* %14, null
br i1 %15, label %19, label %16
16: ; preds = %10
%17 = load i8, i8* %14
%18 = icmp eq i8 %17, 0
br i1 %18, label %69, label %20
19: ; preds = %10
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 16 dereferenceable(15) getelementptr inbounds ([2048 x i8], [2048 x i8]* @DISK_decodeDisasm.temporaryBuffer, i64 0, i64 0), i8* align 1 dereferenceable(15) getelementptr inbounds ([15 x i8], [15 x i8]* @.str, i64 0, i64 0), i64 15, i1 false)
br label %72
20: ; preds = %16, %61
%21 = phi i8 [ %67, %61 ], [ %17, %16 ]
%22 = phi i32 [ %65, %61 ], [ 0, %16 ]
%23 = phi i32 [ %64, %61 ], [ 0, %16 ]
%24 = phi i8* [ %63, %61 ], [ getelementptr inbounds ([2048 x i8], [2048 x i8]* @DISK_decodeDisasm.temporaryBuffer, i64 0, i64 0), %16 ]
%25 = phi i8* [ %66, %61 ], [ %14, %16 ]
%26 = icmp eq i32 %22, 0
br i1 %26, label %27, label %36
27: ; preds = %20
%28 = icmp eq i8 %21, 37
br i1 %28, label %29, label %34
29: ; preds = %27
%30 = getelementptr inbounds i8, i8* %25, i64 1
%31 = load i8, i8* %30
%32 = icmp eq i8 %31, 36
%33 = select i1 %32, i8* %30, i8* %25
br label %61
34: ; preds = %27
%35 = getelementptr inbounds i8, i8* %24, i64 1
store i8 %21, i8* %24
br label %61
36: ; preds = %20
%37 = icmp eq i8 %21, 45
%38 = zext i1 %37 to i64
%39 = getelementptr i8, i8* %25, i64 %38
%40 = load i8, i8* %39
%41 = sext i8 %40 to i32
%42 = add nsw i32 %41, -48
%43 = sub nsw i32 48, %41
%44 = select i1 %37, i32 %43, i32 %42
%45 = add i32 %44, %1
%46 = tail call i32 @DISK_GetByte(i32 %45)
%47 = call i32 (i8*, i8*, ...) @sprintf(i8* %6, i8* dereferenceable(1) getelementptr inbounds ([5 x i8], [5 x i8]* @.str.1, i64 0, i64 0), i32 %46)
%48 = load i8, i8* %6
%49 = icmp eq i8 %48, 0
br i1 %49, label %58, label %50
50: ; preds = %36, %50
%51 = phi i8 [ %56, %50 ], [ %48, %36 ]
%52 = phi i8* [ %54, %50 ], [ %6, %36 ]
%53 = phi i8* [ %55, %50 ], [ %24, %36 ]
%54 = getelementptr inbounds i8, i8* %52, i64 1
%55 = getelementptr inbounds i8, i8* %53, i64 1
store i8 %51, i8* %53
%56 = load i8, i8* %54
%57 = icmp eq i8 %56, 0
br i1 %57, label %58, label %50
58: ; preds = %50, %36
%59 = phi i8* [ %24, %36 ], [ %55, %50 ]
%60 = add nsw i32 %23, 1
br label %61
61: ; preds = %29, %34, %58
%62 = phi i8* [ %39, %58 ], [ %25, %34 ], [ %33, %29 ]
%63 = phi i8* [ %59, %58 ], [ %35, %34 ], [ %24, %29 ]
%64 = phi i32 [ %60, %58 ], [ %23, %34 ], [ %23, %29 ]
%65 = phi i32 [ 0, %58 ], [ 0, %34 ], [ 1, %29 ]
%66 = getelementptr inbounds i8, i8* %62, i64 1
%67 = load i8, i8* %66
%68 = icmp eq i8 %67, 0
br i1 %68, label %69, label %20
69: ; preds = %61, %16
%70 = phi i8* [ getelementptr inbounds ([2048 x i8], [2048 x i8]* @DISK_decodeDisasm.temporaryBuffer, i64 0, i64 0), %16 ], [ %63, %61 ]
%71 = phi i32 [ 0, %16 ], [ %64, %61 ]
store i8 0, i8* %70
store i32 %71, i32* %2
br label %72
72: ; preds = %19, %69, %9
ret i8* getelementptr inbounds ([2048 x i8], [2048 x i8]* @DISK_decodeDisasm.temporaryBuffer, i64 0, i64 0)
}