#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 /*<<< orphan*/ strcpy(char *, char *);
int strlen(char *);
int /*<<< orphan*/ strncat(char *, char *, int);
char *strrchr(char *, char);
int unpackpfx(int nprefix, char *call) {
  char nc, pfx[4] = {'\0'}, tmpcall[7];
  int i;
  int n;
  strcpy(tmpcall, call);
  if (nprefix < 60000) {
    n = nprefix;
    for (i = 2; i >= 0; i--) {
      nc = n % 37;
      if ((nc >= 0) & (nc <= 9)) {
        pfx[i] = nc + 48;
      } else if ((nc >= 10) & (nc <= 35)) {
        pfx[i] = nc + 55;
      } else {
        pfx[i] = ' ';
      }
      n = n / 37;
    }
    char *p = strrchr(pfx, ' ');
    strcpy(call, p ? p + 1 : pfx);
    strncat(call, "/", 1);
    strncat(call, tmpcall, strlen(tmpcall));
  } else {
    nc = nprefix - 60000;
    if ((nc >= 0) & (nc <= 9)) {
      pfx[0] = nc + 48;
      strcpy(call, tmpcall);
      strncat(call, "/", 1);
      strncat(call, pfx, 1);
    } else if ((nc >= 10) & (nc <= 35)) {
      pfx[0] = nc + 55;
      strcpy(call, tmpcall);
      strncat(call, "/", 1);
      strncat(call, pfx, 1);
    } else if ((nc >= 36) & (nc <= 125)) {
      pfx[0] = (nc - 26) / 10 + 48;
      pfx[1] = (nc - 26) % 10 + 48;
      strcpy(call, tmpcall);
      strncat(call, "/", 1);
      strncat(call, pfx, 2);
    } else {
      return 0;
    }
  }
  return 1;
}


