#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*/ printf(char *, ...);
int /*<<< orphan*/ strcmp95(char *, char *, long, int **);
long strlen(char *);
int /*<<< orphan*/ strncat(char *, char *, long);
int main(int argc, char *argv[]) {
  long ying_length, yang_length, length, diff;
  char *ying;
  char *yang;
  char ying_hold[61], yang_hold[61];
  register int i, j, k;
  double weight;
  int flags[2];
  char *flag_str;
  flag_str = argv[3];
  for (i = 0; i < 2; i++) {
    flags[i] = 1 ? flag_str[i] == 49 : 0;
  }
  ying = argv[1];
  yang = argv[2];
  ying_length = strlen(ying);
  yang_length = strlen(yang);
  length = (ying_length > yang_length) ? ying_length : yang_length;
  printf("ying: '%s' (len %ld)\n", ying, ying_length);
  printf("yang: '%s' (len %ld)\n", yang, yang_length);
  printf("length: %ld\n", length);
  printf("flags: %d %d\n", flags[0], flags[1]);
  ying_hold[0] = yang_hold[0] = 0;
  strncat(ying_hold,
          "                                                            ",
          length);
  strncat(yang_hold,
          "                                                            ",
          length);
  for (i = 0; i < ying_length; i++)
    ying_hold[i] = ying[i];
  for (i = 0; i < yang_length; i++)
    yang_hold[i] = yang[i];
  strcmp95(ying_hold, yang_hold, length, &flags);
}


