#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*/ exit(int);
int /*<<< orphan*/ lt_match(char **, char **);
int /*<<< orphan*/ op_match(char **, char **);
int /*<<< orphan*/ printf(char *, char, ...);
int /*<<< orphan*/ sb_match(char **, char **);
int any_match(char **buffer, char **speech, char start, char end) {
  if (**buffer != start) {
    printf("ERROR, any_match() called, but **buffer != '%c'\n", start);
    exit(1);
  }
  ++(*buffer);
  char *buf = *buffer;
  char *Gspeech = *speech;
  char *tmpSpeech = *speech;
  int stop = 1;
  while (stop != 0) {
    if (**buffer == '\n' || **buffer == '\0' || **buffer == '\r') {
      printf("ERROR, inconnect syntax of %c%c\n", start, end);
      exit(1);
    }
    if (**buffer == start) {
      ++stop;
    }
    if (**buffer == end) {
      --stop;
    }
    ++(*buffer);
    if (**buffer == '\\') {
      ++(*buffer);
      if (**buffer != '\0')
        ++(*buffer);
    }
  }
  --(*buffer);
  while (buf != *buffer) {
    if (*buf == ',') {
      if (tmpSpeech > Gspeech) {
        Gspeech = tmpSpeech;
        tmpSpeech = *speech;
      }
      ++buf;
    }
    if (*buf == '<') {
      if (!lt_match(&buf, &tmpSpeech)) {
        tmpSpeech = *speech;
        while (!(buf == *buffer || *buf == ',')) {
          ++buf;
        }
      }
      continue;
    }
    if (*buf == '(') {
      if (!op_match(&buf, &tmpSpeech)) {
        tmpSpeech = *speech;
        while (!(buf == *buffer || *buf == ',')) {
          ++buf;
        }
      }
      continue;
    }
    if (*buf == '[') {
      sb_match(&buf, &tmpSpeech);
      continue;
    }
    if (*buf == '\\') {
      ++buf;
    }
    if (*buf == *tmpSpeech) {
      ++buf;
      ++tmpSpeech;
    } else {
      tmpSpeech = *speech;
      while (!(buf == *buffer || *buf == ',')) {
        ++buf;
      }
    }
  }
  if (tmpSpeech > Gspeech) {
    Gspeech = tmpSpeech;
    tmpSpeech = *speech;
  }
  ++buf;
  *buffer = buf;
  if (Gspeech > *speech) {
    *speech = Gspeech;
    return 1;
  }
  return 0;
}


