#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*/ inverseArray(unsigned char *, unsigned short);
unsigned char inverseStrToBCD(unsigned char *s, unsigned short sLen,
                              unsigned char *t, unsigned short tLen) {
  unsigned short i = 0;
  if (sLen % 2)
    return 0x01;
  for (i = 0; i < sLen / 2; i++, s += 2) {
    t[i] =
        (((s[0] >= '0' && s[0] <= '9')
              ? (s[0] - '0')
              : ((s[0] >= 'A' && s[0] <= 'F')
                     ? (s[0] - 'A' + 10)
                     : ((s[0] >= 'a' && s[0] <= 'f') ? (s[0] - 'a' + 10) : 0)))
             << 4 |
         ((s[1] >= '0' && s[1] <= '9')
              ? (s[1] - '0')
              : ((s[1] >= 'A' && s[1] <= 'F')
                     ? (s[1] - 'A' + 10)
                     : ((s[1] >= 'a' && s[1] <= 'f') ? (s[1] - 'a' + 10)
                                                     : 0))));
  }
  inverseArray(t, i);
  return 0x00;
}


x86 assembly (clang, -O0):
<inverseStrToBCD>:
push   %rbp
mov    %rsp,%rbp
sub    $0x50,%rsp
mov    %cx,%ax
mov    %si,%cx
mov    %rdi,-0x10(%rbp)
mov    %cx,-0x12(%rbp)
mov    %rdx,-0x20(%rbp)
mov    %ax,-0x22(%rbp)
movw   $0x0,-0x24(%rbp)
movzwl -0x12(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
cmp    $0x0,%edx
je     1152 <inverseStrToBCD+0x42>
movb   $0x1,-0x1(%rbp)
jmp    1331 <inverseStrToBCD+0x221>
movw   $0x0,-0x24(%rbp)
movzwl -0x24(%rbp),%eax
mov    %eax,-0x28(%rbp)
movzwl -0x12(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0x28(%rbp),%eax
cmp    %ecx,%eax
jge    1320 <inverseStrToBCD+0x210>
mov    -0x10(%rbp),%rax
movzbl (%rax),%eax
cmp    $0x30,%eax
jl     11aa <inverseStrToBCD+0x9a>
mov    -0x10(%rbp),%rax
movzbl (%rax),%eax
cmp    $0x39,%eax
jg     11aa <inverseStrToBCD+0x9a>
mov    -0x10(%rbp),%rax
movzbl (%rax),%eax
sub    $0x30,%eax
mov    %eax,-0x2c(%rbp)
jmp    122a <inverseStrToBCD+0x11a>
mov    -0x10(%rbp),%rax
movzbl (%rax),%eax
cmp    $0x41,%eax
jl     11df <inverseStrToBCD+0xcf>
mov    -0x10(%rbp),%rax
movzbl (%rax),%eax
cmp    $0x46,%eax
jg     11df <inverseStrToBCD+0xcf>
mov    -0x10(%rbp),%rax
movzbl (%rax),%eax
sub    $0x41,%eax
add    $0xa,%eax
mov    %eax,-0x30(%rbp)
jmp    1224 <inverseStrToBCD+0x114>
mov    -0x10(%rbp),%rax
movzbl (%rax),%eax
cmp    $0x61,%eax
jl     1214 <inverseStrToBCD+0x104>
mov    -0x10(%rbp),%rax
movzbl (%rax),%eax
cmp    $0x66,%eax
jg     1214 <inverseStrToBCD+0x104>
mov    -0x10(%rbp),%rax
movzbl (%rax),%eax
sub    $0x61,%eax
add    $0xa,%eax
mov    %eax,-0x34(%rbp)
jmp    121e <inverseStrToBCD+0x10e>
xor    %eax,%eax
mov    %eax,-0x34(%rbp)
jmp    121e <inverseStrToBCD+0x10e>
mov    -0x34(%rbp),%eax
mov    %eax,-0x30(%rbp)
mov    -0x30(%rbp),%eax
mov    %eax,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
shl    $0x4,%eax
mov    %eax,-0x38(%rbp)
mov    -0x10(%rbp),%rax
movzbl 0x1(%rax),%eax
cmp    $0x30,%eax
jl     1268 <inverseStrToBCD+0x158>
mov    -0x10(%rbp),%rax
movzbl 0x1(%rax),%eax
cmp    $0x39,%eax
jg     1268 <inverseStrToBCD+0x158>
mov    -0x10(%rbp),%rax
movzbl 0x1(%rax),%eax
sub    $0x30,%eax
mov    %eax,-0x3c(%rbp)
jmp    12ee <inverseStrToBCD+0x1de>
mov    -0x10(%rbp),%rax
movzbl 0x1(%rax),%eax
cmp    $0x41,%eax
jl     12a0 <inverseStrToBCD+0x190>
mov    -0x10(%rbp),%rax
movzbl 0x1(%rax),%eax
cmp    $0x46,%eax
jg     12a0 <inverseStrToBCD+0x190>
mov    -0x10(%rbp),%rax
movzbl 0x1(%rax),%eax
sub    $0x41,%eax
add    $0xa,%eax
mov    %eax,-0x40(%rbp)
jmp    12e8 <inverseStrToBCD+0x1d8>
mov    -0x10(%rbp),%rax
movzbl 0x1(%rax),%eax
cmp    $0x61,%eax
jl     12d8 <inverseStrToBCD+0x1c8>
mov    -0x10(%rbp),%rax
movzbl 0x1(%rax),%eax
cmp    $0x66,%eax
jg     12d8 <inverseStrToBCD+0x1c8>
mov    -0x10(%rbp),%rax
movzbl 0x1(%rax),%eax
sub    $0x61,%eax
add    $0xa,%eax
mov    %eax,-0x44(%rbp)
jmp    12e2 <inverseStrToBCD+0x1d2>
xor    %eax,%eax
mov    %eax,-0x44(%rbp)
jmp    12e2 <inverseStrToBCD+0x1d2>
mov    -0x44(%rbp),%eax
mov    %eax,-0x40(%rbp)
mov    -0x40(%rbp),%eax
mov    %eax,-0x3c(%rbp)
mov    -0x38(%rbp),%eax
mov    -0x3c(%rbp),%ecx
or     %ecx,%eax
mov    %al,%dl
mov    -0x20(%rbp),%rax
movzwl -0x24(%rbp),%ecx
mov    %dl,(%rax,%rcx,1)
mov    -0x24(%rbp),%ax
add    $0x1,%ax
mov    %ax,-0x24(%rbp)
mov    -0x10(%rbp),%rax
add    $0x2,%rax
mov    %rax,-0x10(%rbp)
jmp    1158 <inverseStrToBCD+0x48>
mov    -0x20(%rbp),%rdi
movzwl -0x24(%rbp),%esi
call   1030 <inverseArray@plt>
movb   $0x0,-0x1(%rbp)
movzbl -0x1(%rbp),%eax
add    $0x50,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<inverseStrToBCD>:
mov    $0x1,%al
test   $0x1,%sil
jne    1131 <inverseStrToBCD+0x21>
push   %rbx
cmp    $0x2,%si
jae    1132 <inverseStrToBCD+0x22>
xor    %r9d,%r9d
movzwl %r9w,%esi
mov    %rdx,%rdi
call   1030 <inverseArray@plt>
xor    %eax,%eax
pop    %rbx
ret
shr    %esi
cmp    $0x2,%esi
mov    $0x1,%r9d
cmovae %esi,%r9d
xor    %r8d,%r8d
cmp    $0x8,%r9d
jb     1164 <inverseStrToBCD+0x54>
lea    (%rdi,%r9,2),%rax
cmp    %rdx,%rax
jbe    11f3 <inverseStrToBCD+0xe3>
lea    (%rdx,%r9,1),%rax
cmp    %rdi,%rax
jbe    11f3 <inverseStrToBCD+0xe3>
xor    %eax,%eax
mov    %rdi,%r10
lea    (%rdx,%rax,1),%r11
mov    %r9,%rdi
sub    %rax,%rdi
xor    %eax,%eax
jmp    11a1 <inverseStrToBCD+0x91>
nopw   0x0(%rax,%rax,1)
lea    -0x61(%rsi),%ebx
add    $0xa9,%sil
cmp    $0x6,%bl
movzbl %sil,%ebx
cmovae %r8d,%ebx
or     %cl,%bl
mov    %bl,(%r11,%rax,1)
add    $0x1,%rax
cmp    %rax,%rdi
je     1122 <inverseStrToBCD+0x12>
movzbl (%r10,%rax,2),%esi
lea    -0x30(%rsi),%ecx
cmp    $0xa,%cl
jb     11d2 <inverseStrToBCD+0xc2>
lea    -0x41(%rsi),%ecx
cmp    $0x5,%cl
ja     11c0 <inverseStrToBCD+0xb0>
add    $0xc9,%sil
mov    %esi,%ecx
jmp    11d2 <inverseStrToBCD+0xc2>
xchg   %ax,%ax
lea    -0x61(%rsi),%ecx
add    $0xa9,%sil
cmp    $0x6,%cl
movzbl %sil,%ecx
cmovae %r8d,%ecx
shl    $0x4,%cl
movzbl 0x1(%r10,%rax,2),%esi
lea    -0x30(%rsi),%ebx
cmp    $0xa,%bl
jb     1192 <inverseStrToBCD+0x82>
lea    -0x41(%rsi),%ebx
cmp    $0x5,%bl
ja     1180 <inverseStrToBCD+0x70>
add    $0xc9,%sil
mov    %esi,%ebx
jmp    1192 <inverseStrToBCD+0x82>
cmp    $0x10,%r9d
jae    1200 <inverseStrToBCD+0xf0>
xor    %eax,%eax
jmp    13f3 <inverseStrToBCD+0x2e3>
mov    %r9d,%eax
and    $0xfffffff0,%eax
xor    %ecx,%ecx
movdqa 0xe00(%rip),%xmm5
movdqa 0xe17(%rip),%xmm13
movdqa 0xe3f(%rip),%xmm6
movdqa 0xe46(%rip),%xmm14
movdqa 0xe4d(%rip),%xmm15
movdqa 0xe54(%rip),%xmm12
nopl   0x0(%rax)
movdqu (%rdi,%rcx,2),%xmm10
movdqu 0x10(%rdi,%rcx,2),%xmm1
movdqa %xmm1,%xmm2
movdqa 0xda8(%rip),%xmm0
pand   %xmm0,%xmm2
movdqa %xmm10,%xmm7
pand   %xmm0,%xmm7
packuswb %xmm2,%xmm7
psrlw  $0x8,%xmm1
psrlw  $0x8,%xmm10
packuswb %xmm1,%xmm10
movdqa %xmm7,%xmm2
paddb  %xmm5,%xmm2
movdqa %xmm2,%xmm8
movdqa 0xd91(%rip),%xmm11
pmaxub %xmm11,%xmm8
pcmpeqb %xmm2,%xmm8
movdqa %xmm2,%xmm1
pminub %xmm13,%xmm1
pcmpeqb %xmm2,%xmm1
movdqa %xmm7,%xmm3
paddb  0xd8e(%rip),%xmm3
movdqa %xmm3,%xmm9
pmaxub 0xd90(%rip),%xmm9
pcmpeqb %xmm3,%xmm9
movdqa %xmm3,%xmm0
pminub %xmm6,%xmm0
pcmpeqb %xmm3,%xmm0
movdqa %xmm7,%xmm4
paddb  %xmm14,%xmm4
movdqa %xmm4,%xmm3
pminub %xmm6,%xmm3
pcmpeqb %xmm4,%xmm3
movdqa %xmm7,%xmm4
paddb  %xmm15,%xmm4
pand   %xmm3,%xmm4
paddb  %xmm12,%xmm7
por    %xmm1,%xmm0
pand   %xmm0,%xmm7
pandn  %xmm4,%xmm0
por    %xmm7,%xmm0
movdqa %xmm1,%xmm3
pandn  %xmm0,%xmm3
pand   %xmm1,%xmm2
por    %xmm3,%xmm2
movdqa %xmm10,%xmm0
paddb  %xmm5,%xmm0
movdqa %xmm0,%xmm3
pmaxub %xmm11,%xmm3
pcmpeqb %xmm0,%xmm3
movdqa %xmm10,%xmm4
paddb  0xd75(%rip),%xmm4
movdqa %xmm4,%xmm11
pminub 0xd77(%rip),%xmm11
pcmpeqb %xmm4,%xmm11
pand   %xmm3,%xmm11
movdqa %xmm10,%xmm3
paddb  %xmm14,%xmm3
movdqa %xmm3,%xmm4
pminub %xmm6,%xmm4
pcmpeqb %xmm3,%xmm4
movdqa %xmm10,%xmm3
paddb  %xmm15,%xmm3
pand   %xmm4,%xmm3
por    %xmm8,%xmm1
por    %xmm9,%xmm1
movdqa %xmm0,%xmm4
pminub %xmm13,%xmm4
pcmpeqb %xmm0,%xmm4
pand   %xmm1,%xmm11
pand   %xmm4,%xmm1
paddb  %xmm12,%xmm10
pand   %xmm11,%xmm3
pandn  %xmm10,%xmm11
por    %xmm3,%xmm11
pand   %xmm1,%xmm0
pandn  %xmm11,%xmm1
por    %xmm0,%xmm1
psllw  $0x4,%xmm2
pand   0xcdb(%rip),%xmm2
por    %xmm2,%xmm1
movdqu %xmm1,(%rdx,%rcx,1)
add    $0x10,%rcx
cmp    %rcx,%rax
jne    1240 <inverseStrToBCD+0x130>
cmp    %r9,%rax
je     1122 <inverseStrToBCD+0x12>
test   $0x8,%r9b
jne    13f3 <inverseStrToBCD+0x2e3>
lea    (%rdi,%rax,2),%r10
jmp    1169 <inverseStrToBCD+0x59>
mov    %rax,%rsi
mov    %r9d,%eax
and    $0xfffffff8,%eax
lea    (%rdi,%rax,2),%r10
movdqa 0xcd7(%rip),%xmm15
movdqa 0xcee(%rip),%xmm14
movdqa 0xcf5(%rip),%xmm10
movdqa 0xcfc(%rip),%xmm11
movdqa 0xd03(%rip),%xmm12
nopl   (%rax)
movdqu (%rdi,%rsi,2),%xmm2
movdqa %xmm2,%xmm4
movdqa 0xbbe(%rip),%xmm13
pand   %xmm13,%xmm4
packuswb %xmm4,%xmm4
movdqa %xmm4,%xmm8
movdqa 0xc77(%rip),%xmm9
paddb  %xmm9,%xmm8
movdqa %xmm8,%xmm6
pmaxub %xmm15,%xmm6
pcmpeqb %xmm8,%xmm6
punpcklbw %xmm6,%xmm0
movdqa %xmm6,%xmm5
pcmpeqd %xmm13,%xmm13
pxor   %xmm13,%xmm5
punpcklbw %xmm5,%xmm3
por    %xmm0,%xmm3
movdqa %xmm4,%xmm7
paddb  0xc5d(%rip),%xmm7
movdqa %xmm7,%xmm0
pmaxub %xmm14,%xmm0
pcmpeqb %xmm7,%xmm0
punpcklbw %xmm0,%xmm7
por    %xmm3,%xmm7
movdqa %xmm4,%xmm1
paddb  %xmm10,%xmm1
movdqa %xmm1,%xmm3
pmaxub %xmm14,%xmm3
pcmpeqb %xmm1,%xmm3
movdqa %xmm4,%xmm1
paddb  %xmm11,%xmm1
pandn  %xmm1,%xmm3
psrlw  $0x8,%xmm2
packuswb %xmm2,%xmm2
pxor   %xmm13,%xmm0
paddb  %xmm12,%xmm4
por    %xmm5,%xmm0
pand   %xmm0,%xmm4
pandn  %xmm3,%xmm0
por    %xmm4,%xmm0
pand   %xmm6,%xmm0
pandn  %xmm8,%xmm6
por    %xmm0,%xmm6
movdqa %xmm2,%xmm8
paddb  %xmm9,%xmm8
movdqa %xmm8,%xmm0
pmaxub %xmm15,%xmm0
pcmpeqb %xmm8,%xmm0
movdqa %xmm0,%xmm9
punpcklbw %xmm0,%xmm0
movdqa %xmm2,%xmm1
paddb  0xc17(%rip),%xmm1
movdqa %xmm1,%xmm4
pmaxub 0xc1b(%rip),%xmm4
pcmpeqb %xmm1,%xmm4
pxor   %xmm13,%xmm4
punpcklbw %xmm4,%xmm4
pand   %xmm0,%xmm4
movdqa %xmm2,%xmm0
paddb  %xmm10,%xmm0
movdqa %xmm0,%xmm1
pmaxub %xmm14,%xmm1
pcmpeqb %xmm0,%xmm1
movdqa %xmm2,%xmm0
paddb  %xmm11,%xmm0
pandn  %xmm0,%xmm1
psraw  $0x8,%xmm7
pand   %xmm7,%xmm4
movdqa 0xa86(%rip),%xmm5
pand   %xmm5,%xmm4
packuswb %xmm4,%xmm4
psllw  $0x7,%xmm4
movdqa 0xbd1(%rip),%xmm3
pand   %xmm3,%xmm4
pxor   %xmm0,%xmm0
pcmpgtb %xmm4,%xmm0
pxor   %xmm13,%xmm9
punpcklbw %xmm9,%xmm9
pand   %xmm5,%xmm9
pand   %xmm7,%xmm9
packuswb %xmm9,%xmm9
psllw  $0x7,%xmm9
pand   %xmm3,%xmm9
pxor   %xmm3,%xmm3
pcmpgtb %xmm9,%xmm3
paddb  %xmm12,%xmm2
pand   %xmm0,%xmm1
pandn  %xmm2,%xmm0
por    %xmm1,%xmm0
pand   %xmm3,%xmm8
pandn  %xmm0,%xmm3
por    %xmm8,%xmm3
psllw  $0x4,%xmm6
pand   0xaac(%rip),%xmm6
por    %xmm6,%xmm3
movq   %xmm3,(%rdx,%rsi,1)
add    $0x8,%rsi
cmp    %rsi,%rax
jne    1430 <inverseStrToBCD+0x320>
cmp    %r9,%rax
je     1122 <inverseStrToBCD+0x12>
jmp    1169 <inverseStrToBCD+0x59>

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

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