#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 */
scalar_t__ malloc(int);
int strlen(char *);
char *licenseKeyFormatting(char *S, int K) {
  int charNum = 0;
  int size = strlen(S);
  if (size == 0)
    return S;
  for (int i = 0; i < size; i++) {
    if (('a' <= S[i] && S[i] <= 'z') || ('A' <= S[i] && S[i] <= 'Z') ||
        ('0' <= S[i] && S[i] <= '9'))
      charNum++;
  }
  if (charNum == 0)
    return "";
  int dashNum = charNum / K;
  if (charNum % K == 0)
    dashNum--;
  int resLen = dashNum + charNum;
  char *res = (char *)malloc((resLen + 1) * sizeof(char));
  res[resLen] = 0;
  int resIdx = resLen - 1;
  int cnt = 0;
  for (int i = size - 1; i >= 0 && resIdx >= 0; i--) {
    if ('a' <= S[i] && S[i] <= 'z') {
      res[resIdx] = S[i] - 'a' + 'A';
      resIdx--;
      cnt++;
    } else if (('A' <= S[i] && S[i] <= 'Z') || ('0' <= S[i] && S[i] <= '9')) {
      res[resIdx] = S[i];
      resIdx--;
      cnt++;
    }
    if (cnt == K && resIdx >= 0) {
      res[resIdx] = '-';
      resIdx--;
      cnt = 0;
    }
  }
  return res;
}


