#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 *);
void helper(char *s, char *t, int *returnSize) {
  int len = strlen(s);
  if (!len)
    return;
  int count[26] = {0};
  int index = 0;
  for (int i = 0; i < len; i++)
    count[s[i] - 'a']++;
  for (int i = 0; i < len; i++) {
    if (s[i] < s[index])
      index = i;
    if (!(--count[s[i] - 'a']))
      break;
  }
  char c = s[index];
  *returnSize += 1;
  t[*returnSize - 1] = c;
  int newIndex = 0;
  for (int i = index + 1; i < len; i++)
    if (s[i] != c)
      s[newIndex++] = s[i];
  s[newIndex] = '\0';
  helper(s, t, returnSize);
}


x86 assembly (clang, -O0):
<helper>:
push   %rbp
mov    %rsp,%rbp
sub    $0xb0,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    -0x8(%rbp),%rdi
call   1030 <strlen@plt>
mov    %eax,-0x1c(%rbp)
cmpl   $0x0,-0x1c(%rbp)
jne    1162 <helper+0x32>
jmp    1349 <helper+0x219>
lea    -0x90(%rbp),%rdi
xor    %esi,%esi
mov    $0x68,%edx
call   1040 <memset@plt>
movl   $0x0,-0x94(%rbp)
movl   $0x0,-0x98(%rbp)
mov    -0x98(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    11d1 <helper+0xa1>
mov    -0x8(%rbp),%rax
movslq -0x98(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
sub    $0x61,%eax
cltq
mov    -0x90(%rbp,%rax,4),%ecx
add    $0x1,%ecx
mov    %ecx,-0x90(%rbp,%rax,4)
mov    -0x98(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x98(%rbp)
jmp    1189 <helper+0x59>
movl   $0x0,-0x9c(%rbp)
mov    -0x9c(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    1269 <helper+0x139>
mov    -0x8(%rbp),%rax
movslq -0x9c(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
mov    -0x8(%rbp),%rcx
movslq -0x94(%rbp),%rdx
movsbl (%rcx,%rdx,1),%ecx
cmp    %ecx,%eax
jge    121c <helper+0xec>
mov    -0x9c(%rbp),%eax
mov    %eax,-0x94(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x9c(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
sub    $0x61,%eax
movslq %eax,%rcx
mov    -0x90(%rbp,%rcx,4),%eax
add    $0xffffffff,%eax
mov    %eax,-0x90(%rbp,%rcx,4)
cmp    $0x0,%eax
jne    1250 <helper+0x120>
jmp    1269 <helper+0x139>
jmp    1255 <helper+0x125>
mov    -0x9c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9c(%rbp)
jmp    11db <helper+0xab>
mov    -0x8(%rbp),%rax
movslq -0x94(%rbp),%rcx
mov    (%rax,%rcx,1),%al
mov    %al,-0x9d(%rbp)
mov    -0x18(%rbp),%rax
mov    (%rax),%ecx
add    $0x1,%ecx
mov    %ecx,(%rax)
mov    -0x9d(%rbp),%dl
mov    -0x10(%rbp),%rax
mov    -0x18(%rbp),%rcx
mov    (%rcx),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
movl   $0x0,-0xa4(%rbp)
mov    -0x94(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xa8(%rbp)
mov    -0xa8(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    1329 <helper+0x1f9>
mov    -0x8(%rbp),%rax
movslq -0xa8(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
movsbl -0x9d(%rbp),%ecx
cmp    %ecx,%eax
je     1310 <helper+0x1e0>
mov    -0x8(%rbp),%rax
movslq -0xa8(%rbp),%rcx
mov    (%rax,%rcx,1),%dl
mov    -0x8(%rbp),%rax
mov    -0xa4(%rbp),%ecx
mov    %ecx,%esi
add    $0x1,%esi
mov    %esi,-0xa4(%rbp)
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
jmp    1315 <helper+0x1e5>
mov    -0xa8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xa8(%rbp)
jmp    12ba <helper+0x18a>
mov    -0x8(%rbp),%rax
movslq -0xa4(%rbp),%rcx
movb   $0x0,(%rax,%rcx,1)
mov    -0x8(%rbp),%rdi
mov    -0x10(%rbp),%rsi
mov    -0x18(%rbp),%rdx
call   1050 <helper@plt>
add    $0xb0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<helper>:
push   %r15
push   %r14
push   %r12
push   %rbx
sub    $0x68,%rsp
mov    %rdx,%r15
mov    %rsi,%r14
mov    %rdi,%r12
jmp    113b <helper+0x2b>
cs nopw 0x0(%rax,%rax,1)
movslq %edx,%rax
movb   $0x0,(%r12,%rax,1)
mov    %r12,%rdi
call   1030 <strlen@plt>
test   %eax,%eax
je     12c4 <helper+0x1b4>
xorps  %xmm0,%xmm0
movaps %xmm0,0x50(%rsp)
movaps %xmm0,0x40(%rsp)
movaps %xmm0,0x30(%rsp)
movaps %xmm0,0x20(%rsp)
movaps %xmm0,0x10(%rsp)
movaps %xmm0,(%rsp)
movq   $0x0,0x60(%rsp)
mov    $0x0,%edi
test   %eax,%eax
jle    1220 <helper+0x110>
mov    %eax,%r8d
cmp    $0x1,%eax
jne    1190 <helper+0x80>
xor    %edx,%edx
jmp    11c4 <helper+0xb4>
nopw   0x0(%rax,%rax,1)
mov    %r8d,%esi
and    $0xfffffffe,%esi
xor    %edx,%edx
nopl   0x0(%rax,%rax,1)
movsbq (%r12,%rdx,1),%rcx
addl   $0x1,-0x184(%rsp,%rcx,4)
01
movsbq 0x1(%r12,%rdx,1),%rcx
addl   $0x1,-0x184(%rsp,%rcx,4)
01
add    $0x2,%rdx
cmp    %rdx,%rsi
jne    11a0 <helper+0x90>
test   $0x1,%r8b
je     11d7 <helper+0xc7>
movsbq (%r12,%rdx,1),%rcx
addl   $0x1,-0x184(%rsp,%rcx,4)
01
mov    $0x0,%edi
test   %eax,%eax
jle    1220 <helper+0x110>
xor    %edx,%edx
xor    %esi,%esi
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movsbq (%r12,%rdx,1),%rcx
movslq %esi,%rbx
mov    %edx,%edi
cmp    (%r12,%rbx,1),%cl
jl     1202 <helper+0xf2>
mov    %esi,%edi
addl   $0xffffffff,-0x184(%rsp,%rcx,4)
ff
je     1220 <helper+0x110>
add    $0x1,%rdx
mov    %edi,%esi
cmp    %r8,%rdx
jb     11f0 <helper+0xe0>
nopw   0x0(%rax,%rax,1)
movslq %edi,%rsi
mov    (%r12,%rsi,1),%r9b
movslq (%r15),%rcx
lea    0x1(%rcx),%edx
mov    %edx,(%r15)
mov    %r9b,(%r14,%rcx,1)
add    $0x1,%esi
xor    %edx,%edx
cmp    %eax,%esi
jge    1130 <helper+0x20>
movslq %esi,%rsi
mov    %edi,%r8d
not    %r8d
add    %eax,%r8d
add    $0xfffffffe,%eax
xor    %edx,%edx
cmp    %edi,%eax
jne    1280 <helper+0x170>
test   $0x1,%r8b
je     1130 <helper+0x20>
mov    (%r12,%rsi,1),%al
cmp    %r9b,%al
je     1130 <helper+0x20>
movslq %edx,%rcx
add    $0x1,%edx
mov    %al,(%r12,%rcx,1)
jmp    1130 <helper+0x20>
nopl   0x0(%rax)
mov    %r8d,%eax
and    $0xfffffffe,%eax
xor    %edx,%edx
jmp    1299 <helper+0x189>
nopw   0x0(%rax,%rax,1)
add    $0x2,%rsi
add    $0xfffffffe,%eax
je     1256 <helper+0x146>
movzbl (%r12,%rsi,1),%ecx
cmp    %r9b,%cl
je     12ad <helper+0x19d>
movslq %edx,%rdi
add    $0x1,%edx
mov    %cl,(%r12,%rdi,1)
movzbl 0x1(%r12,%rsi,1),%ecx
cmp    %r9b,%cl
je     1290 <helper+0x180>
movslq %edx,%rdi
add    $0x1,%edx
mov    %cl,(%r12,%rdi,1)
jmp    1290 <helper+0x180>
add    $0x68,%rsp
pop    %rbx
pop    %r12
pop    %r14
pop    %r15
ret

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

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