unsigned char *encode_seed(const unsigned short *seed) {
  static unsigned char buf[9] = {0, 0, 0, 0, 0, 0, 0, 0, 0};
  int i;
  buf[0] = seed[0] >> 10;
  buf[1] = seed[0] >> 4;
  buf[2] = (seed[0] << 2) | (seed[1] >> 14);
  buf[3] = seed[1] >> 8;
  buf[4] = seed[1] >> 2;
  buf[5] = (seed[1] << 4) | (seed[2] >> 12);
  buf[6] = seed[2] >> 6;
  buf[7] = seed[2];
  for (i = 0; i < 8; i++) {
    buf[i] &= 63;
    if (buf[i] < 10) {
      buf[i] += '0';
    } else if (buf[i] < 36) {
      buf[i] += 'A' - 10;
    } else if (buf[i] < 62) {
      buf[i] += 'a' - 36;
    } else if (buf[i] == 62) {
      buf[i] = '_';
    } else {
      buf[i] = '.';
    }
  }
  return buf;
}


x86 assembly (clang, -O0):
<encode_seed>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
mov    -0x8(%rbp),%rax
movzwl (%rax),%eax
sar    $0xa,%eax
mov    %al,0x2f09(%rip)
mov    -0x8(%rbp),%rax
movzwl (%rax),%eax
sar    $0x4,%eax
mov    %al,0x2efa(%rip)
mov    -0x8(%rbp),%rax
movzwl (%rax),%eax
shl    $0x2,%eax
mov    -0x8(%rbp),%rcx
movzwl 0x2(%rcx),%ecx
sar    $0xe,%ecx
or     %ecx,%eax
mov    %al,0x2ede(%rip)
mov    -0x8(%rbp),%rax
movzwl 0x2(%rax),%eax
sar    $0x8,%eax
mov    %al,0x2ece(%rip)
mov    -0x8(%rbp),%rax
movzwl 0x2(%rax),%eax
sar    $0x2,%eax
mov    %al,0x2ebe(%rip)
mov    -0x8(%rbp),%rax
movzwl 0x2(%rax),%eax
shl    $0x4,%eax
mov    -0x8(%rbp),%rcx
movzwl 0x4(%rcx),%ecx
sar    $0xc,%ecx
or     %ecx,%eax
mov    %al,0x2ea1(%rip)
mov    -0x8(%rbp),%rax
movzwl 0x4(%rax),%eax
sar    $0x6,%eax
mov    %al,0x2e91(%rip)
mov    -0x8(%rbp),%rax
mov    0x4(%rax),%ax
mov    %al,0x2e84(%rip)
movl   $0x0,-0xc(%rbp)
cmpl   $0x8,-0xc(%rbp)
jge    12e1 <encode_seed+0x1e1>
movslq -0xc(%rbp),%rcx
lea    0x2e61(%rip),%rax
movzbl (%rax,%rcx,1),%eax
and    $0x3f,%eax
mov    %al,%dl
lea    0x2e51(%rip),%rax
mov    %dl,(%rax,%rcx,1)
movslq -0xc(%rbp),%rcx
lea    0x2e43(%rip),%rax
movzbl (%rax,%rcx,1),%eax
cmp    $0xa,%eax
jge    120e <encode_seed+0x10e>
movslq -0xc(%rbp),%rcx
lea    0x2e2b(%rip),%rax
movzbl (%rax,%rcx,1),%eax
add    $0x30,%eax
mov    %al,%dl
lea    0x2e1b(%rip),%rax
mov    %dl,(%rax,%rcx,1)
jmp    12ce <encode_seed+0x1ce>
movslq -0xc(%rbp),%rcx
lea    0x2e08(%rip),%rax
movzbl (%rax,%rcx,1),%eax
cmp    $0x24,%eax
jge    1249 <encode_seed+0x149>
movslq -0xc(%rbp),%rcx
lea    0x2df0(%rip),%rax
movzbl (%rax,%rcx,1),%eax
add    $0x37,%eax
mov    %al,%dl
lea    0x2de0(%rip),%rax
mov    %dl,(%rax,%rcx,1)
jmp    12c9 <encode_seed+0x1c9>
movslq -0xc(%rbp),%rcx
lea    0x2dcd(%rip),%rax
movzbl (%rax,%rcx,1),%eax
cmp    $0x3e,%eax
jge    1284 <encode_seed+0x184>
movslq -0xc(%rbp),%rcx
lea    0x2db5(%rip),%rax
movzbl (%rax,%rcx,1),%eax
add    $0x3d,%eax
mov    %al,%dl
lea    0x2da5(%rip),%rax
mov    %dl,(%rax,%rcx,1)
jmp    12c4 <encode_seed+0x1c4>
movslq -0xc(%rbp),%rcx
lea    0x2d92(%rip),%rax
movzbl (%rax,%rcx,1),%eax
cmp    $0x3e,%eax
jne    12b0 <encode_seed+0x1b0>
movslq -0xc(%rbp),%rcx
lea    0x2d7a(%rip),%rax
movb   $0x5f,(%rax,%rcx,1)
jmp    12bf <encode_seed+0x1bf>
movslq -0xc(%rbp),%rcx
lea    0x2d66(%rip),%rax
movb   $0x2e,(%rax,%rcx,1)
jmp    12c4 <encode_seed+0x1c4>
jmp    12c9 <encode_seed+0x1c9>
jmp    12ce <encode_seed+0x1ce>
jmp    12d3 <encode_seed+0x1d3>
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc(%rbp)
jmp    11ab <encode_seed+0xab>
lea    0x2d39(%rip),%rax
pop    %rbp
ret