x86 assembly (clang, -O0):
<unpackpfx>:
push   %rbp
mov    %rsp,%rbp
sub    $0x50,%rsp
mov    %edi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
lea    -0x15(%rbp),%rdi
xor    %esi,%esi
mov    $0x4,%edx
call   1060 <memset@plt>
lea    -0x1c(%rbp),%rdi
mov    -0x10(%rbp),%rsi
call   1030 <strcpy@plt>
cmpl   $0xea60,-0x8(%rbp)
jge    12e7 <unpackpfx+0x197>
mov    -0x8(%rbp),%eax
mov    %eax,-0x24(%rbp)
movl   $0x2,-0x20(%rbp)
cmpl   $0x0,-0x20(%rbp)
jl     125a <unpackpfx+0x10a>
mov    -0x24(%rbp),%eax
mov    $0x25,%ecx
cltd
idiv   %ecx
mov    %dl,%al
mov    %al,-0x11(%rbp)
movsbl -0x11(%rbp),%eax
cmp    $0x0,%eax
setge  %al
and    $0x1,%al
movzbl %al,%eax
movsbl -0x11(%rbp),%ecx
cmp    $0x9,%ecx
setle  %cl
and    $0x1,%cl
movzbl %cl,%ecx
and    %ecx,%eax
cmp    $0x0,%eax
je     11f0 <unpackpfx+0xa0>
movsbl -0x11(%rbp),%eax
add    $0x30,%eax
mov    %al,%cl
movslq -0x20(%rbp),%rax
mov    %cl,-0x15(%rbp,%rax,1)
jmp    123e <unpackpfx+0xee>
movsbl -0x11(%rbp),%eax
cmp    $0xa,%eax
setge  %al
and    $0x1,%al
movzbl %al,%eax
movsbl -0x11(%rbp),%ecx
cmp    $0x23,%ecx
setle  %cl
and    $0x1,%cl
movzbl %cl,%ecx
and    %ecx,%eax
cmp    $0x0,%eax
je     1230 <unpackpfx+0xe0>
movsbl -0x11(%rbp),%eax
add    $0x37,%eax
mov    %al,%cl
movslq -0x20(%rbp),%rax
mov    %cl,-0x15(%rbp,%rax,1)
jmp    1239 <unpackpfx+0xe9>
movslq -0x20(%rbp),%rax
movb   $0x20,-0x15(%rbp,%rax,1)
jmp    123e <unpackpfx+0xee>
mov    -0x24(%rbp),%eax
mov    $0x25,%ecx
cltd
idiv   %ecx
mov    %eax,-0x24(%rbp)
mov    -0x20(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x20(%rbp)
jmp    1196 <unpackpfx+0x46>
lea    -0x15(%rbp),%rdi
mov    $0x20,%esi
call   1050 <strrchr@plt>
mov    %rax,-0x30(%rbp)
mov    -0x10(%rbp),%rax
mov    %rax,-0x38(%rbp)
cmpq   $0x0,-0x30(%rbp)
je     1290 <unpackpfx+0x140>
mov    -0x30(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x40(%rbp)
jmp    1298 <unpackpfx+0x148>
lea    -0x15(%rbp),%rax
mov    %rax,-0x40(%rbp)
mov    -0x38(%rbp),%rdi
mov    -0x40(%rbp),%rsi
call   1030 <strcpy@plt>
mov    -0x10(%rbp),%rdi
lea    0xd50(%rip),%rsi
mov    $0x1,%edx
call   1070 <strncat@plt>
mov    -0x10(%rbp),%rax
mov    %rax,-0x50(%rbp)
lea    -0x1c(%rbp),%rax
mov    %rax,-0x48(%rbp)
lea    -0x1c(%rbp),%rdi
call   1040 <strlen@plt>
mov    -0x50(%rbp),%rdi
mov    -0x48(%rbp),%rsi
mov    %eax,%edx
call   1070 <strncat@plt>
jmp    1476 <unpackpfx+0x326>
mov    -0x8(%rbp),%eax
sub    $0xea60,%eax
mov    %al,-0x11(%rbp)
movsbl -0x11(%rbp),%eax
cmp    $0x0,%eax
setge  %al
and    $0x1,%al
movzbl %al,%eax
movsbl -0x11(%rbp),%ecx
cmp    $0x9,%ecx
setle  %cl
and    $0x1,%cl
movzbl %cl,%ecx
and    %ecx,%eax
cmp    $0x0,%eax
je     135f <unpackpfx+0x20f>
movsbl -0x11(%rbp),%eax
add    $0x30,%eax
mov    %al,-0x15(%rbp)
mov    -0x10(%rbp),%rdi
lea    -0x1c(%rbp),%rsi
call   1030 <strcpy@plt>
mov    -0x10(%rbp),%rdi
lea    0xcc2(%rip),%rsi
mov    $0x1,%edx
call   1070 <strncat@plt>
mov    -0x10(%rbp),%rdi
lea    -0x15(%rbp),%rsi
mov    $0x1,%edx
call   1070 <strncat@plt>
jmp    1471 <unpackpfx+0x321>
movsbl -0x11(%rbp),%eax
cmp    $0xa,%eax
setge  %al
and    $0x1,%al
movzbl %al,%eax
movsbl -0x11(%rbp),%ecx
cmp    $0x23,%ecx
setle  %cl
and    $0x1,%cl
movzbl %cl,%ecx
and    %ecx,%eax
cmp    $0x0,%eax
je     13cc <unpackpfx+0x27c>
movsbl -0x11(%rbp),%eax
add    $0x37,%eax
mov    %al,-0x15(%rbp)
mov    -0x10(%rbp),%rdi
lea    -0x1c(%rbp),%rsi
call   1030 <strcpy@plt>
mov    -0x10(%rbp),%rdi
lea    0xc55(%rip),%rsi
mov    $0x1,%edx
call   1070 <strncat@plt>
mov    -0x10(%rbp),%rdi
lea    -0x15(%rbp),%rsi
mov    $0x1,%edx
call   1070 <strncat@plt>
jmp    146c <unpackpfx+0x31c>
movsbl -0x11(%rbp),%eax
cmp    $0x24,%eax
setge  %al
and    $0x1,%al
movzbl %al,%eax
movsbl -0x11(%rbp),%ecx
cmp    $0x7d,%ecx
setle  %cl
and    $0x1,%cl
movzbl %cl,%ecx
and    %ecx,%eax
cmp    $0x0,%eax
je     145b <unpackpfx+0x30b>
movsbl -0x11(%rbp),%eax
sub    $0x1a,%eax
mov    $0xa,%ecx
cltd
idiv   %ecx
add    $0x30,%eax
mov    %al,-0x15(%rbp)
movsbl -0x11(%rbp),%eax
sub    $0x1a,%eax
mov    $0xa,%ecx
cltd
idiv   %ecx
add    $0x30,%edx
mov    %dl,%al
mov    %al,-0x14(%rbp)
mov    -0x10(%rbp),%rdi
lea    -0x1c(%rbp),%rsi
call   1030 <strcpy@plt>
mov    -0x10(%rbp),%rdi
lea    0xbc6(%rip),%rsi
mov    $0x1,%edx
call   1070 <strncat@plt>
mov    -0x10(%rbp),%rdi
lea    -0x15(%rbp),%rsi
mov    $0x2,%edx
call   1070 <strncat@plt>
jmp    1467 <unpackpfx+0x317>
movl   $0x0,-0x4(%rbp)
jmp    147d <unpackpfx+0x32d>
jmp    146c <unpackpfx+0x31c>
jmp    1471 <unpackpfx+0x321>
jmp    1476 <unpackpfx+0x326>
movl   $0x1,-0x4(%rbp)
mov    -0x4(%rbp),%eax
add    $0x50,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<unpackpfx>:
push   %rbp
push   %r14
push   %rbx
sub    $0x10,%rsp
mov    %rsi,%r14
mov    %edi,%ebx
movl   $0x0,0x4(%rsp)
lea    0x9(%rsp),%rdi
call   1030 <strcpy@plt>
cmp    $0xea5f,%ebx
jg     11a2 <unpackpfx+0x62>
movslq %ebx,%rax
imul   $0xffffffffdd67c8a7,%rax,%rcx
shr    $0x20,%rcx
add    %ebx,%ecx
mov    %ecx,%edx
shr    $0x1f,%edx
sar    $0x5,%ecx
add    %edx,%ecx
lea    (%rcx,%rcx,8),%edx
lea    (%rcx,%rdx,4),%edx
sub    %edx,%ebx
mov    %ebx,%edx
not    %edx
shr    $0x1f,%edx
xor    %esi,%esi
cmp    $0xa,%ebx
setl   %sil
test   %esi,%edx
je     1210 <unpackpfx+0xd0>
add    $0x30,%bl
jmp    121d <unpackpfx+0xdd>
shl    $0x18,%ebx
lea    -0x60000000(%rbx),%eax
sar    $0x18,%eax
lea    -0x5f000001(%rbx),%ecx
cmp    $0xafffffe,%ecx
ja     11c0 <unpackpfx+0x80>
add    $0x30,%al
jmp    11d4 <unpackpfx+0x94>
lea    -0x69000001(%rbx),%ecx
cmp    $0x1afffffe,%ecx
ja     1335 <unpackpfx+0x1f5>
add    $0x37,%al
mov    %al,0x4(%rsp)
lea    0x9(%rsp),%rsi
mov    %r14,%rdi
call   1030 <strcpy@plt>
lea    0xe14(%rip),%rsi
mov    $0x1,%ebp
mov    %r14,%rdi
mov    $0x1,%edx
call   1060 <strncat@plt>
lea    0x4(%rsp),%rsi
mov    %r14,%rdi
mov    $0x1,%edx
jmp    1325 <unpackpfx+0x1e5>
lea    -0xa(%rbx),%esi
mov    $0x20,%dl
cmp    $0x19,%esi
ja     121f <unpackpfx+0xdf>
add    $0x37,%bl
mov    %ebx,%edx
mov    %dl,0x6(%rsp)
movslq %ecx,%rdx
imul   $0xffffffffdd67c8a7,%rdx,%rdx
shr    $0x20,%rdx
add    %ecx,%edx
mov    %edx,%esi
shr    $0x1f,%esi
sar    $0x5,%edx
add    %esi,%edx
lea    (%rdx,%rdx,8),%esi
lea    (%rdx,%rsi,4),%edx
sub    %edx,%ecx
mov    %ecx,%edx
not    %edx
shr    $0x1f,%edx
xor    %esi,%esi
cmp    $0xa,%ecx
setl   %sil
test   %esi,%edx
je     125e <unpackpfx+0x11e>
add    $0x30,%cl
jmp    126b <unpackpfx+0x12b>
lea    -0xa(%rcx),%esi
mov    $0x20,%dl
cmp    $0x19,%esi
ja     126d <unpackpfx+0x12d>
add    $0x37,%cl
mov    %ecx,%edx
mov    %dl,0x5(%rsp)
imul   $0x5fbe2d41,%rax,%rax
mov    %rax,%rcx
shr    $0x3f,%rcx
shr    $0x20,%rax
sar    $0x9,%eax
add    %ecx,%eax
cltq
imul   $0xffffffffdd67c8a7,%rax,%rcx
shr    $0x20,%rcx
add    %eax,%ecx
mov    %ecx,%edx
shr    $0x1f,%edx
sar    $0x5,%ecx
add    %edx,%ecx
lea    (%rcx,%rcx,8),%edx
lea    (%rcx,%rdx,4),%ecx
sub    %ecx,%eax
mov    %eax,%ecx
not    %ecx
shr    $0x1f,%ecx
xor    %edx,%edx
cmp    $0xa,%eax
setl   %dl
test   %edx,%ecx
je     12c0 <unpackpfx+0x180>
add    $0x30,%al
jmp    12ce <unpackpfx+0x18e>
lea    -0xa(%rax),%ecx
cmp    $0x1a,%ecx
jae    13a1 <unpackpfx+0x261>
add    $0x37,%al
mov    %al,0x4(%rsp)
lea    0x4(%rsp),%rbx
mov    %rbx,%rdi
mov    $0x20,%esi
call   1050 <strrchr@plt>
lea    0x1(%rax),%rsi
test   %rax,%rax
cmove  %rbx,%rsi
mov    %r14,%rdi
call   1030 <strcpy@plt>
lea    0xd02(%rip),%rsi
mov    $0x1,%ebp
mov    %r14,%rdi
mov    $0x1,%edx
call   1060 <strncat@plt>
lea    0x9(%rsp),%rbx
mov    %rbx,%rdi
call   1040 <strlen@plt>
mov    %r14,%rdi
mov    %rbx,%rsi
mov    %eax,%edx
call   1060 <strncat@plt>
mov    %ebp,%eax
add    $0x10,%rsp
pop    %rbx
pop    %r14
pop    %rbp
ret
add    $0x7cffffff,%ebx
xor    %ebp,%ebp
cmp    $0x5afffffe,%ebx
ja     132a <unpackpfx+0x1ea>
add    $0xffffffe6,%eax
imul   $0x6667,%eax,%ecx
mov    %ecx,%edx
shr    $0x1f,%edx
sar    $0x12,%ecx
add    %edx,%ecx
lea    0x30(%rcx),%edx
mov    %dl,0x4(%rsp)
add    %ecx,%ecx
lea    (%rcx,%rcx,4),%ecx
sub    %ecx,%eax
add    $0x30,%al
mov    %al,0x5(%rsp)
lea    0x9(%rsp),%rsi
mov    %r14,%rdi
call   1030 <strcpy@plt>
lea    0xc80(%rip),%rsi
mov    $0x1,%ebp
mov    %r14,%rdi
mov    $0x1,%edx
call   1060 <strncat@plt>
lea    0x4(%rsp),%rsi
mov    %r14,%rdi
mov    $0x2,%edx
jmp    1325 <unpackpfx+0x1e5>
movb   $0x20,0x4(%rsp)
jmp    12d2 <unpackpfx+0x192>

LLVM IR (-O0):
@.str = [2 x i8] c"/\00"
define i32 @unpackpfx(i32 %0, i8* %1) {
%3 = alloca i32
%4 = alloca i32
%5 = alloca i8*
%6 = alloca i8
%7 = alloca [4 x i8]
%8 = alloca [7 x i8]
%9 = alloca i32
%10 = alloca i32
%11 = alloca i8*
store i32 %0, i32* %4
store i8* %1, i8** %5
%12 = bitcast [4 x i8]* %7 to i8*
%13 = getelementptr inbounds [7 x i8], [7 x i8]* %8, i64 0, i64 0
%14 = load i8*, i8** %5
%15 = call i32 @strcpy(i8* %13, i8* %14)
%16 = load i32, i32* %4
%17 = icmp slt i32 %16, 60000
br i1 %17, label %18, label %96
18: ; preds = %2
%19 = load i32, i32* %4
store i32 %19, i32* %10
store i32 2, i32* %9
br label %20
20: ; preds = %72, %18
%21 = load i32, i32* %9
%22 = icmp sge i32 %21, 0
br i1 %22, label %23, label %75
23: ; preds = %20
%24 = load i32, i32* %10
%25 = srem i32 %24, 37
%26 = trunc i32 %25 to i8
store i8 %26, i8* %6
%27 = load i8, i8* %6
%28 = sext i8 %27 to i32
%29 = icmp sge i32 %28, 0
%30 = zext i1 %29 to i32
%31 = load i8, i8* %6
%32 = sext i8 %31 to i32
%33 = icmp sle i32 %32, 9
%34 = zext i1 %33 to i32
%35 = and i32 %30, %34
%36 = icmp ne i32 %35, 0
br i1 %36, label %37, label %45
37: ; preds = %23
%38 = load i8, i8* %6
%39 = sext i8 %38 to i32
%40 = add nsw i32 %39, 48
%41 = trunc i32 %40 to i8
%42 = load i32, i32* %9
%43 = sext i32 %42 to i64
%44 = getelementptr inbounds [4 x i8], [4 x i8]* %7, i64 0, i64 %43
store i8 %41, i8* %44
br label %69
45: ; preds = %23
%46 = load i8, i8* %6
%47 = sext i8 %46 to i32
%48 = icmp sge i32 %47, 10
%49 = zext i1 %48 to i32
%50 = load i8, i8* %6
%51 = sext i8 %50 to i32
%52 = icmp sle i32 %51, 35
%53 = zext i1 %52 to i32
%54 = and i32 %49, %53
%55 = icmp ne i32 %54, 0
br i1 %55, label %56, label %64
56: ; preds = %45
%57 = load i8, i8* %6
%58 = sext i8 %57 to i32
%59 = add nsw i32 %58, 55
%60 = trunc i32 %59 to i8
%61 = load i32, i32* %9
%62 = sext i32 %61 to i64
%63 = getelementptr inbounds [4 x i8], [4 x i8]* %7, i64 0, i64 %62
store i8 %60, i8* %63
br label %68
64: ; preds = %45
%65 = load i32, i32* %9
%66 = sext i32 %65 to i64
%67 = getelementptr inbounds [4 x i8], [4 x i8]* %7, i64 0, i64 %66
store i8 32, i8* %67
br label %68
68: ; preds = %64, %56
br label %69
69: ; preds = %68, %37
%70 = load i32, i32* %10
%71 = sdiv i32 %70, 37
store i32 %71, i32* %10
br label %72
72: ; preds = %69
%73 = load i32, i32* %9
%74 = add nsw i32 %73, -1
store i32 %74, i32* %9
br label %20
75: ; preds = %20
%76 = getelementptr inbounds [4 x i8], [4 x i8]* %7, i64 0, i64 0
%77 = call i8* @strrchr(i8* %76, i8 signext 32)
store i8* %77, i8** %11
%78 = load i8*, i8** %5
%79 = load i8*, i8** %11
%80 = icmp ne i8* %79, null
br i1 %80, label %81, label %84
81: ; preds = %75
%82 = load i8*, i8** %11
%83 = getelementptr inbounds i8, i8* %82, i64 1
br label %86
84: ; preds = %75
%85 = getelementptr inbounds [4 x i8], [4 x i8]* %7, i64 0, i64 0
br label %86
86: ; preds = %84, %81
%87 = phi i8* [ %83, %81 ], [ %85, %84 ]
%88 = call i32 @strcpy(i8* %78, i8* %87)
%89 = load i8*, i8** %5
%90 = call i32 @strncat(i8* %89, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str, i64 0, i64 0), i32 1)
%91 = load i8*, i8** %5
%92 = getelementptr inbounds [7 x i8], [7 x i8]* %8, i64 0, i64 0
%93 = getelementptr inbounds [7 x i8], [7 x i8]* %8, i64 0, i64 0
%94 = call i32 @strlen(i8* %93)
%95 = call i32 @strncat(i8* %91, i8* %92, i32 %94)
br label %187
96: ; preds = %2
%97 = load i32, i32* %4
%98 = sub nsw i32 %97, 60000
%99 = trunc i32 %98 to i8
store i8 %99, i8* %6
%100 = load i8, i8* %6
%101 = sext i8 %100 to i32
%102 = icmp sge i32 %101, 0
%103 = zext i1 %102 to i32
%104 = load i8, i8* %6
%105 = sext i8 %104 to i32
%106 = icmp sle i32 %105, 9
%107 = zext i1 %106 to i32
%108 = and i32 %103, %107
%109 = icmp ne i32 %108, 0
br i1 %109, label %110, label %124
110: ; preds = %96
%111 = load i8, i8* %6
%112 = sext i8 %111 to i32
%113 = add nsw i32 %112, 48
%114 = trunc i32 %113 to i8
%115 = getelementptr inbounds [4 x i8], [4 x i8]* %7, i64 0, i64 0
store i8 %114, i8* %115
%116 = load i8*, i8** %5
%117 = getelementptr inbounds [7 x i8], [7 x i8]* %8, i64 0, i64 0
%118 = call i32 @strcpy(i8* %116, i8* %117)
%119 = load i8*, i8** %5
%120 = call i32 @strncat(i8* %119, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str, i64 0, i64 0), i32 1)
%121 = load i8*, i8** %5
%122 = getelementptr inbounds [4 x i8], [4 x i8]* %7, i64 0, i64 0
%123 = call i32 @strncat(i8* %121, i8* %122, i32 1)
br label %186
124: ; preds = %96
%125 = load i8, i8* %6
%126 = sext i8 %125 to i32
%127 = icmp sge i32 %126, 10
%128 = zext i1 %127 to i32
%129 = load i8, i8* %6
%130 = sext i8 %129 to i32
%131 = icmp sle i32 %130, 35
%132 = zext i1 %131 to i32
%133 = and i32 %128, %132
%134 = icmp ne i32 %133, 0
br i1 %134, label %135, label %149
135: ; preds = %124
%136 = load i8, i8* %6
%137 = sext i8 %136 to i32
%138 = add nsw i32 %137, 55
%139 = trunc i32 %138 to i8
%140 = getelementptr inbounds [4 x i8], [4 x i8]* %7, i64 0, i64 0
store i8 %139, i8* %140
%141 = load i8*, i8** %5
%142 = getelementptr inbounds [7 x i8], [7 x i8]* %8, i64 0, i64 0
%143 = call i32 @strcpy(i8* %141, i8* %142)
%144 = load i8*, i8** %5
%145 = call i32 @strncat(i8* %144, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str, i64 0, i64 0), i32 1)
%146 = load i8*, i8** %5
%147 = getelementptr inbounds [4 x i8], [4 x i8]* %7, i64 0, i64 0
%148 = call i32 @strncat(i8* %146, i8* %147, i32 1)
br label %185
149: ; preds = %124
%150 = load i8, i8* %6
%151 = sext i8 %150 to i32
%152 = icmp sge i32 %151, 36
%153 = zext i1 %152 to i32
%154 = load i8, i8* %6
%155 = sext i8 %154 to i32
%156 = icmp sle i32 %155, 125
%157 = zext i1 %156 to i32
%158 = and i32 %153, %157
%159 = icmp ne i32 %158, 0
br i1 %159, label %160, label %183
160: ; preds = %149
%161 = load i8, i8* %6
%162 = sext i8 %161 to i32
%163 = sub nsw i32 %162, 26
%164 = sdiv i32 %163, 10
%165 = add nsw i32 %164, 48
%166 = trunc i32 %165 to i8
%167 = getelementptr inbounds [4 x i8], [4 x i8]* %7, i64 0, i64 0
store i8 %166, i8* %167
%168 = load i8, i8* %6
%169 = sext i8 %168 to i32
%170 = sub nsw i32 %169, 26
%171 = srem i32 %170, 10
%172 = add nsw i32 %171, 48
%173 = trunc i32 %172 to i8
%174 = getelementptr inbounds [4 x i8], [4 x i8]* %7, i64 0, i64 1
store i8 %173, i8* %174
%175 = load i8*, i8** %5
%176 = getelementptr inbounds [7 x i8], [7 x i8]* %8, i64 0, i64 0
%177 = call i32 @strcpy(i8* %175, i8* %176)
%178 = load i8*, i8** %5
%179 = call i32 @strncat(i8* %178, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str, i64 0, i64 0), i32 1)
%180 = load i8*, i8** %5
%181 = getelementptr inbounds [4 x i8], [4 x i8]* %7, i64 0, i64 0
%182 = call i32 @strncat(i8* %180, i8* %181, i32 2)
br label %184
183: ; preds = %149
store i32 0, i32* %3
br label %188
184: ; preds = %160
br label %185
185: ; preds = %184, %135
br label %186
186: ; preds = %185, %110
br label %187
187: ; preds = %186, %86
store i32 1, i32* %3
br label %188
188: ; preds = %187, %183
%189 = load i32, i32* %3
ret i32 %189
}

