int case_strstr(const char *haystack, const char *needle) {
  const char *h = haystack, *n = needle;
  while (*h) {
    if (((*h) >= 'A' && (*h) <= 'Z' ? (*h) - 'A' + 'a' : (*h)) ==
        ((*(needle)) >= 'A' && (*(needle)) <= 'Z' ? (*(needle)) - 'A' + 'a'
                                                  : (*(needle)))) {
      n = needle;
      while (1) {
        if (!(*n))
          return 1;
        if (((*h) >= 'A' && (*h) <= 'Z' ? (*h) - 'A' + 'a' : (*h)) !=
            ((*n) >= 'A' && (*n) <= 'Z' ? (*n) - 'A' + 'a' : (*n)))
          break;
        h++, n++;
      }
    }
    h++;
  }
  return 0;
}


x86 assembly (clang, -O0):
<case_strstr>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x10(%rbp)
mov    %rsi,-0x18(%rbp)
mov    -0x10(%rbp),%rax
mov    %rax,-0x20(%rbp)
mov    -0x18(%rbp),%rax
mov    %rax,-0x28(%rbp)
mov    -0x20(%rbp),%rax
cmpb   $0x0,(%rax)
je     12a6 <case_strstr+0x1a6>
mov    -0x20(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x41,%eax
jl     115e <case_strstr+0x5e>
mov    -0x20(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x5a,%eax
jg     115e <case_strstr+0x5e>
mov    -0x20(%rbp),%rax
movsbl (%rax),%eax
sub    $0x41,%eax
add    $0x61,%eax
mov    %eax,-0x2c(%rbp)
jmp    1168 <case_strstr+0x68>
mov    -0x20(%rbp),%rax
movsbl (%rax),%eax
mov    %eax,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
mov    %eax,-0x30(%rbp)
mov    -0x18(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x41,%eax
jl     11a3 <case_strstr+0xa3>
mov    -0x18(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x5a,%eax
jg     11a3 <case_strstr+0xa3>
mov    -0x18(%rbp),%rax
movsbl (%rax),%eax
sub    $0x41,%eax
add    $0x61,%eax
mov    %eax,-0x34(%rbp)
jmp    11ad <case_strstr+0xad>
mov    -0x18(%rbp),%rax
movsbl (%rax),%eax
mov    %eax,-0x34(%rbp)
mov    -0x30(%rbp),%eax
mov    -0x34(%rbp),%ecx
cmp    %ecx,%eax
jne    1295 <case_strstr+0x195>
mov    -0x18(%rbp),%rax
mov    %rax,-0x28(%rbp)
mov    -0x28(%rbp),%rax
cmpb   $0x0,(%rax)
jne    11dc <case_strstr+0xdc>
movl   $0x1,-0x4(%rbp)
jmp    12ad <case_strstr+0x1ad>
mov    -0x20(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x41,%eax
jl     1211 <case_strstr+0x111>
mov    -0x20(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x5a,%eax
jg     1211 <case_strstr+0x111>
mov    -0x20(%rbp),%rax
movsbl (%rax),%eax
sub    $0x41,%eax
add    $0x61,%eax
mov    %eax,-0x38(%rbp)
jmp    121b <case_strstr+0x11b>
mov    -0x20(%rbp),%rax
movsbl (%rax),%eax
mov    %eax,-0x38(%rbp)
mov    -0x38(%rbp),%eax
mov    %eax,-0x3c(%rbp)
mov    -0x28(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x41,%eax
jl     1256 <case_strstr+0x156>
mov    -0x28(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x5a,%eax
jg     1256 <case_strstr+0x156>
mov    -0x28(%rbp),%rax
movsbl (%rax),%eax
sub    $0x41,%eax
add    $0x61,%eax
mov    %eax,-0x40(%rbp)
jmp    1260 <case_strstr+0x160>
mov    -0x28(%rbp),%rax
movsbl (%rax),%eax
mov    %eax,-0x40(%rbp)
mov    -0x3c(%rbp),%eax
mov    -0x40(%rbp),%ecx
cmp    %ecx,%eax
je     1273 <case_strstr+0x173>
jmp    1290 <case_strstr+0x190>
mov    -0x20(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x20(%rbp)
mov    -0x28(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x28(%rbp)
jmp    11c3 <case_strstr+0xc3>
jmp    1295 <case_strstr+0x195>
mov    -0x20(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x20(%rbp)
jmp    111c <case_strstr+0x1c>
movl   $0x0,-0x4(%rbp)
mov    -0x4(%rbp),%eax
pop    %rbp
ret

x86 assembly (clang, -O2):
<case_strstr>:
push   %rbp
push   %rbx
mov    (%rdi),%cl
xor    %eax,%eax
test   %cl,%cl
je     11ad <case_strstr+0xad>
movsbl (%rsi),%r8d
lea    -0x41(%r8),%edx
lea    0x20(%r8),%r9d
cmp    $0x1a,%dl
cmovae %r8d,%r9d
add    $0x1,%rsi
jmp    113b <case_strstr+0x3b>
nopw   0x0(%rax,%rax,1)
mov    0x1(%rdi),%cl
add    $0x1,%rdi
test   %cl,%cl
je     11ad <case_strstr+0xad>
movsbl %cl,%ecx
lea    -0x41(%rcx),%r10d
lea    0x20(%rcx),%r11d
cmp    $0x1a,%r10b
mov    %ecx,%edx
cmovb  %r11d,%edx
cmp    %r9d,%edx
jne    1130 <case_strstr+0x30>
test   %r8b,%r8b
je     11a8 <case_strstr+0xa8>
cmp    $0x1a,%r10b
cmovb  %r11d,%ecx
cmp    %r9d,%ecx
jne    1130 <case_strstr+0x30>
mov    %rsi,%rcx
nopw   0x0(%rax,%rax,1)
movsbl (%rcx),%edx
test   %edx,%edx
je     11a8 <case_strstr+0xa8>
movsbl 0x1(%rdi),%r10d
add    $0x1,%rdi
lea    -0x41(%r10),%r11d
lea    0x20(%r10),%ebp
cmp    $0x1a,%r11b
cmovae %r10d,%ebp
lea    -0x41(%rdx),%r10d
lea    0x20(%rdx),%ebx
cmp    $0x1a,%r10b
cmovae %edx,%ebx
add    $0x1,%rcx
cmp    %ebx,%ebp
je     1170 <case_strstr+0x70>
jmp    1130 <case_strstr+0x30>
mov    $0x1,%eax
pop    %rbx
pop    %rbp
ret

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

LLVM IR (-O2):
define i32 @case_strstr(i8* nocapture %0, i8* nocapture %1) {
%3 = load i8, i8* %0
%4 = icmp eq i8 %3, 0
br i1 %4, label %60, label %5
5: ; preds = %2
%6 = load i8, i8* %1
%7 = sext i8 %6 to i32
%8 = add i8 %6, -65
%9 = icmp ult i8 %8, 26
%10 = add nsw i32 %7, 32
%11 = select i1 %9, i32 %10, i32 %7
%12 = icmp eq i8 %6, 0
%13 = sext i8 %6 to i32
%14 = add i8 %6, -65
%15 = icmp ult i8 %14, 26
%16 = add nsw i32 %13, 32
%17 = select i1 %15, i32 %16, i32 %13
br label %18
18: ; preds = %5, %55
%19 = phi i8 [ %3, %5 ], [ %58, %55 ]
%20 = phi i8* [ %0, %5 ], [ %57, %55 ]
%21 = sext i8 %19 to i32
%22 = add i8 %19, -65
%23 = icmp ult i8 %22, 26
%24 = add nsw i32 %21, 32
%25 = select i1 %23, i32 %24, i32 %21
%26 = icmp eq i32 %25, %11
br i1 %26, label %27, label %55
27: ; preds = %18
br i1 %12, label %60, label %28
28: ; preds = %27
%29 = sext i8 %19 to i32
%30 = add i8 %19, -65
%31 = icmp ult i8 %30, 26
%32 = add nsw i32 %29, 32
%33 = select i1 %31, i32 %32, i32 %29
%34 = icmp eq i32 %33, %17
br i1 %34, label %35, label %55
35: ; preds = %28, %42
%36 = phi i8* [ %38, %42 ], [ %20, %28 ]
%37 = phi i8* [ %39, %42 ], [ %1, %28 ]
%38 = getelementptr inbounds i8, i8* %36, i64 1
%39 = getelementptr inbounds i8, i8* %37, i64 1
%40 = load i8, i8* %39
%41 = icmp eq i8 %40, 0
br i1 %41, label %60, label %42
42: ; preds = %35
%43 = load i8, i8* %38
%44 = sext i8 %43 to i32
%45 = add i8 %43, -65
%46 = icmp ult i8 %45, 26
%47 = add nsw i32 %44, 32
%48 = select i1 %46, i32 %47, i32 %44
%49 = sext i8 %40 to i32
%50 = add i8 %40, -65
%51 = icmp ult i8 %50, 26
%52 = add nsw i32 %49, 32
%53 = select i1 %51, i32 %52, i32 %49
%54 = icmp eq i32 %48, %53
br i1 %54, label %35, label %55
55: ; preds = %42, %28, %18
%56 = phi i8* [ %20, %18 ], [ %20, %28 ], [ %38, %42 ]
%57 = getelementptr inbounds i8, i8* %56, i64 1
%58 = load i8, i8* %57
%59 = icmp eq i8 %58, 0
br i1 %59, label %60, label %18
60: ; preds = %55, %27, %35, %2
%61 = phi i32 [ 0, %2 ], [ 1, %35 ], [ 1, %27 ], [ 0, %55 ]
ret i32 %61
}