#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 */
void *malloc(int);
int strlen(char *);
int numDistinct(char *s, char *t) {
  int s_len = strlen(s);
  int t_len = strlen(t);
  if (t_len == 0 || s_len < t_len) {
    return 0;
  }
  int start = 0;
  while (start < s_len && s[start] != t[0]) {
    start++;
  }
  if (start == s_len) {
    return 0;
  }
  int i, j;
  int *table = malloc((s_len - start) * t_len * sizeof(int));
  int **dp = malloc((s_len - start) * sizeof(int *));
  for (i = 0; i < s_len - start; i++) {
    dp[i] = &table[i * t_len];
  }
  dp[0][0] = 1;
  for (i = 1; i < t_len; i++) {
    dp[0][i] = 0;
  }
  for (i = 1; i < s_len - start; i++) {
    dp[i][0] = dp[i - 1][0];
    if (s[start + i] == t[0]) {
      dp[i][0]++;
    }
  }
  for (i = 1; i < s_len - start; i++) {
    for (j = 1; j < t_len; j++) {
      dp[i][j] = dp[i - 1][j];
      if (s[start + i] == t[j]) {
        dp[i][j] += dp[i - 1][j - 1];
      }
    }
  }
  return dp[s_len - start - 1][t_len - 1];
}


x86 assembly (clang, -O0):
<numDistinct>:
push   %rbp
mov    %rsp,%rbp
sub    $0x50,%rsp
mov    %rdi,-0x10(%rbp)
mov    %rsi,-0x18(%rbp)
mov    -0x10(%rbp),%rdi
call   1030 <strlen@plt>
mov    %eax,-0x1c(%rbp)
mov    -0x18(%rbp),%rdi
call   1030 <strlen@plt>
mov    %eax,-0x20(%rbp)
cmpl   $0x0,-0x20(%rbp)
je     115e <numDistinct+0x3e>
mov    -0x1c(%rbp),%eax
cmp    -0x20(%rbp),%eax
jge    116a <numDistinct+0x4a>
movl   $0x0,-0x4(%rbp)
jmp    1401 <numDistinct+0x2e1>
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%ecx
xor    %eax,%eax
cmp    -0x1c(%rbp),%ecx
mov    %al,-0x41(%rbp)
jge    119d <numDistinct+0x7d>
mov    -0x10(%rbp),%rax
movslq -0x24(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
mov    -0x18(%rbp),%rcx
movsbl (%rcx),%ecx
cmp    %ecx,%eax
setne  %al
mov    %al,-0x41(%rbp)
mov    -0x41(%rbp),%al
test   $0x1,%al
jne    11ad <numDistinct+0x8d>
jmp    11bb <numDistinct+0x9b>
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    1171 <numDistinct+0x51>
mov    -0x24(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jne    11d3 <numDistinct+0xb3>
movl   $0x0,-0x4(%rbp)
jmp    1401 <numDistinct+0x2e1>
mov    -0x1c(%rbp),%eax
sub    -0x24(%rbp),%eax
imul   -0x20(%rbp),%eax
cltq
shl    $0x2,%rax
mov    %eax,%edi
call   1040 <malloc@plt>
mov    %rax,-0x38(%rbp)
mov    -0x1c(%rbp),%eax
sub    -0x24(%rbp),%eax
cltq
shl    $0x3,%rax
mov    %eax,%edi
call   1040 <malloc@plt>
mov    %rax,-0x40(%rbp)
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
mov    -0x1c(%rbp),%ecx
sub    -0x24(%rbp),%ecx
cmp    %ecx,%eax
jge    124b <numDistinct+0x12b>
mov    -0x38(%rbp),%rdx
mov    -0x28(%rbp),%eax
imul   -0x20(%rbp),%eax
cltq
shl    $0x2,%rax
add    %rax,%rdx
mov    -0x40(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    120c <numDistinct+0xec>
mov    -0x40(%rbp),%rax
mov    (%rax),%rax
movl   $0x1,(%rax)
movl   $0x1,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x20(%rbp),%eax
jge    128b <numDistinct+0x16b>
mov    -0x40(%rbp),%rax
mov    (%rax),%rax
movslq -0x28(%rbp),%rcx
movl   $0x0,(%rax,%rcx,4)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    125f <numDistinct+0x13f>
movl   $0x1,-0x28(%rbp)
mov    -0x28(%rbp),%eax
mov    -0x1c(%rbp),%ecx
sub    -0x24(%rbp),%ecx
cmp    %ecx,%eax
jge    130a <numDistinct+0x1ea>
mov    -0x40(%rbp),%rax
mov    -0x28(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
mov    (%rax),%ecx
mov    -0x40(%rbp),%rax
movslq -0x28(%rbp),%rdx
mov    (%rax,%rdx,8),%rax
mov    %ecx,(%rax)
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
add    -0x28(%rbp),%ecx
movslq %ecx,%rcx
movsbl (%rax,%rcx,1),%eax
mov    -0x18(%rbp),%rcx
movsbl (%rcx),%ecx
cmp    %ecx,%eax
jne    12f7 <numDistinct+0x1d7>
mov    -0x40(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    (%rax),%ecx
add    $0x1,%ecx
mov    %ecx,(%rax)
jmp    12fc <numDistinct+0x1dc>
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    1292 <numDistinct+0x172>
movl   $0x1,-0x28(%rbp)
mov    -0x28(%rbp),%eax
mov    -0x1c(%rbp),%ecx
sub    -0x24(%rbp),%ecx
cmp    %ecx,%eax
jge    13de <numDistinct+0x2be>
movl   $0x1,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x20(%rbp),%eax
jge    13cb <numDistinct+0x2ab>
mov    -0x40(%rbp),%rax
mov    -0x28(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x40(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x2c(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
add    -0x28(%rbp),%ecx
movslq %ecx,%rcx
movsbl (%rax,%rcx,1),%eax
mov    -0x18(%rbp),%rcx
movslq -0x2c(%rbp),%rdx
movsbl (%rcx,%rdx,1),%ecx
cmp    %ecx,%eax
jne    13b8 <numDistinct+0x298>
mov    -0x40(%rbp),%rax
mov    -0x28(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x40(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x2c(%rbp),%rcx
add    (%rax,%rcx,4),%edx
mov    %edx,(%rax,%rcx,4)
jmp    13bd <numDistinct+0x29d>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1329 <numDistinct+0x209>
jmp    13d0 <numDistinct+0x2b0>
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    1311 <numDistinct+0x1f1>
mov    -0x40(%rbp),%rax
mov    -0x1c(%rbp),%ecx
sub    -0x24(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x20(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x4(%rbp)
mov    -0x4(%rbp),%eax
add    $0x50,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<numDistinct>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x28,%rsp
mov    %rsi,%r14
mov    %rdi,%r12
call   1030 <strlen@plt>
mov    %eax,%ebx
mov    %r14,%rdi
call   1030 <strlen@plt>
mov    %eax,%esi
xor    %eax,%eax
test   %esi,%esi
je     1384 <numDistinct+0x254>
cmp    %esi,%ebx
jl     1384 <numDistinct+0x254>
xor    %eax,%eax
mov    $0x0,%r15d
test   %ebx,%ebx
jle    1196 <numDistinct+0x66>
mov    (%r14),%cl
mov    %ebx,%edx
xor    %r15d,%r15d
nopl   0x0(%rax,%rax,1)
cmp    %cl,(%r12,%r15,1)
je     1196 <numDistinct+0x66>
add    $0x1,%r15
cmp    %r15,%rdx
jne    1180 <numDistinct+0x50>
xor    %eax,%eax
jmp    1384 <numDistinct+0x254>
sub    %r15d,%ebx
je     1384 <numDistinct+0x254>
mov    %esi,%edi
imul   %ebx,%edi
shl    $0x2,%edi
mov    %rbx,0x8(%rsp)
mov    %rsi,%rbx
call   1050 <malloc@plt>
mov    %rax,%rbp
mov    0x8(%rsp),%rax
lea    0x0(,%rax,8),%edi
call   1050 <malloc@plt>
mov    %rbx,%rcx
mov    0x8(%rsp),%r11
mov    %rax,%r13
movslq %ecx,%rax
lea    -0x1(%r11),%rcx
mov    %r11d,%r8d
and    $0x3,%r8d
mov    %rcx,0x10(%rsp)
cmp    $0x3,%rcx
mov    %rax,0x18(%rsp)
mov    %rbp,0x20(%rsp)
jae    11fa <numDistinct+0xca>
xor    %ecx,%ecx
jmp    125c <numDistinct+0x12c>
mov    %r11d,%r10d
and    $0x7ffffffc,%r10d
lea    0x0(,%rax,8),%r9
mov    %rax,%rdi
shl    $0x4,%rdi
lea    0x0(,%rax,4),%rax
lea    (%rax,%rax,2),%rsi
xor    %ecx,%ecx
mov    %rbp,%rdx
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    %rdx,0x0(%r13,%rcx,8)
lea    (%rdx,%rax,1),%rbp
mov    %rbp,0x8(%r13,%rcx,8)
lea    (%rdx,%r9,1),%rbp
mov    %rbp,0x10(%r13,%rcx,8)
lea    (%rdx,%rsi,1),%rbp
mov    %rbp,0x18(%r13,%rcx,8)
add    $0x4,%rcx
add    %rdi,%rdx
cmp    %rcx,%r10
jne    1230 <numDistinct+0x100>
test   %r8,%r8
je     12a0 <numDistinct+0x170>
lea    0x0(,%rcx,8),%rax
add    %r13,%rax
mov    0x18(%rsp),%rdx
imul   %rdx,%rcx
mov    0x20(%rsp),%rsi
lea    (%rsi,%rcx,4),%rcx
lea    0x0(,%rdx,4),%rdx
xor    %esi,%esi
nopl   0x0(%rax,%rax,1)
mov    %rcx,(%rax,%rsi,8)
add    $0x1,%rsi
add    %rdx,%rcx
cmp    %rsi,%r8
jne    1290 <numDistinct+0x160>
mov    0x0(%r13),%rdi
movl   $0x1,(%rdi)
mov    %rbx,%r9
cmp    $0x2,%r9d
jl     12ce <numDistinct+0x19e>
add    $0x4,%rdi
lea    -0x1(%r9),%edx
shl    $0x2,%rdx
xor    %esi,%esi
call   1040 <memset@plt>
mov    %rbx,%r9
mov    0x8(%rsp),%r11
cmp    $0x2,%r11d
jl     1373 <numDistinct+0x243>
cmp    $0x2,%r11d
jne    1393 <numDistinct+0x263>
mov    $0x1,%ecx
mov    $0x1,%eax
mov    0x10(%rsp),%r8
test   $0x1,%r8b
je     130f <numDistinct+0x1df>
mov    0x0(%r13,%rcx,8),%rdx
mov    %eax,(%rdx)
add    %r15d,%ecx
mov    (%r12,%rcx,1),%cl
cmp    (%r14),%cl
jne    130f <numDistinct+0x1df>
add    $0x1,%eax
mov    %eax,(%rdx)
cmp    $0x2,%r11d
jl     1373 <numDistinct+0x243>
mov    %r9d,%eax
mov    $0x1,%r8d
jmp    1329 <numDistinct+0x1f9>
add    $0x1,%r8
cmp    %r11,%r8
je     1373 <numDistinct+0x243>
cmp    $0x2,%r9d
jl     1320 <numDistinct+0x1f0>
mov    -0x8(%r13,%r8,8),%rdx
mov    0x0(%r13,%r8,8),%rsi
lea    (%r15,%r8,1),%edi
mov    $0x1,%ebx
jmp    1359 <numDistinct+0x229>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
add    $0x1,%rbx
cmp    %rbx,%rax
je     1320 <numDistinct+0x1f0>
mov    (%rdx,%rbx,4),%ebp
mov    %ebp,(%rsi,%rbx,4)
movzbl (%r12,%rdi,1),%ecx
cmp    (%r14,%rbx,1),%cl
jne    1350 <numDistinct+0x220>
add    -0x4(%rdx,%rbx,4),%ebp
mov    %ebp,(%rsi,%rbx,4)
jmp    1350 <numDistinct+0x220>
movslq %r11d,%rax
mov    -0x8(%r13,%rax,8),%rax
mov    0x18(%rsp),%rcx
mov    -0x4(%rax,%rcx,4),%eax
add    $0x28,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
mov    %r15d,%edx
mov    0x10(%rsp),%r8
mov    %r8,%rsi
and    $0xfffffffffffffffe,%rsi
neg    %rsi
mov    $0x1,%ecx
mov    $0x1,%eax
jmp    13d6 <numDistinct+0x2a6>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
lea    (%rsi,%rcx,1),%rdi
add    $0x2,%rdi
add    $0x2,%rcx
cmp    $0x1,%rdi
je     12f1 <numDistinct+0x1c1>
mov    0x0(%r13,%rcx,8),%rdi
mov    %eax,(%rdi)
lea    (%rdx,%rcx,1),%ebp
movzbl (%r12,%rbp,1),%ebx
cmp    (%r14),%bl
jne    13ef <numDistinct+0x2bf>
add    $0x1,%eax
mov    %eax,(%rdi)
mov    0x8(%r13,%rcx,8),%rdi
mov    %eax,(%rdi)
lea    (%rdx,%rcx,1),%ebp
add    $0x1,%ebp
movzbl (%r12,%rbp,1),%ebx
cmp    (%r14),%bl
jne    13c0 <numDistinct+0x290>
add    $0x1,%eax
mov    %eax,(%rdi)
jmp    13c0 <numDistinct+0x290>

LLVM IR (-O0):
define i32 @numDistinct(i8* %0, i8* %1) {
%3 = alloca i32
%4 = alloca i8*
%5 = alloca i8*
%6 = alloca i32
%7 = alloca i32
%8 = alloca i32
%9 = alloca i32
%10 = alloca i32
%11 = alloca i32*
%12 = alloca i32**
store i8* %0, i8** %4
store i8* %1, i8** %5
%13 = load i8*, i8** %4
%14 = call i32 @strlen(i8* %13)
store i32 %14, i32* %6
%15 = load i8*, i8** %5
%16 = call i32 @strlen(i8* %15)
store i32 %16, i32* %7
%17 = load i32, i32* %7
%18 = icmp eq i32 %17, 0
br i1 %18, label %23, label %19
19: ; preds = %2
%20 = load i32, i32* %6
%21 = load i32, i32* %7
%22 = icmp slt i32 %20, %21
br i1 %22, label %23, label %24
23: ; preds = %19, %2
store i32 0, i32* %3
br label %247
24: ; preds = %19
store i32 0, i32* %8
br label %25
25: ; preds = %43, %24
%26 = load i32, i32* %8
%27 = load i32, i32* %6
%28 = icmp slt i32 %26, %27
br i1 %28, label %29, label %41
29: ; preds = %25
%30 = load i8*, i8** %4
%31 = load i32, i32* %8
%32 = sext i32 %31 to i64
%33 = getelementptr inbounds i8, i8* %30, i64 %32
%34 = load i8, i8* %33
%35 = sext i8 %34 to i32
%36 = load i8*, i8** %5
%37 = getelementptr inbounds i8, i8* %36, i64 0
%38 = load i8, i8* %37
%39 = sext i8 %38 to i32
%40 = icmp ne i32 %35, %39
br label %41
41: ; preds = %29, %25
%42 = phi i1 [ false, %25 ], [ %40, %29 ]
br i1 %42, label %43, label %46
43: ; preds = %41
%44 = load i32, i32* %8
%45 = add nsw i32 %44, 1
store i32 %45, i32* %8
br label %25
46: ; preds = %41
%47 = load i32, i32* %8
%48 = load i32, i32* %6
%49 = icmp eq i32 %47, %48
br i1 %49, label %50, label %51
50: ; preds = %46
store i32 0, i32* %3
br label %247
51: ; preds = %46
%52 = load i32, i32* %6
%53 = load i32, i32* %8
%54 = sub nsw i32 %52, %53
%55 = load i32, i32* %7
%56 = mul nsw i32 %54, %55
%57 = sext i32 %56 to i64
%58 = mul i64 %57, 4
%59 = trunc i64 %58 to i32
%60 = call i8* @malloc(i32 %59)
%61 = bitcast i8* %60 to i32*
store i32* %61, i32** %11
%62 = load i32, i32* %6
%63 = load i32, i32* %8
%64 = sub nsw i32 %62, %63
%65 = sext i32 %64 to i64
%66 = mul i64 %65, 8
%67 = trunc i64 %66 to i32
%68 = call i8* @malloc(i32 %67)
%69 = bitcast i8* %68 to i32**
store i32** %69, i32*** %12
store i32 0, i32* %9
br label %70
70: ; preds = %87, %51
%71 = load i32, i32* %9
%72 = load i32, i32* %6
%73 = load i32, i32* %8
%74 = sub nsw i32 %72, %73
%75 = icmp slt i32 %71, %74
br i1 %75, label %76, label %90
76: ; preds = %70
%77 = load i32*, i32** %11
%78 = load i32, i32* %9
%79 = load i32, i32* %7
%80 = mul nsw i32 %78, %79
%81 = sext i32 %80 to i64
%82 = getelementptr inbounds i32, i32* %77, i64 %81
%83 = load i32**, i32*** %12
%84 = load i32, i32* %9
%85 = sext i32 %84 to i64
%86 = getelementptr inbounds i32*, i32** %83, i64 %85
store i32* %82, i32** %86
br label %87
87: ; preds = %76
%88 = load i32, i32* %9
%89 = add nsw i32 %88, 1
store i32 %89, i32* %9
br label %70
90: ; preds = %70
%91 = load i32**, i32*** %12
%92 = getelementptr inbounds i32*, i32** %91, i64 0
%93 = load i32*, i32** %92
%94 = getelementptr inbounds i32, i32* %93, i64 0
store i32 1, i32* %94
store i32 1, i32* %9
br label %95
95: ; preds = %106, %90
%96 = load i32, i32* %9
%97 = load i32, i32* %7
%98 = icmp slt i32 %96, %97
br i1 %98, label %99, label %109
99: ; preds = %95
%100 = load i32**, i32*** %12
%101 = getelementptr inbounds i32*, i32** %100, i64 0
%102 = load i32*, i32** %101
%103 = load i32, i32* %9
%104 = sext i32 %103 to i64
%105 = getelementptr inbounds i32, i32* %102, i64 %104
store i32 0, i32* %105
br label %106
106: ; preds = %99
%107 = load i32, i32* %9
%108 = add nsw i32 %107, 1
store i32 %108, i32* %9
br label %95
109: ; preds = %95
store i32 1, i32* %9
br label %110
110: ; preds = %154, %109
%111 = load i32, i32* %9
%112 = load i32, i32* %6
%113 = load i32, i32* %8
%114 = sub nsw i32 %112, %113
%115 = icmp slt i32 %111, %114
br i1 %115, label %116, label %157
116: ; preds = %110
%117 = load i32**, i32*** %12
%118 = load i32, i32* %9
%119 = sub nsw i32 %118, 1
%120 = sext i32 %119 to i64
%121 = getelementptr inbounds i32*, i32** %117, i64 %120
%122 = load i32*, i32** %121
%123 = getelementptr inbounds i32, i32* %122, i64 0
%124 = load i32, i32* %123
%125 = load i32**, i32*** %12
%126 = load i32, i32* %9
%127 = sext i32 %126 to i64
%128 = getelementptr inbounds i32*, i32** %125, i64 %127
%129 = load i32*, i32** %128
%130 = getelementptr inbounds i32, i32* %129, i64 0
store i32 %124, i32* %130
%131 = load i8*, i8** %4
%132 = load i32, i32* %8
%133 = load i32, i32* %9
%134 = add nsw i32 %132, %133
%135 = sext i32 %134 to i64
%136 = getelementptr inbounds i8, i8* %131, i64 %135
%137 = load i8, i8* %136
%138 = sext i8 %137 to i32
%139 = load i8*, i8** %5
%140 = getelementptr inbounds i8, i8* %139, i64 0
%141 = load i8, i8* %140
%142 = sext i8 %141 to i32
%143 = icmp eq i32 %138, %142
br i1 %143, label %144, label %153
144: ; preds = %116
%145 = load i32**, i32*** %12
%146 = load i32, i32* %9
%147 = sext i32 %146 to i64
%148 = getelementptr inbounds i32*, i32** %145, i64 %147
%149 = load i32*, i32** %148
%150 = getelementptr inbounds i32, i32* %149, i64 0
%151 = load i32, i32* %150
%152 = add nsw i32 %151, 1
store i32 %152, i32* %150
br label %153
153: ; preds = %144, %116
br label %154
154: ; preds = %153
%155 = load i32, i32* %9
%156 = add nsw i32 %155, 1
store i32 %156, i32* %9
br label %110
157: ; preds = %110
store i32 1, i32* %9
br label %158
158: ; preds = %230, %157
%159 = load i32, i32* %9
%160 = load i32, i32* %6
%161 = load i32, i32* %8
%162 = sub nsw i32 %160, %161
%163 = icmp slt i32 %159, %162
br i1 %163, label %164, label %233
164: ; preds = %158
store i32 1, i32* %10
br label %165
165: ; preds = %226, %164
%166 = load i32, i32* %10
%167 = load i32, i32* %7
%168 = icmp slt i32 %166, %167
br i1 %168, label %169, label %229
169: ; preds = %165
%170 = load i32**, i32*** %12
%171 = load i32, i32* %9
%172 = sub nsw i32 %171, 1
%173 = sext i32 %172 to i64
%174 = getelementptr inbounds i32*, i32** %170, i64 %173
%175 = load i32*, i32** %174
%176 = load i32, i32* %10
%177 = sext i32 %176 to i64
%178 = getelementptr inbounds i32, i32* %175, i64 %177
%179 = load i32, i32* %178
%180 = load i32**, i32*** %12
%181 = load i32, i32* %9
%182 = sext i32 %181 to i64
%183 = getelementptr inbounds i32*, i32** %180, i64 %182
%184 = load i32*, i32** %183
%185 = load i32, i32* %10
%186 = sext i32 %185 to i64
%187 = getelementptr inbounds i32, i32* %184, i64 %186
store i32 %179, i32* %187
%188 = load i8*, i8** %4
%189 = load i32, i32* %8
%190 = load i32, i32* %9
%191 = add nsw i32 %189, %190
%192 = sext i32 %191 to i64
%193 = getelementptr inbounds i8, i8* %188, i64 %192
%194 = load i8, i8* %193
%195 = sext i8 %194 to i32
%196 = load i8*, i8** %5
%197 = load i32, i32* %10
%198 = sext i32 %197 to i64
%199 = getelementptr inbounds i8, i8* %196, i64 %198
%200 = load i8, i8* %199
%201 = sext i8 %200 to i32
%202 = icmp eq i32 %195, %201
br i1 %202, label %203, label %225
203: ; preds = %169
%204 = load i32**, i32*** %12
%205 = load i32, i32* %9
%206 = sub nsw i32 %205, 1
%207 = sext i32 %206 to i64
%208 = getelementptr inbounds i32*, i32** %204, i64 %207
%209 = load i32*, i32** %208
%210 = load i32, i32* %10
%211 = sub nsw i32 %210, 1
%212 = sext i32 %211 to i64
%213 = getelementptr inbounds i32, i32* %209, i64 %212
%214 = load i32, i32* %213
%215 = load i32**, i32*** %12
%216 = load i32, i32* %9
%217 = sext i32 %216 to i64
%218 = getelementptr inbounds i32*, i32** %215, i64 %217
%219 = load i32*, i32** %218
%220 = load i32, i32* %10
%221 = sext i32 %220 to i64
%222 = getelementptr inbounds i32, i32* %219, i64 %221
%223 = load i32, i32* %222
%224 = add nsw i32 %223, %214
store i32 %224, i32* %222
br label %225
225: ; preds = %203, %169
br label %226
226: ; preds = %225
%227 = load i32, i32* %10
%228 = add nsw i32 %227, 1
store i32 %228, i32* %10
br label %165
229: ; preds = %165
br label %230
230: ; preds = %229
%231 = load i32, i32* %9
%232 = add nsw i32 %231, 1
store i32 %232, i32* %9
br label %158
233: ; preds = %158
%234 = load i32**, i32*** %12
%235 = load i32, i32* %6
%236 = load i32, i32* %8
%237 = sub nsw i32 %235, %236
%238 = sub nsw i32 %237, 1
%239 = sext i32 %238 to i64
%240 = getelementptr inbounds i32*, i32** %234, i64 %239
%241 = load i32*, i32** %240
%242 = load i32, i32* %7
%243 = sub nsw i32 %242, 1
%244 = sext i32 %243 to i64
%245 = getelementptr inbounds i32, i32* %241, i64 %244
%246 = load i32, i32* %245
store i32 %246, i32* %3
br label %247
247: ; preds = %233, %50, %23
%248 = load i32, i32* %3
ret i32 %248
}

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