#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 strlen(char *);
char *strtok(char *, char *);
void intervalize(char *notes, int notes_len, char *text, int text_len) {
  int i = 0;
  int indexes_len = text_len + 1;
  int indexes[indexes_len];
  char space = ' ';
  char *note;
  note = strtok(notes, &space);
  int len;
  while (note != NULL) {
    len = strlen(note);
    int index = note[0];
    index = index - 65;
    switch (index) {
    case 0:
      indexes[i] = 1;
      break;
    case 1:
      indexes[i] = 3;
      break;
    case 2:
      indexes[i] = 4;
      break;
    case 3:
      indexes[i] = 6;
      break;
    case 4:
      indexes[i] = 8;
      break;
    case 5:
      indexes[i] = 9;
      break;
    case 6:
      indexes[i] = 11;
      break;
    }
    if (len > 1) {
      if (note[1] == '#') {
        indexes[i] = indexes[i] + 1;
      }
      if (note[1] == 'b') {
        indexes[i] = indexes[i] - 1;
      }
    }
    i = i + 1;
    note = strtok(NULL, &space);
  }
  int intervals_len = indexes_len - 1;
  int intervals[intervals_len];
  int dist;
  for (i = 0; i < intervals_len; i++) {
    dist = indexes[i + 1] - indexes[i];
    if (dist < 0) {
      dist = dist + 12;
    }
    intervals[i] = dist;
  }
  for (i = 0; i < text_len; i++) {
    text[i] = (char)(intervals[i] + 97);
  }
  text[text_len] = '\0';
  return;
}


