#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 */
char *scan_note(char *, int *, int *);
char *scan_octave(char *, int *);
char *scan_rest(char *, int *);
int roi_song(unsigned char *buff, unsigned char no, char *args) {
  int note, octave = 4;
  int numb = 0;
  int length;
  char *p;
  buff[0] = (140);
  buff[1] = no;
  for (p = args; *p != '\0';) {
    if (*p == '>') {
      octave++;
      p++;
    }
    if (*p == '<') {
      octave--;
      p++;
    }
    if (*p == 'O') {
      p = scan_octave(p, &octave);
    }
    if (*p == 'R') {
      p = scan_rest(p, &length);
      buff[3 + 2 * numb + 0] = 0;
      buff[3 + 2 * numb + 1] = length;
      numb++;
    }
    if (*p == 'C' || *p == 'D' || *p == 'E' || *p == 'F' || *p == 'G' ||
        *p == 'A' || *p == 'B') {
      p = scan_note(p, &note, &length);
      buff[3 + 2 * numb + 0] = note + (octave + 1) * 12;
      buff[3 + 2 * numb + 1] = length;
      numb++;
    }
  }
  buff[2] = numb;
  return (3 + numb * 2);
}


x86 assembly (clang, -O0):
<roi_song>:
push   %rbp
mov    %rsp,%rbp
sub    $0x30,%rsp
mov    %sil,%al
mov    %rdi,-0x8(%rbp)
mov    %al,-0x9(%rbp)
mov    %rdx,-0x18(%rbp)
movl   $0x4,-0x20(%rbp)
movl   $0x0,-0x24(%rbp)
mov    -0x8(%rbp),%rax
movb   $0x8c,(%rax)
mov    -0x9(%rbp),%cl
mov    -0x8(%rbp),%rax
mov    %cl,0x1(%rax)
mov    -0x18(%rbp),%rax
mov    %rax,-0x30(%rbp)
mov    -0x30(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x0,%eax
je     1318 <roi_song+0x1e8>
mov    -0x30(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x3e,%eax
jne    11a2 <roi_song+0x72>
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
mov    -0x30(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x30(%rbp)
mov    -0x30(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x3c,%eax
jne    11c7 <roi_song+0x97>
mov    -0x20(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x20(%rbp)
mov    -0x30(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x30(%rbp)
mov    -0x30(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x4f,%eax
jne    11e8 <roi_song+0xb8>
mov    -0x30(%rbp),%rdi
lea    -0x20(%rbp),%rsi
call   1050 <scan_octave@plt>
mov    %rax,-0x30(%rbp)
mov    -0x30(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x52,%eax
jne    1244 <roi_song+0x114>
mov    -0x30(%rbp),%rdi
lea    -0x28(%rbp),%rsi
call   1030 <scan_rest@plt>
mov    %rax,-0x30(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x24(%rbp),%ecx
shl    $0x1,%ecx
add    $0x3,%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
movb   $0x0,(%rax,%rcx,1)
mov    -0x28(%rbp),%eax
mov    %al,%dl
mov    -0x8(%rbp),%rax
mov    -0x24(%rbp),%ecx
shl    $0x1,%ecx
add    $0x3,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
mov    -0x30(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x43,%eax
je     12b4 <roi_song+0x184>
mov    -0x30(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x44,%eax
je     12b4 <roi_song+0x184>
mov    -0x30(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x45,%eax
je     12b4 <roi_song+0x184>
mov    -0x30(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x46,%eax
je     12b4 <roi_song+0x184>
mov    -0x30(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x47,%eax
je     12b4 <roi_song+0x184>
mov    -0x30(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x41,%eax
je     12b4 <roi_song+0x184>
mov    -0x30(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x42,%eax
jne    1313 <roi_song+0x1e3>
mov    -0x30(%rbp),%rdi
lea    -0x1c(%rbp),%rsi
lea    -0x28(%rbp),%rdx
call   1040 <scan_note@plt>
mov    %rax,-0x30(%rbp)
mov    -0x1c(%rbp),%eax
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
imul   $0xc,%ecx,%ecx
add    %ecx,%eax
mov    %al,%dl
mov    -0x8(%rbp),%rax
mov    -0x24(%rbp),%ecx
shl    $0x1,%ecx
add    $0x3,%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x28(%rbp),%eax
mov    %al,%dl
mov    -0x8(%rbp),%rax
mov    -0x24(%rbp),%ecx
shl    $0x1,%ecx
add    $0x3,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    116d <roi_song+0x3d>
mov    -0x24(%rbp),%eax
mov    %al,%cl
mov    -0x8(%rbp),%rax
mov    %cl,0x2(%rax)
mov    -0x24(%rbp),%eax
shl    $0x1,%eax
add    $0x3,%eax
add    $0x30,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<roi_song>:
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x10,%rsp
mov    %rdx,%rax
mov    %rdi,%r13
movl   $0x4,0x4(%rsp)
movb   $0x8c,(%rdi)
mov    %sil,0x1(%rdi)
xor    %ebx,%ebx
lea    0x4(%rsp),%r14
lea    0x8(%rsp),%r15
lea    0xc(%rsp),%r12
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movzbl (%rax),%ecx
cmp    $0x3e,%cl
je     1200 <roi_song+0xd0>
test   %cl,%cl
je     1248 <roi_song+0x118>
cmp    $0x3c,%cl
je     1216 <roi_song+0xe6>
cmp    $0x4f,%cl
je     122c <roi_song+0xfc>
cmp    $0x52,%cl
jne    11bf <roi_song+0x8f>
mov    %rax,%rdi
mov    %r15,%rsi
call   1030 <scan_rest@plt>
movslq %ebx,%rcx
movb   $0x0,0x3(%r13,%rcx,2)
movzbl 0x8(%rsp),%edx
mov    %dl,0x4(%r13,%rcx,2)
add    $0x1,%ebx
movzbl (%rax),%ecx
add    $0xbf,%cl
cmp    $0x6,%cl
ja     1170 <roi_song+0x40>
mov    %rax,%rdi
mov    %r12,%rsi
mov    %r15,%rdx
call   1040 <scan_note@plt>
mov    0x4(%rsp),%ecx
lea    (%rcx,%rcx,2),%ecx
shl    $0x2,%ecx
add    0xc(%rsp),%ecx
add    $0xc,%cl
movslq %ebx,%rbx
mov    %cl,0x3(%r13,%rbx,2)
movzbl 0x8(%rsp),%ecx
mov    %cl,0x4(%r13,%rbx,2)
add    $0x1,%ebx
jmp    1170 <roi_song+0x40>
addl   $0x1,0x4(%rsp)
movzbl 0x1(%rax),%ecx
add    $0x1,%rax
cmp    $0x3c,%cl
jne    118d <roi_song+0x5d>
addl   $0xffffffff,0x4(%rsp)
movzbl 0x1(%rax),%ecx
add    $0x1,%rax
cmp    $0x4f,%cl
jne    1196 <roi_song+0x66>
mov    %rax,%rdi
mov    %r14,%rsi
call   1050 <scan_octave@plt>
movzbl (%rax),%ecx
cmp    $0x52,%cl
je     119b <roi_song+0x6b>
jmp    11bf <roi_song+0x8f>
mov    %bl,0x2(%r13)
lea    (%rbx,%rbx,1),%eax
add    $0x3,%eax
add    $0x10,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
ret

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

LLVM IR (-O2):
define i32 @roi_song(i8* nocapture writeonly %0, i8 zeroext %1, i8* %2) {
%4 = alloca i32
%5 = alloca i32
%6 = alloca i32
%7 = bitcast i32* %4 to i8*
%8 = bitcast i32* %5 to i8*
store i32 4, i32* %5
%9 = bitcast i32* %6 to i8*
store i8 -116, i8* %0
%10 = getelementptr inbounds i8, i8* %0, i64 1
store i8 %1, i8* %10
br label %11
11: ; preds = %59, %3
%12 = phi i32 [ 0, %3 ], [ %60, %59 ]
%13 = phi i8* [ %2, %3 ], [ %61, %59 ]
%14 = load i8, i8* %13
switch i8 %14, label %20 [
i8 0, label %80
i8 62, label %15
]
15: ; preds = %11
%16 = load i32, i32* %5
%17 = add nsw i32 %16, 1
store i32 %17, i32* %5
%18 = getelementptr inbounds i8, i8* %13, i64 1
%19 = load i8, i8* %18
br label %20
20: ; preds = %11, %15
%21 = phi i8 [ %14, %11 ], [ %19, %15 ]
%22 = phi i8* [ %13, %11 ], [ %18, %15 ]
%23 = icmp eq i8 %21, 60
br i1 %23, label %24, label %29
24: ; preds = %20
%25 = load i32, i32* %5
%26 = add nsw i32 %25, -1
store i32 %26, i32* %5
%27 = getelementptr inbounds i8, i8* %22, i64 1
%28 = load i8, i8* %27
br label %29
29: ; preds = %24, %20
%30 = phi i8 [ %28, %24 ], [ %21, %20 ]
%31 = phi i8* [ %27, %24 ], [ %22, %20 ]
%32 = icmp eq i8 %30, 79
br i1 %32, label %33, label %36
33: ; preds = %29
%34 = call i8* @scan_octave(i8* %31, i32* %5)
%35 = load i8, i8* %34
br label %36
36: ; preds = %33, %29
%37 = phi i8 [ %35, %33 ], [ %30, %29 ]
%38 = phi i8* [ %34, %33 ], [ %31, %29 ]
%39 = icmp eq i8 %37, 82
br i1 %39, label %40, label %53
40: ; preds = %36
%41 = call i8* @scan_rest(i8* %38, i32* %6)
%42 = shl nsw i32 %12, 1
%43 = add nsw i32 %42, 3
%44 = sext i32 %43 to i64
%45 = getelementptr inbounds i8, i8* %0, i64 %44
store i8 0, i8* %45
%46 = load i32, i32* %6
%47 = trunc i32 %46 to i8
%48 = add nsw i32 %42, 4
%49 = sext i32 %48 to i64
%50 = getelementptr inbounds i8, i8* %0, i64 %49
store i8 %47, i8* %50
%51 = add nsw i32 %12, 1
%52 = load i8, i8* %41
br label %53
53: ; preds = %40, %36
%54 = phi i8 [ %52, %40 ], [ %37, %36 ]
%55 = phi i32 [ %51, %40 ], [ %12, %36 ]
%56 = phi i8* [ %41, %40 ], [ %38, %36 ]
%57 = add i8 %54, -65
%58 = icmp ult i8 %57, 7
br i1 %58, label %62, label %59
59: ; preds = %53, %62
%60 = phi i32 [ %79, %62 ], [ %55, %53 ]
%61 = phi i8* [ %63, %62 ], [ %56, %53 ]
br label %11
62: ; preds = %53
%63 = call i8* @scan_note(i8* %56, i32* %4, i32* %6)
%64 = load i32, i32* %4
%65 = load i32, i32* %5
%66 = mul i32 %65, 12
%67 = add i32 %64, 12
%68 = add i32 %67, %66
%69 = trunc i32 %68 to i8
%70 = shl nsw i32 %55, 1
%71 = add nsw i32 %70, 3
%72 = sext i32 %71 to i64
%73 = getelementptr inbounds i8, i8* %0, i64 %72
store i8 %69, i8* %73
%74 = load i32, i32* %6
%75 = trunc i32 %74 to i8
%76 = add nsw i32 %70, 4
%77 = sext i32 %76 to i64
%78 = getelementptr inbounds i8, i8* %0, i64 %77
store i8 %75, i8* %78
%79 = add nsw i32 %55, 1
br label %59
80: ; preds = %11
%81 = trunc i32 %12 to i8
%82 = getelementptr inbounds i8, i8* %0, i64 2
store i8 %81, i8* %82
%83 = shl nsw i32 %12, 1
%84 = add nsw i32 %83, 3
ret i32 %84
}