#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*/ gensprintf(char *, char *);
int /*<<< orphan*/ isdigit(char);
char FindFormatFlag(const char *formatString, size_t *a, char *formatBuffer,
                    size_t bufferMax) {
  char inchar, formatFlagType;
  size_t copy_pos = 0;
  formatFlagType = ' ';
  if (formatString[*a] == 'n') {
    gensprintf(formatBuffer, "\n");
    (*a)++;
    return (formatFlagType);
  } else if (formatString[*a] == 'r') {
    gensprintf(formatBuffer, "\r");
    (*a)++;
    return (formatFlagType);
  } else if (formatString[*a] == 't') {
    gensprintf(formatBuffer, "\t");
    (*a)++;
    return (formatFlagType);
  } else if (formatString[*a] == 'v') {
    gensprintf(formatBuffer, "\v");
    (*a)++;
    return (formatFlagType);
  } else if (formatString[*a] == '%') {
    gensprintf(formatBuffer, "%%");
    (*a)++;
    return (formatFlagType);
  }
  formatBuffer[copy_pos++] = '%';
  formatBuffer[copy_pos] = '\0';
  while ((formatString[*a] != '%') && (formatString[*a] != '\0') &&
         (copy_pos < (bufferMax - 5))) {
    inchar = formatString[*a];
    (*a)++;
    if ((inchar == 'd') || (inchar == 'o') || (inchar == 'x') ||
        (inchar == 'u')) {
      formatFlagType = inchar;
      formatBuffer[copy_pos++] = 'l';
      formatBuffer[copy_pos++] = 'l';
      formatBuffer[copy_pos++] = inchar;
      formatBuffer[copy_pos] = '\0';
      return (formatFlagType);
    } else if ((inchar == 'c') || (inchar == 's') || (inchar == 'e') ||
               (inchar == 'f') || (inchar == 'g')) {
      formatBuffer[copy_pos++] = inchar;
      formatBuffer[copy_pos] = '\0';
      formatFlagType = inchar;
      return (formatFlagType);
    }
    if ((!isdigit(inchar)) && (inchar != '.') && (inchar != '-')) {
      formatBuffer[copy_pos++] = inchar;
      formatBuffer[copy_pos] = '\0';
      return ('-');
    }
    formatBuffer[copy_pos++] = inchar;
    formatBuffer[copy_pos] = '\0';
  }
  return (formatFlagType);
}


