#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 in_l;
typedef int in_h;

/* Variables and functions */
#define CHAR_BIT 128
int /*<<< orphan*/ host_is_bigendian();
char *to_base16(char *dst, const unsigned char *src, unsigned int len) {
  static const unsigned char base16c[] = "0123456789abcdef";
  unsigned i;
  static const unsigned long vals[] = {
      ((size_t)0x0f0f0f0fUL |
       ((size_t)0x0f0f0f0fUL << ((sizeof(size_t)) * CHAR_BIT) / 2)),
      ((size_t)0x30303030UL |
       ((size_t)0x30303030UL << ((sizeof(size_t)) * CHAR_BIT) / 2)),
  };
  for (; len >= (sizeof(size_t));
       len -= (sizeof(size_t)), src += (sizeof(size_t))) {
    size_t in_l, in_h, m_l, m_h;
    size_t t1, t2;
    in_l = *(const size_t *)src;
    in_h = (in_l & (~vals[0])) >> 4;
    in_l &= vals[0];
    in_h += vals[1];
    in_l += vals[1];
    m_h =
        ((((in_h) + ~0UL / 255 * (127 - (0x39))) | (in_h)) & ~0UL / 255 * 128);
    m_l =
        ((((in_l) + ~0UL / 255 * (127 - (0x39))) | (in_l)) & ~0UL / 255 * 128);
    m_h >>= 7;
    m_l >>= 7;
    in_h += 0x27 * m_h;
    in_l += 0x27 * m_l;
    if (!host_is_bigendian()) {
      t1 = in_h;
      t2 = in_l;
      for (i = 0; i < (sizeof(size_t)); i++, dst += 2) {
        dst[0] = (t1 & 0x000000ff);
        dst[1] = (t2 & 0x000000ff);
        t1 >>= CHAR_BIT;
        t2 >>= CHAR_BIT;
      }
    } else {
      t1 = in_h;
      t2 = in_l;
      for (i = (sizeof(size_t)); i; i--) {
        dst[(i * 2) - 2] = (t1 & 0x000000ff);
        dst[(i * 2) - 1] = (t2 & 0x000000ff);
        t1 >>= CHAR_BIT;
        t2 >>= CHAR_BIT;
      }
      dst += (sizeof(size_t)) * 2;
    }
  }
  for (i = 0; i < len; i++) {
    *dst++ = base16c[src[i] / 16];
    *dst++ = base16c[src[i] % 16];
  }
  return dst;
}


