#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 GetUtf8ByteNumForWord(unsigned char);
unsigned short SearchCodeTable(unsigned short);
int /*<<< orphan*/ memcpy(unsigned short *, char *, int);
int /*<<< orphan*/ printf(char *);
void Utf8ToGb2312(const char *utf8, int len, unsigned short int *gbArray) {
  int k = 0;
  int byteCount = 0;
  int i = 0;
  int j = 0;
  char temp[10];
  unsigned short int unicodeKey = 0;
  unsigned short int gbKey = 0;
  while (i < len) {
    switch (GetUtf8ByteNumForWord((unsigned char)utf8[i])) {
    case 0:
      temp[j] = utf8[i];
      byteCount = 1;
      break;
    case 2:
      temp[j] = utf8[i];
      temp[j + 1] = utf8[i + 1];
      byteCount = 2;
      break;
    case 3:
      temp[j + 1] = ((utf8[i] & 0x0F) << 4) | ((utf8[i + 1] >> 2) & 0x0F);
      temp[j] = ((utf8[i + 1] & 0x03) << 6) + (utf8[i + 2] & 0x3F);
      memcpy(&unicodeKey, (temp + j), 2);
      gbKey = SearchCodeTable(unicodeKey);
      gbArray[k++] = gbKey;
      byteCount = 3;
      break;
    case 4:
      byteCount = 4;
      break;
    case 5:
      byteCount = 5;
      break;
    case 6:
      byteCount = 6;
      break;
    default:
      printf("the len is more than 6\n");
      break;
    }
    i += byteCount;
    if (byteCount == 1) {
      j++;
    } else {
      j += 2;
    }
  }
}