x86 assembly (clang, -O0):
<main>:
push   %rbp
mov    %rsp,%rbp
sub    $0xf0,%rsp
movl   $0x0,-0x4(%rbp)
mov    %edi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    -0x10(%rbp),%rax
mov    0x18(%rax),%rax
mov    %rax,-0xe8(%rbp)
movl   $0x0,-0xc4(%rbp)
cmpl   $0x2,-0xc4(%rbp)
jge    11be <main+0x7e>
mov    -0xe8(%rbp),%rax
movslq -0xc4(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x31,%eax
sete   %al
and    $0x1,%al
movzbl %al,%ecx
movslq -0xc4(%rbp),%rax
mov    %ecx,-0xe0(%rbp,%rax,4)
mov    -0xc4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc4(%rbp)
jmp    1172 <main+0x32>
mov    -0x10(%rbp),%rax
mov    0x8(%rax),%rax
mov    %rax,-0x38(%rbp)
mov    -0x10(%rbp),%rax
mov    0x10(%rax),%rax
mov    %rax,-0x40(%rbp)
mov    -0x38(%rbp),%rdi
call   1030 <strlen@plt>
mov    %rax,-0x18(%rbp)
mov    -0x40(%rbp),%rdi
call   1030 <strlen@plt>
mov    %rax,-0x20(%rbp)
mov    -0x18(%rbp),%rax
cmp    -0x20(%rbp),%rax
jle    120e <main+0xce>
mov    -0x18(%rbp),%rax
mov    %rax,-0xf0(%rbp)
jmp    1219 <main+0xd9>
mov    -0x20(%rbp),%rax
mov    %rax,-0xf0(%rbp)
mov    -0xf0(%rbp),%rax
mov    %rax,-0x28(%rbp)
mov    -0x38(%rbp),%rsi
mov    -0x18(%rbp),%rdx
lea    0xdcd(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
mov    -0x40(%rbp),%rsi
mov    -0x20(%rbp),%rdx
lea    0xdcd(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
mov    -0x28(%rbp),%rsi
lea    0xdd1(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
mov    -0xe0(%rbp),%esi
mov    -0xdc(%rbp),%edx
lea    0xdc4(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
movb   $0x0,-0xc0(%rbp)
movb   $0x0,-0x80(%rbp)
lea    -0x80(%rbp),%rdi
mov    -0x28(%rbp),%rdx
lea    0xdb1(%rip),%rsi
call   1050 <strncat@plt>
lea    -0xc0(%rbp),%rdi
mov    -0x28(%rbp),%rdx
lea    0xd9a(%rip),%rsi
call   1050 <strncat@plt>
movl   $0x0,-0xc4(%rbp)
movslq -0xc4(%rbp),%rax
cmp    -0x18(%rbp),%rax
jge    12fa <main+0x1ba>
mov    -0x38(%rbp),%rax
movslq -0xc4(%rbp),%rcx
mov    (%rax,%rcx,1),%cl
movslq -0xc4(%rbp),%rax
mov    %cl,-0x80(%rbp,%rax,1)
mov    -0xc4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc4(%rbp)
jmp    12bc <main+0x17c>
movl   $0x0,-0xc4(%rbp)
movslq -0xc4(%rbp),%rax
cmp    -0x20(%rbp),%rax
jge    1345 <main+0x205>
mov    -0x40(%rbp),%rax
movslq -0xc4(%rbp),%rcx
mov    (%rax,%rcx,1),%cl
movslq -0xc4(%rbp),%rax
mov    %cl,-0xc0(%rbp,%rax,1)
mov    -0xc4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc4(%rbp)
jmp    1304 <main+0x1c4>
lea    -0x80(%rbp),%rdi
lea    -0xc0(%rbp),%rsi
mov    -0x28(%rbp),%rdx
lea    -0xe0(%rbp),%rcx
call   1060 <strcmp95@plt>
mov    -0x4(%rbp),%eax
add    $0xf0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<main>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0xa8,%rsp
mov    0x18(%rsi),%rax
xor    %ecx,%ecx
cmpb   $0x31,(%rax)
sete   %cl
mov    %ecx,0x4(%rsp)
mov    %ecx,0x8(%rsp)
xor    %r13d,%r13d
cmpb   $0x31,0x1(%rax)
sete   %r13b
mov    %r13d,0xc(%rsp)
mov    0x8(%rsi),%rbx
mov    0x10(%rsi),%r12
mov    %rbx,%rdi
call   1030 <strlen@plt>
mov    %rax,%rbp
mov    %r12,%rdi
call   1030 <strlen@plt>
mov    %rax,%r15
mov    %rbp,0x98(%rsp)
cmp    %rax,%rbp
mov    %rax,%r14
cmovg  %rbp,%r14
lea    0xe54(%rip),%rdi
mov    %rbx,%rsi
mov    %rbp,%rdx
xor    %eax,%eax
call   1040 <printf@plt>
lea    0xe56(%rip),%rdi
mov    %r12,%rsi
mov    %r15,0xa0(%rsp)
mov    %r15,%rdx
xor    %eax,%eax
call   1040 <printf@plt>
lea    0xe50(%rip),%rdi
mov    %r14,%rsi
xor    %eax,%eax
call   1040 <printf@plt>
lea    0xe4c(%rip),%rdi
mov    0x4(%rsp),%esi
mov    %r13d,%edx
xor    %eax,%eax
call   1040 <printf@plt>
movb   $0x0,0x10(%rsp)
movb   $0x0,0x50(%rsp)
lea    0xe3b(%rip),%rbp
lea    0x50(%rsp),%r15
mov    %r15,%rdi
mov    %rbp,%rsi
mov    %r14,%rdx
call   1050 <strncat@plt>
lea    0x10(%rsp),%r13
mov    %r13,%rdi
mov    %rbp,%rsi
mov    %r14,%rdx
call   1050 <strncat@plt>
mov    0x98(%rsp),%rbp
test   %rbp,%rbp
jle    12cc <main+0x18c>
cmp    $0x8,%rbp
jb     1267 <main+0x127>
lea    (%rbx,%rbp,1),%rax
cmp    %rax,%r15
jae    139b <main+0x25b>
lea    (%rsp,%rbp,1),%rax
add    $0x50,%rax
cmp    %rax,%rbx
jae    139b <main+0x25b>
xor    %eax,%eax
mov    %rax,%rsi
not    %rsi
add    %rbp,%rsi
mov    %rbp,%rdx
and    $0x3,%rdx
je     1292 <main+0x152>
nopl   0x0(%rax,%rax,1)
movzbl (%rbx,%rax,1),%ecx
mov    %cl,0x50(%rsp,%rax,1)
add    $0x1,%rax
add    $0xffffffffffffffff,%rdx
jne    1280 <main+0x140>
cmp    $0x3,%rsi
jb     12cc <main+0x18c>
nopl   0x0(%rax,%rax,1)
movzbl (%rbx,%rax,1),%ecx
mov    %cl,0x50(%rsp,%rax,1)
movzbl 0x1(%rbx,%rax,1),%ecx
mov    %cl,0x51(%rsp,%rax,1)
movzbl 0x2(%rbx,%rax,1),%ecx
mov    %cl,0x52(%rsp,%rax,1)
movzbl 0x3(%rbx,%rax,1),%ecx
mov    %cl,0x53(%rsp,%rax,1)
add    $0x4,%rax
cmp    %rax,%rbp
jne    12a0 <main+0x160>
mov    0xa0(%rsp),%rbp
test   %rbp,%rbp
jle    1370 <main+0x230>
cmp    $0x8,%rbp
jb     1301 <main+0x1c1>
lea    (%r12,%rbp,1),%rax
cmp    %rax,%r13
jae    13a8 <main+0x268>
lea    (%rsp,%rbp,1),%rax
add    $0x10,%rax
cmp    %rax,%r12
jae    13a8 <main+0x268>
xor    %eax,%eax
mov    %rax,%rcx
not    %rcx
add    %rbp,%rcx
mov    %rbp,%rdx
and    $0x3,%rdx
je     1333 <main+0x1f3>
cs nopw 0x0(%rax,%rax,1)
nop
movzbl (%r12,%rax,1),%ebx
mov    %bl,0x10(%rsp,%rax,1)
add    $0x1,%rax
add    $0xffffffffffffffff,%rdx
jne    1320 <main+0x1e0>
cmp    $0x3,%rcx
jb     1370 <main+0x230>
nopl   0x0(%rax)
movzbl (%r12,%rax,1),%ecx
mov    %cl,0x10(%rsp,%rax,1)
movzbl 0x1(%r12,%rax,1),%ecx
mov    %cl,0x11(%rsp,%rax,1)
movzbl 0x2(%r12,%rax,1),%ecx
mov    %cl,0x12(%rsp,%rax,1)
movzbl 0x3(%r12,%rax,1),%ecx
mov    %cl,0x13(%rsp,%rax,1)
add    $0x4,%rax
cmp    %rax,%rbp
jne    1340 <main+0x200>
lea    0x50(%rsp),%rdi
lea    0x10(%rsp),%rsi
lea    0x8(%rsp),%rcx
mov    %r14,%rdx
call   1060 <strcmp95@plt>
xor    %eax,%eax
add    $0xa8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
cmp    $0x20,%rbp
jae    13b5 <main+0x275>
xor    %eax,%eax
jmp    14ce <main+0x38e>
cmp    $0x20,%rbp
jae    13dd <main+0x29d>
xor    %eax,%eax
jmp    15be <main+0x47e>
mov    %rbp,%rax
and    $0xffffffffffffffe0,%rax
lea    -0x20(%rax),%rsi
mov    %rsi,%rdx
shr    $0x5,%rdx
add    $0x1,%rdx
mov    %edx,%ecx
and    $0x3,%ecx
cmp    $0x60,%rsi
jae    1409 <main+0x2c9>
xor    %esi,%esi
jmp    1478 <main+0x338>
mov    %rbp,%rax
and    $0xffffffffffffffe0,%rax
lea    -0x20(%rax),%rsi
mov    %rsi,%rdx
shr    $0x5,%rdx
add    $0x1,%rdx
mov    %edx,%ecx
and    $0x3,%ecx
cmp    $0x60,%rsi
jae    1500 <main+0x3c0>
xor    %esi,%esi
jmp    1574 <main+0x434>
and    $0xfffffffffffffffc,%rdx
xor    %esi,%esi
nop
movups (%rbx,%rsi,1),%xmm0
movups 0x10(%rbx,%rsi,1),%xmm1
movaps %xmm0,0x50(%rsp,%rsi,1)
movaps %xmm1,0x60(%rsp,%rsi,1)
movups 0x20(%rbx,%rsi,1),%xmm0
movups 0x30(%rbx,%rsi,1),%xmm1
movaps %xmm0,0x70(%rsp,%rsi,1)
movaps %xmm1,0x80(%rsp,%rsi,1)
movups 0x40(%rbx,%rsi,1),%xmm0
movups 0x50(%rbx,%rsi,1),%xmm1
movaps %xmm0,0x90(%rsp,%rsi,1)
movaps %xmm1,0xa0(%rsp,%rsi,1)
movups 0x60(%rbx,%rsi,1),%xmm0
movups 0x70(%rbx,%rsi,1),%xmm1
movaps %xmm0,0xb0(%rsp,%rsi,1)
movaps %xmm1,0xc0(%rsp,%rsi,1)
sub    $0xffffffffffffff80,%rsi
add    $0xfffffffffffffffc,%rdx
jne    1410 <main+0x2d0>
test   %rcx,%rcx
je     14bb <main+0x37b>
lea    (%rsp,%rsi,1),%rdx
add    $0x60,%rdx
add    %rbx,%rsi
add    $0x10,%rsi
shl    $0x5,%rcx
xor    %edi,%edi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movups -0x10(%rsi,%rdi,1),%xmm0
movups (%rsi,%rdi,1),%xmm1
movaps %xmm0,-0x10(%rdx,%rdi,1)
movaps %xmm1,(%rdx,%rdi,1)
add    $0x20,%rdi
cmp    %rdi,%rcx
jne    14a0 <main+0x360>
cmp    %rax,%rbp
je     12cc <main+0x18c>
test   $0x18,%bpl
je     1269 <main+0x129>
mov    %rax,%rcx
mov    %rbp,%rax
and    $0xfffffffffffffff8,%rax
nopl   0x0(%rax,%rax,1)
mov    (%rbx,%rcx,1),%rdx
mov    %rdx,0x50(%rsp,%rcx,1)
add    $0x8,%rcx
cmp    %rcx,%rax
jne    14e0 <main+0x3a0>
cmp    %rax,%rbp
je     12cc <main+0x18c>
jmp    1269 <main+0x129>
and    $0xfffffffffffffffc,%rdx
xor    %esi,%esi
cs nopw 0x0(%rax,%rax,1)
movups (%r12,%rsi,1),%xmm0
movups 0x10(%r12,%rsi,1),%xmm1
movaps %xmm0,0x10(%rsp,%rsi,1)
movaps %xmm1,0x20(%rsp,%rsi,1)
movups 0x20(%r12,%rsi,1),%xmm0
movups 0x30(%r12,%rsi,1),%xmm1
movaps %xmm0,0x30(%rsp,%rsi,1)
movaps %xmm1,0x40(%rsp,%rsi,1)
movups 0x40(%r12,%rsi,1),%xmm0
movups 0x50(%r12,%rsi,1),%xmm1
movaps %xmm0,0x50(%rsp,%rsi,1)
movaps %xmm1,0x60(%rsp,%rsi,1)
movups 0x60(%r12,%rsi,1),%xmm0
movups 0x70(%r12,%rsi,1),%xmm1
movaps %xmm0,0x70(%rsp,%rsi,1)
movaps %xmm1,0x80(%rsp,%rsi,1)
sub    $0xffffffffffffff80,%rsi
add    $0xfffffffffffffffc,%rdx
jne    1510 <main+0x3d0>
test   %rcx,%rcx
je     15ab <main+0x46b>
lea    (%rsp,%rsi,1),%rdx
add    $0x20,%rdx
add    %r12,%rsi
add    $0x10,%rsi
shl    $0x5,%rcx
xor    %edi,%edi
xchg   %ax,%ax
movups -0x10(%rsi,%rdi,1),%xmm0
movups (%rsi,%rdi,1),%xmm1
movaps %xmm0,-0x10(%rdx,%rdi,1)
movaps %xmm1,(%rdx,%rdi,1)
add    $0x20,%rdi
cmp    %rdi,%rcx
jne    1590 <main+0x450>
cmp    %rax,%rbp
je     1370 <main+0x230>
test   $0x18,%bpl
je     1303 <main+0x1c3>
mov    %rax,%rcx
mov    %rbp,%rax
and    $0xfffffffffffffff8,%rax
nopl   0x0(%rax,%rax,1)
mov    (%r12,%rcx,1),%rdx
mov    %rdx,0x10(%rsp,%rcx,1)
add    $0x8,%rcx
cmp    %rcx,%rax
jne    15d0 <main+0x490>
cmp    %rax,%rbp
je     1370 <main+0x230>
jmp    1303 <main+0x1c3>

LLVM IR (-O0):
@.str = [22 x i8] c"ying: '%s' (len %ld)\0A\00"
@.str.1 = [22 x i8] c"yang: '%s' (len %ld)\0A\00"
@.str.2 = [13 x i8] c"length: %ld\0A\00"
@.str.3 = [14 x i8] c"flags: %d %d\0A\00"
@.str.4 = [61 x i8] c" \00"
define i32 @main(i32 %0, i8** %1) {
%3 = alloca i32
%4 = alloca i32
%5 = alloca i8**
%6 = alloca i64
%7 = alloca i64
%8 = alloca i64
%9 = alloca i64
%10 = alloca i8*
%11 = alloca i8*
%12 = alloca [61 x i8]
%13 = alloca [61 x i8]
%14 = alloca i32
%15 = alloca i32
%16 = alloca i32
%17 = alloca double
%18 = alloca [2 x i32]
%19 = alloca i8*
store i32 0, i32* %3
store i32 %0, i32* %4
store i8** %1, i8*** %5
%20 = load i8**, i8*** %5
%21 = getelementptr inbounds i8*, i8** %20, i64 3
%22 = load i8*, i8** %21
store i8* %22, i8** %19
store i32 0, i32* %14
br label %23
23: ; preds = %38, %2
%24 = load i32, i32* %14
%25 = icmp slt i32 %24, 2
br i1 %25, label %26, label %41
26: ; preds = %23
%27 = load i8*, i8** %19
%28 = load i32, i32* %14
%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 eq i32 %32, 49
%34 = zext i1 %33 to i32
%35 = load i32, i32* %14
%36 = sext i32 %35 to i64
%37 = getelementptr inbounds [2 x i32], [2 x i32]* %18, i64 0, i64 %36
store i32 %34, i32* %37
br label %38
38: ; preds = %26
%39 = load i32, i32* %14
%40 = add nsw i32 %39, 1
store i32 %40, i32* %14
br label %23
41: ; preds = %23
%42 = load i8**, i8*** %5
%43 = getelementptr inbounds i8*, i8** %42, i64 1
%44 = load i8*, i8** %43
store i8* %44, i8** %10
%45 = load i8**, i8*** %5
%46 = getelementptr inbounds i8*, i8** %45, i64 2
%47 = load i8*, i8** %46
store i8* %47, i8** %11
%48 = load i8*, i8** %10
%49 = call i64 @strlen(i8* %48)
store i64 %49, i64* %6
%50 = load i8*, i8** %11
%51 = call i64 @strlen(i8* %50)
store i64 %51, i64* %7
%52 = load i64, i64* %6
%53 = load i64, i64* %7
%54 = icmp sgt i64 %52, %53
br i1 %54, label %55, label %57
55: ; preds = %41
%56 = load i64, i64* %6
br label %59
57: ; preds = %41
%58 = load i64, i64* %7
br label %59
59: ; preds = %57, %55
%60 = phi i64 [ %56, %55 ], [ %58, %57 ]
store i64 %60, i64* %8
%61 = load i8*, i8** %10
%62 = load i64, i64* %6
%63 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([22 x i8], [22 x i8]* @.str, i64 0, i64 0), i8* %61, i64 %62)
%64 = load i8*, i8** %11
%65 = load i64, i64* %7
%66 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([22 x i8], [22 x i8]* @.str.1, i64 0, i64 0), i8* %64, i64 %65)
%67 = load i64, i64* %8
%68 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str.2, i64 0, i64 0), i64 %67)
%69 = getelementptr inbounds [2 x i32], [2 x i32]* %18, i64 0, i64 0
%70 = load i32, i32* %69
%71 = getelementptr inbounds [2 x i32], [2 x i32]* %18, i64 0, i64 1
%72 = load i32, i32* %71
%73 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([14 x i8], [14 x i8]* @.str.3, i64 0, i64 0), i32 %70, i32 %72)
%74 = getelementptr inbounds [61 x i8], [61 x i8]* %13, i64 0, i64 0
store i8 0, i8* %74
%75 = getelementptr inbounds [61 x i8], [61 x i8]* %12, i64 0, i64 0
store i8 0, i8* %75
%76 = getelementptr inbounds [61 x i8], [61 x i8]* %12, i64 0, i64 0
%77 = load i64, i64* %8
%78 = call i32 @strncat(i8* %76, i8* getelementptr inbounds ([61 x i8], [61 x i8]* @.str.4, i64 0, i64 0), i64 %77)
%79 = getelementptr inbounds [61 x i8], [61 x i8]* %13, i64 0, i64 0
%80 = load i64, i64* %8
%81 = call i32 @strncat(i8* %79, i8* getelementptr inbounds ([61 x i8], [61 x i8]* @.str.4, i64 0, i64 0), i64 %80)
store i32 0, i32* %14
br label %82
82: ; preds = %96, %59
%83 = load i32, i32* %14
%84 = sext i32 %83 to i64
%85 = load i64, i64* %6
%86 = icmp slt i64 %84, %85
br i1 %86, label %87, label %99
87: ; preds = %82
%88 = load i8*, i8** %10
%89 = load i32, i32* %14
%90 = sext i32 %89 to i64
%91 = getelementptr inbounds i8, i8* %88, i64 %90
%92 = load i8, i8* %91
%93 = load i32, i32* %14
%94 = sext i32 %93 to i64
%95 = getelementptr inbounds [61 x i8], [61 x i8]* %12, i64 0, i64 %94
store i8 %92, i8* %95
br label %96
96: ; preds = %87
%97 = load i32, i32* %14
%98 = add nsw i32 %97, 1
store i32 %98, i32* %14
br label %82
99: ; preds = %82
store i32 0, i32* %14
br label %100
100: ; preds = %114, %99
%101 = load i32, i32* %14
%102 = sext i32 %101 to i64
%103 = load i64, i64* %7
%104 = icmp slt i64 %102, %103
br i1 %104, label %105, label %117
105: ; preds = %100
%106 = load i8*, i8** %11
%107 = load i32, i32* %14
%108 = sext i32 %107 to i64
%109 = getelementptr inbounds i8, i8* %106, i64 %108
%110 = load i8, i8* %109
%111 = load i32, i32* %14
%112 = sext i32 %111 to i64
%113 = getelementptr inbounds [61 x i8], [61 x i8]* %13, i64 0, i64 %112
store i8 %110, i8* %113
br label %114
114: ; preds = %105
%115 = load i32, i32* %14
%116 = add nsw i32 %115, 1
store i32 %116, i32* %14
br label %100
117: ; preds = %100
%118 = getelementptr inbounds [61 x i8], [61 x i8]* %12, i64 0, i64 0
%119 = getelementptr inbounds [61 x i8], [61 x i8]* %13, i64 0, i64 0
%120 = load i64, i64* %8
%121 = bitcast [2 x i32]* %18 to i32**
%122 = call i32 @strcmp95(i8* %118, i8* %119, i64 %120, i32** %121)
%123 = load i32, i32* %3
ret i32 %123
}