x86 assembly (clang, -O0):
<any_match>:
push   %rbp
mov    %rsp,%rbp
sub    $0x40,%rsp
mov    %cl,%al
mov    %dl,%cl
mov    %rdi,-0x10(%rbp)
mov    %rsi,-0x18(%rbp)
mov    %cl,-0x19(%rbp)
mov    %al,-0x1a(%rbp)
mov    -0x10(%rbp),%rax
mov    (%rax),%rax
movsbl (%rax),%eax
movsbl -0x19(%rbp),%ecx
cmp    %ecx,%eax
je     119c <any_match+0x4c>
lea    0xe79(%rip),%rdi
movsbl -0x19(%rbp),%esi
mov    $0x0,%al
call   1040 <printf@plt>
mov    $0x1,%edi
call   1070 <exit@plt>
mov    -0x10(%rbp),%rax
mov    (%rax),%rcx
add    $0x1,%rcx
mov    %rcx,(%rax)
mov    -0x10(%rbp),%rax
mov    (%rax),%rax
mov    %rax,-0x28(%rbp)
mov    -0x18(%rbp),%rax
mov    (%rax),%rax
mov    %rax,-0x30(%rbp)
mov    -0x18(%rbp),%rax
mov    (%rax),%rax
mov    %rax,-0x38(%rbp)
movl   $0x1,-0x3c(%rbp)
cmpl   $0x0,-0x3c(%rbp)
je     12cf <any_match+0x17f>
mov    -0x10(%rbp),%rax
mov    (%rax),%rax
movsbl (%rax),%eax
cmp    $0xa,%eax
je     1215 <any_match+0xc5>
mov    -0x10(%rbp),%rax
mov    (%rax),%rax
movsbl (%rax),%eax
cmp    $0x0,%eax
je     1215 <any_match+0xc5>
mov    -0x10(%rbp),%rax
mov    (%rax),%rax
movsbl (%rax),%eax
cmp    $0xd,%eax
jne    1237 <any_match+0xe7>
mov    -0x19(%rbp),%al
movsbl -0x1a(%rbp),%edx
lea    0xe0e(%rip),%rdi
movsbl %al,%esi
mov    $0x0,%al
call   1040 <printf@plt>
mov    $0x1,%edi
call   1070 <exit@plt>
mov    -0x10(%rbp),%rax
mov    (%rax),%rax
movsbl (%rax),%eax
movsbl -0x19(%rbp),%ecx
cmp    %ecx,%eax
jne    1256 <any_match+0x106>
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
mov    -0x10(%rbp),%rax
mov    (%rax),%rax
movsbl (%rax),%eax
movsbl -0x1a(%rbp),%ecx
cmp    %ecx,%eax
jne    1275 <any_match+0x125>
mov    -0x3c(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x3c(%rbp)
mov    -0x10(%rbp),%rax
mov    (%rax),%rcx
add    $0x1,%rcx
mov    %rcx,(%rax)
mov    -0x10(%rbp),%rax
mov    (%rax),%rax
movsbl (%rax),%eax
cmp    $0x5c,%eax
jne    12ca <any_match+0x17a>
mov    -0x10(%rbp),%rax
mov    (%rax),%rcx
add    $0x1,%rcx
mov    %rcx,(%rax)
mov    -0x10(%rbp),%rax
mov    (%rax),%rax
movsbl (%rax),%eax
cmp    $0x0,%eax
je     12c5 <any_match+0x175>
mov    -0x10(%rbp),%rax
mov    (%rax),%rcx
add    $0x1,%rcx
mov    %rcx,(%rax)
jmp    12ca <any_match+0x17a>
jmp    11d2 <any_match+0x82>
mov    -0x10(%rbp),%rax
mov    (%rax),%rcx
add    $0xffffffffffffffff,%rcx
mov    %rcx,(%rax)
mov    -0x28(%rbp),%rax
mov    -0x10(%rbp),%rcx
cmp    (%rcx),%rax
je     1502 <any_match+0x3b2>
mov    -0x28(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x2c,%eax
jne    132b <any_match+0x1db>
mov    -0x38(%rbp),%rax
cmp    -0x30(%rbp),%rax
jbe    131f <any_match+0x1cf>
mov    -0x38(%rbp),%rax
mov    %rax,-0x30(%rbp)
mov    -0x18(%rbp),%rax
mov    (%rax),%rax
mov    %rax,-0x38(%rbp)
mov    -0x28(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x28(%rbp)
mov    -0x28(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x3c,%eax
jne    13af <any_match+0x25f>
lea    -0x28(%rbp),%rdi
lea    -0x38(%rbp),%rsi
call   1060 <lt_match@plt>
cmp    $0x0,%eax
jne    13aa <any_match+0x25a>
mov    -0x18(%rbp),%rax
mov    (%rax),%rax
mov    %rax,-0x38(%rbp)
mov    -0x28(%rbp),%rcx
mov    -0x10(%rbp),%rdx
mov    $0x1,%al
cmp    (%rdx),%rcx
mov    %al,-0x3d(%rbp)
je     1382 <any_match+0x232>
mov    -0x28(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x2c,%eax
sete   %al
mov    %al,-0x3d(%rbp)
mov    -0x3d(%rbp),%al
xor    $0xff,%al
test   $0x1,%al
jne    1394 <any_match+0x244>
jmp    13a5 <any_match+0x255>
mov    -0x28(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x28(%rbp)
jmp    135c <any_match+0x20c>
jmp    13aa <any_match+0x25a>
jmp    12dd <any_match+0x18d>
mov    -0x28(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x28,%eax
jne    1433 <any_match+0x2e3>
lea    -0x28(%rbp),%rdi
lea    -0x38(%rbp),%rsi
call   1050 <op_match@plt>
cmp    $0x0,%eax
jne    142e <any_match+0x2de>
mov    -0x18(%rbp),%rax
mov    (%rax),%rax
mov    %rax,-0x38(%rbp)
mov    -0x28(%rbp),%rcx
mov    -0x10(%rbp),%rdx
mov    $0x1,%al
cmp    (%rdx),%rcx
mov    %al,-0x3e(%rbp)
je     1406 <any_match+0x2b6>
mov    -0x28(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x2c,%eax
sete   %al
mov    %al,-0x3e(%rbp)
mov    -0x3e(%rbp),%al
xor    $0xff,%al
test   $0x1,%al
jne    1418 <any_match+0x2c8>
jmp    1429 <any_match+0x2d9>
mov    -0x28(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x28(%rbp)
jmp    13e0 <any_match+0x290>
jmp    142e <any_match+0x2de>
jmp    12dd <any_match+0x18d>
mov    -0x28(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x5b,%eax
jne    1455 <any_match+0x305>
lea    -0x28(%rbp),%rdi
lea    -0x38(%rbp),%rsi
call   1030 <sb_match@plt>
jmp    12dd <any_match+0x18d>
mov    -0x28(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x5c,%eax
jne    1471 <any_match+0x321>
mov    -0x28(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x28(%rbp)
mov    -0x28(%rbp),%rax
movsbl (%rax),%eax
mov    -0x38(%rbp),%rcx
movsbl (%rcx),%ecx
cmp    %ecx,%eax
jne    14a4 <any_match+0x354>
mov    -0x28(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x28(%rbp)
mov    -0x38(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x38(%rbp)
jmp    14fd <any_match+0x3ad>
mov    -0x18(%rbp),%rax
mov    (%rax),%rax
mov    %rax,-0x38(%rbp)
mov    -0x28(%rbp),%rcx
mov    -0x10(%rbp),%rdx
mov    $0x1,%al
cmp    (%rdx),%rcx
mov    %al,-0x3f(%rbp)
je     14d5 <any_match+0x385>
mov    -0x28(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x2c,%eax
sete   %al
mov    %al,-0x3f(%rbp)
mov    -0x3f(%rbp),%al
xor    $0xff,%al
test   $0x1,%al
jne    14e7 <any_match+0x397>
jmp    14f8 <any_match+0x3a8>
mov    -0x28(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x28(%rbp)
jmp    14af <any_match+0x35f>
jmp    14fd <any_match+0x3ad>
jmp    12dd <any_match+0x18d>
mov    -0x38(%rbp),%rax
cmp    -0x30(%rbp),%rax
jbe    1523 <any_match+0x3d3>
mov    -0x38(%rbp),%rax
mov    %rax,-0x30(%rbp)
mov    -0x18(%rbp),%rax
mov    (%rax),%rax
mov    %rax,-0x38(%rbp)
mov    -0x28(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x28(%rbp)
mov    -0x28(%rbp),%rcx
mov    -0x10(%rbp),%rax
mov    %rcx,(%rax)
mov    -0x30(%rbp),%rax
mov    -0x18(%rbp),%rcx
cmp    (%rcx),%rax
jbe    1562 <any_match+0x412>
mov    -0x30(%rbp),%rcx
mov    -0x18(%rbp),%rax
mov    %rcx,(%rax)
movl   $0x1,-0x4(%rbp)
jmp    1569 <any_match+0x419>
movl   $0x0,-0x4(%rbp)
mov    -0x4(%rbp),%eax
add    $0x40,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<any_match>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x18,%rsp
mov    (%rdi),%r9
cmp    %dl,(%r9)
jne    13fe <any_match+0x2ae>
mov    %rsi,%r14
mov    %rdi,%r15
lea    0x1(%r9),%rax
mov    %rax,(%rdi)
mov    %rax,0x8(%rsp)
mov    (%rsi),%r13
mov    %r13,0x10(%rsp)
mov    $0x1,%ebx
mov    $0x1,%edi
mov    $0x2401,%r8d
jmp    11a8 <any_match+0x58>
cs nopw 0x0(%rax,%rax,1)
add    $0x1,%rdi
test   %ebx,%ebx
je     1210 <any_match+0xc0>
movzbl (%r9,%rdi,1),%ebp
cmp    $0xd,%rbp
ja     11bd <any_match+0x6d>
bt     %rbp,%r8
jb     13de <any_match+0x28e>
xor    %esi,%esi
cmp    %dl,%bpl
sete   %sil
add    %esi,%ebx
xor    %esi,%esi
cmp    %cl,%bpl
sete   %sil
sub    %esi,%ebx
lea    (%r9,%rdi,1),%rsi
add    $0x1,%rsi
mov    %rsi,(%r15)
cmpb   $0x5c,0x1(%r9,%rdi,1)
jne    11a0 <any_match+0x50>
lea    (%r9,%rdi,1),%rsi
add    $0x2,%rsi
mov    %rsi,(%r15)
cmpb   $0x0,0x2(%r9,%rdi,1)
je     120a <any_match+0xba>
lea    (%r9,%rdi,1),%rsi
add    $0x3,%rsi
add    $0x3,%rdi
mov    %rsi,(%r15)
jmp    11a4 <any_match+0x54>
add    $0x2,%rdi
jmp    11a4 <any_match+0x54>
lea    (%r9,%rdi,1),%rcx
add    $0xffffffffffffffff,%rcx
add    $0xffffffffffffffff,%rdi
mov    %rcx,(%r15)
cmp    $0x1,%rdi
je     13b9 <any_match+0x269>
lea    0x8(%rsp),%rbx
lea    0x10(%rsp),%r12
jmp    1261 <any_match+0x111>
cs nopw 0x0(%rax,%rax,1)
nop
mov    %rbx,%rdi
mov    %r12,%rsi
call   1030 <sb_match@plt>
nopl   0x0(%rax,%rax,1)
mov    0x8(%rsp),%rax
mov    (%r15),%rcx
cmp    %rcx,%rax
je     13ad <any_match+0x25d>
mov    (%rax),%dl
cmp    $0x2c,%dl
jne    128c <any_match+0x13c>
mov    0x10(%rsp),%rdx
cmp    %r13,%rdx
jbe    127d <any_match+0x12d>
mov    (%r14),%rsi
mov    %rsi,0x10(%rsp)
mov    %rdx,%r13
lea    0x1(%rax),%rsi
mov    %rsi,0x8(%rsp)
mov    0x1(%rax),%dl
mov    %rsi,%rax
cmp    $0x5a,%dl
jg     12f0 <any_match+0x1a0>
cmp    $0x28,%dl
je     1330 <any_match+0x1e0>
cmp    $0x3c,%dl
jne    130d <any_match+0x1bd>
mov    %rbx,%rdi
mov    %r12,%rsi
call   1060 <lt_match@plt>
test   %eax,%eax
jne    1250 <any_match+0x100>
mov    (%r14),%rax
mov    %rax,0x10(%rsp)
mov    (%r15),%rax
mov    0x8(%rsp),%rcx
cmp    %rax,%rcx
je     1250 <any_match+0x100>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
cmpb   $0x2c,(%rcx)
je     1250 <any_match+0x100>
add    $0x1,%rcx
mov    %rcx,0x8(%rsp)
cmp    %rax,%rcx
jne    12d0 <any_match+0x180>
jmp    1250 <any_match+0x100>
nopl   0x0(%rax)
cmp    $0x5b,%dl
je     1240 <any_match+0xf0>
cmp    $0x5c,%dl
jne    130d <any_match+0x1bd>
lea    0x1(%rax),%rsi
mov    %rsi,0x8(%rsp)
mov    0x1(%rax),%dl
mov    %rsi,%rax
mov    0x10(%rsp),%rsi
cmp    (%rsi),%dl
jne    1380 <any_match+0x230>
add    $0x1,%rax
mov    %rax,0x8(%rsp)
add    $0x1,%rsi
mov    %rsi,0x10(%rsp)
jmp    1250 <any_match+0x100>
nopl   (%rax)
mov    %rbx,%rdi
mov    %r12,%rsi
call   1050 <op_match@plt>
test   %eax,%eax
jne    1250 <any_match+0x100>
mov    (%r14),%rax
mov    %rax,0x10(%rsp)
mov    (%r15),%rax
mov    0x8(%rsp),%rcx
cmp    %rax,%rcx
je     1250 <any_match+0x100>
nopl   0x0(%rax)
cmpb   $0x2c,(%rcx)
je     1250 <any_match+0x100>
add    $0x1,%rcx
mov    %rcx,0x8(%rsp)
cmp    %rax,%rcx
jne    1360 <any_match+0x210>
jmp    1250 <any_match+0x100>
nopl   0x0(%rax)
mov    (%r14),%rdx
mov    %rdx,0x10(%rsp)
nopl   0x0(%rax,%rax,1)
cmp    %rcx,%rax
je     1250 <any_match+0x100>
cmpb   $0x2c,(%rax)
je     1250 <any_match+0x100>
add    $0x1,%rax
mov    %rax,0x8(%rsp)
jmp    1390 <any_match+0x240>
mov    0x10(%rsp),%rcx
cmp    %r13,%rcx
cmova  %rcx,%r13
add    $0x1,%rax
mov    %rax,(%r15)
xor    %eax,%eax
cmp    (%r14),%r13
jbe    13cf <any_match+0x27f>
mov    %r13,(%r14)
mov    $0x1,%eax
add    $0x18,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
movsbl %cl,%eax
movsbl %dl,%esi
lea    0xc46(%rip),%rdi
mov    %eax,%edx
xor    %eax,%eax
call   1040 <printf@plt>
mov    $0x1,%edi
call   1070 <exit@plt>
movsbl %dl,%esi
lea    0xbf8(%rip),%rdi
xor    %eax,%eax
call   1040 <printf@plt>
mov    $0x1,%edi
call   1070 <exit@plt>

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

LLVM IR (-O2):
@.str = [49 x i8] c"ERROR, any_match() called, but **buffer != '%c'\0A\00"
@.str.1 = [33 x i8] c"ERROR, inconnect syntax of %c%c\0A\00"
define i32 @any_match(i8** nocapture %0, i8** nocapture %1, i8 signext %2, i8 signext %3) {
%5 = alloca i8*
%6 = alloca i8*
%7 = load i8*, i8** %0
%8 = load i8, i8* %7
%9 = icmp eq i8 %8, %2
br i1 %9, label %13, label %10
10: ; preds = %4
%11 = tail call i32 (i8*, i8, ...) @printf(i8* getelementptr inbounds ([49 x i8], [49 x i8]* @.str, i64 0, i64 0), i8 signext %2)
%12 = tail call i32 @exit(i32 1)
unreachable
13: ; preds = %4
%14 = getelementptr inbounds i8, i8* %7, i64 1
store i8* %14, i8** %0
%15 = bitcast i8** %5 to i8*
store i8* %14, i8** %5
%16 = load i8*, i8** %1
%17 = bitcast i8** %6 to i8*
store i8* %16, i8** %6
br label %18
18: ; preds = %13, %46
%19 = phi i64 [ 1, %13 ], [ %47, %46 ]
%20 = phi i32 [ 1, %13 ], [ %33, %46 ]
%21 = getelementptr inbounds i8, i8* %7, i64 %19
%22 = load i8, i8* %21
switch i8 %22, label %27 [
i8 10, label %23
i8 0, label %23
i8 13, label %23
]
23: ; preds = %18, %18, %18
%24 = sext i8 %3 to i32
%25 = tail call i32 (i8*, i8, ...) @printf(i8* getelementptr inbounds ([33 x i8], [33 x i8]* @.str.1, i64 0, i64 0), i8 signext %2, i32 %24)
%26 = tail call i32 @exit(i32 1)
unreachable
27: ; preds = %18
%28 = icmp eq i8 %22, %2
%29 = zext i1 %28 to i32
%30 = add nsw i32 %20, %29
%31 = icmp eq i8 %22, %3
%32 = sext i1 %31 to i32
%33 = add nsw i32 %30, %32
%34 = add nsw i64 %19, 1
%35 = getelementptr inbounds i8, i8* %7, i64 %34
store i8* %35, i8** %0
%36 = load i8, i8* %35
%37 = icmp eq i8 %36, 92
br i1 %37, label %38, label %46
38: ; preds = %27
%39 = add nsw i64 %19, 2
%40 = getelementptr inbounds i8, i8* %7, i64 %39
store i8* %40, i8** %0
%41 = load i8, i8* %40
%42 = icmp eq i8 %41, 0
br i1 %42, label %46, label %43
43: ; preds = %38
%44 = add nsw i64 %19, 3
%45 = getelementptr inbounds i8, i8* %7, i64 %44
store i8* %45, i8** %0
br label %46
46: ; preds = %38, %43, %27
%47 = phi i64 [ %39, %38 ], [ %44, %43 ], [ %34, %27 ]
%48 = icmp eq i32 %33, 0
br i1 %48, label %49, label %18
49: ; preds = %46
%50 = add nsw i64 %47, -1
%51 = getelementptr inbounds i8, i8* %7, i64 %50
store i8* %51, i8** %0
%52 = icmp eq i64 %50, 1
br i1 %52, label %134, label %53
53: ; preds = %49, %87
%54 = phi i8* [ %89, %87 ], [ %51, %49 ]
%55 = phi i8* [ %88, %87 ], [ %14, %49 ]
%56 = phi i8* [ %71, %87 ], [ %16, %49 ]
%57 = load i8, i8* %55
%58 = icmp eq i8 %57, 44
br i1 %58, label %59, label %68
59: ; preds = %53
%60 = load i8*, i8** %6
%61 = icmp ugt i8* %60, %56
br i1 %61, label %62, label %64
62: ; preds = %59
%63 = load i8*, i8** %1
store i8* %63, i8** %6
br label %64
64: ; preds = %62, %59
%65 = phi i8* [ %60, %62 ], [ %56, %59 ]
%66 = getelementptr inbounds i8, i8* %55, i64 1
store i8* %66, i8** %5
%67 = load i8, i8* %66
br label %68
68: ; preds = %64, %53
%69 = phi i8 [ %67, %64 ], [ %57, %53 ]
%70 = phi i8* [ %66, %64 ], [ %55, %53 ]
%71 = phi i8* [ %65, %64 ], [ %56, %53 ]
switch i8 %69, label %111 [
i8 60, label %72
i8 40, label %91
i8 91, label %106
i8 92, label %108
]
72: ; preds = %68
%73 = call i32 @lt_match(i8** %5, i8** %6)
%74 = icmp eq i32 %73, 0
br i1 %74, label %75, label %87
75: ; preds = %72
%76 = load i8*, i8** %1
store i8* %76, i8** %6
%77 = load i8*, i8** %0
%78 = load i8*, i8** %5
%79 = icmp eq i8* %78, %77
br i1 %79, label %87, label %80
80: ; preds = %75, %84
%81 = phi i8* [ %85, %84 ], [ %78, %75 ]
%82 = load i8, i8* %81
%83 = icmp eq i8 %82, 44
br i1 %83, label %87, label %84
84: ; preds = %80
%85 = getelementptr inbounds i8, i8* %81, i64 1
store i8* %85, i8** %5
%86 = icmp eq i8* %85, %77
br i1 %86, label %87, label %80
87: ; preds = %103, %99, %84, %80, %127, %123, %117, %120, %91, %94, %72, %75, %106
%88 = load i8*, i8** %5
%89 = load i8*, i8** %0
%90 = icmp eq i8* %88, %89
br i1 %90, label %130, label %53
91: ; preds = %68
%92 = call i32 @op_match(i8** %5, i8** %6)
%93 = icmp eq i32 %92, 0
br i1 %93, label %94, label %87
94: ; preds = %91
%95 = load i8*, i8** %1
store i8* %95, i8** %6
%96 = load i8*, i8** %0
%97 = load i8*, i8** %5
%98 = icmp eq i8* %97, %96
br i1 %98, label %87, label %99
99: ; preds = %94, %103
%100 = phi i8* [ %104, %103 ], [ %97, %94 ]
%101 = load i8, i8* %100
%102 = icmp eq i8 %101, 44
br i1 %102, label %87, label %103
103: ; preds = %99
%104 = getelementptr inbounds i8, i8* %100, i64 1
store i8* %104, i8** %5
%105 = icmp eq i8* %104, %96
br i1 %105, label %87, label %99
106: ; preds = %68
%107 = call i32 @sb_match(i8** %5, i8** %6)
br label %87
108: ; preds = %68
%109 = getelementptr inbounds i8, i8* %70, i64 1
store i8* %109, i8** %5
%110 = load i8, i8* %109
br label %111
111: ; preds = %68, %108
%112 = phi i8 [ %69, %68 ], [ %110, %108 ]
%113 = phi i8* [ %70, %68 ], [ %109, %108 ]
%114 = load i8*, i8** %6
%115 = load i8, i8* %114
%116 = icmp eq i8 %112, %115
br i1 %116, label %117, label %120
117: ; preds = %111
%118 = getelementptr inbounds i8, i8* %113, i64 1
store i8* %118, i8** %5
%119 = getelementptr inbounds i8, i8* %114, i64 1
store i8* %119, i8** %6
br label %87
120: ; preds = %111
%121 = load i8*, i8** %1
store i8* %121, i8** %6
%122 = icmp eq i8* %113, %54
br i1 %122, label %87, label %123
123: ; preds = %120, %127
%124 = phi i8* [ %128, %127 ], [ %113, %120 ]
%125 = load i8, i8* %124
%126 = icmp eq i8 %125, 44
br i1 %126, label %87, label %127
127: ; preds = %123
%128 = getelementptr inbounds i8, i8* %124, i64 1
store i8* %128, i8** %5
%129 = icmp eq i8* %128, %54
br i1 %129, label %87, label %123
130: ; preds = %87
%131 = load i8*, i8** %6
%132 = icmp ugt i8* %131, %71
%133 = select i1 %132, i8* %131, i8* %71
br label %134
134: ; preds = %130, %49
%135 = phi i8* [ %14, %49 ], [ %88, %130 ]
%136 = phi i8* [ %16, %49 ], [ %133, %130 ]
%137 = getelementptr inbounds i8, i8* %135, i64 1
store i8* %137, i8** %0
%138 = load i8*, i8** %1
%139 = icmp ugt i8* %136, %138
br i1 %139, label %140, label %141
140: ; preds = %134
store i8* %136, i8** %1
br label %141
141: ; preds = %134, %140
%142 = phi i32 [ 1, %140 ], [ 0, %134 ]
ret i32 %142
}