#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 *, char *);
int /*<<< orphan*/ scanf(char *, char *);
int main() {
  char s1[100], s2[100];
  scanf("%s", s1);
  scanf("%s", s2);
  int i, j, k, count, m;
  for (count = 0; count < 100; count++) {
    if (s2[count] == '\0') {
      break;
    }
  }
  for (m = 0; m < 100; m++) {
    if (s1[m] == '\0') {
      break;
    }
  }
  int l;
  for (j = 0; j < m; j++) {
    l = 0;
    for (k = 0; k < count; k++) {
      if (s2[k] == s1[j + k]) {
        l++;
      }
    }
    if (l == count) {
      for (i = 0; i < count; i++) {
        s1[j + count - 1 - i] = s2[i];
      }
      j = j + count;
    }
  }
  printf("%s", s1);
  return 0;
}


x86 assembly (clang, -O0):
<main>:
push   %rbp
mov    %rsp,%rbp
sub    $0x100,%rsp
movl   $0x0,-0x4(%rbp)
lea    -0x70(%rbp),%rsi
lea    0xec3(%rip),%rdi
call   1040 <scanf@plt>
lea    -0xe0(%rbp),%rsi
lea    0xeb0(%rip),%rdi
call   1040 <scanf@plt>
movl   $0x0,-0xf0(%rbp)
cmpl   $0x64,-0xf0(%rbp)
jge    11a2 <main+0x82>
movslq -0xf0(%rbp),%rax
movsbl -0xe0(%rbp,%rax,1),%eax
ff
cmp    $0x0,%eax
jne    1189 <main+0x69>
jmp    11a2 <main+0x82>
jmp    118e <main+0x6e>
mov    -0xf0(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xf0(%rbp)
jmp    115f <main+0x3f>
movl   $0x0,-0xf4(%rbp)
cmpl   $0x64,-0xf4(%rbp)
jge    11ec <main+0xcc>
movslq -0xf4(%rbp),%rax
movsbl -0x70(%rbp,%rax,1),%eax
cmp    $0x0,%eax
jne    11d3 <main+0xb3>
jmp    11ec <main+0xcc>
jmp    11d8 <main+0xb8>
mov    -0xf4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xf4(%rbp)
jmp    11ac <main+0x8c>
movl   $0x0,-0xe8(%rbp)
mov    -0xe8(%rbp),%eax
cmp    -0xf4(%rbp),%eax
jge    1317 <main+0x1f7>
movl   $0x0,-0xf8(%rbp)
movl   $0x0,-0xec(%rbp)
mov    -0xec(%rbp),%eax
cmp    -0xf0(%rbp),%eax
jge    1281 <main+0x161>
movslq -0xec(%rbp),%rax
movsbl -0xe0(%rbp,%rax,1),%eax
ff
mov    -0xe8(%rbp),%ecx
add    -0xec(%rbp),%ecx
movslq %ecx,%rcx
movsbl -0x70(%rbp,%rcx,1),%ecx
cmp    %ecx,%eax
jne    1268 <main+0x148>
mov    -0xf8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xf8(%rbp)
jmp    126d <main+0x14d>
mov    -0xec(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xec(%rbp)
jmp    121c <main+0xfc>
mov    -0xf8(%rbp),%eax
cmp    -0xf0(%rbp),%eax
jne    12fe <main+0x1de>
movl   $0x0,-0xe4(%rbp)
mov    -0xe4(%rbp),%eax
cmp    -0xf0(%rbp),%eax
jge    12ec <main+0x1cc>
movslq -0xe4(%rbp),%rax
mov    -0xe0(%rbp,%rax,1),%cl
mov    -0xe8(%rbp),%eax
add    -0xf0(%rbp),%eax
sub    $0x1,%eax
sub    -0xe4(%rbp),%eax
cltq
mov    %cl,-0x70(%rbp,%rax,1)
mov    -0xe4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xe4(%rbp)
jmp    129d <main+0x17d>
mov    -0xe8(%rbp),%eax
add    -0xf0(%rbp),%eax
mov    %eax,-0xe8(%rbp)
jmp    1303 <main+0x1e3>
mov    -0xe8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xe8(%rbp)
jmp    11f6 <main+0xd6>
lea    -0x70(%rbp),%rsi
lea    0xcde(%rip),%rdi
call   1030 <printf@plt>
xor    %eax,%eax
add    $0x100,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<main>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0xf8,%rsp
lea    0xed8(%rip),%rbx
lea    0x20(%rsp),%rsi
mov    %rbx,%rdi
call   1040 <scanf@plt>
lea    0x90(%rsp),%rsi
mov    %rbx,%rdi
call   1040 <scanf@plt>
mov    $0x4,%r15d
nopl   0x0(%rax,%rax,1)
cmpb   $0x0,0x8c(%rsp,%r15,1)
je     11a9 <main+0x89>
cmpb   $0x0,0x8d(%rsp,%r15,1)
je     11af <main+0x8f>
cmpb   $0x0,0x8e(%rsp,%r15,1)
je     11b5 <main+0x95>
cmpb   $0x0,0x8f(%rsp,%r15,1)
je     11bb <main+0x9b>
cmpb   $0x0,0x90(%rsp,%r15,1)
je     11bf <main+0x9f>
add    $0x5,%r15
cmp    $0x68,%r15
jne    1160 <main+0x40>
mov    $0x64,%r15d
jmp    11bf <main+0x9f>
add    $0xfffffffffffffffc,%r15
jmp    11bf <main+0x9f>
add    $0xfffffffffffffffd,%r15
jmp    11bf <main+0x9f>
add    $0xfffffffffffffffe,%r15
jmp    11bf <main+0x9f>
add    $0xffffffffffffffff,%r15
mov    $0x4,%r10d
cs nopw 0x0(%rax,%rax,1)
nop
cmpb   $0x0,0x1c(%rsp,%r10,1)
je     120e <main+0xee>
cmpb   $0x0,0x1d(%rsp,%r10,1)
je     121c <main+0xfc>
cmpb   $0x0,0x1e(%rsp,%r10,1)
je     122a <main+0x10a>
cmpb   $0x0,0x1f(%rsp,%r10,1)
je     16be <main+0x59e>
cmpb   $0x0,0x20(%rsp,%r10,1)
je     122e <main+0x10e>
add    $0x5,%r10
cmp    $0x68,%r10
jne    11d0 <main+0xb0>
mov    $0x64,%r10d
jmp    1237 <main+0x117>
add    $0xfffffffffffffffc,%r10
test   %r10d,%r10d
jg     1237 <main+0x117>
jmp    16cb <main+0x5ab>
add    $0xfffffffffffffffd,%r10
test   %r10d,%r10d
jg     1237 <main+0x117>
jmp    16cb <main+0x5ab>
add    $0xfffffffffffffffe,%r10
test   %r10d,%r10d
jle    16cb <main+0x5ab>
mov    %r15d,%edx
lea    -0x1(%rdx),%r12
lea    -0x1(%r15),%eax
mov    %rax,(%rsp)
mov    %edx,%r8d
and    $0xfffffffc,%r8d
lea    -0x4(%r8),%r14
mov    %r14,0x18(%rsp)
shr    $0x2,%r14
add    $0x1,%r14
mov    %r14,%rax
and    $0xfffffffffffffffe,%rax
mov    %rax,0x10(%rsp)
mov    %edx,%r11d
and    $0xfffffff0,%r11d
movdqa 0x90(%rsp),%xmm1
movdqa 0xa0(%rsp),%xmm2
movdqa 0xb0(%rsp),%xmm3
movdqa 0xc0(%rsp),%xmm4
pxor   %xmm0,%xmm0
movdqa %xmm1,%xmm5
punpcklbw %xmm0,%xmm5
pshufd $0x4e,%xmm5,%xmm5
pshuflw $0x1b,%xmm5,%xmm5
pshufhw $0x1b,%xmm5,%xmm5
punpckhbw %xmm0,%xmm1
pshufd $0x4e,%xmm1,%xmm1
pshuflw $0x1b,%xmm1,%xmm1
pshufhw $0x1b,%xmm1,%xmm1
packuswb %xmm5,%xmm1
movdqa %xmm2,%xmm5
punpcklbw %xmm0,%xmm5
pshufd $0x4e,%xmm5,%xmm5
pshuflw $0x1b,%xmm5,%xmm5
pshufhw $0x1b,%xmm5,%xmm5
punpckhbw %xmm0,%xmm2
pshufd $0x4e,%xmm2,%xmm2
pshuflw $0x1b,%xmm2,%xmm2
pshufhw $0x1b,%xmm2,%xmm2
packuswb %xmm5,%xmm2
movdqa %xmm3,%xmm5
punpcklbw %xmm0,%xmm5
pshufd $0x4e,%xmm5,%xmm5
pshuflw $0x1b,%xmm5,%xmm5
pshufhw $0x1b,%xmm5,%xmm5
punpckhbw %xmm0,%xmm3
pshufd $0x4e,%xmm3,%xmm3
pshuflw $0x1b,%xmm3,%xmm3
pshufhw $0x1b,%xmm3,%xmm9
packuswb %xmm5,%xmm9
movdqa %xmm4,%xmm5
punpcklbw %xmm0,%xmm5
pshufd $0x4e,%xmm5,%xmm5
pshuflw $0x1b,%xmm5,%xmm5
pshufhw $0x1b,%xmm5,%xmm5
punpckhbw %xmm0,%xmm4
pshufd $0x4e,%xmm4,%xmm4
pshuflw $0x1b,%xmm4,%xmm4
pshufhw $0x1b,%xmm4,%xmm8
packuswb %xmm5,%xmm8
movdqa 0xd0(%rsp),%xmm4
movdqa %xmm4,%xmm5
punpcklbw %xmm0,%xmm5
pshufd $0x4e,%xmm5,%xmm5
pshuflw $0x1b,%xmm5,%xmm5
pshufhw $0x1b,%xmm5,%xmm6
punpckhbw %xmm0,%xmm4
pshufd $0x4e,%xmm4,%xmm4
pshuflw $0x1b,%xmm4,%xmm4
pshufhw $0x1b,%xmm4,%xmm10
packuswb %xmm6,%xmm10
movdqa 0xe0(%rsp),%xmm4
movdqa %xmm4,%xmm6
punpcklbw %xmm0,%xmm6
pshufd $0x4e,%xmm6,%xmm6
pshuflw $0x1b,%xmm6,%xmm6
pshufhw $0x1b,%xmm6,%xmm7
punpckhbw %xmm0,%xmm4
pshufd $0x4e,%xmm4,%xmm4
pshuflw $0x1b,%xmm4,%xmm4
pshufhw $0x1b,%xmm4,%xmm6
packuswb %xmm7,%xmm6
mov    %edx,%r9d
and    $0xfffffff8,%r9d
mov    %rdx,%rax
neg    %rax
mov    %rax,0x8(%rsp)
xor    %ebp,%ebp
movdqa 0xc1f(%rip),%xmm7
jmp    13ff <main+0x2df>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
add    %r15d,%ebp
add    $0x1,%ebp
cmp    %r10d,%ebp
jge    16cb <main+0x5ab>
test   %r15d,%r15d
je     13f0 <main+0x2d0>
movslq %ebp,%rsi
cmp    $0x4,%r15d
jae    1420 <main+0x300>
xor    %edi,%edi
xor    %ecx,%ecx
jmp    14d9 <main+0x3b9>
cs nopw 0x0(%rax,%rax,1)
cmpq   $0x0,0x18(%rsp)
je     15ce <main+0x4ae>
lea    0x24(%rsp),%rax
lea    (%rax,%rsi,1),%rdi
pxor   %xmm4,%xmm4
mov    0x10(%rsp),%rcx
xor    %ebx,%ebx
movq   0x90(%rsp,%rbx,1),%xmm3
movd   -0x4(%rdi,%rbx,1),%xmm5
pcmpeqb %xmm3,%xmm5
punpcklbw %xmm5,%xmm5
punpcklwd %xmm5,%xmm5
pand   %xmm7,%xmm5
paddd  %xmm4,%xmm5
movd   0x94(%rsp,%rbx,1),%xmm3
movd   (%rdi,%rbx,1),%xmm4
pcmpeqb %xmm3,%xmm4
punpcklbw %xmm4,%xmm4
punpcklwd %xmm4,%xmm4
pand   %xmm7,%xmm4
paddd  %xmm5,%xmm4
add    $0x8,%rbx
add    $0xfffffffffffffffe,%rcx
jne    1440 <main+0x320>
test   $0x1,%r14b
je     14bb <main+0x39b>
movd   0x90(%rsp,%rbx,1),%xmm3
add    %rsi,%rbx
movd   0x20(%rsp,%rbx,1),%xmm5
pcmpeqb %xmm3,%xmm5
punpcklbw %xmm5,%xmm5
punpcklwd %xmm5,%xmm5
pand   %xmm7,%xmm5
paddd  %xmm5,%xmm4
pshufd $0xee,%xmm4,%xmm3
paddd  %xmm4,%xmm3
pshufd $0x55,%xmm3,%xmm4
paddd  %xmm3,%xmm4
movd   %xmm4,%ecx
mov    %r8,%rdi
cmp    %rdx,%r8
je     14fb <main+0x3db>
add    %rsp,%rsi
add    $0x20,%rsi
movzbl 0x90(%rsp,%rdi,1),%ebx
xor    %eax,%eax
cmp    (%rsi,%rdi,1),%bl
sete   %al
add    %eax,%ecx
add    $0x1,%rdi
cmp    %rdi,%rdx
jne    14e0 <main+0x3c0>
cmp    %r15d,%ecx
jne    13f3 <main+0x2d3>
test   %r15d,%r15d
je     13f0 <main+0x2d0>
mov    %r12,%rbx
lea    (%r15,%rbp,1),%r13d
cmp    $0x8,%r15d
jb     154e <main+0x42e>
mov    (%rsp),%rax
lea    (%rax,%rbp,1),%r12d
mov    %r12d,%eax
mov    %rbx,%rcx
sub    %ecx,%eax
cmp    %r12d,%eax
jg     154e <main+0x42e>
mov    %rcx,%rax
shr    $0x20,%rax
mov    $0x0,%edi
jne    1550 <main+0x430>
cmp    $0x10,%r15d
jae    15e3 <main+0x4c3>
xor    %ecx,%ecx
jmp    1669 <main+0x549>
xor    %edi,%edi
mov    %rdi,%rsi
test   $0x1,%dl
je     1574 <main+0x454>
mov    0x90(%rsp,%rdi,1),%al
mov    %edi,%ecx
not    %ecx
add    %r13d,%ecx
movslq %ecx,%rcx
mov    %al,0x20(%rsp,%rcx,1)
mov    %rdi,%rsi
or     $0x1,%rsi
not    %rdi
cmp    0x8(%rsp),%rdi
mov    %rbx,%r12
je     15c6 <main+0x4a6>
mov    %rdx,%rcx
sub    %rsi,%rcx
add    (%rsp),%ebp
sub    %esi,%ebp
lea    0x91(%rsp),%rax
add    %rax,%rsi
xor    %edi,%edi
nopl   0x0(%rax)
movzbl -0x1(%rsi,%rdi,1),%eax
movslq %ebp,%rbp
mov    %al,0x20(%rsp,%rbp,1)
movzbl (%rsi,%rdi,1),%eax
lea    -0x1(%rbp),%ebx
movslq %ebx,%rbx
mov    %al,0x20(%rsp,%rbx,1)
add    $0x2,%rdi
add    $0xfffffffe,%ebp
cmp    %rdi,%rcx
jne    15a0 <main+0x480>
mov    %r13d,%ebp
jmp    13f3 <main+0x2d3>
pxor   %xmm4,%xmm4
xor    %ebx,%ebx
test   $0x1,%r14b
jne    1495 <main+0x375>
jmp    14bb <main+0x39b>
lea    -0x1(%r13),%eax
cltq
movdqu %xmm1,0x11(%rsp,%rax,1)
mov    %r11,%rdi
cmp    $0x10,%edi
je     164a <main+0x52a>
lea    -0x11(%r13),%eax
cltq
movdqu %xmm2,0x11(%rsp,%rax,1)
cmp    $0x20,%edi
je     164a <main+0x52a>
lea    -0x21(%r13),%eax
cltq
movdqu %xmm9,0x11(%rsp,%rax,1)
cmp    $0x30,%edi
je     164a <main+0x52a>
lea    -0x31(%r13),%eax
cltq
movdqu %xmm8,0x11(%rsp,%rax,1)
cmp    $0x40,%edi
je     164a <main+0x52a>
lea    -0x41(%r13),%eax
cltq
movdqu %xmm10,0x11(%rsp,%rax,1)
cmp    $0x50,%edi
je     164a <main+0x52a>
lea    -0x51(%r13),%eax
cltq
movdqu %xmm6,0x11(%rsp,%rax,1)
cmp    %rdx,%rdi
jne    165d <main+0x53d>
mov    %r13d,%ebp
mov    %rbx,%r12
mov    %rdi,%r11
jmp    13f3 <main+0x2d3>
mov    %rdi,%rcx
test   $0x8,%dl
je     1550 <main+0x430>
sub    %ecx,%r12d
nopl   0x0(%rax)
movq   0x90(%rsp,%rcx,1),%xmm3
movslq %r12d,%r12
punpcklbw %xmm0,%xmm3
pshufd $0x4e,%xmm3,%xmm3
pshuflw $0x1b,%xmm3,%xmm3
pshufhw $0x1b,%xmm3,%xmm3
packuswb %xmm3,%xmm3
movq   %xmm3,0x19(%rsp,%r12,1)
add    $0x8,%rcx
add    $0xfffffff8,%r12d
cmp    %rcx,%r9
jne    1670 <main+0x550>
mov    %r9,%rdi
cmp    %rdx,%r9
jne    1550 <main+0x430>
mov    %r13d,%ebp
mov    %rbx,%r12
jmp    13f3 <main+0x2d3>
add    $0xffffffffffffffff,%r10
test   %r10d,%r10d
jg     1237 <main+0x117>
lea    0x93e(%rip),%rdi
lea    0x20(%rsp),%rsi
call   1030 <printf@plt>
xor    %eax,%eax
add    $0xf8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
@.str = [3 x i8] c"%s\00"
define i32 @main() {
%1 = alloca i32
%2 = alloca [100 x i8]
%3 = alloca [100 x i8]
%4 = alloca i32
%5 = alloca i32
%6 = alloca i32
%7 = alloca i32
%8 = alloca i32
%9 = alloca i32
store i32 0, i32* %1
%10 = getelementptr inbounds [100 x i8], [100 x i8]* %2, i64 0, i64 0
%11 = call i32 @scanf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str, i64 0, i64 0), i8* %10)
%12 = getelementptr inbounds [100 x i8], [100 x i8]* %3, i64 0, i64 0
%13 = call i32 @scanf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str, i64 0, i64 0), i8* %12)
store i32 0, i32* %7
br label %14
14: ; preds = %26, %0
%15 = load i32, i32* %7
%16 = icmp slt i32 %15, 100
br i1 %16, label %17, label %29
17: ; preds = %14
%18 = load i32, i32* %7
%19 = sext i32 %18 to i64
%20 = getelementptr inbounds [100 x i8], [100 x i8]* %3, i64 0, i64 %19
%21 = load i8, i8* %20
%22 = sext i8 %21 to i32
%23 = icmp eq i32 %22, 0
br i1 %23, label %24, label %25
24: ; preds = %17
br label %29
25: ; preds = %17
br label %26
26: ; preds = %25
%27 = load i32, i32* %7
%28 = add nsw i32 %27, 1
store i32 %28, i32* %7
br label %14
29: ; preds = %24, %14
store i32 0, i32* %8
br label %30
30: ; preds = %42, %29
%31 = load i32, i32* %8
%32 = icmp slt i32 %31, 100
br i1 %32, label %33, label %45
33: ; preds = %30
%34 = load i32, i32* %8
%35 = sext i32 %34 to i64
%36 = getelementptr inbounds [100 x i8], [100 x i8]* %2, i64 0, i64 %35
%37 = load i8, i8* %36
%38 = sext i8 %37 to i32
%39 = icmp eq i32 %38, 0
br i1 %39, label %40, label %41
40: ; preds = %33
br label %45
41: ; preds = %33
br label %42
42: ; preds = %41
%43 = load i32, i32* %8
%44 = add nsw i32 %43, 1
store i32 %44, i32* %8
br label %30
45: ; preds = %40, %30
store i32 0, i32* %5
br label %46
46: ; preds = %106, %45
%47 = load i32, i32* %5
%48 = load i32, i32* %8
%49 = icmp slt i32 %47, %48
br i1 %49, label %50, label %109
50: ; preds = %46
store i32 0, i32* %9
store i32 0, i32* %6
br label %51
51: ; preds = %73, %50
%52 = load i32, i32* %6
%53 = load i32, i32* %7
%54 = icmp slt i32 %52, %53
br i1 %54, label %55, label %76
55: ; preds = %51
%56 = load i32, i32* %6
%57 = sext i32 %56 to i64
%58 = getelementptr inbounds [100 x i8], [100 x i8]* %3, i64 0, i64 %57
%59 = load i8, i8* %58
%60 = sext i8 %59 to i32
%61 = load i32, i32* %5
%62 = load i32, i32* %6
%63 = add nsw i32 %61, %62
%64 = sext i32 %63 to i64
%65 = getelementptr inbounds [100 x i8], [100 x i8]* %2, i64 0, i64 %64
%66 = load i8, i8* %65
%67 = sext i8 %66 to i32
%68 = icmp eq i32 %60, %67
br i1 %68, label %69, label %72
69: ; preds = %55
%70 = load i32, i32* %9
%71 = add nsw i32 %70, 1
store i32 %71, i32* %9
br label %72
72: ; preds = %69, %55
br label %73
73: ; preds = %72
%74 = load i32, i32* %6
%75 = add nsw i32 %74, 1
store i32 %75, i32* %6
br label %51
76: ; preds = %51
%77 = load i32, i32* %9
%78 = load i32, i32* %7
%79 = icmp eq i32 %77, %78
br i1 %79, label %80, label %105
80: ; preds = %76
store i32 0, i32* %4
br label %81
81: ; preds = %98, %80
%82 = load i32, i32* %4
%83 = load i32, i32* %7
%84 = icmp slt i32 %82, %83
br i1 %84, label %85, label %101
85: ; preds = %81
%86 = load i32, i32* %4
%87 = sext i32 %86 to i64
%88 = getelementptr inbounds [100 x i8], [100 x i8]* %3, i64 0, i64 %87
%89 = load i8, i8* %88
%90 = load i32, i32* %5
%91 = load i32, i32* %7
%92 = add nsw i32 %90, %91
%93 = sub nsw i32 %92, 1
%94 = load i32, i32* %4
%95 = sub nsw i32 %93, %94
%96 = sext i32 %95 to i64
%97 = getelementptr inbounds [100 x i8], [100 x i8]* %2, i64 0, i64 %96
store i8 %89, i8* %97
br label %98
98: ; preds = %85
%99 = load i32, i32* %4
%100 = add nsw i32 %99, 1
store i32 %100, i32* %4
br label %81
101: ; preds = %81
%102 = load i32, i32* %5
%103 = load i32, i32* %7
%104 = add nsw i32 %102, %103
store i32 %104, i32* %5
br label %105
105: ; preds = %101, %76
br label %106
106: ; preds = %105
%107 = load i32, i32* %5
%108 = add nsw i32 %107, 1
store i32 %108, i32* %5
br label %46
109: ; preds = %46
%110 = getelementptr inbounds [100 x i8], [100 x i8]* %2, i64 0, i64 0
%111 = call i32 @printf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str, i64 0, i64 0), i8* %110)
ret i32 0
}

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