#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 */
void *digit_to_hex(int);
int encode_password(const char *pass, char *buf) {
  const uint8_t g_pass_shuffle_table[] = {
      0x05, 0x0A, 0x1F, 0x18, 0x08, 0x1E, 0x1C, 0x01, 0x11, 0x0D, 0x0C,
      0x0E, 0x1B, 0x03, 0x15, 0x16, 0x1D, 0x14, 0x00, 0x07, 0x10, 0x0B,
      0x19, 0x04, 0x13, 0x12, 0x06, 0x1A, 0x09, 0x02, 0x0F, 0x17};
  const uint8_t g_pass_key[] = {0xCA, 0xFE, 0x28, 0xA9};
  uint8_t tmp_buf[32] = {0};
  char tmp;
  int i, j;
  for (i = 0; i < 4; ++i) {
    tmp = pass[i];
    for (j = 0; j < 8; ++j) {
      tmp_buf[g_pass_shuffle_table[8 * i + j] >> 3] |=
          ((tmp & 1) << (g_pass_shuffle_table[8 * i + j] & 7));
      tmp >>= 1;
    }
  }
  for (i = 0; i < 4; ++i) {
    tmp_buf[i] ^= g_pass_key[i];
  }
  for (i = 0; i < 4; ++i) {
    *buf++ = digit_to_hex((unsigned char)tmp_buf[i] >> 4);
    *buf++ = digit_to_hex(tmp_buf[i] & 0xF);
  }
  *buf = 0;
  return 0;
}