x86 assembly (clang, -O2):
<encode_seed>:
movzwl (%rdi),%eax
shr    $0xa,%eax
mov    %al,0x2f15(%rip)
movzwl (%rdi),%ecx
shr    $0x4,%ecx
mov    %cl,0x2f0a(%rip)
mov    (%rdi),%cl
shl    $0x2,%cl
movzwl 0x2(%rdi),%edx
shr    $0xe,%edx
or     %cl,%dl
mov    %dl,0x2ef7(%rip)
mov    0x3(%rdi),%cl
mov    %cl,0x2eef(%rip)
movzwl 0x2(%rdi),%ecx
shr    $0x2,%ecx
mov    %cl,0x2ee3(%rip)
mov    0x2(%rdi),%cl
shl    $0x4,%cl
movzwl 0x4(%rdi),%edx
shr    $0xc,%edx
or     %cl,%dl
mov    %dl,0x2ecf(%rip)
movzwl 0x4(%rdi),%ecx
shr    $0x6,%ecx
mov    %cl,0x2ec3(%rip)
mov    0x4(%rdi),%cl
mov    %cl,0x2ebb(%rip)
cmp    $0x9,%al
ja     1175 <encode_seed+0x75>
add    $0x30,%al
jmp    1194 <encode_seed+0x94>
cmp    $0x23,%al
ja     117d <encode_seed+0x7d>
add    $0x37,%al
jmp    1194 <encode_seed+0x94>
cmp    $0x3d,%al
ja     1185 <encode_seed+0x85>
add    $0x3d,%al
jmp    1194 <encode_seed+0x94>
cmp    $0x3e,%al
mov    $0x5f,%ecx
mov    $0x2e,%eax
cmove  %ecx,%eax
mov    %al,0x2e87(%rip)
mov    0x2e82(%rip),%al
and    $0x3f,%al
cmp    $0xa,%al
jae    11aa <encode_seed+0xaa>
add    $0x30,%al
jmp    11c7 <encode_seed+0xc7>
cmp    $0x24,%al
jae    11b2 <encode_seed+0xb2>
add    $0x37,%al
jmp    11c7 <encode_seed+0xc7>
cmp    $0x3e,%al
jae    11ba <encode_seed+0xba>
add    $0x3d,%al
jmp    11c7 <encode_seed+0xc7>
mov    $0x5f,%ecx
mov    $0x2e,%eax
cmove  %ecx,%eax
mov    %al,0x2e55(%rip)
mov    0x2e50(%rip),%al
and    $0x3f,%al
cmp    $0xa,%al
jae    11dd <encode_seed+0xdd>
add    $0x30,%al
jmp    11fa <encode_seed+0xfa>
cmp    $0x24,%al
jae    11e5 <encode_seed+0xe5>
add    $0x37,%al
jmp    11fa <encode_seed+0xfa>
cmp    $0x3e,%al
jae    11ed <encode_seed+0xed>
add    $0x3d,%al
jmp    11fa <encode_seed+0xfa>
mov    $0x5f,%ecx
mov    $0x2e,%eax
cmove  %ecx,%eax
mov    %al,0x2e23(%rip)
mov    0x2e1e(%rip),%al
and    $0x3f,%al
cmp    $0xa,%al
jae    1210 <encode_seed+0x110>
add    $0x30,%al
jmp    122d <encode_seed+0x12d>
cmp    $0x24,%al
jae    1218 <encode_seed+0x118>
add    $0x37,%al
jmp    122d <encode_seed+0x12d>
cmp    $0x3e,%al
jae    1220 <encode_seed+0x120>
add    $0x3d,%al
jmp    122d <encode_seed+0x12d>
mov    $0x5f,%ecx
mov    $0x2e,%eax
cmove  %ecx,%eax
mov    %al,0x2df1(%rip)
mov    0x2dec(%rip),%al
and    $0x3f,%al
cmp    $0xa,%al
jae    1243 <encode_seed+0x143>
add    $0x30,%al
jmp    1260 <encode_seed+0x160>
cmp    $0x24,%al
jae    124b <encode_seed+0x14b>
add    $0x37,%al
jmp    1260 <encode_seed+0x160>
cmp    $0x3e,%al
jae    1253 <encode_seed+0x153>
add    $0x3d,%al
jmp    1260 <encode_seed+0x160>
mov    $0x5f,%ecx
mov    $0x2e,%eax
cmove  %ecx,%eax
mov    %al,0x2dbf(%rip)
mov    0x2dba(%rip),%al
and    $0x3f,%al
cmp    $0xa,%al
jae    1276 <encode_seed+0x176>
add    $0x30,%al
jmp    1293 <encode_seed+0x193>
cmp    $0x24,%al
jae    127e <encode_seed+0x17e>
add    $0x37,%al
jmp    1293 <encode_seed+0x193>
cmp    $0x3e,%al
jae    1286 <encode_seed+0x186>
add    $0x3d,%al
jmp    1293 <encode_seed+0x193>
mov    $0x5f,%ecx
mov    $0x2e,%eax
cmove  %ecx,%eax
mov    %al,0x2d8d(%rip)
mov    0x2d88(%rip),%al
and    $0x3f,%al
cmp    $0xa,%al
jae    12a9 <encode_seed+0x1a9>
add    $0x30,%al
jmp    12c6 <encode_seed+0x1c6>
cmp    $0x24,%al
jae    12b1 <encode_seed+0x1b1>
add    $0x37,%al
jmp    12c6 <encode_seed+0x1c6>
cmp    $0x3e,%al
jae    12b9 <encode_seed+0x1b9>
add    $0x3d,%al
jmp    12c6 <encode_seed+0x1c6>
mov    $0x5f,%ecx
mov    $0x2e,%eax
cmove  %ecx,%eax
mov    %al,0x2d5b(%rip)
mov    0x2d56(%rip),%al
and    $0x3f,%al
cmp    $0xa,%al
jae    12dc <encode_seed+0x1dc>
add    $0x30,%al
jmp    12f9 <encode_seed+0x1f9>
cmp    $0x24,%al
jae    12e4 <encode_seed+0x1e4>
add    $0x37,%al
jmp    12f9 <encode_seed+0x1f9>
cmp    $0x3e,%al
jae    12ec <encode_seed+0x1ec>
add    $0x3d,%al
jmp    12f9 <encode_seed+0x1f9>
mov    $0x5f,%ecx
mov    $0x2e,%eax
cmove  %ecx,%eax
mov    %al,0x2d29(%rip)
lea    0x2d1b(%rip),%rax
ret

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

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