LLVM IR (-O2):
@.str = [22 x i8] c"ying: '%s' (len %ld)\0A\00"
@.str.1 = [22 x i8] c"yang: '%s' (len %ld)\0A\00"
@.str.2 = [13 x i8] c"length: %ld\0A\00"
@.str.3 = [14 x i8] c"flags: %d %d\0A\00"
@.str.4 = [61 x i8] c" \00"
define i32 @main(i32 %0, i8** nocapture %1) {
%3 = alloca [61 x i8]
%4 = getelementptr inbounds [61 x i8], [61 x i8]* %3, i64 0, i64 0
%5 = alloca [61 x i8]
%6 = getelementptr inbounds [61 x i8], [61 x i8]* %5, i64 0, i64 0
%7 = alloca i32*
%8 = bitcast i32** %7 to [2 x i32]*
%9 = getelementptr inbounds [61 x i8], [61 x i8]* %3, i64 0, i64 0
%10 = getelementptr inbounds [61 x i8], [61 x i8]* %5, i64 0, i64 0
%11 = bitcast i32** %7 to i8*
%12 = getelementptr inbounds i8*, i8** %1, i64 3
%13 = load i8*, i8** %12
%14 = load i8, i8* %13
%15 = icmp eq i8 %14, 49
%16 = zext i1 %15 to i32
%17 = bitcast i32** %7 to i32*
store i32 %16, i32* %17
%18 = getelementptr inbounds i8, i8* %13, i64 1
%19 = load i8, i8* %18
%20 = icmp eq i8 %19, 49
%21 = zext i1 %20 to i32
%22 = getelementptr inbounds [2 x i32], [2 x i32]* %8, i64 0, i64 1
store i32 %21, i32* %22
%23 = getelementptr inbounds i8*, i8** %1, i64 1
%24 = load i8*, i8** %23
%25 = getelementptr inbounds i8*, i8** %1, i64 2
%26 = load i8*, i8** %25
%27 = tail call i64 @strlen(i8* dereferenceable(1) %24)
%28 = tail call i64 @strlen(i8* dereferenceable(1) %26)
%29 = icmp sgt i64 %27, %28
%30 = select i1 %29, i64 %27, i64 %28
%31 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([22 x i8], [22 x i8]* @.str, i64 0, i64 0), i8* %24, i64 %27)
%32 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([22 x i8], [22 x i8]* @.str.1, i64 0, i64 0), i8* %26, i64 %28)
%33 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([13 x i8], [13 x i8]* @.str.2, i64 0, i64 0), i64 %30)
%34 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([14 x i8], [14 x i8]* @.str.3, i64 0, i64 0), i32 %16, i32 %21)
store i8 0, i8* %10
store i8 0, i8* %9
%35 = call i32 @strncat(i8* %9, i8* getelementptr inbounds ([61 x i8], [61 x i8]* @.str.4, i64 0, i64 0), i64 %30)
%36 = call i32 @strncat(i8* %10, i8* getelementptr inbounds ([61 x i8], [61 x i8]* @.str.4, i64 0, i64 0), i64 %30)
%37 = icmp sgt i64 %27, 0
br i1 %37, label %38, label %162
38: ; preds = %2
%39 = icmp ult i64 %27, 8
br i1 %39, label %144, label %40
40: ; preds = %38
%41 = getelementptr [61 x i8], [61 x i8]* %3, i64 0, i64 %27
%42 = getelementptr i8, i8* %24, i64 %27
%43 = icmp ult i8* %4, %42
%44 = icmp ult i8* %24, %41
%45 = and i1 %43, %44
br i1 %45, label %144, label %46
46: ; preds = %40
%47 = icmp ult i64 %27, 32
br i1 %47, label %130, label %48
48: ; preds = %46
%49 = and i64 %27, -32
%50 = add i64 %49, -32
%51 = lshr exact i64 %50, 5
%52 = add nuw nsw i64 %51, 1
%53 = and i64 %52, 3
%54 = icmp ult i64 %50, 96
br i1 %54, label %106, label %55
55: ; preds = %48
%56 = and i64 %52, 1152921504606846972
br label %57
57: ; preds = %57, %55
%58 = phi i64 [ 0, %55 ], [ %103, %57 ]
%59 = phi i64 [ 0, %55 ], [ %104, %57 ]
%60 = getelementptr inbounds i8, i8* %24, i64 %58
%61 = bitcast i8* %60 to <16 x i8>*
%62 = load <16 x i8>, <16 x i8>* %61
%63 = getelementptr inbounds i8, i8* %60, i64 16
%64 = bitcast i8* %63 to <16 x i8>*
%65 = load <16 x i8>, <16 x i8>* %64
%66 = getelementptr inbounds [61 x i8], [61 x i8]* %3, i64 0, i64 %58
%67 = bitcast i8* %66 to <16 x i8>*
store <16 x i8> %62, <16 x i8>* %67
%68 = getelementptr inbounds i8, i8* %66, i64 16
%69 = bitcast i8* %68 to <16 x i8>*
store <16 x i8> %65, <16 x i8>* %69
%70 = or i64 %58, 32
%71 = getelementptr inbounds i8, i8* %24, i64 %70
%72 = bitcast i8* %71 to <16 x i8>*
%73 = load <16 x i8>, <16 x i8>* %72
%74 = getelementptr inbounds i8, i8* %71, i64 16
%75 = bitcast i8* %74 to <16 x i8>*
%76 = load <16 x i8>, <16 x i8>* %75
%77 = getelementptr inbounds [61 x i8], [61 x i8]* %3, i64 0, i64 %70
%78 = bitcast i8* %77 to <16 x i8>*
store <16 x i8> %73, <16 x i8>* %78
%79 = getelementptr inbounds i8, i8* %77, i64 16
%80 = bitcast i8* %79 to <16 x i8>*
store <16 x i8> %76, <16 x i8>* %80
%81 = or i64 %58, 64
%82 = getelementptr inbounds i8, i8* %24, i64 %81
%83 = bitcast i8* %82 to <16 x i8>*
%84 = load <16 x i8>, <16 x i8>* %83
%85 = getelementptr inbounds i8, i8* %82, i64 16
%86 = bitcast i8* %85 to <16 x i8>*
%87 = load <16 x i8>, <16 x i8>* %86
%88 = getelementptr inbounds [61 x i8], [61 x i8]* %3, i64 0, i64 %81
%89 = bitcast i8* %88 to <16 x i8>*
store <16 x i8> %84, <16 x i8>* %89
%90 = getelementptr inbounds i8, i8* %88, i64 16
%91 = bitcast i8* %90 to <16 x i8>*
store <16 x i8> %87, <16 x i8>* %91
%92 = or i64 %58, 96
%93 = getelementptr inbounds i8, i8* %24, i64 %92
%94 = bitcast i8* %93 to <16 x i8>*
%95 = load <16 x i8>, <16 x i8>* %94
%96 = getelementptr inbounds i8, i8* %93, i64 16
%97 = bitcast i8* %96 to <16 x i8>*
%98 = load <16 x i8>, <16 x i8>* %97
%99 = getelementptr inbounds [61 x i8], [61 x i8]* %3, i64 0, i64 %92
%100 = bitcast i8* %99 to <16 x i8>*
store <16 x i8> %95, <16 x i8>* %100
%101 = getelementptr inbounds i8, i8* %99, i64 16
%102 = bitcast i8* %101 to <16 x i8>*
store <16 x i8> %98, <16 x i8>* %102
%103 = add nuw i64 %58, 128
%104 = add i64 %59, 4
%105 = icmp eq i64 %104, %56
br i1 %105, label %106, label %57
106: ; preds = %57, %48
%107 = phi i64 [ 0, %48 ], [ %103, %57 ]
%108 = icmp eq i64 %53, 0
br i1 %108, label %125, label %109
109: ; preds = %106, %109
%110 = phi i64 [ %122, %109 ], [ %107, %106 ]
%111 = phi i64 [ %123, %109 ], [ 0, %106 ]
%112 = getelementptr inbounds i8, i8* %24, i64 %110
%113 = bitcast i8* %112 to <16 x i8>*
%114 = load <16 x i8>, <16 x i8>* %113
%115 = getelementptr inbounds i8, i8* %112, i64 16
%116 = bitcast i8* %115 to <16 x i8>*
%117 = load <16 x i8>, <16 x i8>* %116
%118 = getelementptr inbounds [61 x i8], [61 x i8]* %3, i64 0, i64 %110
%119 = bitcast i8* %118 to <16 x i8>*
store <16 x i8> %114, <16 x i8>* %119
%120 = getelementptr inbounds i8, i8* %118, i64 16
%121 = bitcast i8* %120 to <16 x i8>*
store <16 x i8> %117, <16 x i8>* %121
%122 = add nuw i64 %110, 32
%123 = add i64 %111, 1
%124 = icmp eq i64 %123, %53
br i1 %124, label %125, label %109
125: ; preds = %109, %106
%126 = icmp eq i64 %27, %49
br i1 %126, label %162, label %127
127: ; preds = %125
%128 = and i64 %27, 24
%129 = icmp eq i64 %128, 0
br i1 %129, label %144, label %130
130: ; preds = %46, %127
%131 = phi i64 [ %49, %127 ], [ 0, %46 ]
%132 = and i64 %27, -8
br label %133
133: ; preds = %133, %130
%134 = phi i64 [ %131, %130 ], [ %140, %133 ]
%135 = getelementptr inbounds i8, i8* %24, i64 %134
%136 = bitcast i8* %135 to <8 x i8>*
%137 = load <8 x i8>, <8 x i8>* %136
%138 = getelementptr inbounds [61 x i8], [61 x i8]* %3, i64 0, i64 %134
%139 = bitcast i8* %138 to <8 x i8>*
store <8 x i8> %137, <8 x i8>* %139
%140 = add nuw i64 %134, 8
%141 = icmp eq i64 %140, %132
br i1 %141, label %142, label %133
142: ; preds = %133
%143 = icmp eq i64 %27, %132
br i1 %143, label %162, label %144
144: ; preds = %40, %38, %127, %142
%145 = phi i64 [ 0, %38 ], [ 0, %40 ], [ %49, %127 ], [ %132, %142 ]
%146 = xor i64 %145, -1
%147 = add i64 %27, %146
%148 = and i64 %27, 3
%149 = icmp eq i64 %148, 0
br i1 %149, label %159, label %150
150: ; preds = %144, %150
%151 = phi i64 [ %156, %150 ], [ %145, %144 ]
%152 = phi i64 [ %157, %150 ], [ 0, %144 ]
%153 = getelementptr inbounds i8, i8* %24, i64 %151
%154 = load i8, i8* %153
%155 = getelementptr inbounds [61 x i8], [61 x i8]* %3, i64 0, i64 %151
store i8 %154, i8* %155
%156 = add nuw nsw i64 %151, 1
%157 = add i64 %152, 1
%158 = icmp eq i64 %157, %148
br i1 %158, label %159, label %150
159: ; preds = %150, %144
%160 = phi i64 [ %145, %144 ], [ %156, %150 ]
%161 = icmp ult i64 %147, 3
br i1 %161, label %162, label %288
162: ; preds = %159, %288, %125, %142, %2
%163 = icmp sgt i64 %28, 0
br i1 %163, label %164, label %326
164: ; preds = %162
%165 = icmp ult i64 %28, 8
br i1 %165, label %270, label %166
166: ; preds = %164
%167 = getelementptr [61 x i8], [61 x i8]* %5, i64 0, i64 %28
%168 = getelementptr i8, i8* %26, i64 %28
%169 = icmp ult i8* %6, %168
%170 = icmp ult i8* %26, %167
%171 = and i1 %169, %170
br i1 %171, label %270, label %172
172: ; preds = %166
%173 = icmp ult i64 %28, 32
br i1 %173, label %256, label %174
174: ; preds = %172
%175 = and i64 %28, -32
%176 = add i64 %175, -32
%177 = lshr exact i64 %176, 5
%178 = add nuw nsw i64 %177, 1
%179 = and i64 %178, 3
%180 = icmp ult i64 %176, 96
br i1 %180, label %232, label %181
181: ; preds = %174
%182 = and i64 %178, 1152921504606846972
br label %183
183: ; preds = %183, %181
%184 = phi i64 [ 0, %181 ], [ %229, %183 ]
%185 = phi i64 [ 0, %181 ], [ %230, %183 ]
%186 = getelementptr inbounds i8, i8* %26, i64 %184
%187 = bitcast i8* %186 to <16 x i8>*
%188 = load <16 x i8>, <16 x i8>* %187
%189 = getelementptr inbounds i8, i8* %186, i64 16
%190 = bitcast i8* %189 to <16 x i8>*
%191 = load <16 x i8>, <16 x i8>* %190
%192 = getelementptr inbounds [61 x i8], [61 x i8]* %5, i64 0, i64 %184
%193 = bitcast i8* %192 to <16 x i8>*
store <16 x i8> %188, <16 x i8>* %193
%194 = getelementptr inbounds i8, i8* %192, i64 16
%195 = bitcast i8* %194 to <16 x i8>*
store <16 x i8> %191, <16 x i8>* %195
%196 = or i64 %184, 32
%197 = getelementptr inbounds i8, i8* %26, i64 %196
%198 = bitcast i8* %197 to <16 x i8>*
%199 = load <16 x i8>, <16 x i8>* %198
%200 = getelementptr inbounds i8, i8* %197, i64 16
%201 = bitcast i8* %200 to <16 x i8>*
%202 = load <16 x i8>, <16 x i8>* %201
%203 = getelementptr inbounds [61 x i8], [61 x i8]* %5, i64 0, i64 %196
%204 = bitcast i8* %203 to <16 x i8>*
store <16 x i8> %199, <16 x i8>* %204
%205 = getelementptr inbounds i8, i8* %203, i64 16
%206 = bitcast i8* %205 to <16 x i8>*
store <16 x i8> %202, <16 x i8>* %206
%207 = or i64 %184, 64
%208 = getelementptr inbounds i8, i8* %26, i64 %207
%209 = bitcast i8* %208 to <16 x i8>*
%210 = load <16 x i8>, <16 x i8>* %209
%211 = getelementptr inbounds i8, i8* %208, i64 16
%212 = bitcast i8* %211 to <16 x i8>*
%213 = load <16 x i8>, <16 x i8>* %212
%214 = getelementptr inbounds [61 x i8], [61 x i8]* %5, i64 0, i64 %207
%215 = bitcast i8* %214 to <16 x i8>*
store <16 x i8> %210, <16 x i8>* %215
%216 = getelementptr inbounds i8, i8* %214, i64 16
%217 = bitcast i8* %216 to <16 x i8>*
store <16 x i8> %213, <16 x i8>* %217
%218 = or i64 %184, 96
%219 = getelementptr inbounds i8, i8* %26, i64 %218
%220 = bitcast i8* %219 to <16 x i8>*
%221 = load <16 x i8>, <16 x i8>* %220
%222 = getelementptr inbounds i8, i8* %219, i64 16
%223 = bitcast i8* %222 to <16 x i8>*
%224 = load <16 x i8>, <16 x i8>* %223
%225 = getelementptr inbounds [61 x i8], [61 x i8]* %5, i64 0, i64 %218
%226 = bitcast i8* %225 to <16 x i8>*
store <16 x i8> %221, <16 x i8>* %226
%227 = getelementptr inbounds i8, i8* %225, i64 16
%228 = bitcast i8* %227 to <16 x i8>*
store <16 x i8> %224, <16 x i8>* %228
%229 = add nuw i64 %184, 128
%230 = add i64 %185, 4
%231 = icmp eq i64 %230, %182
br i1 %231, label %232, label %183
232: ; preds = %183, %174
%233 = phi i64 [ 0, %174 ], [ %229, %183 ]
%234 = icmp eq i64 %179, 0
br i1 %234, label %251, label %235
235: ; preds = %232, %235
%236 = phi i64 [ %248, %235 ], [ %233, %232 ]
%237 = phi i64 [ %249, %235 ], [ 0, %232 ]
%238 = getelementptr inbounds i8, i8* %26, i64 %236
%239 = bitcast i8* %238 to <16 x i8>*
%240 = load <16 x i8>, <16 x i8>* %239
%241 = getelementptr inbounds i8, i8* %238, i64 16
%242 = bitcast i8* %241 to <16 x i8>*
%243 = load <16 x i8>, <16 x i8>* %242
%244 = getelementptr inbounds [61 x i8], [61 x i8]* %5, i64 0, i64 %236
%245 = bitcast i8* %244 to <16 x i8>*
store <16 x i8> %240, <16 x i8>* %245
%246 = getelementptr inbounds i8, i8* %244, i64 16
%247 = bitcast i8* %246 to <16 x i8>*
store <16 x i8> %243, <16 x i8>* %247
%248 = add nuw i64 %236, 32
%249 = add i64 %237, 1
%250 = icmp eq i64 %249, %179
br i1 %250, label %251, label %235
251: ; preds = %235, %232
%252 = icmp eq i64 %28, %175
br i1 %252, label %326, label %253
253: ; preds = %251
%254 = and i64 %28, 24
%255 = icmp eq i64 %254, 0
br i1 %255, label %270, label %256
256: ; preds = %172, %253
%257 = phi i64 [ %175, %253 ], [ 0, %172 ]
%258 = and i64 %28, -8
br label %259
259: ; preds = %259, %256
%260 = phi i64 [ %257, %256 ], [ %266, %259 ]
%261 = getelementptr inbounds i8, i8* %26, i64 %260
%262 = bitcast i8* %261 to <8 x i8>*
%263 = load <8 x i8>, <8 x i8>* %262
%264 = getelementptr inbounds [61 x i8], [61 x i8]* %5, i64 0, i64 %260
%265 = bitcast i8* %264 to <8 x i8>*
store <8 x i8> %263, <8 x i8>* %265
%266 = add nuw i64 %260, 8
%267 = icmp eq i64 %266, %258
br i1 %267, label %268, label %259
268: ; preds = %259
%269 = icmp eq i64 %28, %258
br i1 %269, label %326, label %270
270: ; preds = %166, %164, %253, %268
%271 = phi i64 [ 0, %164 ], [ 0, %166 ], [ %175, %253 ], [ %258, %268 ]
%272 = xor i64 %271, -1
%273 = add i64 %28, %272
%274 = and i64 %28, 3
%275 = icmp eq i64 %274, 0
br i1 %275, label %285, label %276
276: ; preds = %270, %276
%277 = phi i64 [ %282, %276 ], [ %271, %270 ]
%278 = phi i64 [ %283, %276 ], [ 0, %270 ]
%279 = getelementptr inbounds i8, i8* %26, i64 %277
%280 = load i8, i8* %279
%281 = getelementptr inbounds [61 x i8], [61 x i8]* %5, i64 0, i64 %277
store i8 %280, i8* %281
%282 = add nuw nsw i64 %277, 1
%283 = add i64 %278, 1
%284 = icmp eq i64 %283, %274
br i1 %284, label %285, label %276
285: ; preds = %276, %270
%286 = phi i64 [ %271, %270 ], [ %282, %276 ]
%287 = icmp ult i64 %273, 3
br i1 %287, label %326, label %307
288: ; preds = %159, %288
%289 = phi i64 [ %305, %288 ], [ %160, %159 ]
%290 = getelementptr inbounds i8, i8* %24, i64 %289
%291 = load i8, i8* %290
%292 = getelementptr inbounds [61 x i8], [61 x i8]* %3, i64 0, i64 %289
store i8 %291, i8* %292
%293 = add nuw nsw i64 %289, 1
%294 = getelementptr inbounds i8, i8* %24, i64 %293
%295 = load i8, i8* %294
%296 = getelementptr inbounds [61 x i8], [61 x i8]* %3, i64 0, i64 %293
store i8 %295, i8* %296
%297 = add nuw nsw i64 %289, 2
%298 = getelementptr inbounds i8, i8* %24, i64 %297
%299 = load i8, i8* %298
%300 = getelementptr inbounds [61 x i8], [61 x i8]* %3, i64 0, i64 %297
store i8 %299, i8* %300
%301 = add nuw nsw i64 %289, 3
%302 = getelementptr inbounds i8, i8* %24, i64 %301
%303 = load i8, i8* %302
%304 = getelementptr inbounds [61 x i8], [61 x i8]* %3, i64 0, i64 %301
store i8 %303, i8* %304
%305 = add nuw nsw i64 %289, 4
%306 = icmp eq i64 %305, %27
br i1 %306, label %162, label %288
307: ; preds = %285, %307
%308 = phi i64 [ %324, %307 ], [ %286, %285 ]
%309 = getelementptr inbounds i8, i8* %26, i64 %308
%310 = load i8, i8* %309
%311 = getelementptr inbounds [61 x i8], [61 x i8]* %5, i64 0, i64 %308
store i8 %310, i8* %311
%312 = add nuw nsw i64 %308, 1
%313 = getelementptr inbounds i8, i8* %26, i64 %312
%314 = load i8, i8* %313
%315 = getelementptr inbounds [61 x i8], [61 x i8]* %5, i64 0, i64 %312
store i8 %314, i8* %315
%316 = add nuw nsw i64 %308, 2
%317 = getelementptr inbounds i8, i8* %26, i64 %316
%318 = load i8, i8* %317
%319 = getelementptr inbounds [61 x i8], [61 x i8]* %5, i64 0, i64 %316
store i8 %318, i8* %319
%320 = add nuw nsw i64 %308, 3
%321 = getelementptr inbounds i8, i8* %26, i64 %320
%322 = load i8, i8* %321
%323 = getelementptr inbounds [61 x i8], [61 x i8]* %5, i64 0, i64 %320
store i8 %322, i8* %323
%324 = add nuw nsw i64 %308, 4
%325 = icmp eq i64 %324, %28
br i1 %325, label %326, label %307
326: ; preds = %285, %307, %251, %268, %162
%327 = call i32 @strcmp95(i8* %9, i8* %10, i64 %30, i32** %7)
ret i32 0
}