x86 assembly (clang, -O0):
<FindFormatFlag>:
push   %rbp
mov    %rsp,%rbp
sub    $0x40,%rsp
mov    %rdi,-0x10(%rbp)
mov    %rsi,-0x18(%rbp)
mov    %rdx,-0x20(%rbp)
mov    %rcx,-0x28(%rbp)
movq   $0x0,-0x38(%rbp)
movb   $0x20,-0x2a(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x18(%rbp),%rcx
mov    (%rcx),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x6e,%eax
jne    1185 <FindFormatFlag+0x65>
mov    -0x20(%rbp),%rdi
lea    0xe99(%rip),%rsi
call   1040 <gensprintf@plt>
mov    -0x18(%rbp),%rax
mov    (%rax),%rcx
add    $0x1,%rcx
mov    %rcx,(%rax)
mov    -0x2a(%rbp),%al
mov    %al,-0x1(%rbp)
jmp    14dc <FindFormatFlag+0x3bc>
mov    -0x10(%rbp),%rax
mov    -0x18(%rbp),%rcx
mov    (%rcx),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x72,%eax
jne    11c6 <FindFormatFlag+0xa6>
mov    -0x20(%rbp),%rdi
lea    0xe5a(%rip),%rsi
call   1040 <gensprintf@plt>
mov    -0x18(%rbp),%rax
mov    (%rax),%rcx
add    $0x1,%rcx
mov    %rcx,(%rax)
mov    -0x2a(%rbp),%al
mov    %al,-0x1(%rbp)
jmp    14dc <FindFormatFlag+0x3bc>
mov    -0x10(%rbp),%rax
mov    -0x18(%rbp),%rcx
mov    (%rcx),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x74,%eax
jne    1207 <FindFormatFlag+0xe7>
mov    -0x20(%rbp),%rdi
lea    0xe1b(%rip),%rsi
call   1040 <gensprintf@plt>
mov    -0x18(%rbp),%rax
mov    (%rax),%rcx
add    $0x1,%rcx
mov    %rcx,(%rax)
mov    -0x2a(%rbp),%al
mov    %al,-0x1(%rbp)
jmp    14dc <FindFormatFlag+0x3bc>
mov    -0x10(%rbp),%rax
mov    -0x18(%rbp),%rcx
mov    (%rcx),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x76,%eax
jne    1248 <FindFormatFlag+0x128>
mov    -0x20(%rbp),%rdi
lea    0xddc(%rip),%rsi
call   1040 <gensprintf@plt>
mov    -0x18(%rbp),%rax
mov    (%rax),%rcx
add    $0x1,%rcx
mov    %rcx,(%rax)
mov    -0x2a(%rbp),%al
mov    %al,-0x1(%rbp)
jmp    14dc <FindFormatFlag+0x3bc>
mov    -0x10(%rbp),%rax
mov    -0x18(%rbp),%rcx
mov    (%rcx),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x25,%eax
jne    1289 <FindFormatFlag+0x169>
mov    -0x20(%rbp),%rdi
lea    0xd9d(%rip),%rsi
call   1040 <gensprintf@plt>
mov    -0x18(%rbp),%rax
mov    (%rax),%rcx
add    $0x1,%rcx
mov    %rcx,(%rax)
mov    -0x2a(%rbp),%al
mov    %al,-0x1(%rbp)
jmp    14dc <FindFormatFlag+0x3bc>
jmp    128e <FindFormatFlag+0x16e>
jmp    1293 <FindFormatFlag+0x173>
jmp    1298 <FindFormatFlag+0x178>
jmp    129d <FindFormatFlag+0x17d>
mov    -0x20(%rbp),%rax
mov    -0x38(%rbp),%rcx
mov    %rcx,%rdx
add    $0x1,%rdx
mov    %rdx,-0x38(%rbp)
movb   $0x25,(%rax,%rcx,1)
mov    -0x20(%rbp),%rax
mov    -0x38(%rbp),%rcx
movb   $0x0,(%rax,%rcx,1)
mov    -0x10(%rbp),%rax
mov    -0x18(%rbp),%rcx
mov    (%rcx),%rcx
movsbl (%rax,%rcx,1),%ecx
xor    %eax,%eax
cmp    $0x25,%ecx
mov    %al,-0x39(%rbp)
je     130f <FindFormatFlag+0x1ef>
mov    -0x10(%rbp),%rax
mov    -0x18(%rbp),%rcx
mov    (%rcx),%rcx
movsbl (%rax,%rcx,1),%ecx
xor    %eax,%eax
cmp    $0x0,%ecx
mov    %al,-0x39(%rbp)
je     130f <FindFormatFlag+0x1ef>
mov    -0x38(%rbp),%rax
mov    -0x28(%rbp),%rcx
sub    $0x5,%rcx
cmp    %rcx,%rax
setb   %al
mov    %al,-0x39(%rbp)
mov    -0x39(%rbp),%al
test   $0x1,%al
jne    131f <FindFormatFlag+0x1ff>
jmp    14d6 <FindFormatFlag+0x3b6>
mov    -0x10(%rbp),%rax
mov    -0x18(%rbp),%rcx
mov    (%rcx),%rcx
mov    (%rax,%rcx,1),%al
mov    %al,-0x29(%rbp)
mov    -0x18(%rbp),%rax
mov    (%rax),%rcx
add    $0x1,%rcx
mov    %rcx,(%rax)
movsbl -0x29(%rbp),%eax
cmp    $0x64,%eax
je     1372 <FindFormatFlag+0x252>
movsbl -0x29(%rbp),%eax
cmp    $0x6f,%eax
je     1372 <FindFormatFlag+0x252>
movsbl -0x29(%rbp),%eax
cmp    $0x78,%eax
je     1372 <FindFormatFlag+0x252>
movsbl -0x29(%rbp),%eax
cmp    $0x75,%eax
jne    13d6 <FindFormatFlag+0x2b6>
mov    -0x29(%rbp),%al
mov    %al,-0x2a(%rbp)
mov    -0x20(%rbp),%rax
mov    -0x38(%rbp),%rcx
mov    %rcx,%rdx
add    $0x1,%rdx
mov    %rdx,-0x38(%rbp)
movb   $0x6c,(%rax,%rcx,1)
mov    -0x20(%rbp),%rax
mov    -0x38(%rbp),%rcx
mov    %rcx,%rdx
add    $0x1,%rdx
mov    %rdx,-0x38(%rbp)
movb   $0x6c,(%rax,%rcx,1)
mov    -0x29(%rbp),%dl
mov    -0x20(%rbp),%rax
mov    -0x38(%rbp),%rcx
mov    %rcx,%rsi
add    $0x1,%rsi
mov    %rsi,-0x38(%rbp)
mov    %dl,(%rax,%rcx,1)
mov    -0x20(%rbp),%rax
mov    -0x38(%rbp),%rcx
movb   $0x0,(%rax,%rcx,1)
mov    -0x2a(%rbp),%al
mov    %al,-0x1(%rbp)
jmp    14dc <FindFormatFlag+0x3bc>
movsbl -0x29(%rbp),%eax
cmp    $0x63,%eax
je     1417 <FindFormatFlag+0x2f7>
movsbl -0x29(%rbp),%eax
cmp    $0x73,%eax
je     1417 <FindFormatFlag+0x2f7>
movsbl -0x29(%rbp),%eax
cmp    $0x65,%eax
je     1417 <FindFormatFlag+0x2f7>
movsbl -0x29(%rbp),%eax
cmp    $0x66,%eax
je     1417 <FindFormatFlag+0x2f7>
movsbl -0x29(%rbp),%eax
cmp    $0x67,%eax
jne    144d <FindFormatFlag+0x32d>
mov    -0x29(%rbp),%dl
mov    -0x20(%rbp),%rax
mov    -0x38(%rbp),%rcx
mov    %rcx,%rsi
add    $0x1,%rsi
mov    %rsi,-0x38(%rbp)
mov    %dl,(%rax,%rcx,1)
mov    -0x20(%rbp),%rax
mov    -0x38(%rbp),%rcx
movb   $0x0,(%rax,%rcx,1)
mov    -0x29(%rbp),%al
mov    %al,-0x2a(%rbp)
mov    -0x2a(%rbp),%al
mov    %al,-0x1(%rbp)
jmp    14dc <FindFormatFlag+0x3bc>
jmp    1452 <FindFormatFlag+0x332>
movsbl -0x29(%rbp),%edi
call   1030 <isdigit@plt>
cmp    $0x0,%eax
jne    14ac <FindFormatFlag+0x38c>
movsbl -0x29(%rbp),%eax
cmp    $0x2e,%eax
je     14ac <FindFormatFlag+0x38c>
movsbl -0x29(%rbp),%eax
cmp    $0x2d,%eax
je     14ac <FindFormatFlag+0x38c>
mov    -0x29(%rbp),%dl
mov    -0x20(%rbp),%rax
mov    -0x38(%rbp),%rcx
mov    %rcx,%rsi
add    $0x1,%rsi
mov    %rsi,-0x38(%rbp)
mov    %dl,(%rax,%rcx,1)
mov    -0x20(%rbp),%rax
mov    -0x38(%rbp),%rcx
movb   $0x0,(%rax,%rcx,1)
movb   $0x2d,-0x1(%rbp)
jmp    14dc <FindFormatFlag+0x3bc>
mov    -0x29(%rbp),%dl
mov    -0x20(%rbp),%rax
mov    -0x38(%rbp),%rcx
mov    %rcx,%rsi
add    $0x1,%rsi
mov    %rsi,-0x38(%rbp)
mov    %dl,(%rax,%rcx,1)
mov    -0x20(%rbp),%rax
mov    -0x38(%rbp),%rcx
movb   $0x0,(%rax,%rcx,1)
jmp    12c0 <FindFormatFlag+0x1a0>
mov    -0x2a(%rbp),%al
mov    %al,-0x1(%rbp)
movsbl -0x1(%rbp),%eax
add    $0x40,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<FindFormatFlag>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
push   %rax
mov    %rcx,%r15
mov    %rdx,%r14
mov    %rsi,%r13
mov    %rdi,%r12
mov    (%rsi),%rax
mov    (%rdi,%rax,1),%al
lea    -0x6e(%rax),%ecx
cmp    $0x8,%cl
ja     1164 <FindFormatFlag+0x44>
movzbl %cl,%eax
lea    0xeb1(%rip),%rcx
movslq (%rcx,%rax,4),%rax
add    %rcx,%rax
jmp    *%rax
lea    0xec5(%rip),%rsi
jmp    121e <FindFormatFlag+0xfe>
cmp    $0x25,%al
jne    1174 <FindFormatFlag+0x54>
lea    0xebd(%rip),%rsi
jmp    121e <FindFormatFlag+0xfe>
movw   $0x25,(%r14)
add    $0xfffffffffffffffb,%r15
cmp    $0x2,%r15
mov    $0x1,%ebx
cmovb  %rbx,%r15
mov    0x0(%r13),%rcx
movzbl (%r12,%rcx,1),%ebp
mov    $0x20,%al
test   %bpl,%bpl
je     122d <FindFormatFlag+0x10d>
cmp    $0x25,%bpl
je     122d <FindFormatFlag+0x10d>
cmp    %rbx,%r15
je     122d <FindFormatFlag+0x10d>
add    $0x1,%rcx
mov    %rcx,0x0(%r13)
lea    -0x63(%rbp),%eax
cmp    $0x15,%al
ja     11d6 <FindFormatFlag+0xb6>
movzbl %al,%eax
mov    $0x1001d,%ecx
bt     %rax,%rcx
jb     123c <FindFormatFlag+0x11c>
mov    $0x241002,%ecx
bt     %rax,%rcx
jb     124a <FindFormatFlag+0x12a>
movsbl %bpl,%edi
call   1030 <isdigit@plt>
lea    0x1(%rbx),%rcx
mov    %bpl,(%r14,%rbx,1)
movb   $0x0,0x1(%r14,%rbx,1)
mov    %rcx,%rbx
test   %eax,%eax
jne    118b <FindFormatFlag+0x6b>
add    $0xd3,%bpl
mov    $0x2d,%al
mov    %rcx,%rbx
cmp    $0x2,%bpl
jb     118b <FindFormatFlag+0x6b>
jmp    122d <FindFormatFlag+0x10d>
lea    0xe1a(%rip),%rsi
jmp    121e <FindFormatFlag+0xfe>
lea    0xe13(%rip),%rsi
jmp    121e <FindFormatFlag+0xfe>
lea    0xe0c(%rip),%rsi
mov    %r14,%rdi
call   1040 <gensprintf@plt>
addq   $0x1,0x0(%r13)
mov    $0x20,%al
add    $0x8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
mov    %bpl,(%r14,%rbx,1)
movb   $0x0,0x1(%r14,%rbx,1)
mov    %ebp,%eax
jmp    122d <FindFormatFlag+0x10d>
movw   $0x6c6c,(%r14,%rbx,1)
mov    %bpl,0x2(%r14,%rbx,1)
movb   $0x0,0x3(%r14,%rbx,1)
mov    %ebp,%eax
jmp    122d <FindFormatFlag+0x10d>

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

LLVM IR (-O2):
@.str = [2 x i8] c"\0A\00"
@.str.1 = [2 x i8] c"\0D\00"
@.str.2 = [2 x i8] c"\09\00"
@.str.3 = [2 x i8] c"\0B\00"
@.str.4 = [3 x i8] c"%%\00"
define signext i8 @FindFormatFlag(i8* nocapture %0, i64* nocapture %1, i8* %2, i64 %3) {
%5 = load i64, i64* %1
%6 = getelementptr inbounds i8, i8* %0, i64 %5
%7 = load i8, i8* %6
switch i8 %7, label %28 [
i8 110, label %8
i8 114, label %12
i8 116, label %16
i8 118, label %20
i8 37, label %24
]
8: ; preds = %4
%9 = tail call i32 @gensprintf(i8* %2, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str, i64 0, i64 0))
%10 = load i64, i64* %1
%11 = add i64 %10, 1
store i64 %11, i64* %1
br label %63
12: ; preds = %4
%13 = tail call i32 @gensprintf(i8* %2, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.1, i64 0, i64 0))
%14 = load i64, i64* %1
%15 = add i64 %14, 1
store i64 %15, i64* %1
br label %63
16: ; preds = %4
%17 = tail call i32 @gensprintf(i8* %2, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.2, i64 0, i64 0))
%18 = load i64, i64* %1
%19 = add i64 %18, 1
store i64 %19, i64* %1
br label %63
20: ; preds = %4
%21 = tail call i32 @gensprintf(i8* %2, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.3, i64 0, i64 0))
%22 = load i64, i64* %1
%23 = add i64 %22, 1
store i64 %23, i64* %1
br label %63
24: ; preds = %4
%25 = tail call i32 @gensprintf(i8* %2, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.4, i64 0, i64 0))
%26 = load i64, i64* %1
%27 = add i64 %26, 1
store i64 %27, i64* %1
br label %63
28: ; preds = %4
store i8 37, i8* %2
%29 = getelementptr inbounds i8, i8* %2, i64 1
store i8 0, i8* %29
%30 = add i64 %3, -5
%31 = call i64 @llvm.umax.i64(i64 %30, i64 1)
br label %32
32: ; preds = %53, %28
%33 = phi i64 [ 1, %28 ], [ %60, %53 ]
%34 = load i64, i64* %1
%35 = getelementptr inbounds i8, i8* %0, i64 %34
%36 = load i8, i8* %35
switch i8 %36, label %37 [
i8 37, label %63
i8 0, label %63
]
37: ; preds = %32
%38 = icmp eq i64 %33, %31
br i1 %38, label %63, label %39
39: ; preds = %37
%40 = add i64 %34, 1
store i64 %40, i64* %1
switch i8 %36, label %53 [
i8 120, label %41
i8 117, label %41
i8 111, label %41
i8 100, label %41
i8 115, label %49
i8 103, label %49
i8 102, label %49
i8 101, label %49
i8 99, label %49
]
41: ; preds = %39, %39, %39, %39
%42 = add nuw i64 %33, 1
%43 = getelementptr inbounds i8, i8* %2, i64 %33
store i8 108, i8* %43
%44 = add i64 %33, 2
%45 = getelementptr inbounds i8, i8* %2, i64 %42
store i8 108, i8* %45
%46 = add i64 %33, 3
%47 = getelementptr inbounds i8, i8* %2, i64 %44
store i8 %36, i8* %47
%48 = getelementptr inbounds i8, i8* %2, i64 %46
store i8 0, i8* %48
br label %63
49: ; preds = %39, %39, %39, %39, %39
%50 = add nuw i64 %33, 1
%51 = getelementptr inbounds i8, i8* %2, i64 %33
store i8 %36, i8* %51
%52 = getelementptr inbounds i8, i8* %2, i64 %50
store i8 0, i8* %52
br label %63
53: ; preds = %39
%54 = tail call i32 @isdigit(i8 signext %36)
%55 = freeze i32 %54
%56 = icmp ne i32 %55, 0
%57 = add i8 %36, -45
%58 = icmp ult i8 %57, 2
%59 = select i1 %56, i1 true, i1 %58
%60 = add i64 %33, 1
%61 = getelementptr inbounds i8, i8* %2, i64 %33
store i8 %36, i8* %61
%62 = getelementptr inbounds i8, i8* %2, i64 %60
store i8 0, i8* %62
br i1 %59, label %32, label %63
63: ; preds = %37, %32, %32, %53, %49, %41, %24, %20, %16, %12, %8
%64 = phi i8 [ 32, %8 ], [ 32, %12 ], [ 32, %16 ], [ 32, %20 ], [ 32, %24 ], [ %36, %41 ], [ %36, %49 ], [ 32, %37 ], [ 32, %32 ], [ 32, %32 ], [ 45, %53 ]
ret i8 %64
}