x86 assembly (clang, -O0):
<encode_password>:
push   %rbp
mov    %rsp,%rbp
sub    $0x130,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
lea    -0x90(%rbp),%rdi
lea    0xeaf(%rip),%rsi
mov    $0x80,%edx
call   1040 <memcpy@plt>
mov    0xf1e(%rip),%rax
mov    %rax,-0xa0(%rbp)
mov    0xf18(%rip),%rax
mov    %rax,-0x98(%rbp)
lea    -0x120(%rbp),%rdi
xor    %esi,%esi
mov    $0x80,%edx
call   1030 <memset@plt>
movl   $0x0,-0x128(%rbp)
cmpl   $0x4,-0x128(%rbp)
jge    125e <encode_password+0x12e>
mov    -0x8(%rbp),%rax
movslq -0x128(%rbp),%rcx
mov    (%rax,%rcx,1),%al
mov    %al,-0x121(%rbp)
movl   $0x0,-0x12c(%rbp)
cmpl   $0x8,-0x12c(%rbp)
jge    1245 <encode_password+0x115>
movsbl -0x121(%rbp),%eax
and    $0x1,%eax
mov    -0x128(%rbp),%ecx
shl    $0x3,%ecx
add    -0x12c(%rbp),%ecx
movslq %ecx,%rcx
mov    -0x90(%rbp,%rcx,4),%ecx
and    $0x7,%ecx
shl    %cl,%eax
mov    %eax,%ecx
mov    -0x128(%rbp),%eax
shl    $0x3,%eax
add    -0x12c(%rbp),%eax
cltq
mov    -0x90(%rbp,%rax,4),%eax
sar    $0x3,%eax
cltq
or     -0x120(%rbp,%rax,4),%ecx
mov    %ecx,-0x120(%rbp,%rax,4)
movsbl -0x121(%rbp),%eax
sar    $0x1,%eax
mov    %al,-0x121(%rbp)
mov    -0x12c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x12c(%rbp)
jmp    11bf <encode_password+0x8f>
jmp    124a <encode_password+0x11a>
mov    -0x128(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x128(%rbp)
jmp    1194 <encode_password+0x64>
movl   $0x0,-0x128(%rbp)
cmpl   $0x4,-0x128(%rbp)
jge    12ac <encode_password+0x17c>
movslq -0x128(%rbp),%rax
mov    -0xa0(%rbp,%rax,4),%ecx
movslq -0x128(%rbp),%rax
xor    -0x120(%rbp,%rax,4),%ecx
mov    %ecx,-0x120(%rbp,%rax,4)
mov    -0x128(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x128(%rbp)
jmp    1268 <encode_password+0x138>
movl   $0x0,-0x128(%rbp)
cmpl   $0x4,-0x128(%rbp)
jge    132c <encode_password+0x1fc>
movslq -0x128(%rbp),%rax
mov    -0x120(%rbp,%rax,4),%eax
movzbl %al,%edi
sar    $0x4,%edi
call   1050 <digit_to_hex@plt>
mov    %al,%cl
mov    -0x10(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x10(%rbp)
mov    %cl,(%rax)
movslq -0x128(%rbp),%rax
mov    -0x120(%rbp,%rax,4),%edi
and    $0xf,%edi
call   1050 <digit_to_hex@plt>
mov    %al,%cl
mov    -0x10(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x10(%rbp)
mov    %cl,(%rax)
mov    -0x128(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x128(%rbp)
jmp    12b6 <encode_password+0x186>
mov    -0x10(%rbp),%rax
movb   $0x0,(%rax)
xor    %eax,%eax
add    $0x130,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<encode_password>:
push   %rbp
push   %r15
push   %r14
push   %r12
push   %rbx
sub    $0x80,%rsp
mov    %rsi,%r14
xorps  %xmm0,%xmm0
movaps %xmm0,0x70(%rsp)
movaps %xmm0,0x60(%rsp)
movaps %xmm0,0x50(%rsp)
movaps %xmm0,0x40(%rsp)
movaps %xmm0,0x30(%rsp)
movaps %xmm0,0x20(%rsp)
movaps %xmm0,0x10(%rsp)
movaps %xmm0,(%rsp)
lea    0xec9(%rip),%rax
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
nop
movzbl (%rdi,%rdx,1),%ebp
mov    %ebp,%esi
and    $0x1,%esi
mov    -0x1c(%rax),%ebx
mov    %ebx,%ecx
and    $0x7,%cl
shl    %cl,%esi
sar    $0x3,%ebx
movslq %ebx,%rcx
or     %esi,(%rsp,%rcx,4)
mov    %ebp,%esi
shr    %esi
and    $0x1,%esi
mov    -0x18(%rax),%ebx
mov    %ebx,%ecx
and    $0x7,%cl
shl    %cl,%esi
sar    $0x3,%ebx
movslq %ebx,%rcx
or     %esi,(%rsp,%rcx,4)
mov    %ebp,%esi
shr    $0x2,%esi
and    $0x1,%esi
mov    -0x14(%rax),%ebx
mov    %ebx,%ecx
and    $0x7,%cl
shl    %cl,%esi
sar    $0x3,%ebx
movslq %ebx,%rcx
or     %esi,(%rsp,%rcx,4)
mov    %ebp,%esi
shr    $0x3,%esi
and    $0x1,%esi
mov    -0x10(%rax),%ebx
mov    %ebx,%ecx
and    $0x7,%cl
shl    %cl,%esi
sar    $0x3,%ebx
movslq %ebx,%rcx
or     %esi,(%rsp,%rcx,4)
mov    %ebp,%esi
shr    $0x4,%esi
and    $0x1,%esi
mov    -0xc(%rax),%ebx
mov    %ebx,%ecx
and    $0x7,%cl
shl    %cl,%esi
sar    $0x3,%ebx
movslq %ebx,%rcx
or     %esi,(%rsp,%rcx,4)
mov    %ebp,%esi
shr    $0x5,%esi
and    $0x1,%esi
mov    -0x8(%rax),%ebx
mov    %ebx,%ecx
and    $0x7,%cl
shl    %cl,%esi
sar    $0x3,%ebx
movslq %ebx,%rcx
or     %esi,(%rsp,%rcx,4)
mov    %ebp,%esi
shr    $0x6,%esi
and    $0x1,%esi
mov    -0x4(%rax),%ebx
mov    %ebx,%ecx
and    $0x7,%cl
shl    %cl,%esi
sar    $0x3,%ebx
movslq %ebx,%rcx
or     %esi,(%rsp,%rcx,4)
shr    $0x7,%ebp
mov    (%rax),%esi
mov    %esi,%ecx
and    $0x7,%cl
shl    %cl,%ebp
sar    $0x3,%esi
movslq %esi,%rcx
or     %ebp,(%rsp,%rcx,4)
add    $0x1,%rdx
add    $0x20,%rax
cmp    $0x4,%rdx
jne    1160 <encode_password+0x50>
mov    $0xca,%ebx
xor    (%rsp),%ebx
mov    $0xfe,%ebp
xor    0x4(%rsp),%ebp
mov    0x8(%rsp),%r12d
xor    $0x28,%r12d
mov    $0xa9,%r15d
xor    0xc(%rsp),%r15d
mov    %ebx,%edi
shr    $0x4,%edi
and    $0xf,%edi
call   1030 <digit_to_hex@plt>
mov    %al,(%r14)
and    $0xf,%ebx
mov    %ebx,%edi
call   1030 <digit_to_hex@plt>
mov    %al,0x1(%r14)
mov    %ebp,%edi
shr    $0x4,%edi
and    $0xf,%edi
call   1030 <digit_to_hex@plt>
mov    %al,0x2(%r14)
and    $0xf,%ebp
mov    %ebp,%edi
call   1030 <digit_to_hex@plt>
mov    %al,0x3(%r14)
mov    %r12d,%edi
shr    $0x4,%edi
and    $0xf,%edi
call   1030 <digit_to_hex@plt>
mov    %al,0x4(%r14)
and    $0xf,%r12d
mov    %r12d,%edi
call   1030 <digit_to_hex@plt>
mov    %al,0x5(%r14)
mov    %r15d,%edi
shr    $0x4,%edi
and    $0xf,%edi
call   1030 <digit_to_hex@plt>
mov    %al,0x6(%r14)
and    $0xf,%r15d
mov    %r15d,%edi
call   1030 <digit_to_hex@plt>
mov    %al,0x7(%r14)
movb   $0x0,0x8(%r14)
xor    %eax,%eax
add    $0x80,%rsp
pop    %rbx
pop    %r12
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
@__const.encode_password.g_pass_shuffle_table = [32 x i32] [i32 5, i32 10, i32 31, i32 24, i32 8, i32 30, i32 28, i32 1, i32 17, i32 13, i32 12, i32 14, i32 27, i32 3, i32 21, i32 22, i32 29, i32 20, i32 0, i32 7, i32 16, i32 11, i32 25, i32 4, i32 19, i32 18, i32 6, i32 26, i32 9, i32 2, i32 15, i32 23]
@__const.encode_password.g_pass_key = [4 x i32] [i32 202, i32 254, i32 40, i32 169]
define i32 @encode_password(i8* %0, i8* %1) {
%3 = alloca i8*
%4 = alloca i8*
%5 = alloca [32 x i32]
%6 = alloca [4 x i32]
%7 = alloca [32 x i32]
%8 = alloca i8
%9 = alloca i32
%10 = alloca i32
store i8* %0, i8** %3
store i8* %1, i8** %4
%11 = bitcast [32 x i32]* %5 to i8*
%12 = bitcast [4 x i32]* %6 to i8*
%13 = bitcast [32 x i32]* %7 to i8*
store i32 0, i32* %9
br label %14
14: ; preds = %59, %2
%15 = load i32, i32* %9
%16 = icmp slt i32 %15, 4
br i1 %16, label %17, label %62
17: ; preds = %14
%18 = load i8*, i8** %3
%19 = load i32, i32* %9
%20 = sext i32 %19 to i64
%21 = getelementptr inbounds i8, i8* %18, i64 %20
%22 = load i8, i8* %21
store i8 %22, i8* %8
store i32 0, i32* %10
br label %23
23: ; preds = %55, %17
%24 = load i32, i32* %10
%25 = icmp slt i32 %24, 8
br i1 %25, label %26, label %58
26: ; preds = %23
%27 = load i8, i8* %8
%28 = sext i8 %27 to i32
%29 = and i32 %28, 1
%30 = load i32, i32* %9
%31 = mul nsw i32 8, %30
%32 = load i32, i32* %10
%33 = add nsw i32 %31, %32
%34 = sext i32 %33 to i64
%35 = getelementptr inbounds [32 x i32], [32 x i32]* %5, i64 0, i64 %34
%36 = load i32, i32* %35
%37 = and i32 %36, 7
%38 = shl i32 %29, %37
%39 = load i32, i32* %9
%40 = mul nsw i32 8, %39
%41 = load i32, i32* %10
%42 = add nsw i32 %40, %41
%43 = sext i32 %42 to i64
%44 = getelementptr inbounds [32 x i32], [32 x i32]* %5, i64 0, i64 %43
%45 = load i32, i32* %44
%46 = ashr i32 %45, 3
%47 = sext i32 %46 to i64
%48 = getelementptr inbounds [32 x i32], [32 x i32]* %7, i64 0, i64 %47
%49 = load i32, i32* %48
%50 = or i32 %49, %38
store i32 %50, i32* %48
%51 = load i8, i8* %8
%52 = sext i8 %51 to i32
%53 = ashr i32 %52, 1
%54 = trunc i32 %53 to i8
store i8 %54, i8* %8
br label %55
55: ; preds = %26
%56 = load i32, i32* %10
%57 = add nsw i32 %56, 1
store i32 %57, i32* %10
br label %23
58: ; preds = %23
br label %59
59: ; preds = %58
%60 = load i32, i32* %9
%61 = add nsw i32 %60, 1
store i32 %61, i32* %9
br label %14
62: ; preds = %14
store i32 0, i32* %9
br label %63
63: ; preds = %76, %62
%64 = load i32, i32* %9
%65 = icmp slt i32 %64, 4
br i1 %65, label %66, label %79
66: ; preds = %63
%67 = load i32, i32* %9
%68 = sext i32 %67 to i64
%69 = getelementptr inbounds [4 x i32], [4 x i32]* %6, i64 0, i64 %68
%70 = load i32, i32* %69
%71 = load i32, i32* %9
%72 = sext i32 %71 to i64
%73 = getelementptr inbounds [32 x i32], [32 x i32]* %7, i64 0, i64 %72
%74 = load i32, i32* %73
%75 = xor i32 %74, %70
store i32 %75, i32* %73
br label %76
76: ; preds = %66
%77 = load i32, i32* %9
%78 = add nsw i32 %77, 1
store i32 %78, i32* %9
br label %63
79: ; preds = %63
store i32 0, i32* %9
br label %80
80: ; preds = %104, %79
%81 = load i32, i32* %9
%82 = icmp slt i32 %81, 4
br i1 %82, label %83, label %107
83: ; preds = %80
%84 = load i32, i32* %9
%85 = sext i32 %84 to i64
%86 = getelementptr inbounds [32 x i32], [32 x i32]* %7, i64 0, i64 %85
%87 = load i32, i32* %86
%88 = trunc i32 %87 to i8
%89 = zext i8 %88 to i32
%90 = ashr i32 %89, 4
%91 = call i8* @digit_to_hex(i32 %90)
%92 = ptrtoint i8* %91 to i8
%93 = load i8*, i8** %4
%94 = getelementptr inbounds i8, i8* %93, i32 1
store i8* %94, i8** %4
store i8 %92, i8* %93
%95 = load i32, i32* %9
%96 = sext i32 %95 to i64
%97 = getelementptr inbounds [32 x i32], [32 x i32]* %7, i64 0, i64 %96
%98 = load i32, i32* %97
%99 = and i32 %98, 15
%100 = call i8* @digit_to_hex(i32 %99)
%101 = ptrtoint i8* %100 to i8
%102 = load i8*, i8** %4
%103 = getelementptr inbounds i8, i8* %102, i32 1
store i8* %103, i8** %4
store i8 %101, i8* %102
br label %104
104: ; preds = %83
%105 = load i32, i32* %9
%106 = add nsw i32 %105, 1
store i32 %106, i32* %9
br label %80
107: ; preds = %80
%108 = load i8*, i8** %4
store i8 0, i8* %108
ret i32 0
}

LLVM IR (-O2):
@__const.encode_password.g_pass_shuffle_table = [32 x i32] [i32 5, i32 10, i32 31, i32 24, i32 8, i32 30, i32 28, i32 1, i32 17, i32 13, i32 12, i32 14, i32 27, i32 3, i32 21, i32 22, i32 29, i32 20, i32 0, i32 7, i32 16, i32 11, i32 25, i32 4, i32 19, i32 18, i32 6, i32 26, i32 9, i32 2, i32 15, i32 23]
define i32 @encode_password(i8* nocapture %0, i8* nocapture writeonly %1) {
%3 = alloca [32 x i32]
%4 = bitcast [32 x i32]* %3 to i8*
br label %5
5: ; preds = %2, %5
%6 = phi i64 [ 0, %2 ], [ %111, %5 ]
%7 = getelementptr inbounds i8, i8* %0, i64 %6
%8 = load i8, i8* %7
%9 = shl nsw i64 %6, 3
%10 = and i8 %8, 1
%11 = zext i8 %10 to i32
%12 = getelementptr inbounds [32 x i32], [32 x i32]* @__const.encode_password.g_pass_shuffle_table, i64 0, i64 %9
%13 = load i32, i32* %12
%14 = and i32 %13, 7
%15 = shl nuw nsw i32 %11, %14
%16 = ashr i32 %13, 3
%17 = sext i32 %16 to i64
%18 = getelementptr inbounds [32 x i32], [32 x i32]* %3, i64 0, i64 %17
%19 = load i32, i32* %18
%20 = or i32 %15, %19
store i32 %20, i32* %18
%21 = lshr i8 %8, 1
%22 = and i8 %21, 1
%23 = zext i8 %22 to i32
%24 = or i64 %9, 1
%25 = getelementptr inbounds [32 x i32], [32 x i32]* @__const.encode_password.g_pass_shuffle_table, i64 0, i64 %24
%26 = load i32, i32* %25
%27 = and i32 %26, 7
%28 = shl nuw nsw i32 %23, %27
%29 = ashr i32 %26, 3
%30 = sext i32 %29 to i64
%31 = getelementptr inbounds [32 x i32], [32 x i32]* %3, i64 0, i64 %30
%32 = load i32, i32* %31
%33 = or i32 %28, %32
store i32 %33, i32* %31
%34 = lshr i8 %8, 2
%35 = and i8 %34, 1
%36 = zext i8 %35 to i32
%37 = or i64 %9, 2
%38 = getelementptr inbounds [32 x i32], [32 x i32]* @__const.encode_password.g_pass_shuffle_table, i64 0, i64 %37
%39 = load i32, i32* %38
%40 = and i32 %39, 7
%41 = shl nuw nsw i32 %36, %40
%42 = ashr i32 %39, 3
%43 = sext i32 %42 to i64
%44 = getelementptr inbounds [32 x i32], [32 x i32]* %3, i64 0, i64 %43
%45 = load i32, i32* %44
%46 = or i32 %41, %45
store i32 %46, i32* %44
%47 = lshr i8 %8, 3
%48 = and i8 %47, 1
%49 = zext i8 %48 to i32
%50 = or i64 %9, 3
%51 = getelementptr inbounds [32 x i32], [32 x i32]* @__const.encode_password.g_pass_shuffle_table, i64 0, i64 %50
%52 = load i32, i32* %51
%53 = and i32 %52, 7
%54 = shl nuw nsw i32 %49, %53
%55 = ashr i32 %52, 3
%56 = sext i32 %55 to i64
%57 = getelementptr inbounds [32 x i32], [32 x i32]* %3, i64 0, i64 %56
%58 = load i32, i32* %57
%59 = or i32 %54, %58
store i32 %59, i32* %57
%60 = lshr i8 %8, 4
%61 = and i8 %60, 1
%62 = zext i8 %61 to i32
%63 = or i64 %9, 4
%64 = getelementptr inbounds [32 x i32], [32 x i32]* @__const.encode_password.g_pass_shuffle_table, i64 0, i64 %63
%65 = load i32, i32* %64
%66 = and i32 %65, 7
%67 = shl nuw nsw i32 %62, %66
%68 = ashr i32 %65, 3
%69 = sext i32 %68 to i64
%70 = getelementptr inbounds [32 x i32], [32 x i32]* %3, i64 0, i64 %69
%71 = load i32, i32* %70
%72 = or i32 %67, %71
store i32 %72, i32* %70
%73 = lshr i8 %8, 5
%74 = and i8 %73, 1
%75 = zext i8 %74 to i32
%76 = or i64 %9, 5
%77 = getelementptr inbounds [32 x i32], [32 x i32]* @__const.encode_password.g_pass_shuffle_table, i64 0, i64 %76
%78 = load i32, i32* %77
%79 = and i32 %78, 7
%80 = shl nuw nsw i32 %75, %79
%81 = ashr i32 %78, 3
%82 = sext i32 %81 to i64
%83 = getelementptr inbounds [32 x i32], [32 x i32]* %3, i64 0, i64 %82
%84 = load i32, i32* %83
%85 = or i32 %80, %84
store i32 %85, i32* %83
%86 = lshr i8 %8, 6
%87 = and i8 %86, 1
%88 = zext i8 %87 to i32
%89 = or i64 %9, 6
%90 = getelementptr inbounds [32 x i32], [32 x i32]* @__const.encode_password.g_pass_shuffle_table, i64 0, i64 %89
%91 = load i32, i32* %90
%92 = and i32 %91, 7
%93 = shl nuw nsw i32 %88, %92
%94 = ashr i32 %91, 3
%95 = sext i32 %94 to i64
%96 = getelementptr inbounds [32 x i32], [32 x i32]* %3, i64 0, i64 %95
%97 = load i32, i32* %96
%98 = or i32 %93, %97
store i32 %98, i32* %96
%99 = lshr i8 %8, 7
%100 = zext i8 %99 to i32
%101 = or i64 %9, 7
%102 = getelementptr inbounds [32 x i32], [32 x i32]* @__const.encode_password.g_pass_shuffle_table, i64 0, i64 %101
%103 = load i32, i32* %102
%104 = and i32 %103, 7
%105 = shl nuw nsw i32 %100, %104
%106 = ashr i32 %103, 3
%107 = sext i32 %106 to i64
%108 = getelementptr inbounds [32 x i32], [32 x i32]* %3, i64 0, i64 %107
%109 = load i32, i32* %108
%110 = or i32 %105, %109
store i32 %110, i32* %108
%111 = add nuw nsw i64 %6, 1
%112 = icmp eq i64 %111, 4
br i1 %112, label %113, label %5
113: ; preds = %5
%114 = getelementptr inbounds [32 x i32], [32 x i32]* %3, i64 0, i64 0
%115 = load i32, i32* %114
%116 = xor i32 %115, 202
%117 = getelementptr inbounds [32 x i32], [32 x i32]* %3, i64 0, i64 1
%118 = load i32, i32* %117
%119 = xor i32 %118, 254
%120 = getelementptr inbounds [32 x i32], [32 x i32]* %3, i64 0, i64 2
%121 = load i32, i32* %120
%122 = xor i32 %121, 40
%123 = getelementptr inbounds [32 x i32], [32 x i32]* %3, i64 0, i64 3
%124 = load i32, i32* %123
%125 = xor i32 %124, 169
%126 = lshr i32 %116, 4
%127 = and i32 %126, 15
%128 = tail call i8* @digit_to_hex(i32 %127)
%129 = ptrtoint i8* %128 to i64
%130 = trunc i64 %129 to i8
%131 = getelementptr inbounds i8, i8* %1, i64 1
store i8 %130, i8* %1
%132 = and i32 %116, 15
%133 = tail call i8* @digit_to_hex(i32 %132)
%134 = ptrtoint i8* %133 to i64
%135 = trunc i64 %134 to i8
%136 = getelementptr inbounds i8, i8* %1, i64 2
store i8 %135, i8* %131
%137 = lshr i32 %119, 4
%138 = and i32 %137, 15
%139 = tail call i8* @digit_to_hex(i32 %138)
%140 = ptrtoint i8* %139 to i64
%141 = trunc i64 %140 to i8
%142 = getelementptr inbounds i8, i8* %1, i64 3
store i8 %141, i8* %136
%143 = and i32 %119, 15
%144 = tail call i8* @digit_to_hex(i32 %143)
%145 = ptrtoint i8* %144 to i64
%146 = trunc i64 %145 to i8
%147 = getelementptr inbounds i8, i8* %1, i64 4
store i8 %146, i8* %142
%148 = lshr i32 %122, 4
%149 = and i32 %148, 15
%150 = tail call i8* @digit_to_hex(i32 %149)
%151 = ptrtoint i8* %150 to i64
%152 = trunc i64 %151 to i8
%153 = getelementptr inbounds i8, i8* %1, i64 5
store i8 %152, i8* %147
%154 = and i32 %122, 15
%155 = tail call i8* @digit_to_hex(i32 %154)
%156 = ptrtoint i8* %155 to i64
%157 = trunc i64 %156 to i8
%158 = getelementptr inbounds i8, i8* %1, i64 6
store i8 %157, i8* %153
%159 = lshr i32 %125, 4
%160 = and i32 %159, 15
%161 = tail call i8* @digit_to_hex(i32 %160)
%162 = ptrtoint i8* %161 to i64
%163 = trunc i64 %162 to i8
%164 = getelementptr inbounds i8, i8* %1, i64 7
store i8 %163, i8* %158
%165 = and i32 %125, 15
%166 = tail call i8* @digit_to_hex(i32 %165)
%167 = ptrtoint i8* %166 to i64
%168 = trunc i64 %167 to i8
%169 = getelementptr inbounds i8, i8* %1, i64 8
store i8 %168, i8* %164
store i8 0, i8* %169
ret i32 0
}