#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 *, ...);
int main() {
  int l, r, k, sz, n, range, i;
  char s[10005], ch[10005];
  scanf("%s", s + 1);
  scanf("%d", &n);
  while (n--) {
    scanf("%d%d%d", &l, &r, &k);
    range = r - l + 1;
    k = k % range;
    for (i = r; i > r - k; i--)
      ch[r - i] = s[i];
    for (i = 0; i < range - k; i++)
      s[r - i] = s[r - k - i];
    for (i = 0; i < k; i++)
      s[l + i] = ch[k - i - 1];
  }
  printf("%s\n", s + 1);
  return 0;
}


x86 assembly (clang, -O0):
<main>:
push   %rbp
mov    %rsp,%rbp
sub    $0x4e60,%rsp
movl   $0x0,-0x4(%rbp)
lea    -0x2740(%rbp),%rsi
add    $0x1,%rsi
lea    0xebc(%rip),%rdi
mov    $0x0,%al
call   1040 <scanf@plt>
lea    0xeb5(%rip),%rdi
lea    -0x18(%rbp),%rsi
mov    $0x0,%al
call   1040 <scanf@plt>
mov    -0x18(%rbp),%eax
mov    %eax,%ecx
add    $0xffffffff,%ecx
mov    %ecx,-0x18(%rbp)
cmp    $0x0,%eax
je     126e <main+0x14e>
lea    0xe8b(%rip),%rdi
lea    -0x8(%rbp),%rsi
lea    -0xc(%rbp),%rdx
lea    -0x10(%rbp),%rcx
mov    $0x0,%al
call   1040 <scanf@plt>
mov    -0xc(%rbp),%eax
sub    -0x8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
mov    -0x10(%rbp),%eax
cltd
idivl  -0x1c(%rbp)
mov    %edx,-0x10(%rbp)
mov    -0xc(%rbp),%eax
mov    %eax,-0x20(%rbp)
mov    -0x20(%rbp),%eax
mov    -0xc(%rbp),%ecx
sub    -0x10(%rbp),%ecx
cmp    %ecx,%eax
jle    11e0 <main+0xc0>
movslq -0x20(%rbp),%rax
mov    -0x2740(%rbp,%rax,1),%cl
mov    -0xc(%rbp),%eax
sub    -0x20(%rbp),%eax
cltq
mov    %cl,-0x4e60(%rbp,%rax,1)
mov    -0x20(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x20(%rbp)
jmp    11a7 <main+0x87>
movl   $0x0,-0x20(%rbp)
mov    -0x20(%rbp),%eax
mov    -0x1c(%rbp),%ecx
sub    -0x10(%rbp),%ecx
cmp    %ecx,%eax
jge    1227 <main+0x107>
mov    -0xc(%rbp),%eax
sub    -0x10(%rbp),%eax
sub    -0x20(%rbp),%eax
cltq
mov    -0x2740(%rbp,%rax,1),%cl
mov    -0xc(%rbp),%eax
sub    -0x20(%rbp),%eax
cltq
mov    %cl,-0x2740(%rbp,%rax,1)
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    11e7 <main+0xc7>
movl   $0x0,-0x20(%rbp)
mov    -0x20(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    1269 <main+0x149>
mov    -0x10(%rbp),%eax
sub    -0x20(%rbp),%eax
sub    $0x1,%eax
cltq
mov    -0x4e60(%rbp,%rax,1),%cl
mov    -0x8(%rbp),%eax
add    -0x20(%rbp),%eax
cltq
mov    %cl,-0x2740(%rbp,%rax,1)
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    122e <main+0x10e>
jmp    115d <main+0x3d>
lea    -0x2740(%rbp),%rsi
add    $0x1,%rsi
lea    0xd8a(%rip),%rdi
call   1030 <printf@plt>
xor    %eax,%eax
add    $0x4e60,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<main>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x4e48,%rsp
lea    0x11(%rsp),%r15
lea    0xec3(%rip),%rdi
mov    %r15,%rsi
xor    %eax,%eax
call   1040 <scanf@plt>
lea    0xeb9(%rip),%rdi
mov    %rsp,%rsi
xor    %eax,%eax
call   1040 <scanf@plt>
subl   $0x1,(%rsp)
jae    1181 <main+0x61>
lea    0xea5(%rip),%rdi
mov    %r15,%rsi
call   1030 <printf@plt>
xor    %eax,%eax
add    $0x4e48,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
lea    0x4(%rsp),%r14
jmp    1196 <main+0x76>
nopl   0x0(%rax,%rax,1)
subl   $0x1,(%rsp)
jb     115e <main+0x3e>
lea    0xe66(%rip),%rdi
lea    0xc(%rsp),%rsi
lea    0x8(%rsp),%rdx
mov    %r14,%rcx
xor    %eax,%eax
call   1040 <scanf@plt>
pxor   %xmm3,%xmm3
movslq 0x8(%rsp),%r8
movslq 0xc(%rsp),%r10
mov    %r8d,%r12d
sub    %r10d,%r12d
add    $0x1,%r12d
mov    0x4(%rsp),%eax
cltd
idiv   %r12d
mov    %edx,0x4(%rsp)
test   %edx,%edx
jle    1374 <main+0x254>
mov    %r8d,%eax
sub    %edx,%eax
movslq %eax,%r13
lea    -0x1(%r8),%r9
cmp    %r9,%r13
mov    %r9,%rcx
cmovl  %r13,%rcx
mov    %r8,%r11
sub    %rcx,%r11
mov    %r8,%rbx
cmp    $0x8,%r11
jb     1350 <main+0x230>
cmp    $0x20,%r11
jae    1213 <main+0xf3>
xor    %esi,%esi
jmp    12d1 <main+0x1b1>
mov    %r15,%rax
mov    %r11,%rsi
and    $0xffffffffffffffe0,%rsi
mov    %rsi,%rbp
neg    %rbp
lea    0x1(%rsp),%rcx
lea    (%rcx,%r8,1),%rbx
xor    %ecx,%ecx
lea    0x2740(%rsp),%r15
cs nopw 0x0(%rax,%rax,1)
movdqu -0x10(%rbx,%rcx,1),%xmm0
movdqu (%rbx,%rcx,1),%xmm1
movdqa %xmm1,%xmm2
punpcklbw %xmm3,%xmm2
pshufd $0x4e,%xmm2,%xmm2
pshuflw $0x1b,%xmm2,%xmm2
pshufhw $0x1b,%xmm2,%xmm2
punpckhbw %xmm3,%xmm1
pshufd $0x4e,%xmm1,%xmm1
pshuflw $0x1b,%xmm1,%xmm1
pshufhw $0x1b,%xmm1,%xmm1
packuswb %xmm2,%xmm1
movdqa %xmm0,%xmm2
punpcklbw %xmm3,%xmm2
pshufd $0x4e,%xmm2,%xmm2
pshuflw $0x1b,%xmm2,%xmm2
pshufhw $0x1b,%xmm2,%xmm2
punpckhbw %xmm3,%xmm0
pshufd $0x4e,%xmm0,%xmm0
pshuflw $0x1b,%xmm0,%xmm0
pshufhw $0x1b,%xmm0,%xmm0
packuswb %xmm2,%xmm0
movdqa %xmm1,-0x10(%r15)
movdqa %xmm0,(%r15)
add    $0x20,%r15
add    $0xffffffffffffffe0,%rcx
cmp    %rcx,%rbp
jne    1240 <main+0x120>
cmp    %rsi,%r11
mov    %rax,%r15
je     1374 <main+0x254>
test   $0x18,%r11b
je     1345 <main+0x225>
cmp    %r9,%r13
cmovl  %r13,%r9
mov    %r8,%r11
sub    %r9,%r11
mov    %r11,%r9
and    $0xfffffffffffffff8,%r9
mov    %r8,%rbx
sub    %r9,%rbx
lea    (%rsp,%rsi,1),%rbp
add    $0x2730,%rbp
mov    %r8,%rcx
sub    %rsi,%rcx
sub    %r9,%rsi
lea    0x9(%rsp),%rax
add    %rax,%rcx
xor    %edi,%edi
nopl   0x0(%rax)
movq   (%rcx,%rdi,1),%xmm0
punpcklbw %xmm3,%xmm0
pshufd $0x4e,%xmm0,%xmm0
pshuflw $0x1b,%xmm0,%xmm0
pshufhw $0x1b,%xmm0,%xmm0
packuswb %xmm0,%xmm0
movq   %xmm0,0x0(%rbp)
add    $0x8,%rbp
add    $0xfffffffffffffff8,%rdi
cmp    %rdi,%rsi
jne    1310 <main+0x1f0>
cmp    %r9,%r11
jne    1350 <main+0x230>
jmp    1374 <main+0x254>
mov    %r8,%rbx
sub    %rsi,%rbx
nopl   0x0(%rax,%rax,1)
mov    %r8,%rcx
sub    %rbx,%rcx
add    %rsp,%rcx
add    $0x2730,%rcx
movzbl 0x10(%rsp,%rbx,1),%eax
mov    %al,(%rcx)
add    $0xffffffffffffffff,%rbx
add    $0x1,%rcx
cmp    %r13,%rbx
jg     1360 <main+0x240>
sub    %edx,%r12d
test   %r12d,%r12d
jle    1407 <main+0x2e7>
mov    %r12d,%eax
cmp    $0x8,%r12d
jae    14a0 <main+0x380>
xor    %r11d,%r11d
mov    %r11,%rsi
test   $0x1,%al
je     13b7 <main+0x297>
mov    %r8d,%esi
sub    %edx,%esi
sub    %r11d,%esi
movslq %esi,%rcx
mov    0x10(%rsp,%rcx,1),%cl
mov    %r8,%rsi
sub    %r11,%rsi
mov    %cl,0x10(%rsp,%rsi,1)
mov    %r11,%rsi
or     $0x1,%rsi
not    %r11
neg    %rax
cmp    %rax,%r11
je     1407 <main+0x2e7>
mov    %rsi,%rcx
neg    %rcx
mov    %r8d,%edi
sub    %edx,%edi
sub    %esi,%edi
lea    (%rsp,%r8,1),%rbp
add    $0x10,%rbp
sub    %edx,%r8d
not    %esi
add    %r8d,%esi
nop
movslq %edi,%rdi
movzbl 0x10(%rsp,%rdi,1),%ebx
mov    %bl,0x0(%rbp,%rcx,1)
movslq %esi,%rsi
movzbl 0x10(%rsp,%rsi,1),%ebx
mov    %bl,-0x1(%rbp,%rcx,1)
add    $0xfffffffffffffffe,%rcx
add    $0xfffffffe,%edi
add    $0xfffffffe,%esi
cmp    %rcx,%rax
jne    13e0 <main+0x2c0>
test   %edx,%edx
jle    1190 <main+0x70>
mov    %edx,%ebx
cmp    $0x8,%edx
jae    1590 <main+0x470>
xor    %eax,%eax
mov    %rax,%rsi
test   $0x1,%bl
je     1443 <main+0x323>
mov    %eax,%ecx
not    %ecx
add    %edx,%ecx
movslq %ecx,%rcx
mov    0x2730(%rsp,%rcx,1),%cl
lea    (%rax,%r10,1),%rsi
mov    %cl,0x10(%rsp,%rsi,1)
mov    %rax,%rsi
or     $0x1,%rsi
not    %rax
add    %rbx,%rax
je     1190 <main+0x70>
sub    %rsi,%rbx
mov    %esi,%ecx
not    %ecx
add    %edx,%ecx
add    %rsi,%r10
add    %r15,%r10
xor    %eax,%eax
movslq %ecx,%rcx
movzbl 0x2730(%rsp,%rcx,1),%edx
mov    %dl,-0x1(%r10,%rax,1)
lea    -0x1(%rcx),%edx
movslq %edx,%rdx
movzbl 0x2730(%rsp,%rdx,1),%edx
mov    %dl,(%r10,%rax,1)
add    $0x2,%rax
add    $0xfffffffe,%ecx
cmp    %rax,%rbx
jne    1460 <main+0x340>
jmp    1190 <main+0x70>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
lea    -0x1(%rax),%rcx
mov    %r8d,%esi
sub    %edx,%esi
mov    %esi,%edi
sub    %ecx,%edi
cmp    %esi,%edi
jg     138d <main+0x26d>
shr    $0x20,%rcx
jne    138d <main+0x26d>
lea    (%rsp,%r8,1),%rdi
add    $0x10,%rdi
mov    $0x1,%ecx
sub    %rax,%rcx
lea    (%rdi,%rcx,1),%rbp
cmp    %rdi,%rbp
ja     138d <main+0x26d>
movslq %esi,%rdi
add    %rsp,%rdi
add    $0x10,%rdi
add    %rdi,%rcx
mov    $0x0,%r11d
cmp    %rdi,%rcx
ja     1390 <main+0x270>
mov    %r8,%rdi
sub    %rax,%rdi
add    %r15,%rdi
mov    %r8d,%ecx
sub    %edx,%ecx
movslq %ecx,%rcx
lea    (%r15,%rcx,1),%rbp
cmp    %rbp,%rdi
jae    1525 <main+0x405>
lea    (%r15,%r8,1),%rdi
sub    %rax,%rcx
add    %r15,%rcx
cmp    %rdi,%rcx
jb     138d <main+0x26d>
cmp    $0x10,%r12d
jae    16d2 <main+0x5b2>
xor    %r11d,%r11d
mov    %r8,%rcx
sub    %r11,%rcx
mov    %r11,%rsi
add    %edx,%r11d
mov    %r8d,%edi
sub    %r11d,%edi
mov    %eax,%r11d
and    $0xfffffff8,%r11d
lea    0x9(%rsp),%rbp
add    %rbp,%rcx
sub    %r11,%rsi
xor    %ebx,%ebx
nopl   0x0(%rax,%rax,1)
lea    (%rdi,%rbx,1),%ebp
movslq %ebp,%rbp
mov    0x9(%rsp,%rbp,1),%rbp
mov    %rbp,(%rcx,%rbx,1)
add    $0xfffffffffffffff8,%rbx
cmp    %rbx,%rsi
jne    1560 <main+0x440>
cmp    %rax,%r11
jne    1390 <main+0x270>
jmp    1407 <main+0x2e7>
cs nopw 0x0(%rax,%rax,1)
lea    -0x1(%rbx),%rax
lea    -0x1(%rdx),%edi
mov    %edi,%ecx
sub    %eax,%ecx
cmp    %edi,%ecx
jg     141a <main+0x2fa>
shr    $0x20,%rax
mov    $0x0,%eax
jne    141c <main+0x2fc>
cmp    $0x20,%edx
jae    15be <main+0x49e>
xor    %eax,%eax
jmp    166e <main+0x54e>
mov    %ebx,%eax
and    $0xffffffe0,%eax
lea    0x20(%rsp),%rcx
add    %r10,%rcx
xor    %ebp,%ebp
nopl   (%rax)
movslq %edi,%rdi
movdqu 0x2711(%rsp,%rdi,1),%xmm0
movdqu 0x2721(%rsp,%rdi,1),%xmm1
movdqa %xmm1,%xmm2
punpcklbw %xmm3,%xmm2
pshufd $0x4e,%xmm2,%xmm2
pshuflw $0x1b,%xmm2,%xmm2
pshufhw $0x1b,%xmm2,%xmm2
punpckhbw %xmm3,%xmm1
pshufd $0x4e,%xmm1,%xmm1
pshuflw $0x1b,%xmm1,%xmm1
pshufhw $0x1b,%xmm1,%xmm1
packuswb %xmm2,%xmm1
movdqa %xmm0,%xmm2
punpcklbw %xmm3,%xmm2
pshufd $0x4e,%xmm2,%xmm2
pshuflw $0x1b,%xmm2,%xmm2
pshufhw $0x1b,%xmm2,%xmm2
punpckhbw %xmm3,%xmm0
pshufd $0x4e,%xmm0,%xmm0
pshuflw $0x1b,%xmm0,%xmm0
pshufhw $0x1b,%xmm0,%xmm0
packuswb %xmm2,%xmm0
movdqu %xmm1,-0x10(%rcx,%rbp,1)
movdqu %xmm0,(%rcx,%rbp,1)
add    $0x20,%rbp
add    $0xffffffe0,%edi
cmp    %rbp,%rax
jne    15d0 <main+0x4b0>
cmp    %rbx,%rax
je     1190 <main+0x70>
test   $0x18,%bl
je     141c <main+0x2fc>
mov    %rax,%rsi
mov    %ebx,%eax
and    $0xfffffff8,%eax
lea    (%rsp,%r10,1),%rdi
add    $0x10,%rdi
mov    %esi,%ecx
not    %ecx
add    %edx,%ecx
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movslq %ecx,%rcx
movq   0x2729(%rsp,%rcx,1),%xmm0
punpcklbw %xmm3,%xmm0
pshufd $0x4e,%xmm0,%xmm0
pshuflw $0x1b,%xmm0,%xmm0
pshufhw $0x1b,%xmm0,%xmm0
packuswb %xmm0,%xmm0
movq   %xmm0,(%rdi,%rsi,1)
add    $0x8,%rsi
add    $0xfffffff8,%ecx
cmp    %rsi,%rax
jne    1690 <main+0x570>
cmp    %rbx,%rax
je     1190 <main+0x70>
jmp    141c <main+0x2fc>
mov    %eax,%r11d
and    $0xfffffff0,%r11d
lea    -0x10(%r11),%rcx
mov    %rcx,%r9
shr    $0x4,%r9
add    $0x1,%r9
test   %rcx,%rcx
je     1766 <main+0x646>
mov    %r9,%rcx
and    $0xfffffffffffffffe,%rcx
lea    0x1(%rsp),%rdi
add    %r8,%rdi
xor    %ebx,%ebx
xchg   %ax,%ax
movslq %esi,%rsi
movups 0x1(%rsp,%rsi,1),%xmm0
movups %xmm0,(%rdi,%rbx,1)
lea    -0x10(%rsi),%ebp
movslq %ebp,%rbp
movdqu 0x1(%rsp,%rbp,1),%xmm0
movdqu %xmm0,-0x10(%rdi,%rbx,1)
add    $0xffffffe0,%esi
add    $0xffffffffffffffe0,%rbx
add    $0xfffffffffffffffe,%rcx
jne    1700 <main+0x5e0>
neg    %rbx
test   $0x1,%r9b
je     1750 <main+0x630>
mov    %r8d,%esi
sub    %edx,%esi
sub    %ebx,%esi
movslq %esi,%rcx
movdqu 0x1(%rsp,%rcx,1),%xmm0
mov    %r8,%rcx
sub    %rbx,%rcx
movdqu %xmm0,0x1(%rsp,%rcx,1)
cmp    %rax,%r11
je     1407 <main+0x2e7>
test   $0x8,%al
je     1390 <main+0x270>
jmp    1532 <main+0x412>
xor    %ebx,%ebx
test   $0x1,%r9b
jne    1734 <main+0x614>
jmp    1750 <main+0x630>

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

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