x86 assembly (clang, -O0):
<intervalize>:
push   %rbp
mov    %rsp,%rbp
sub    $0x80,%rsp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %ecx,-0x1c(%rbp)
movl   $0x0,-0x20(%rbp)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
mov    -0x24(%rbp),%eax
mov    %rsp,%rcx
mov    %rcx,-0x30(%rbp)
lea    0xf(,%rax,4),%rdx
and    $0xfffffffffffffff0,%rdx
mov    %rsp,%rcx
sub    %rdx,%rcx
mov    %rcx,-0x70(%rbp)
mov    %rcx,%rsp
mov    %rax,-0x38(%rbp)
movb   $0x20,-0x39(%rbp)
mov    -0x8(%rbp),%rdi
lea    -0x39(%rbp),%rsi
call   1040 <strtok@plt>
mov    %rax,-0x48(%rbp)
cmpq   $0x0,-0x48(%rbp)
je     12d5 <intervalize+0x1b5>
mov    -0x48(%rbp),%rdi
call   1030 <strlen@plt>
mov    %eax,-0x4c(%rbp)
mov    -0x48(%rbp),%rax
movsbl (%rax),%eax
mov    %eax,-0x50(%rbp)
mov    -0x50(%rbp),%eax
add    $0xffffffbf,%eax
mov    %eax,-0x50(%rbp)
mov    -0x50(%rbp),%eax
mov    %rax,-0x78(%rbp)
sub    $0x6,%rax
ja     125b <intervalize+0x13b>
mov    -0x78(%rbp),%rax
lea    0xe35(%rip),%rcx
movslq (%rcx,%rax,4),%rax
add    %rcx,%rax
jmp    *%rax
mov    -0x70(%rbp),%rax
movslq -0x20(%rbp),%rcx
movl   $0x1,(%rax,%rcx,4)
jmp    125b <intervalize+0x13b>
mov    -0x70(%rbp),%rax
movslq -0x20(%rbp),%rcx
movl   $0x3,(%rax,%rcx,4)
jmp    125b <intervalize+0x13b>
mov    -0x70(%rbp),%rax
movslq -0x20(%rbp),%rcx
movl   $0x4,(%rax,%rcx,4)
jmp    125b <intervalize+0x13b>
mov    -0x70(%rbp),%rax
movslq -0x20(%rbp),%rcx
movl   $0x6,(%rax,%rcx,4)
jmp    125b <intervalize+0x13b>
mov    -0x70(%rbp),%rax
movslq -0x20(%rbp),%rcx
movl   $0x8,(%rax,%rcx,4)
jmp    125b <intervalize+0x13b>
mov    -0x70(%rbp),%rax
movslq -0x20(%rbp),%rcx
movl   $0x9,(%rax,%rcx,4)
jmp    125b <intervalize+0x13b>
mov    -0x70(%rbp),%rax
movslq -0x20(%rbp),%rcx
movl   $0xb,(%rax,%rcx,4)
cmpl   $0x1,-0x4c(%rbp)
jle    12b6 <intervalize+0x196>
mov    -0x48(%rbp),%rax
movsbl 0x1(%rax),%eax
cmp    $0x23,%eax
jne    128b <intervalize+0x16b>
mov    -0x70(%rbp),%rax
movslq -0x20(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
add    $0x1,%edx
movslq -0x20(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x48(%rbp),%rax
movsbl 0x1(%rax),%eax
cmp    $0x62,%eax
jne    12b1 <intervalize+0x191>
mov    -0x70(%rbp),%rax
movslq -0x20(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
sub    $0x1,%edx
movslq -0x20(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
jmp    12b6 <intervalize+0x196>
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
xor    %eax,%eax
mov    %eax,%edi
lea    -0x39(%rbp),%rsi
call   1040 <strtok@plt>
mov    %rax,-0x48(%rbp)
jmp    1185 <intervalize+0x65>
mov    -0x24(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x54(%rbp)
mov    -0x54(%rbp),%eax
lea    0xf(,%rax,4),%rdx
and    $0xfffffffffffffff0,%rdx
mov    %rsp,%rcx
sub    %rdx,%rcx
mov    %rcx,-0x80(%rbp)
mov    %rcx,%rsp
mov    %rax,-0x60(%rbp)
movl   $0x0,-0x20(%rbp)
mov    -0x20(%rbp),%eax
cmp    -0x54(%rbp),%eax
jge    1359 <intervalize+0x239>
mov    -0x70(%rbp),%rcx
mov    -0x20(%rbp),%eax
add    $0x1,%eax
cltq
mov    (%rcx,%rax,4),%eax
movslq -0x20(%rbp),%rdx
sub    (%rcx,%rdx,4),%eax
mov    %eax,-0x64(%rbp)
cmpl   $0x0,-0x64(%rbp)
jge    133d <intervalize+0x21d>
mov    -0x64(%rbp),%eax
add    $0xc,%eax
mov    %eax,-0x64(%rbp)
mov    -0x80(%rbp),%rax
mov    -0x64(%rbp),%edx
movslq -0x20(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    1305 <intervalize+0x1e5>
movl   $0x0,-0x20(%rbp)
mov    -0x20(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    1395 <intervalize+0x275>
mov    -0x80(%rbp),%rax
movslq -0x20(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
add    $0x61,%eax
mov    %al,%dl
mov    -0x18(%rbp),%rax
movslq -0x20(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    1360 <intervalize+0x240>
mov    -0x18(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movb   $0x0,(%rax,%rcx,1)
mov    -0x30(%rbp),%rax
mov    %rax,%rsp
mov    %rbp,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<intervalize>:
push   %rbp
mov    %rsp,%rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x18,%rsp
mov    %rdx,%r15
mov    %rcx,-0x38(%rbp)
lea    0x1(%rcx),%eax
mov    %rsp,%r14
lea    0xf(,%rax,4),%rax
and    $0xfffffffffffffff0,%rax
sub    %rax,%r14
mov    %r14,%rsp
movb   $0x20,-0x29(%rbp)
lea    -0x29(%rbp),%rsi
call   1040 <strtok@plt>
test   %rax,%rax
je     11cd <intervalize+0xad>
mov    %rax,%rbx
lea    -0x29(%rbp),%r12
mov    %r14,%r13
jmp    118d <intervalize+0x6d>
mov    $0x1,%eax
add    %eax,0x0(%r13)
xor    %edi,%edi
mov    %r12,%rsi
call   1040 <strtok@plt>
mov    %rax,%rbx
add    $0x4,%r13
test   %rax,%rax
je     11cd <intervalize+0xad>
mov    %rbx,%rdi
call   1030 <strlen@plt>
movsbl (%rbx),%ecx
lea    -0x41(%rcx),%edx
cmp    $0x6,%edx
ja     11b5 <intervalize+0x95>
movslq %ecx,%rcx
lea    0xe86(%rip),%rdx
mov    -0x104(%rdx,%rcx,4),%ecx
mov    %ecx,0x0(%r13)
cmp    $0x2,%eax
jl     1177 <intervalize+0x57>
movzbl 0x1(%rbx),%eax
cmp    $0x23,%al
je     116e <intervalize+0x4e>
cmp    $0x62,%al
jne    1177 <intervalize+0x57>
mov    $0xffffffff,%eax
jmp    1173 <intervalize+0x53>
mov    -0x38(%rbp),%r9
mov    %r9d,%r8d
mov    %rsp,%rcx
lea    0xf(,%r8,4),%rdx
and    $0xfffffffffffffff0,%rdx
sub    %rdx,%rcx
mov    %rcx,%rsp
test   %r9d,%r9d
jle    1413 <intervalize+0x2f3>
mov    (%r14),%esi
cmp    $0x8,%r9d
jae    1202 <intervalize+0xe2>
xor    %eax,%eax
jmp    12c0 <intervalize+0x1a0>
mov    %r8d,%eax
and    $0xfffffff8,%eax
movd   %esi,%xmm0
pshufd $0x0,%xmm0,%xmm1
lea    0x0(,%r8,4),%rsi
and    $0xffffffffffffffe0,%rsi
xor    %edi,%edi
movdqa 0xdd9(%rip),%xmm0
nopw   0x0(%rax,%rax,1)
movups 0x4(%r14,%rdi,1),%xmm2
shufps $0x3,%xmm2,%xmm1
shufps $0x98,%xmm2,%xmm1
movaps %xmm2,%xmm3
psubd  %xmm1,%xmm2
movups 0x14(%r14,%rdi,1),%xmm1
shufps $0x3,%xmm1,%xmm3
shufps $0x98,%xmm1,%xmm3
movaps %xmm1,%xmm4
psubd  %xmm3,%xmm4
pxor   %xmm3,%xmm3
pcmpgtd %xmm2,%xmm3
pxor   %xmm5,%xmm5
pcmpgtd %xmm4,%xmm5
movdqa %xmm3,%xmm6
pandn  %xmm2,%xmm6
paddd  %xmm0,%xmm2
pand   %xmm3,%xmm2
por    %xmm6,%xmm2
movdqa %xmm5,%xmm3
pandn  %xmm4,%xmm3
paddd  %xmm0,%xmm4
pand   %xmm5,%xmm4
por    %xmm3,%xmm4
movdqa %xmm2,(%rcx,%rdi,1)
movdqa %xmm4,0x10(%rcx,%rdi,1)
add    $0x20,%rdi
cmp    %rdi,%rsi
jne    1230 <intervalize+0x110>
cmp    %r8,%rax
je     12e2 <intervalize+0x1c2>
pshufd $0xff,%xmm1,%xmm0
movd   %xmm0,%esi
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    0x4(%r14,%rax,4),%edi
mov    %edi,%ebx
sub    %esi,%ebx
lea    0xc(%rbx),%esi
test   %ebx,%ebx
cmovns %ebx,%esi
mov    %esi,(%rcx,%rax,4)
lea    0x1(%rax),%rdx
mov    %edi,%esi
mov    %rdx,%rax
cmp    %rdx,%r8
jne    12c0 <intervalize+0x1a0>
test   %r9d,%r9d
jle    1413 <intervalize+0x2f3>
cmp    $0x8,%r9d
jae    12f8 <intervalize+0x1d8>
xor    %edx,%edx
jmp    1400 <intervalize+0x2e0>
mov    %r8d,%edx
and    $0xfffffff8,%edx
lea    -0x8(%rdx),%rsi
mov    %rsi,%rbx
shr    $0x3,%rbx
add    $0x1,%rbx
test   %rsi,%rsi
je     142a <intervalize+0x30a>
mov    %rbx,%rdi
and    $0xfffffffffffffffe,%rdi
xor    %esi,%esi
movdqa 0xce9(%rip),%xmm0
movdqa 0xcf1(%rip),%xmm1
nop
movdqa (%rcx,%rsi,4),%xmm2
pand   %xmm0,%xmm2
packuswb %xmm2,%xmm2
packuswb %xmm2,%xmm2
movdqa 0x10(%rcx,%rsi,4),%xmm3
pand   %xmm0,%xmm3
packuswb %xmm3,%xmm3
packuswb %xmm3,%xmm3
paddb  %xmm1,%xmm2
paddb  %xmm1,%xmm3
movd   %xmm2,(%r15,%rsi,1)
movd   %xmm3,0x4(%r15,%rsi,1)
movdqa 0x20(%rcx,%rsi,4),%xmm2
pand   %xmm0,%xmm2
packuswb %xmm2,%xmm2
packuswb %xmm2,%xmm2
movdqa 0x30(%rcx,%rsi,4),%xmm3
pand   %xmm0,%xmm3
packuswb %xmm3,%xmm3
packuswb %xmm3,%xmm3
paddb  %xmm1,%xmm2
paddb  %xmm1,%xmm3
movd   %xmm2,0x8(%r15,%rsi,1)
movd   %xmm3,0xc(%r15,%rsi,1)
add    $0x10,%rsi
add    $0xfffffffffffffffe,%rdi
jne    1330 <intervalize+0x210>
test   $0x1,%bl
je     13f5 <intervalize+0x2d5>
movdqa 0xc57(%rip),%xmm0
movdqa (%rcx,%rsi,4),%xmm1
pand   %xmm0,%xmm1
packuswb %xmm1,%xmm1
pand   0x10(%rcx,%rsi,4),%xmm0
packuswb %xmm1,%xmm1
packuswb %xmm0,%xmm0
packuswb %xmm0,%xmm0
movdqa 0xc40(%rip),%xmm2
paddb  %xmm2,%xmm1
paddb  %xmm2,%xmm0
movd   %xmm1,(%r15,%rsi,1)
movd   %xmm0,0x4(%r15,%rsi,1)
cmp    %r8,%rdx
je     1413 <intervalize+0x2f3>
nopw   0x0(%rax,%rax,1)
movzbl (%rcx,%rdx,4),%eax
add    $0x61,%al
mov    %al,(%r15,%rdx,1)
add    $0x1,%rdx
cmp    %rdx,%r8
jne    1400 <intervalize+0x2e0>
movslq %r9d,%rax
movb   $0x0,(%r15,%rax,1)
lea    -0x28(%rbp),%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
xor    %esi,%esi
test   $0x1,%bl
jne    13b1 <intervalize+0x291>
jmp    13f5 <intervalize+0x2d5>

LLVM IR (-O0):
define void @intervalize(i8* %0, i32 %1, i8* %2, i32 %3) {
%5 = alloca i8*
%6 = alloca i32
%7 = alloca i8*
%8 = alloca i32
%9 = alloca i32
%10 = alloca i32
%11 = alloca i8*
%12 = alloca i64
%13 = alloca i8
%14 = alloca i8*
%15 = alloca i32
%16 = alloca i32
%17 = alloca i32
%18 = alloca i64
%19 = alloca i32
store i8* %0, i8** %5
store i32 %1, i32* %6
store i8* %2, i8** %7
store i32 %3, i32* %8
store i32 0, i32* %9
%20 = load i32, i32* %8
%21 = add nsw i32 %20, 1
store i32 %21, i32* %10
%22 = load i32, i32* %10
%23 = zext i32 %22 to i64
%24 = call i8* @llvm.stacksave()
store i8* %24, i8** %11
%25 = alloca i32, i64 %23
store i64 %23, i64* %12
store i8 32, i8* %13
%26 = load i8*, i8** %5
%27 = call i8* @strtok(i8* %26, i8* %13)
store i8* %27, i8** %14
br label %28
28: ; preds = %103, %4
%29 = load i8*, i8** %14
%30 = icmp ne i8* %29, null
br i1 %30, label %31, label %107
31: ; preds = %28
%32 = load i8*, i8** %14
%33 = call i32 @strlen(i8* %32)
store i32 %33, i32* %15
%34 = load i8*, i8** %14
%35 = getelementptr inbounds i8, i8* %34, i64 0
%36 = load i8, i8* %35
%37 = sext i8 %36 to i32
store i32 %37, i32* %16
%38 = load i32, i32* %16
%39 = sub nsw i32 %38, 65
store i32 %39, i32* %16
%40 = load i32, i32* %16
switch i32 %40, label %69 [
i32 0, label %41
i32 1, label %45
i32 2, label %49
i32 3, label %53
i32 4, label %57
i32 5, label %61
i32 6, label %65
]
41: ; preds = %31
%42 = load i32, i32* %9
%43 = sext i32 %42 to i64
%44 = getelementptr inbounds i32, i32* %25, i64 %43
store i32 1, i32* %44
br label %69
45: ; preds = %31
%46 = load i32, i32* %9
%47 = sext i32 %46 to i64
%48 = getelementptr inbounds i32, i32* %25, i64 %47
store i32 3, i32* %48
br label %69
49: ; preds = %31
%50 = load i32, i32* %9
%51 = sext i32 %50 to i64
%52 = getelementptr inbounds i32, i32* %25, i64 %51
store i32 4, i32* %52
br label %69
53: ; preds = %31
%54 = load i32, i32* %9
%55 = sext i32 %54 to i64
%56 = getelementptr inbounds i32, i32* %25, i64 %55
store i32 6, i32* %56
br label %69
57: ; preds = %31
%58 = load i32, i32* %9
%59 = sext i32 %58 to i64
%60 = getelementptr inbounds i32, i32* %25, i64 %59
store i32 8, i32* %60
br label %69
61: ; preds = %31
%62 = load i32, i32* %9
%63 = sext i32 %62 to i64
%64 = getelementptr inbounds i32, i32* %25, i64 %63
store i32 9, i32* %64
br label %69
65: ; preds = %31
%66 = load i32, i32* %9
%67 = sext i32 %66 to i64
%68 = getelementptr inbounds i32, i32* %25, i64 %67
store i32 11, i32* %68
br label %69
69: ; preds = %31, %65, %61, %57, %53, %49, %45, %41
%70 = load i32, i32* %15
%71 = icmp sgt i32 %70, 1
br i1 %71, label %72, label %103
72: ; preds = %69
%73 = load i8*, i8** %14
%74 = getelementptr inbounds i8, i8* %73, i64 1
%75 = load i8, i8* %74
%76 = sext i8 %75 to i32
%77 = icmp eq i32 %76, 35
br i1 %77, label %78, label %87
78: ; preds = %72
%79 = load i32, i32* %9
%80 = sext i32 %79 to i64
%81 = getelementptr inbounds i32, i32* %25, i64 %80
%82 = load i32, i32* %81
%83 = add nsw i32 %82, 1
%84 = load i32, i32* %9
%85 = sext i32 %84 to i64
%86 = getelementptr inbounds i32, i32* %25, i64 %85
store i32 %83, i32* %86
br label %87
87: ; preds = %78, %72
%88 = load i8*, i8** %14
%89 = getelementptr inbounds i8, i8* %88, i64 1
%90 = load i8, i8* %89
%91 = sext i8 %90 to i32
%92 = icmp eq i32 %91, 98
br i1 %92, label %93, label %102
93: ; preds = %87
%94 = load i32, i32* %9
%95 = sext i32 %94 to i64
%96 = getelementptr inbounds i32, i32* %25, i64 %95
%97 = load i32, i32* %96
%98 = sub nsw i32 %97, 1
%99 = load i32, i32* %9
%100 = sext i32 %99 to i64
%101 = getelementptr inbounds i32, i32* %25, i64 %100
store i32 %98, i32* %101
br label %102
102: ; preds = %93, %87
br label %103
103: ; preds = %102, %69
%104 = load i32, i32* %9
%105 = add nsw i32 %104, 1
store i32 %105, i32* %9
%106 = call i8* @strtok(i8* null, i8* %13)
store i8* %106, i8** %14
br label %28
107: ; preds = %28
%108 = load i32, i32* %10
%109 = sub nsw i32 %108, 1
store i32 %109, i32* %17
%110 = load i32, i32* %17
%111 = zext i32 %110 to i64
%112 = alloca i32, i64 %111
store i64 %111, i64* %18
store i32 0, i32* %9
br label %113
113: ; preds = %138, %107
%114 = load i32, i32* %9
%115 = load i32, i32* %17
%116 = icmp slt i32 %114, %115
br i1 %116, label %117, label %141
117: ; preds = %113
%118 = load i32, i32* %9
%119 = add nsw i32 %118, 1
%120 = sext i32 %119 to i64
%121 = getelementptr inbounds i32, i32* %25, i64 %120
%122 = load i32, i32* %121
%123 = load i32, i32* %9
%124 = sext i32 %123 to i64
%125 = getelementptr inbounds i32, i32* %25, i64 %124
%126 = load i32, i32* %125
%127 = sub nsw i32 %122, %126
store i32 %127, i32* %19
%128 = load i32, i32* %19
%129 = icmp slt i32 %128, 0
br i1 %129, label %130, label %133
130: ; preds = %117
%131 = load i32, i32* %19
%132 = add nsw i32 %131, 12
store i32 %132, i32* %19
br label %133
133: ; preds = %130, %117
%134 = load i32, i32* %19
%135 = load i32, i32* %9
%136 = sext i32 %135 to i64
%137 = getelementptr inbounds i32, i32* %112, i64 %136
store i32 %134, i32* %137
br label %138
138: ; preds = %133
%139 = load i32, i32* %9
%140 = add nsw i32 %139, 1
store i32 %140, i32* %9
br label %113
141: ; preds = %113
store i32 0, i32* %9
br label %142
142: ; preds = %157, %141
%143 = load i32, i32* %9
%144 = load i32, i32* %8
%145 = icmp slt i32 %143, %144
br i1 %145, label %146, label %160
146: ; preds = %142
%147 = load i32, i32* %9
%148 = sext i32 %147 to i64
%149 = getelementptr inbounds i32, i32* %112, i64 %148
%150 = load i32, i32* %149
%151 = add nsw i32 %150, 97
%152 = trunc i32 %151 to i8
%153 = load i8*, i8** %7
%154 = load i32, i32* %9
%155 = sext i32 %154 to i64
%156 = getelementptr inbounds i8, i8* %153, i64 %155
store i8 %152, i8* %156
br label %157
157: ; preds = %146
%158 = load i32, i32* %9
%159 = add nsw i32 %158, 1
store i32 %159, i32* %9
br label %142
160: ; preds = %142
%161 = load i8*, i8** %7
%162 = load i32, i32* %8
%163 = sext i32 %162 to i64
%164 = getelementptr inbounds i8, i8* %161, i64 %163
store i8 0, i8* %164
%165 = load i8*, i8** %11
ret void
}

LLVM IR (-O2):
@switch.table.intervalize = [7 x i32] [i32 1, i32 3, i32 4, i32 6, i32 8, i32 9, i32 11]
define void @intervalize(i8* %0, i32 %1, i8* nocapture writeonly %2, i32 %3) {
%5 = alloca i8
%6 = add nsw i32 %3, 1
%7 = zext i32 %6 to i64
%8 = alloca i32, i64 %7
store i8 32, i8* %5
%9 = call i8* @strtok(i8* %0, i8* %5)
%10 = icmp eq i8* %9, null
br i1 %10, label %39, label %11
11: ; preds = %4, %35
%12 = phi i64 [ %36, %35 ], [ 0, %4 ]
%13 = phi i8* [ %37, %35 ], [ %9, %4 ]
%14 = tail call i32 @strlen(i8* %13)
%15 = load i8, i8* %13
%16 = sext i8 %15 to i32
%17 = add nsw i32 %16, -65
%18 = icmp ult i32 %17, 7
br i1 %18, label %19, label %24
19: ; preds = %11
%20 = sext i32 %17 to i64
%21 = getelementptr inbounds [7 x i32], [7 x i32]* @switch.table.intervalize, i64 0, i64 %20
%22 = load i32, i32* %21
%23 = getelementptr inbounds i32, i32* %8, i64 %12
store i32 %22, i32* %23
br label %24
24: ; preds = %11, %19
%25 = icmp sgt i32 %14, 1
br i1 %25, label %26, label %35
26: ; preds = %24
%27 = getelementptr inbounds i8, i8* %13, i64 1
%28 = load i8, i8* %27
switch i8 %28, label %35 [
i8 35, label %30
i8 98, label %29
]
29: ; preds = %26
br label %30
30: ; preds = %26, %29
%31 = phi i32 [ -1, %29 ], [ 1, %26 ]
%32 = getelementptr inbounds i32, i32* %8, i64 %12
%33 = load i32, i32* %32
%34 = add nsw i32 %33, %31
store i32 %34, i32* %32
br label %35
35: ; preds = %30, %26, %24
%36 = add nuw i64 %12, 1
%37 = call i8* @strtok(i8* null, i8* %5)
%38 = icmp eq i8* %37, null
br i1 %38, label %39, label %11
39: ; preds = %35, %4
%40 = zext i32 %3 to i64
%41 = alloca i32, i64 %40
%42 = icmp sgt i32 %3, 0
br i1 %42, label %43, label %171
43: ; preds = %39
%44 = load i32, i32* %8
%45 = icmp ult i32 %3, 8
br i1 %45, label %78, label %46
46: ; preds = %43
%47 = and i64 %40, 4294967288
%48 = insertelement <4 x i32> poison, i32 %44, i64 3
br label %49
49: ; preds = %49, %46
%50 = phi i64 [ 0, %46 ], [ %73, %49 ]
%51 = phi <4 x i32> [ %48, %46 ], [ %58, %49 ]
%52 = or i64 %50, 1
%53 = getelementptr inbounds i32, i32* %8, i64 %52
%54 = bitcast i32* %53 to <4 x i32>*
%55 = load <4 x i32>, <4 x i32>* %54
%56 = getelementptr inbounds i32, i32* %53, i64 4
%57 = bitcast i32* %56 to <4 x i32>*
%58 = load <4 x i32>, <4 x i32>* %57
%59 = shufflevector <4 x i32> %51, <4 x i32> %55, <4 x i32> <i32 3, i32 4, i32 5, i32 6>
%60 = shufflevector <4 x i32> %55, <4 x i32> %58, <4 x i32> <i32 3, i32 4, i32 5, i32 6>
%61 = sub nsw <4 x i32> %55, %59
%62 = sub nsw <4 x i32> %58, %60
%63 = icmp slt <4 x i32> %61, zeroinitializer
%64 = icmp slt <4 x i32> %62, zeroinitializer
%65 = add nsw <4 x i32> %61, <i32 12, i32 12, i32 12, i32 12>
%66 = add nsw <4 x i32> %62, <i32 12, i32 12, i32 12, i32 12>
%67 = select <4 x i1> %63, <4 x i32> %65, <4 x i32> %61
%68 = select <4 x i1> %64, <4 x i32> %66, <4 x i32> %62
%69 = getelementptr inbounds i32, i32* %41, i64 %50
%70 = bitcast i32* %69 to <4 x i32>*
store <4 x i32> %67, <4 x i32>* %70
%71 = getelementptr inbounds i32, i32* %69, i64 4
%72 = bitcast i32* %71 to <4 x i32>*
store <4 x i32> %68, <4 x i32>* %72
%73 = add nuw i64 %50, 8
%74 = icmp eq i64 %73, %47
br i1 %74, label %75, label %49
75: ; preds = %49
%76 = icmp eq i64 %47, %40
%77 = extractelement <4 x i32> %58, i64 3
br i1 %76, label %81, label %78
78: ; preds = %43, %75
%79 = phi i32 [ %77, %75 ], [ %44, %43 ]
%80 = phi i64 [ %47, %75 ], [ 0, %43 ]
br label %150
81: ; preds = %150, %75
br i1 %42, label %82, label %171
82: ; preds = %81
%83 = icmp ult i32 %3, 8
br i1 %83, label %148, label %84
84: ; preds = %82
%85 = and i64 %40, 4294967288
%86 = add nsw i64 %85, -8
%87 = lshr exact i64 %86, 3
%88 = add nuw nsw i64 %87, 1
%89 = and i64 %88, 1
%90 = icmp eq i64 %86, 0
br i1 %90, label %128, label %91
91: ; preds = %84
%92 = and i64 %88, 4611686018427387902
br label %93
93: ; preds = %93, %91
%94 = phi i64 [ 0, %91 ], [ %125, %93 ]
%95 = phi i64 [ 0, %91 ], [ %126, %93 ]
%96 = getelementptr inbounds i32, i32* %41, i64 %94
%97 = bitcast i32* %96 to <4 x i32>*
%98 = load <4 x i32>, <4 x i32>* %97
%99 = getelementptr inbounds i32, i32* %96, i64 4
%100 = bitcast i32* %99 to <4 x i32>*
%101 = load <4 x i32>, <4 x i32>* %100
%102 = trunc <4 x i32> %98 to <4 x i8>
%103 = trunc <4 x i32> %101 to <4 x i8>
%104 = add <4 x i8> %102, <i8 97, i8 97, i8 97, i8 97>
%105 = add <4 x i8> %103, <i8 97, i8 97, i8 97, i8 97>
%106 = getelementptr inbounds i8, i8* %2, i64 %94
%107 = bitcast i8* %106 to <4 x i8>*
store <4 x i8> %104, <4 x i8>* %107
%108 = getelementptr inbounds i8, i8* %106, i64 4
%109 = bitcast i8* %108 to <4 x i8>*
store <4 x i8> %105, <4 x i8>* %109
%110 = or i64 %94, 8
%111 = getelementptr inbounds i32, i32* %41, i64 %110
%112 = bitcast i32* %111 to <4 x i32>*
%113 = load <4 x i32>, <4 x i32>* %112
%114 = getelementptr inbounds i32, i32* %111, i64 4
%115 = bitcast i32* %114 to <4 x i32>*
%116 = load <4 x i32>, <4 x i32>* %115
%117 = trunc <4 x i32> %113 to <4 x i8>
%118 = trunc <4 x i32> %116 to <4 x i8>
%119 = add <4 x i8> %117, <i8 97, i8 97, i8 97, i8 97>
%120 = add <4 x i8> %118, <i8 97, i8 97, i8 97, i8 97>
%121 = getelementptr inbounds i8, i8* %2, i64 %110
%122 = bitcast i8* %121 to <4 x i8>*
store <4 x i8> %119, <4 x i8>* %122
%123 = getelementptr inbounds i8, i8* %121, i64 4
%124 = bitcast i8* %123 to <4 x i8>*
store <4 x i8> %120, <4 x i8>* %124
%125 = add nuw i64 %94, 16
%126 = add i64 %95, 2
%127 = icmp eq i64 %126, %92
br i1 %127, label %128, label %93
128: ; preds = %93, %84
%129 = phi i64 [ 0, %84 ], [ %125, %93 ]
%130 = icmp eq i64 %89, 0
br i1 %130, label %146, label %131
131: ; preds = %128
%132 = getelementptr inbounds i32, i32* %41, i64 %129
%133 = bitcast i32* %132 to <4 x i32>*
%134 = load <4 x i32>, <4 x i32>* %133
%135 = getelementptr inbounds i32, i32* %132, i64 4
%136 = bitcast i32* %135 to <4 x i32>*
%137 = load <4 x i32>, <4 x i32>* %136
%138 = trunc <4 x i32> %134 to <4 x i8>
%139 = trunc <4 x i32> %137 to <4 x i8>
%140 = add <4 x i8> %138, <i8 97, i8 97, i8 97, i8 97>
%141 = add <4 x i8> %139, <i8 97, i8 97, i8 97, i8 97>
%142 = getelementptr inbounds i8, i8* %2, i64 %129
%143 = bitcast i8* %142 to <4 x i8>*
store <4 x i8> %140, <4 x i8>* %143
%144 = getelementptr inbounds i8, i8* %142, i64 4
%145 = bitcast i8* %144 to <4 x i8>*
store <4 x i8> %141, <4 x i8>* %145
br label %146
146: ; preds = %128, %131
%147 = icmp eq i64 %85, %40
br i1 %147, label %171, label %148
148: ; preds = %82, %146
%149 = phi i64 [ 0, %82 ], [ %85, %146 ]
br label %162
150: ; preds = %78, %150
%151 = phi i32 [ %155, %150 ], [ %79, %78 ]
%152 = phi i64 [ %153, %150 ], [ %80, %78 ]
%153 = add nuw nsw i64 %152, 1
%154 = getelementptr inbounds i32, i32* %8, i64 %153
%155 = load i32, i32* %154
%156 = sub nsw i32 %155, %151
%157 = icmp slt i32 %156, 0
%158 = add nsw i32 %156, 12
%159 = select i1 %157, i32 %158, i32 %156
%160 = getelementptr inbounds i32, i32* %41, i64 %152
store i32 %159, i32* %160
%161 = icmp eq i64 %153, %40
br i1 %161, label %81, label %150
162: ; preds = %148, %162
%163 = phi i64 [ %169, %162 ], [ %149, %148 ]
%164 = getelementptr inbounds i32, i32* %41, i64 %163
%165 = load i32, i32* %164
%166 = trunc i32 %165 to i8
%167 = add i8 %166, 97
%168 = getelementptr inbounds i8, i8* %2, i64 %163
store i8 %167, i8* %168
%169 = add nuw nsw i64 %163, 1
%170 = icmp eq i64 %169, %40
br i1 %170, label %171, label %162
171: ; preds = %162, %146, %39, %81
%172 = sext i32 %3 to i64
%173 = getelementptr inbounds i8, i8* %2, i64 %172
store i8 0, i8* %173
ret void
}