x86 assembly (clang, -O0):
<Utf8ToGb2312>:
push   %rbp
mov    %rsp,%rbp
sub    $0x40,%rsp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %rdx,-0x18(%rbp)
movl   $0x0,-0x1c(%rbp)
movl   $0x0,-0x20(%rbp)
movl   $0x0,-0x24(%rbp)
movl   $0x0,-0x28(%rbp)
movw   $0x0,-0x34(%rbp)
movw   $0x0,-0x36(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1330 <Utf8ToGb2312+0x1f0>
mov    -0x8(%rbp),%rax
movslq -0x24(%rbp),%rcx
movzbl (%rax,%rcx,1),%edi
call   1040 <GetUtf8ByteNumForWord@plt>
mov    %eax,%ecx
mov    %rcx,-0x40(%rbp)
sub    $0x6,%eax
ja     12f5 <Utf8ToGb2312+0x1b5>
mov    -0x40(%rbp),%rax
lea    0xe4e(%rip),%rcx
movslq (%rcx,%rax,4),%rax
add    %rcx,%rax
jmp    *%rax
mov    -0x8(%rbp),%rax
movslq -0x24(%rbp),%rcx
mov    (%rax,%rcx,1),%cl
movslq -0x28(%rbp),%rax
mov    %cl,-0x32(%rbp,%rax,1)
movl   $0x1,-0x20(%rbp)
jmp    1301 <Utf8ToGb2312+0x1c1>
mov    -0x8(%rbp),%rax
movslq -0x24(%rbp),%rcx
mov    (%rax,%rcx,1),%cl
movslq -0x28(%rbp),%rax
mov    %cl,-0x32(%rbp,%rax,1)
mov    -0x8(%rbp),%rax
mov    -0x24(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,1),%cl
mov    -0x28(%rbp),%eax
add    $0x1,%eax
cltq
mov    %cl,-0x32(%rbp,%rax,1)
movl   $0x2,-0x20(%rbp)
jmp    1301 <Utf8ToGb2312+0x1c1>
mov    -0x8(%rbp),%rax
movslq -0x24(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
and    $0xf,%eax
shl    $0x4,%eax
mov    -0x8(%rbp),%rcx
mov    -0x24(%rbp),%edx
add    $0x1,%edx
movslq %edx,%rdx
movsbl (%rcx,%rdx,1),%ecx
sar    $0x2,%ecx
and    $0xf,%ecx
or     %ecx,%eax
mov    %al,%cl
mov    -0x28(%rbp),%eax
add    $0x1,%eax
cltq
mov    %cl,-0x32(%rbp,%rax,1)
mov    -0x8(%rbp),%rax
mov    -0x24(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsbl (%rax,%rcx,1),%eax
and    $0x3,%eax
shl    $0x6,%eax
mov    -0x8(%rbp),%rcx
mov    -0x24(%rbp),%edx
add    $0x2,%edx
movslq %edx,%rdx
movsbl (%rcx,%rdx,1),%ecx
and    $0x3f,%ecx
add    %ecx,%eax
mov    %al,%cl
movslq -0x28(%rbp),%rax
mov    %cl,-0x32(%rbp,%rax,1)
lea    -0x32(%rbp),%rsi
movslq -0x28(%rbp),%rax
add    %rax,%rsi
lea    -0x34(%rbp),%rdi
mov    $0x2,%edx
call   1050 <memcpy@plt>
movzwl -0x34(%rbp),%edi
call   1060 <SearchCodeTable@plt>
mov    %ax,-0x36(%rbp)
mov    -0x36(%rbp),%dx
mov    -0x18(%rbp),%rax
mov    -0x1c(%rbp),%ecx
mov    %ecx,%esi
add    $0x1,%esi
mov    %esi,-0x1c(%rbp)
movslq %ecx,%rcx
mov    %dx,(%rax,%rcx,2)
movl   $0x3,-0x20(%rbp)
jmp    1301 <Utf8ToGb2312+0x1c1>
movl   $0x4,-0x20(%rbp)
jmp    1301 <Utf8ToGb2312+0x1c1>
movl   $0x5,-0x20(%rbp)
jmp    1301 <Utf8ToGb2312+0x1c1>
movl   $0x6,-0x20(%rbp)
jmp    1301 <Utf8ToGb2312+0x1c1>
lea    0xd20(%rip),%rdi
call   1030 <printf@plt>
mov    -0x20(%rbp),%eax
add    -0x24(%rbp),%eax
mov    %eax,-0x24(%rbp)
cmpl   $0x1,-0x20(%rbp)
jne    1322 <Utf8ToGb2312+0x1e2>
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    132b <Utf8ToGb2312+0x1eb>
mov    -0x28(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x28(%rbp)
jmp    117b <Utf8ToGb2312+0x3b>
add    $0x40,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<Utf8ToGb2312>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x28,%rsp
mov    %rdx,0x20(%rsp)
movw   $0x0,0xe(%rsp)
test   %esi,%esi
jle    1279 <Utf8ToGb2312+0x139>
mov    %esi,%r13d
mov    %rdi,%rbx
xor    %ebp,%ebp
xor    %r12d,%r12d
xor    %r14d,%r14d
movl   $0x0,0x10(%rsp)
jmp    11fe <Utf8ToGb2312+0xbe>
movzbl (%rbx,%r15,1),%eax
movzbl 0x1(%rbx,%r15,1),%ecx
shl    $0x4,%al
mov    %ecx,%edx
shr    $0x2,%dl
and    $0xf,%dl
or     %al,%dl
movslq %ebp,%rax
mov    %dl,0x17(%rsp,%rax,1)
shl    $0x6,%cl
movzbl 0x2(%rbx,%r15,1),%edx
and    $0x3f,%dl
or     %cl,%dl
lea    (%rsp,%rax,1),%rsi
add    $0x16,%rsi
mov    %dl,0x16(%rsp,%rax,1)
lea    0xe(%rsp),%rdi
mov    $0x2,%edx
call   1050 <memcpy@plt>
movzwl 0xe(%rsp),%edi
call   1060 <SearchCodeTable@plt>
mov    0x10(%rsp),%edx
movslq %edx,%rcx
add    $0x1,%edx
mov    %edx,0x10(%rsp)
mov    0x20(%rsp),%rdx
mov    %ax,(%rdx,%rcx,2)
mov    $0x3,%eax
nopl   0x0(%rax,%rax,1)
add    %eax,%r12d
add    $0x2,%ebp
mov    %eax,%r14d
cmp    %r13d,%r12d
jge    1279 <Utf8ToGb2312+0x139>
movslq %r12d,%r15
movzbl (%rbx,%r15,1),%edi
call   1040 <GetUtf8ByteNumForWord@plt>
cmp    $0x6,%eax
ja     1234 <Utf8ToGb2312+0xf4>
mov    %eax,%ecx
lea    0xde7(%rip),%rdx
movslq (%rdx,%rcx,4),%rcx
add    %rdx,%rcx
jmp    *%rcx
movzbl (%rbx,%r15,1),%eax
movslq %ebp,%rcx
mov    %al,0x16(%rsp,%rcx,1)
add    $0x1,%r12d
jmp    1249 <Utf8ToGb2312+0x109>
lea    0xde1(%rip),%rdi
call   1030 <puts@plt>
add    %r14d,%r12d
cmp    $0x1,%r14d
jne    1274 <Utf8ToGb2312+0x134>
add    $0x1,%ebp
mov    $0x1,%r14d
jmp    11f9 <Utf8ToGb2312+0xb9>
movzbl (%rbx,%r15,1),%eax
movslq %ebp,%rcx
mov    %al,0x16(%rsp,%rcx,1)
movzbl 0x1(%rbx,%r15,1),%eax
mov    %al,0x17(%rsp,%rcx,1)
mov    $0x2,%eax
jmp    11f0 <Utf8ToGb2312+0xb0>
add    $0x2,%ebp
jmp    11f9 <Utf8ToGb2312+0xb9>
add    $0x28,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
@.str = [24 x i8] c"the len is more than 6\0A\00"
define void @Utf8ToGb2312(i8* %0, i32 %1, i16* %2) {
%4 = alloca i8*
%5 = alloca i32
%6 = alloca i16*
%7 = alloca i32
%8 = alloca i32
%9 = alloca i32
%10 = alloca i32
%11 = alloca [10 x i8]
%12 = alloca i16
%13 = alloca i16
store i8* %0, i8** %4
store i32 %1, i32* %5
store i16* %2, i16** %6
store i32 0, i32* %7
store i32 0, i32* %8
store i32 0, i32* %9
store i32 0, i32* %10
store i16 0, i16* %12
store i16 0, i16* %13
br label %14
14: ; preds = %129, %3
%15 = load i32, i32* %9
%16 = load i32, i32* %5
%17 = icmp slt i32 %15, %16
br i1 %17, label %18, label %130
18: ; preds = %14
%19 = load i8*, i8** %4
%20 = load i32, i32* %9
%21 = sext i32 %20 to i64
%22 = getelementptr inbounds i8, i8* %19, i64 %21
%23 = load i8, i8* %22
%24 = call i32 @GetUtf8ByteNumForWord(i8 zeroext %23)
switch i32 %24, label %115 [
i32 0, label %25
i32 2, label %34
i32 3, label %53
i32 4, label %112
i32 5, label %113
i32 6, label %114
]
25: ; preds = %18
%26 = load i8*, i8** %4
%27 = load i32, i32* %9
%28 = sext i32 %27 to i64
%29 = getelementptr inbounds i8, i8* %26, i64 %28
%30 = load i8, i8* %29
%31 = load i32, i32* %10
%32 = sext i32 %31 to i64
%33 = getelementptr inbounds [10 x i8], [10 x i8]* %11, i64 0, i64 %32
store i8 %30, i8* %33
store i32 1, i32* %8
br label %117
34: ; preds = %18
%35 = load i8*, i8** %4
%36 = load i32, i32* %9
%37 = sext i32 %36 to i64
%38 = getelementptr inbounds i8, i8* %35, i64 %37
%39 = load i8, i8* %38
%40 = load i32, i32* %10
%41 = sext i32 %40 to i64
%42 = getelementptr inbounds [10 x i8], [10 x i8]* %11, i64 0, i64 %41
store i8 %39, i8* %42
%43 = load i8*, i8** %4
%44 = load i32, i32* %9
%45 = add nsw i32 %44, 1
%46 = sext i32 %45 to i64
%47 = getelementptr inbounds i8, i8* %43, i64 %46
%48 = load i8, i8* %47
%49 = load i32, i32* %10
%50 = add nsw i32 %49, 1
%51 = sext i32 %50 to i64
%52 = getelementptr inbounds [10 x i8], [10 x i8]* %11, i64 0, i64 %51
store i8 %48, i8* %52
store i32 2, i32* %8
br label %117
53: ; preds = %18
%54 = load i8*, i8** %4
%55 = load i32, i32* %9
%56 = sext i32 %55 to i64
%57 = getelementptr inbounds i8, i8* %54, i64 %56
%58 = load i8, i8* %57
%59 = sext i8 %58 to i32
%60 = and i32 %59, 15
%61 = shl i32 %60, 4
%62 = load i8*, i8** %4
%63 = load i32, i32* %9
%64 = add nsw i32 %63, 1
%65 = sext i32 %64 to i64
%66 = getelementptr inbounds i8, i8* %62, i64 %65
%67 = load i8, i8* %66
%68 = sext i8 %67 to i32
%69 = ashr i32 %68, 2
%70 = and i32 %69, 15
%71 = or i32 %61, %70
%72 = trunc i32 %71 to i8
%73 = load i32, i32* %10
%74 = add nsw i32 %73, 1
%75 = sext i32 %74 to i64
%76 = getelementptr inbounds [10 x i8], [10 x i8]* %11, i64 0, i64 %75
store i8 %72, i8* %76
%77 = load i8*, i8** %4
%78 = load i32, i32* %9
%79 = add nsw i32 %78, 1
%80 = sext i32 %79 to i64
%81 = getelementptr inbounds i8, i8* %77, i64 %80
%82 = load i8, i8* %81
%83 = sext i8 %82 to i32
%84 = and i32 %83, 3
%85 = shl i32 %84, 6
%86 = load i8*, i8** %4
%87 = load i32, i32* %9
%88 = add nsw i32 %87, 2
%89 = sext i32 %88 to i64
%90 = getelementptr inbounds i8, i8* %86, i64 %89
%91 = load i8, i8* %90
%92 = sext i8 %91 to i32
%93 = and i32 %92, 63
%94 = add nsw i32 %85, %93
%95 = trunc i32 %94 to i8
%96 = load i32, i32* %10
%97 = sext i32 %96 to i64
%98 = getelementptr inbounds [10 x i8], [10 x i8]* %11, i64 0, i64 %97
store i8 %95, i8* %98
%99 = getelementptr inbounds [10 x i8], [10 x i8]* %11, i64 0, i64 0
%100 = load i32, i32* %10
%101 = sext i32 %100 to i64
%102 = getelementptr inbounds i8, i8* %99, i64 %101
%103 = call i32 @memcpy(i16* %12, i8* %102, i32 2)
%104 = load i16, i16* %12
%105 = call zeroext i16 @SearchCodeTable(i16 zeroext %104)
store i16 %105, i16* %13
%106 = load i16, i16* %13
%107 = load i16*, i16** %6
%108 = load i32, i32* %7
%109 = add nsw i32 %108, 1
store i32 %109, i32* %7
%110 = sext i32 %108 to i64
%111 = getelementptr inbounds i16, i16* %107, i64 %110
store i16 %106, i16* %111
store i32 3, i32* %8
br label %117
112: ; preds = %18
store i32 4, i32* %8
br label %117
113: ; preds = %18
store i32 5, i32* %8
br label %117
114: ; preds = %18
store i32 6, i32* %8
br label %117
115: ; preds = %18
%116 = call i32 @printf(i8* getelementptr inbounds ([24 x i8], [24 x i8]* @.str, i64 0, i64 0))
br label %117
117: ; preds = %115, %114, %113, %112, %53, %34, %25
%118 = load i32, i32* %8
%119 = load i32, i32* %9
%120 = add nsw i32 %119, %118
store i32 %120, i32* %9
%121 = load i32, i32* %8
%122 = icmp eq i32 %121, 1
br i1 %122, label %123, label %126
123: ; preds = %117
%124 = load i32, i32* %10
%125 = add nsw i32 %124, 1
store i32 %125, i32* %10
br label %129
126: ; preds = %117
%127 = load i32, i32* %10
%128 = add nsw i32 %127, 2
store i32 %128, i32* %10
br label %129
129: ; preds = %126, %123
br label %14
130: ; preds = %14
ret void
}

LLVM IR (-O2):
@str = [23 x i8] c"the len is more than 6\00"
define void @Utf8ToGb2312(i8* nocapture %0, i32 %1, i16* nocapture writeonly %2) {
%4 = alloca [10 x i8]
%5 = alloca i16
%6 = getelementptr inbounds [10 x i8], [10 x i8]* %4, i64 0, i64 0
%7 = bitcast i16* %5 to i8*
store i16 0, i16* %5
%8 = icmp sgt i32 %1, 0
br i1 %8, label %9, label %81
9: ; preds = %3, %75
%10 = phi i32 [ %79, %75 ], [ 0, %3 ]
%11 = phi i32 [ %76, %75 ], [ 0, %3 ]
%12 = phi i32 [ %77, %75 ], [ 0, %3 ]
%13 = phi i32 [ %78, %75 ], [ 0, %3 ]
%14 = sext i32 %11 to i64
%15 = getelementptr inbounds i8, i8* %0, i64 %14
%16 = load i8, i8* %15
%17 = call i32 @GetUtf8ByteNumForWord(i8 zeroext %16)
switch i32 %17, label %67 [
i32 0, label %18
i32 2, label %23
i32 3, label %34
i32 4, label %62
i32 5, label %62
i32 6, label %62
]
18: ; preds = %9
%19 = load i8, i8* %15
%20 = sext i32 %10 to i64
%21 = getelementptr inbounds [10 x i8], [10 x i8]* %4, i64 0, i64 %20
store i8 %19, i8* %21
%22 = add nsw i32 %11, 1
br label %72
23: ; preds = %9
%24 = load i8, i8* %15
%25 = sext i32 %10 to i64
%26 = getelementptr inbounds [10 x i8], [10 x i8]* %4, i64 0, i64 %25
store i8 %24, i8* %26
%27 = add nsw i32 %11, 1
%28 = sext i32 %27 to i64
%29 = getelementptr inbounds i8, i8* %0, i64 %28
%30 = load i8, i8* %29
%31 = add nsw i32 %10, 1
%32 = sext i32 %31 to i64
%33 = getelementptr inbounds [10 x i8], [10 x i8]* %4, i64 0, i64 %32
store i8 %30, i8* %33
br label %62
34: ; preds = %9
%35 = load i8, i8* %15
%36 = shl i8 %35, 4
%37 = add nsw i32 %11, 1
%38 = sext i32 %37 to i64
%39 = getelementptr inbounds i8, i8* %0, i64 %38
%40 = load i8, i8* %39
%41 = lshr i8 %40, 2
%42 = and i8 %41, 15
%43 = or i8 %42, %36
%44 = add nsw i32 %10, 1
%45 = sext i32 %44 to i64
%46 = getelementptr inbounds [10 x i8], [10 x i8]* %4, i64 0, i64 %45
store i8 %43, i8* %46
%47 = shl i8 %40, 6
%48 = add nsw i32 %11, 2
%49 = sext i32 %48 to i64
%50 = getelementptr inbounds i8, i8* %0, i64 %49
%51 = load i8, i8* %50
%52 = and i8 %51, 63
%53 = or i8 %52, %47
%54 = sext i32 %10 to i64
%55 = getelementptr inbounds [10 x i8], [10 x i8]* %4, i64 0, i64 %54
store i8 %53, i8* %55
%56 = call i32 @memcpy(i16* %5, i8* %55, i32 2)
%57 = load i16, i16* %5
%58 = call zeroext i16 @SearchCodeTable(i16 zeroext %57)
%59 = add nsw i32 %13, 1
%60 = sext i32 %13 to i64
%61 = getelementptr inbounds i16, i16* %2, i64 %60
store i16 %58, i16* %61
br label %62
62: ; preds = %9, %9, %34, %23, %9
%63 = phi i32 [ %13, %9 ], [ %13, %23 ], [ %59, %34 ], [ %13, %9 ], [ %13, %9 ]
%64 = phi i32 [ %17, %9 ], [ 2, %23 ], [ 3, %34 ], [ %17, %9 ], [ %17, %9 ]
%65 = add nsw i32 %64, %11
%66 = add nsw i32 %10, 2
br label %75
67: ; preds = %9
%68 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([23 x i8], [23 x i8]* @str, i64 0, i64 0))
%69 = add nsw i32 %11, %12
%70 = icmp eq i32 %12, 1
%71 = add nsw i32 %10, 2
br i1 %70, label %72, label %75
72: ; preds = %18, %67
%73 = phi i32 [ %22, %18 ], [ %69, %67 ]
%74 = add nsw i32 %10, 1
br label %75
75: ; preds = %62, %67, %72
%76 = phi i32 [ %73, %72 ], [ %69, %67 ], [ %65, %62 ]
%77 = phi i32 [ 1, %72 ], [ %12, %67 ], [ %64, %62 ]
%78 = phi i32 [ %13, %72 ], [ %13, %67 ], [ %63, %62 ]
%79 = phi i32 [ %74, %72 ], [ %71, %67 ], [ %66, %62 ]
%80 = icmp slt i32 %76, %1
br i1 %80, label %9, label %81
81: ; preds = %75, %3
ret void
}