LLVM IR (-O2):
@.str = [2 x i8] c"/\00"
define i32 @unpackpfx(i32 %0, i8* %1) {
%3 = alloca i32
%4 = bitcast i32* %3 to [4 x i8]*
%5 = alloca [7 x i8]
%6 = bitcast i32* %3 to i8*
store i32 0, i32* %3
%7 = getelementptr inbounds [7 x i8], [7 x i8]* %5, i64 0, i64 0
%8 = call i32 @strcpy(i8* %7, i8* %1)
%9 = icmp slt i32 %0, 60000
br i1 %9, label %10, label %80
10: ; preds = %2
%11 = srem i32 %0, 37
%12 = sdiv i32 %0, 37
%13 = xor i32 %11, -1
%14 = lshr i32 %13, 31
%15 = icmp slt i32 %11, 10
%16 = zext i1 %15 to i32
%17 = and i32 %14, %16
%18 = icmp eq i32 %17, 0
br i1 %18, label %22, label %19
19: ; preds = %10
%20 = trunc i32 %11 to i8
%21 = add nsw i8 %20, 48
br label %28
22: ; preds = %10
%23 = add nsw i32 %11, -10
%24 = icmp ult i32 %23, 26
br i1 %24, label %25, label %28
25: ; preds = %22
%26 = trunc i32 %11 to i8
%27 = add nuw nsw i8 %26, 55
br label %28
28: ; preds = %22, %25, %19
%29 = phi i8 [ %27, %25 ], [ %21, %19 ], [ 32, %22 ]
%30 = getelementptr inbounds [4 x i8], [4 x i8]* %4, i64 0, i64 2
store i8 %29, i8* %30
%31 = srem i32 %12, 37
%32 = xor i32 %31, -1
%33 = lshr i32 %32, 31
%34 = icmp slt i32 %31, 10
%35 = zext i1 %34 to i32
%36 = and i32 %33, %35
%37 = icmp eq i32 %36, 0
br i1 %37, label %41, label %38
38: ; preds = %28
%39 = trunc i32 %31 to i8
%40 = add nsw i8 %39, 48
br label %47
41: ; preds = %28
%42 = add nsw i32 %31, -10
%43 = icmp ult i32 %42, 26
br i1 %43, label %44, label %47
44: ; preds = %41
%45 = trunc i32 %31 to i8
%46 = add nuw nsw i8 %45, 55
br label %47
47: ; preds = %41, %44, %38
%48 = phi i8 [ %46, %44 ], [ %40, %38 ], [ 32, %41 ]
%49 = getelementptr inbounds [4 x i8], [4 x i8]* %4, i64 0, i64 1
store i8 %48, i8* %49
%50 = sdiv i32 %0, 1369
%51 = srem i32 %50, 37
%52 = xor i32 %51, -1
%53 = lshr i32 %52, 31
%54 = icmp slt i32 %51, 10
%55 = zext i1 %54 to i32
%56 = and i32 %53, %55
%57 = icmp eq i32 %56, 0
br i1 %57, label %62, label %58
58: ; preds = %47
%59 = trunc i32 %51 to i8
%60 = add nsw i8 %59, 48
%61 = bitcast i32* %3 to i8*
store i8 %60, i8* %61
br label %71
62: ; preds = %47
%63 = add nsw i32 %51, -10
%64 = icmp ult i32 %63, 26
br i1 %64, label %67, label %65
65: ; preds = %62
%66 = bitcast i32* %3 to i8*
store i8 32, i8* %66
br label %71
67: ; preds = %62
%68 = trunc i32 %51 to i8
%69 = add nuw nsw i8 %68, 55
%70 = bitcast i32* %3 to i8*
store i8 %69, i8* %70
br label %71
71: ; preds = %67, %65, %58
%72 = call i8* @strrchr(i8* %6, i8 signext 32)
%73 = icmp eq i8* %72, null
%74 = getelementptr inbounds i8, i8* %72, i64 1
%75 = select i1 %73, i8* %6, i8* %74
%76 = call i32 @strcpy(i8* %1, i8* %75)
%77 = call i32 @strncat(i8* %1, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str, i64 0, i64 0), i32 1)
%78 = call i32 @strlen(i8* %7)
%79 = call i32 @strncat(i8* %1, i8* %7, i32 %78)
br label %117
80: ; preds = %2
%81 = shl i32 %0, 24
%82 = add i32 %81, -1610612736
%83 = ashr exact i32 %82, 24
%84 = add i32 %81, -1593835521
%85 = icmp ult i32 %84, 184549375
br i1 %85, label %86, label %92
86: ; preds = %80
%87 = trunc i32 %83 to i8
%88 = add i8 %87, 48
store i8 %88, i8* %6
%89 = call i32 @strcpy(i8* %1, i8* %7)
%90 = call i32 @strncat(i8* %1, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str, i64 0, i64 0), i32 1)
%91 = call i32 @strncat(i8* %1, i8* %6, i32 1)
br label %117
92: ; preds = %80
%93 = add i32 %81, -1761607681
%94 = icmp ult i32 %93, 452984831
br i1 %94, label %95, label %101
95: ; preds = %92
%96 = trunc i32 %83 to i8
%97 = add i8 %96, 55
store i8 %97, i8* %6
%98 = call i32 @strcpy(i8* %1, i8* %7)
%99 = call i32 @strncat(i8* %1, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str, i64 0, i64 0), i32 1)
%100 = call i32 @strncat(i8* %1, i8* %6, i32 1)
br label %117
101: ; preds = %92
%102 = add i32 %81, 2097151999
%103 = icmp ult i32 %102, 1526726655
br i1 %103, label %104, label %117
104: ; preds = %101
%105 = trunc i32 %83 to i16
%106 = add nsw i16 %105, -26
%107 = sdiv i16 %106, 10
%108 = trunc i16 %107 to i8
%109 = add nsw i8 %108, 48
store i8 %109, i8* %6
%110 = srem i16 %106, 10
%111 = trunc i16 %110 to i8
%112 = add nsw i8 %111, 48
%113 = getelementptr inbounds [4 x i8], [4 x i8]* %4, i64 0, i64 1
store i8 %112, i8* %113
%114 = call i32 @strcpy(i8* %1, i8* %7)
%115 = call i32 @strncat(i8* %1, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str, i64 0, i64 0), i32 1)
%116 = call i32 @strncat(i8* %1, i8* %6, i32 2)
br label %117
117: ; preds = %71, %95, %104, %86, %101
%118 = phi i32 [ 0, %101 ], [ 1, %86 ], [ 1, %104 ], [ 1, %95 ], [ 1, %71 ]
ret i32 %118
}