x86 assembly (clang, -O0):
<licenseKeyFormatting>:
push   %rbp
mov    %rsp,%rbp
sub    $0x40,%rsp
mov    %rdi,-0x10(%rbp)
mov    %esi,-0x14(%rbp)
movl   $0x0,-0x18(%rbp)
mov    -0x10(%rbp),%rdi
call   1030 <strlen@plt>
mov    %eax,-0x1c(%rbp)
cmpl   $0x0,-0x1c(%rbp)
jne    1159 <licenseKeyFormatting+0x39>
mov    -0x10(%rbp),%rax
mov    %rax,-0x8(%rbp)
jmp    13f7 <licenseKeyFormatting+0x2d7>
movl   $0x0,-0x20(%rbp)
mov    -0x20(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    1212 <licenseKeyFormatting+0xf2>
mov    -0x10(%rbp),%rax
movslq -0x20(%rbp),%rcx
movsbl (%rax,%rcx,1),%ecx
mov    $0x61,%eax
cmp    %ecx,%eax
jg     119a <licenseKeyFormatting+0x7a>
mov    -0x10(%rbp),%rax
movslq -0x20(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x7a,%eax
jle    11f6 <licenseKeyFormatting+0xd6>
mov    -0x10(%rbp),%rax
movslq -0x20(%rbp),%rcx
movsbl (%rax,%rcx,1),%ecx
mov    $0x41,%eax
cmp    %ecx,%eax
jg     11c8 <licenseKeyFormatting+0xa8>
mov    -0x10(%rbp),%rax
movslq -0x20(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x5a,%eax
jle    11f6 <licenseKeyFormatting+0xd6>
mov    -0x10(%rbp),%rax
movslq -0x20(%rbp),%rcx
movsbl (%rax,%rcx,1),%ecx
mov    $0x30,%eax
cmp    %ecx,%eax
jg     11ff <licenseKeyFormatting+0xdf>
mov    -0x10(%rbp),%rax
movslq -0x20(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x39,%eax
jg     11ff <licenseKeyFormatting+0xdf>
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
jmp    1204 <licenseKeyFormatting+0xe4>
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    1160 <licenseKeyFormatting+0x40>
cmpl   $0x0,-0x18(%rbp)
jne    122c <licenseKeyFormatting+0x10c>
lea    0xddd(%rip),%rax
mov    %rax,-0x8(%rbp)
jmp    13f7 <licenseKeyFormatting+0x2d7>
mov    -0x18(%rbp),%eax
cltd
idivl  -0x14(%rbp)
mov    %eax,-0x24(%rbp)
mov    -0x18(%rbp),%eax
cltd
idivl  -0x14(%rbp)
cmp    $0x0,%edx
jne    124f <licenseKeyFormatting+0x12f>
mov    -0x24(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x24(%rbp)
mov    -0x24(%rbp),%eax
add    -0x18(%rbp),%eax
mov    %eax,-0x28(%rbp)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
cltq
shl    $0x0,%rax
mov    %eax,%edi
call   1040 <malloc@plt>
mov    %rax,-0x30(%rbp)
mov    -0x30(%rbp),%rax
movslq -0x28(%rbp),%rcx
movb   $0x0,(%rax,%rcx,1)
mov    -0x28(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x34(%rbp)
movl   $0x0,-0x38(%rbp)
mov    -0x1c(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x3c(%rbp)
xor    %eax,%eax
cmpl   $0x0,-0x3c(%rbp)
mov    %al,-0x3d(%rbp)
jl     12ad <licenseKeyFormatting+0x18d>
cmpl   $0x0,-0x34(%rbp)
setge  %al
mov    %al,-0x3d(%rbp)
mov    -0x3d(%rbp),%al
test   $0x1,%al
jne    12bd <licenseKeyFormatting+0x19d>
jmp    13ef <licenseKeyFormatting+0x2cf>
mov    -0x10(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsbl (%rax,%rcx,1),%ecx
mov    $0x61,%eax
cmp    %ecx,%eax
jg     1321 <licenseKeyFormatting+0x201>
mov    -0x10(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x7a,%eax
jg     1321 <licenseKeyFormatting+0x201>
mov    -0x10(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
sub    $0x61,%eax
add    $0x41,%eax
mov    %al,%dl
mov    -0x30(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x34(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x34(%rbp)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    13aa <licenseKeyFormatting+0x28a>
mov    -0x10(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsbl (%rax,%rcx,1),%ecx
mov    $0x41,%eax
cmp    %ecx,%eax
jg     134f <licenseKeyFormatting+0x22f>
mov    -0x10(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x5a,%eax
jle    137d <licenseKeyFormatting+0x25d>
mov    -0x10(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsbl (%rax,%rcx,1),%ecx
mov    $0x30,%eax
cmp    %ecx,%eax
jg     13a5 <licenseKeyFormatting+0x285>
mov    -0x10(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x39,%eax
jg     13a5 <licenseKeyFormatting+0x285>
mov    -0x10(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,1),%dl
mov    -0x30(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x34(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x34(%rbp)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    13aa <licenseKeyFormatting+0x28a>
mov    -0x38(%rbp),%eax
cmp    -0x14(%rbp),%eax
jne    13dc <licenseKeyFormatting+0x2bc>
cmpl   $0x0,-0x34(%rbp)
jl     13dc <licenseKeyFormatting+0x2bc>
mov    -0x30(%rbp),%rax
movslq -0x34(%rbp),%rcx
movb   $0x2d,(%rax,%rcx,1)
mov    -0x34(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x34(%rbp)
movl   $0x0,-0x38(%rbp)
jmp    13e1 <licenseKeyFormatting+0x2c1>
mov    -0x3c(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x3c(%rbp)
jmp    1294 <licenseKeyFormatting+0x174>
mov    -0x30(%rbp),%rax
mov    %rax,-0x8(%rbp)
mov    -0x8(%rbp),%rax
add    $0x40,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<licenseKeyFormatting>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
push   %rax
mov    %esi,%r15d
mov    %rdi,%r12
call   1030 <strlen@plt>
test   %eax,%eax
je     115c <licenseKeyFormatting+0x3c>
mov    %eax,%r14d
lea    0xf1c(%rip),%rax
jle    136d <licenseKeyFormatting+0x24d>
mov    %r14d,%r13d
cmp    $0x8,%r14d
jae    1164 <licenseKeyFormatting+0x44>
xor    %esi,%esi
xor    %ecx,%ecx
jmp    1290 <licenseKeyFormatting+0x170>
mov    %r12,%rax
jmp    136d <licenseKeyFormatting+0x24d>
mov    %r13d,%esi
and    $0xfffffff8,%esi
pxor   %xmm0,%xmm0
xor    %ecx,%ecx
movdqa 0xe87(%rip),%xmm8
movdqa 0xe8e(%rip),%xmm9
movdqa 0xe95(%rip),%xmm10
pcmpeqd %xmm4,%xmm4
movdqa 0xe98(%rip),%xmm11
movdqa 0xe9f(%rip),%xmm12
movdqa 0xea6(%rip),%xmm13
pxor   %xmm5,%xmm5
xchg   %ax,%ax
movd   (%r12,%rcx,1),%xmm6
movd   0x4(%r12,%rcx,1),%xmm1
movdqa %xmm6,%xmm3
pand   %xmm8,%xmm3
movdqa %xmm1,%xmm2
pand   %xmm8,%xmm2
paddb  %xmm9,%xmm3
paddb  %xmm9,%xmm2
movdqa %xmm3,%xmm7
pmaxub %xmm10,%xmm7
pcmpeqb %xmm3,%xmm7
pxor   %xmm4,%xmm7
punpcklbw %xmm7,%xmm7
punpcklwd %xmm7,%xmm7
movdqa %xmm2,%xmm3
pmaxub %xmm10,%xmm3
pcmpeqb %xmm2,%xmm3
pxor   %xmm4,%xmm3
punpcklbw %xmm3,%xmm3
punpcklwd %xmm3,%xmm3
paddb  %xmm11,%xmm6
paddb  %xmm11,%xmm1
movdqa %xmm6,%xmm2
pmaxub %xmm12,%xmm2
pcmpeqb %xmm6,%xmm2
pxor   %xmm4,%xmm2
punpcklbw %xmm2,%xmm2
punpcklwd %xmm2,%xmm2
por    %xmm7,%xmm2
movdqa %xmm1,%xmm6
pmaxub %xmm12,%xmm6
pcmpeqb %xmm1,%xmm6
pxor   %xmm4,%xmm6
punpcklbw %xmm6,%xmm6
punpcklwd %xmm6,%xmm6
por    %xmm3,%xmm6
pand   %xmm13,%xmm2
paddd  %xmm2,%xmm0
pand   %xmm13,%xmm6
paddd  %xmm6,%xmm5
add    $0x8,%rcx
cmp    %rcx,%rsi
jne    11b0 <licenseKeyFormatting+0x90>
paddd  %xmm0,%xmm5
pshufd $0xee,%xmm5,%xmm0
paddd  %xmm5,%xmm0
pshufd $0x55,%xmm0,%xmm1
paddd  %xmm0,%xmm1
movd   %xmm1,%ecx
cmp    %r13,%rsi
je     12bc <licenseKeyFormatting+0x19c>
nopl   (%rax)
movzbl (%r12,%rsi,1),%edx
mov    %edx,%ebx
and    $0xdf,%bl
add    $0xbf,%bl
cmp    $0x1a,%bl
setb   %bl
add    $0xd0,%dl
cmp    $0xa,%dl
setb   %dl
or     %bl,%dl
movzbl %dl,%edx
add    %edx,%ecx
add    $0x1,%rsi
cmp    %rsi,%r13
jne    1290 <licenseKeyFormatting+0x170>
test   %ecx,%ecx
je     136d <licenseKeyFormatting+0x24d>
mov    %ecx,%eax
cltd
idiv   %r15d
mov    %eax,%ebp
add    %ecx,%ebp
cmp    $0x1,%edx
sbb    $0x0,%ebp
lea    0x1(%rbp),%edi
call   1040 <malloc@plt>
movslq %ebp,%rcx
movb   $0x0,(%rax,%rcx,1)
test   %r14d,%r14d
jle    136d <licenseKeyFormatting+0x24d>
test   %ebp,%ebp
jle    136d <licenseKeyFormatting+0x24d>
add    $0xffffffff,%ebp
xor    %ecx,%ecx
nopl   0x0(%rax)
lea    -0x1(%r13),%edx
movzbl (%r12,%rdx,1),%edx
lea    -0x61(%rdx),%esi
cmp    $0x19,%sil
ja     1320 <licenseKeyFormatting+0x200>
add    $0xe0,%dl
jmp    1340 <licenseKeyFormatting+0x220>
nopw   0x0(%rax,%rax,1)
lea    -0x41(%rdx),%esi
cmp    $0x1a,%sil
jb     1340 <licenseKeyFormatting+0x220>
lea    -0x30(%rdx),%esi
cmp    $0x9,%sil
ja     134b <licenseKeyFormatting+0x22b>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    %ebp,%esi
mov    %dl,(%rax,%rsi,1)
add    $0xffffffff,%ebp
add    $0x1,%ecx
cmp    %r15d,%ecx
jne    135f <licenseKeyFormatting+0x23f>
test   %ebp,%ebp
js     135f <licenseKeyFormatting+0x23f>
mov    %ebp,%ecx
movb   $0x2d,(%rax,%rcx,1)
add    $0xffffffff,%ebp
xor    %ecx,%ecx
cmp    $0x2,%r13
jb     136d <licenseKeyFormatting+0x24d>
add    $0xffffffffffffffff,%r13
test   %ebp,%ebp
jns    1300 <licenseKeyFormatting+0x1e0>
add    $0x8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

LLVM IR (-O2):
@.str = [1 x i8] zeroinitializer
define i8* @licenseKeyFormatting(i8* %0, i32 %1) {
%3 = tail call i32 @strlen(i8* %0)
%4 = icmp eq i32 %3, 0
br i1 %4, label %122, label %5
5: ; preds = %2
%6 = icmp sgt i32 %3, 0
br i1 %6, label %7, label %122
7: ; preds = %5
%8 = zext i32 %3 to i64
%9 = icmp ult i32 %3, 8
br i1 %9, label %44, label %10
10: ; preds = %7
%11 = and i64 %8, 4294967288
br label %12
12: ; preds = %12, %10
%13 = phi i64 [ 0, %10 ], [ %38, %12 ]
%14 = phi <4 x i32> [ zeroinitializer, %10 ], [ %36, %12 ]
%15 = phi <4 x i32> [ zeroinitializer, %10 ], [ %37, %12 ]
%16 = getelementptr inbounds i8, i8* %0, i64 %13
%17 = bitcast i8* %16 to <4 x i8>*
%18 = load <4 x i8>, <4 x i8>* %17
%19 = getelementptr inbounds i8, i8* %16, i64 4
%20 = bitcast i8* %19 to <4 x i8>*
%21 = load <4 x i8>, <4 x i8>* %20
%22 = and <4 x i8> %18, <i8 -33, i8 -33, i8 -33, i8 -33>
%23 = and <4 x i8> %21, <i8 -33, i8 -33, i8 -33, i8 -33>
%24 = add <4 x i8> %22, <i8 -65, i8 -65, i8 -65, i8 -65>
%25 = add <4 x i8> %23, <i8 -65, i8 -65, i8 -65, i8 -65>
%26 = icmp ult <4 x i8> %24, <i8 26, i8 26, i8 26, i8 26>
%27 = icmp ult <4 x i8> %25, <i8 26, i8 26, i8 26, i8 26>
%28 = add <4 x i8> %18, <i8 -48, i8 -48, i8 -48, i8 -48>
%29 = add <4 x i8> %21, <i8 -48, i8 -48, i8 -48, i8 -48>
%30 = icmp ult <4 x i8> %28, <i8 10, i8 10, i8 10, i8 10>
%31 = icmp ult <4 x i8> %29, <i8 10, i8 10, i8 10, i8 10>
%32 = select <4 x i1> %26, <4 x i1> <i1 true, i1 true, i1 true, i1 true>, <4 x i1> %30
%33 = select <4 x i1> %27, <4 x i1> <i1 true, i1 true, i1 true, i1 true>, <4 x i1> %31
%34 = zext <4 x i1> %32 to <4 x i32>
%35 = zext <4 x i1> %33 to <4 x i32>
%36 = add <4 x i32> %14, %34
%37 = add <4 x i32> %15, %35
%38 = add nuw i64 %13, 8
%39 = icmp eq i64 %38, %11
br i1 %39, label %40, label %12
40: ; preds = %12
%41 = add <4 x i32> %37, %36
%42 = call i32 @llvm.vector.reduce.add.v4i32(<4 x i32> %41)
%43 = icmp eq i64 %11, %8
br i1 %43, label %47, label %44
44: ; preds = %7, %40
%45 = phi i64 [ 0, %7 ], [ %11, %40 ]
%46 = phi i32 [ 0, %7 ], [ %42, %40 ]
br label %50
47: ; preds = %50, %40
%48 = phi i32 [ %42, %40 ], [ %62, %50 ]
%49 = icmp eq i32 %48, 0
br i1 %49, label %122, label %65
50: ; preds = %44, %50
%51 = phi i64 [ %63, %50 ], [ %45, %44 ]
%52 = phi i32 [ %62, %50 ], [ %46, %44 ]
%53 = getelementptr inbounds i8, i8* %0, i64 %51
%54 = load i8, i8* %53
%55 = and i8 %54, -33
%56 = add i8 %55, -65
%57 = icmp ult i8 %56, 26
%58 = add i8 %54, -48
%59 = icmp ult i8 %58, 10
%60 = select i1 %57, i1 true, i1 %59
%61 = zext i1 %60 to i32
%62 = add nuw nsw i32 %52, %61
%63 = add nuw nsw i64 %51, 1
%64 = icmp eq i64 %63, %8
br i1 %64, label %47, label %50
65: ; preds = %47
%66 = sdiv i32 %48, %1
%67 = srem i32 %48, %1
%68 = icmp eq i32 %67, 0
%69 = sext i1 %68 to i32
%70 = add i32 %66, %48
%71 = add i32 %70, %69
%72 = add nsw i32 %71, 1
%73 = tail call i64 @malloc(i32 %72)
%74 = inttoptr i64 %73 to i8*
%75 = sext i32 %71 to i64
%76 = getelementptr inbounds i8, i8* %74, i64 %75
store i8 0, i8* %76
%77 = icmp sgt i32 %71, 0
%78 = select i1 %6, i1 %77, i1 false
br i1 %78, label %79, label %122
79: ; preds = %65
%80 = add nsw i32 %71, -1
%81 = zext i32 %3 to i64
br label %82
82: ; preds = %79, %116
%83 = phi i64 [ %81, %79 ], [ %86, %116 ]
%84 = phi i32 [ 0, %79 ], [ %118, %116 ]
%85 = phi i32 [ %80, %79 ], [ %117, %116 ]
%86 = add nsw i64 %83, -1
%87 = and i64 %86, 4294967295
%88 = getelementptr inbounds i8, i8* %0, i64 %87
%89 = load i8, i8* %88
%90 = add i8 %89, -97
%91 = icmp ult i8 %90, 26
br i1 %91, label %92, label %94
92: ; preds = %82
%93 = add nsw i8 %89, -32
br label %100
94: ; preds = %82
%95 = add i8 %89, -65
%96 = icmp ult i8 %95, 26
%97 = add i8 %89, -48
%98 = icmp ult i8 %97, 10
%99 = or i1 %96, %98
br i1 %99, label %100, label %106
100: ; preds = %94, %92
%101 = phi i8 [ %93, %92 ], [ %89, %94 ]
%102 = zext i32 %85 to i64
%103 = getelementptr inbounds i8, i8* %74, i64 %102
store i8 %101, i8* %103
%104 = add nsw i32 %85, -1
%105 = add nsw i32 %84, 1
br label %106
106: ; preds = %100, %94
%107 = phi i32 [ %85, %94 ], [ %104, %100 ]
%108 = phi i32 [ %84, %94 ], [ %105, %100 ]
%109 = icmp eq i32 %108, %1
%110 = icmp sgt i32 %107, -1
%111 = select i1 %109, i1 %110, i1 false
br i1 %111, label %112, label %116
112: ; preds = %106
%113 = zext i32 %107 to i64
%114 = getelementptr inbounds i8, i8* %74, i64 %113
store i8 45, i8* %114
%115 = add nsw i32 %107, -1
br label %116
116: ; preds = %106, %112
%117 = phi i32 [ %115, %112 ], [ %107, %106 ]
%118 = phi i32 [ 0, %112 ], [ %108, %106 ]
%119 = icmp ugt i64 %83, 1
%120 = icmp sgt i32 %117, -1
%121 = select i1 %119, i1 %120, i1 false
br i1 %121, label %82, label %122
122: ; preds = %116, %5, %65, %47, %2
%123 = phi i8* [ %0, %2 ], [ getelementptr inbounds ([1 x i8], [1 x i8]* @.str, i64 0, i64 0), %47 ], [ %74, %65 ], [ getelementptr inbounds ([1 x i8], [1 x i8]* @.str, i64 0, i64 0), %5 ], [ %74, %116 ]
ret i8* %123
}