x86 assembly (clang, -O0):
<to_base16>:
push   %rbp
mov    %rsp,%rbp
sub    $0x50,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %edx,-0x14(%rbp)
mov    -0x14(%rbp),%eax
cmp    $0x8,%rax
jb     1349 <to_base16+0x239>
mov    -0x10(%rbp),%rax
mov    (%rax),%rax
mov    %rax,-0x20(%rbp)
mov    -0x20(%rbp),%rax
mov    0xeda(%rip),%rcx
xor    $0xffffffffffffffff,%rcx
and    %rcx,%rax
shr    $0x4,%rax
mov    %rax,-0x28(%rbp)
mov    0xec4(%rip),%rax
and    -0x20(%rbp),%rax
mov    %rax,-0x20(%rbp)
mov    0xebd(%rip),%rax
add    -0x28(%rbp),%rax
mov    %rax,-0x28(%rbp)
mov    0xeae(%rip),%rax
add    -0x20(%rbp),%rax
mov    %rax,-0x20(%rbp)
movabs $0x4646464646464646,%rax
46 46 46
add    -0x28(%rbp),%rax
or     -0x28(%rbp),%rax
movabs $0x8080808080808080,%rcx
80 80 80
and    %rcx,%rax
mov    %rax,-0x38(%rbp)
movabs $0x4646464646464646,%rax
46 46 46
add    -0x20(%rbp),%rax
or     -0x20(%rbp),%rax
movabs $0x8080808080808080,%rcx
80 80 80
and    %rcx,%rax
mov    %rax,-0x30(%rbp)
mov    -0x38(%rbp),%rax
shr    $0x7,%rax
mov    %rax,-0x38(%rbp)
mov    -0x30(%rbp),%rax
shr    $0x7,%rax
mov    %rax,-0x30(%rbp)
imul   $0x27,-0x38(%rbp),%rax
add    -0x28(%rbp),%rax
mov    %rax,-0x28(%rbp)
imul   $0x27,-0x30(%rbp),%rax
add    -0x20(%rbp),%rax
mov    %rax,-0x20(%rbp)
mov    $0x0,%al
call   1030 <host_is_bigendian@plt>
cmp    $0x0,%eax
jne    1292 <to_base16+0x182>
mov    -0x28(%rbp),%rax
mov    %rax,-0x40(%rbp)
mov    -0x20(%rbp),%rax
mov    %rax,-0x48(%rbp)
movl   $0x0,-0x18(%rbp)
mov    -0x18(%rbp),%eax
cmp    $0x8,%rax
jae    128d <to_base16+0x17d>
mov    -0x40(%rbp),%rax
and    $0xff,%rax
mov    %al,%cl
mov    -0x8(%rbp),%rax
mov    %cl,(%rax)
mov    -0x48(%rbp),%rax
and    $0xff,%rax
mov    %al,%cl
mov    -0x8(%rbp),%rax
mov    %cl,0x1(%rax)
mov    -0x40(%rbp),%rax
mov    $0x80,%ecx
shr    %cl,%rax
mov    %rax,-0x40(%rbp)
mov    -0x48(%rbp),%rax
mov    $0x80,%ecx
shr    %cl,%rax
mov    %rax,-0x48(%rbp)
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
mov    -0x8(%rbp),%rax
add    $0x2,%rax
mov    %rax,-0x8(%rbp)
jmp    1221 <to_base16+0x111>
jmp    1329 <to_base16+0x219>
mov    -0x28(%rbp),%rax
mov    %rax,-0x40(%rbp)
mov    -0x20(%rbp),%rax
mov    %rax,-0x48(%rbp)
movl   $0x8,-0x18(%rbp)
cmpl   $0x0,-0x18(%rbp)
je     131d <to_base16+0x20d>
mov    -0x40(%rbp),%rax
and    $0xff,%rax
mov    %al,%dl
mov    -0x8(%rbp),%rax
mov    -0x18(%rbp),%ecx
shl    $0x1,%ecx
sub    $0x2,%ecx
mov    %ecx,%ecx
mov    %dl,(%rax,%rcx,1)
mov    -0x48(%rbp),%rax
and    $0xff,%rax
mov    %al,%dl
mov    -0x8(%rbp),%rax
mov    -0x18(%rbp),%ecx
shl    $0x1,%ecx
sub    $0x1,%ecx
mov    %ecx,%ecx
mov    %dl,(%rax,%rcx,1)
mov    -0x40(%rbp),%rax
mov    $0x80,%ecx
shr    %cl,%rax
mov    %rax,-0x40(%rbp)
mov    -0x48(%rbp),%rax
mov    $0x80,%ecx
shr    %cl,%rax
mov    %rax,-0x48(%rbp)
mov    -0x18(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x18(%rbp)
jmp    12a9 <to_base16+0x199>
mov    -0x8(%rbp),%rax
add    $0x10,%rax
mov    %rax,-0x8(%rbp)
jmp    132e <to_base16+0x21e>
mov    -0x14(%rbp),%eax
sub    $0x8,%rax
mov    %eax,-0x14(%rbp)
mov    -0x10(%rbp),%rax
add    $0x8,%rax
mov    %rax,-0x10(%rbp)
jmp    1123 <to_base16+0x13>
movl   $0x0,-0x18(%rbp)
mov    -0x18(%rbp),%eax
cmp    -0x14(%rbp),%eax
jae    13cc <to_base16+0x2bc>
mov    -0x10(%rbp),%rax
mov    -0x18(%rbp),%ecx
movzbl (%rax,%rcx,1),%eax
mov    $0x10,%ecx
cltd
idiv   %ecx
movslq %eax,%rcx
lea    0xc87(%rip),%rax
mov    (%rax,%rcx,1),%cl
mov    -0x8(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x8(%rbp)
mov    %cl,(%rax)
mov    -0x10(%rbp),%rax
mov    -0x18(%rbp),%ecx
movzbl (%rax,%rcx,1),%eax
mov    $0x10,%ecx
cltd
idiv   %ecx
movslq %edx,%rcx
lea    0xc56(%rip),%rax
mov    (%rax,%rcx,1),%cl
mov    -0x8(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x8(%rbp)
mov    %cl,(%rax)
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
jmp    1350 <to_base16+0x240>
mov    -0x8(%rbp),%rax
add    $0x50,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<to_base16>:
push   %rbp
push   %r15
push   %r14
push   %r12
push   %rbx
mov    %edx,%r15d
mov    %rsi,%r14
mov    %rdi,%r12
cmp    $0x8,%edx
jae    11bc <to_base16+0xac>
test   %r15d,%r15d
je     12f4 <to_base16+0x1e4>
mov    %r15d,%ecx
cmp    $0x1,%r15d
jne    125c <to_base16+0x14c>
xor    %eax,%eax
jmp    12c4 <to_base16+0x1b4>
nopw   0x0(%rax,%rax,1)
mov    %bpl,(%r12)
mov    %bl,0x1(%r12)
mov    %bpl,0x2(%r12)
mov    %bl,0x3(%r12)
mov    %bpl,0x4(%r12)
mov    %bl,0x5(%r12)
mov    %bpl,0x6(%r12)
mov    %bl,0x7(%r12)
mov    %bpl,0x8(%r12)
mov    %bl,0x9(%r12)
mov    %bpl,0xa(%r12)
mov    %bl,0xb(%r12)
mov    %bpl,0xc(%r12)
mov    %bl,0xd(%r12)
lea    0xe(%r12),%rcx
mov    $0xf,%eax
mov    %bpl,(%rcx)
mov    %bl,(%r12,%rax,1)
add    $0x10,%r12
add    $0xfffffff8,%r15d
add    $0x8,%r14
cmp    $0x7,%r15d
jbe    112a <to_base16+0x1a>
mov    (%r14),%rax
mov    %rax,%rcx
shr    $0x4,%rcx
and    $0xff0f0f0f,%ecx
and    $0xf0f0f0f,%eax
lea    0x76767676(%rcx),%edx
shr    $0x7,%edx
and    $0x1,%edx
imul   $0x27,%edx,%ebp
add    %ecx,%ebp
lea    0x76767676(%rax),%ecx
shr    $0x7,%ecx
and    $0x1,%ecx
imul   $0x27,%ecx,%ebx
add    %eax,%ebx
xor    %eax,%eax
call   1030 <host_is_bigendian@plt>
add    $0x30,%bpl
add    $0x30,%bl
test   %eax,%eax
je     1150 <to_base16+0x40>
mov    %bpl,0xe(%r12)
mov    %bl,0xf(%r12)
mov    %bpl,0xc(%r12)
mov    %bl,0xd(%r12)
mov    %bpl,0xa(%r12)
mov    %bl,0xb(%r12)
mov    %bpl,0x8(%r12)
mov    %bl,0x9(%r12)
mov    %bpl,0x6(%r12)
mov    %bl,0x7(%r12)
mov    %bpl,0x4(%r12)
mov    %bl,0x5(%r12)
mov    %bpl,0x2(%r12)
mov    %bl,0x3(%r12)
mov    $0x1,%eax
mov    %r12,%rcx
jmp    119f <to_base16+0x8f>
mov    %ecx,%edx
and    $0xfffffffe,%edx
xor    %eax,%eax
lea    0xd96(%rip),%rsi
nopw   0x0(%rax,%rax,1)
movzbl (%r14,%rax,1),%edi
shr    $0x4,%rdi
movzbl (%rdi,%rsi,1),%ebx
mov    %bl,(%r12)
movzbl (%r14,%rax,1),%edi
and    $0xf,%edi
movzbl (%rdi,%rsi,1),%ebx
mov    %bl,0x1(%r12)
movzbl 0x1(%r14,%rax,1),%edi
shr    $0x4,%rdi
movzbl (%rdi,%rsi,1),%ebx
mov    %bl,0x2(%r12)
movzbl 0x1(%r14,%rax,1),%edi
and    $0xf,%edi
movzbl (%rdi,%rsi,1),%ebx
mov    %bl,0x3(%r12)
add    $0x4,%r12
add    $0x2,%rax
cmp    %rax,%rdx
jne    1270 <to_base16+0x160>
test   $0x1,%cl
je     12f4 <to_base16+0x1e4>
movzbl (%r14,%rax,1),%ecx
shr    $0x4,%rcx
lea    0xd27(%rip),%rdx
mov    (%rcx,%rdx,1),%cl
mov    %cl,(%r12)
movzbl (%r14,%rax,1),%eax
and    $0xf,%eax
mov    (%rax,%rdx,1),%al
mov    %al,0x1(%r12)
add    $0x2,%r12
mov    %r12,%rax
pop    %rbx
pop    %r12
pop    %r14
pop    %r15
pop    %rbp
ret

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

LLVM IR (-O2):
@to_base16.base16c = internal unnamed_addr constant [17 x i8] c"0123456789abcdef\00"
define i8* @to_base16(i8* writeonly %0, i8* nocapture %1, i32 %2) {
%4 = icmp ugt i32 %2, 7
br i1 %4, label %16, label %5
5: ; preds = %73, %3
%6 = phi i32 [ %2, %3 ], [ %78, %73 ]
%7 = phi i8* [ %1, %3 ], [ %79, %73 ]
%8 = phi i8* [ %0, %3 ], [ %77, %73 ]
%9 = icmp eq i32 %6, 0
br i1 %9, label %134, label %10
10: ; preds = %5
%11 = zext i32 %6 to i64
%12 = and i64 %11, 1
%13 = icmp eq i32 %6, 1
br i1 %13, label %115, label %14
14: ; preds = %10
%15 = and i64 %11, 4294967294
br label %81
16: ; preds = %3, %73
%17 = phi i8* [ %77, %73 ], [ %0, %3 ]
%18 = phi i8* [ %79, %73 ], [ %1, %3 ]
%19 = phi i32 [ %78, %73 ], [ %2, %3 ]
%20 = bitcast i8* %18 to i64*
%21 = load i64, i64* %20
%22 = lshr i64 %21, 4
%23 = and i64 %22, 576460752287633167
%24 = and i64 %21, -9223372036602130673
%25 = add nuw nsw i64 %23, 808464432
%26 = or i64 %24, 48
%27 = add nuw nsw i64 %23, 19780516818876022
%28 = or i64 %27, %25
%29 = add nuw nsw i64 %24, 5063812099473831542
%30 = or i64 %29, %24
%31 = lshr i64 %28, 7
%32 = and i64 %31, 282578800148737
%33 = lshr i64 %30, 7
%34 = and i64 %33, 72057594054770945
%35 = mul nuw nsw i64 %32, 39
%36 = add nuw nsw i64 %35, %25
%37 = mul nuw nsw i64 %34, 39
%38 = add nuw nsw i64 %37, %26
%39 = tail call i32 (...) @host_is_bigendian()
%40 = icmp eq i32 %39, 0
%41 = trunc i64 %36 to i8
%42 = trunc i64 %38 to i8
br i1 %40, label %58, label %43
43: ; preds = %16
%44 = getelementptr inbounds i8, i8* %17, i64 14
store i8 %41, i8* %44
%45 = getelementptr inbounds i8, i8* %17, i64 15
store i8 %42, i8* %45
%46 = getelementptr inbounds i8, i8* %17, i64 12
store i8 %41, i8* %46
%47 = getelementptr inbounds i8, i8* %17, i64 13
store i8 %42, i8* %47
%48 = getelementptr inbounds i8, i8* %17, i64 10
store i8 %41, i8* %48
%49 = getelementptr inbounds i8, i8* %17, i64 11
store i8 %42, i8* %49
%50 = getelementptr inbounds i8, i8* %17, i64 8
store i8 %41, i8* %50
%51 = getelementptr inbounds i8, i8* %17, i64 9
store i8 %42, i8* %51
%52 = getelementptr inbounds i8, i8* %17, i64 6
store i8 %41, i8* %52
%53 = getelementptr inbounds i8, i8* %17, i64 7
store i8 %42, i8* %53
%54 = getelementptr inbounds i8, i8* %17, i64 4
store i8 %41, i8* %54
%55 = getelementptr inbounds i8, i8* %17, i64 5
store i8 %42, i8* %55
%56 = getelementptr inbounds i8, i8* %17, i64 2
store i8 %41, i8* %56
%57 = getelementptr inbounds i8, i8* %17, i64 3
store i8 %42, i8* %57
br label %73
58: ; preds = %16
store i8 %41, i8* %17
%59 = getelementptr inbounds i8, i8* %17, i64 1
store i8 %42, i8* %59
%60 = getelementptr inbounds i8, i8* %17, i64 2
store i8 %41, i8* %60
%61 = getelementptr inbounds i8, i8* %17, i64 3
store i8 %42, i8* %61
%62 = getelementptr inbounds i8, i8* %17, i64 4
store i8 %41, i8* %62
%63 = getelementptr inbounds i8, i8* %17, i64 5
store i8 %42, i8* %63
%64 = getelementptr inbounds i8, i8* %17, i64 6
store i8 %41, i8* %64
%65 = getelementptr inbounds i8, i8* %17, i64 7
store i8 %42, i8* %65
%66 = getelementptr inbounds i8, i8* %17, i64 8
store i8 %41, i8* %66
%67 = getelementptr inbounds i8, i8* %17, i64 9
store i8 %42, i8* %67
%68 = getelementptr inbounds i8, i8* %17, i64 10
store i8 %41, i8* %68
%69 = getelementptr inbounds i8, i8* %17, i64 11
store i8 %42, i8* %69
%70 = getelementptr inbounds i8, i8* %17, i64 12
store i8 %41, i8* %70
%71 = getelementptr inbounds i8, i8* %17, i64 13
store i8 %42, i8* %71
%72 = getelementptr inbounds i8, i8* %17, i64 14
br label %73
73: ; preds = %58, %43
%74 = phi i8* [ %72, %58 ], [ %17, %43 ]
%75 = phi i64 [ 15, %58 ], [ 1, %43 ]
store i8 %41, i8* %74
%76 = getelementptr inbounds i8, i8* %17, i64 %75
store i8 %42, i8* %76
%77 = getelementptr inbounds i8, i8* %17, i64 16
%78 = add i32 %19, -8
%79 = getelementptr inbounds i8, i8* %18, i64 8
%80 = icmp ugt i32 %78, 7
br i1 %80, label %16, label %5
81: ; preds = %81, %14
%82 = phi i64 [ 0, %14 ], [ %112, %81 ]
%83 = phi i8* [ %8, %14 ], [ %111, %81 ]
%84 = phi i64 [ 0, %14 ], [ %113, %81 ]
%85 = getelementptr inbounds i8, i8* %7, i64 %82
%86 = load i8, i8* %85
%87 = lshr i8 %86, 4
%88 = zext i8 %87 to i64
%89 = getelementptr inbounds [17 x i8], [17 x i8]* @to_base16.base16c, i64 0, i64 %88
%90 = load i8, i8* %89
%91 = getelementptr inbounds i8, i8* %83, i64 1
store i8 %90, i8* %83
%92 = load i8, i8* %85
%93 = and i8 %92, 15
%94 = zext i8 %93 to i64
%95 = getelementptr inbounds [17 x i8], [17 x i8]* @to_base16.base16c, i64 0, i64 %94
%96 = load i8, i8* %95
%97 = getelementptr inbounds i8, i8* %83, i64 2
store i8 %96, i8* %91
%98 = or i64 %82, 1
%99 = getelementptr inbounds i8, i8* %7, i64 %98
%100 = load i8, i8* %99
%101 = lshr i8 %100, 4
%102 = zext i8 %101 to i64
%103 = getelementptr inbounds [17 x i8], [17 x i8]* @to_base16.base16c, i64 0, i64 %102
%104 = load i8, i8* %103
%105 = getelementptr inbounds i8, i8* %83, i64 3
store i8 %104, i8* %97
%106 = load i8, i8* %99
%107 = and i8 %106, 15
%108 = zext i8 %107 to i64
%109 = getelementptr inbounds [17 x i8], [17 x i8]* @to_base16.base16c, i64 0, i64 %108
%110 = load i8, i8* %109
%111 = getelementptr inbounds i8, i8* %83, i64 4
store i8 %110, i8* %105
%112 = add nuw nsw i64 %82, 2
%113 = add i64 %84, 2
%114 = icmp eq i64 %113, %15
br i1 %114, label %115, label %81
115: ; preds = %81, %10
%116 = phi i8* [ undef, %10 ], [ %111, %81 ]
%117 = phi i64 [ 0, %10 ], [ %112, %81 ]
%118 = phi i8* [ %8, %10 ], [ %111, %81 ]
%119 = icmp eq i64 %12, 0
br i1 %119, label %134, label %120
120: ; preds = %115
%121 = getelementptr inbounds i8, i8* %7, i64 %117
%122 = load i8, i8* %121
%123 = lshr i8 %122, 4
%124 = zext i8 %123 to i64
%125 = getelementptr inbounds [17 x i8], [17 x i8]* @to_base16.base16c, i64 0, i64 %124
%126 = load i8, i8* %125
%127 = getelementptr inbounds i8, i8* %118, i64 1
store i8 %126, i8* %118
%128 = load i8, i8* %121
%129 = and i8 %128, 15
%130 = zext i8 %129 to i64
%131 = getelementptr inbounds [17 x i8], [17 x i8]* @to_base16.base16c, i64 0, i64 %130
%132 = load i8, i8* %131
%133 = getelementptr inbounds i8, i8* %118, i64 2
store i8 %132, i8* %127
br label %134
134: ; preds = %120, %115, %5
%135 = phi i8* [ %8, %5 ], [ %116, %115 ], [ %133, %120 ]
ret i8* %135
}