#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 *);
int hash(char *str, int table_size) {
  int sum = 0;
  int frequency[26] = {0};
  int slen = strlen(str);
  for (int i = 0; i < slen; i++) {
    frequency[(str[i] - 'a')]++;
  }
  for (int i = 0; i < 26; i++) {
    sum += (('a' + i) * frequency[i]);
  }
  int hash = (sum % table_size);
  do {
  } while (0);
  return hash;
}


x86 assembly (clang, -O0):
<hash>:
push   %rbp
mov    %rsp,%rbp
sub    $0x90,%rsp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
movl   $0x0,-0x10(%rbp)
lea    -0x80(%rbp),%rdi
xor    %esi,%esi
mov    $0x68,%edx
call   1040 <memset@plt>
mov    -0x8(%rbp),%rdi
call   1030 <strlen@plt>
mov    %eax,-0x84(%rbp)
movl   $0x0,-0x88(%rbp)
mov    -0x88(%rbp),%eax
cmp    -0x84(%rbp),%eax
jge    11a7 <hash+0x87>
mov    -0x8(%rbp),%rax
movslq -0x88(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
sub    $0x61,%eax
cltq
mov    -0x80(%rbp,%rax,4),%ecx
add    $0x1,%ecx
mov    %ecx,-0x80(%rbp,%rax,4)
mov    -0x88(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x88(%rbp)
jmp    1162 <hash+0x42>
movl   $0x0,-0x8c(%rbp)
cmpl   $0x1a,-0x8c(%rbp)
jge    11ed <hash+0xcd>
mov    -0x8c(%rbp),%eax
add    $0x61,%eax
movslq -0x8c(%rbp),%rcx
imul   -0x80(%rbp,%rcx,4),%eax
add    -0x10(%rbp),%eax
mov    %eax,-0x10(%rbp)
mov    -0x8c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8c(%rbp)
jmp    11b1 <hash+0x91>
mov    -0x10(%rbp),%eax
cltd
idivl  -0xc(%rbp)
mov    %edx,-0x90(%rbp)
jmp    11ff <hash+0xdf>
mov    -0x90(%rbp),%eax
add    $0x90,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<hash>:
push   %rbp
push   %rbx
sub    $0x68,%rsp
mov    %esi,%ebp
mov    %rdi,%rbx
pxor   %xmm0,%xmm0
movdqa %xmm0,0x50(%rsp)
movdqa %xmm0,0x40(%rsp)
movdqa %xmm0,0x30(%rsp)
movdqa %xmm0,0x20(%rsp)
movdqa %xmm0,0x10(%rsp)
movdqa %xmm0,(%rsp)
movq   $0x0,0x60(%rsp)
call   1030 <strlen@plt>
test   %eax,%eax
jle    115f <hash+0x4f>
mov    %eax,%ecx
cmp    $0x1,%eax
jne    1166 <hash+0x56>
xor    %eax,%eax
jmp    1194 <hash+0x84>
xor    %ecx,%ecx
jmp    12a4 <hash+0x194>
mov    %ecx,%edx
and    $0xfffffffe,%edx
xor    %eax,%eax
nopl   (%rax)
movsbq (%rbx,%rax,1),%rsi
addl   $0x1,-0x184(%rsp,%rsi,4)
01
movsbq 0x1(%rbx,%rax,1),%rsi
addl   $0x1,-0x184(%rsp,%rsi,4)
01
add    $0x2,%rax
cmp    %rax,%rdx
jne    1170 <hash+0x60>
test   $0x1,%cl
je     11a6 <hash+0x96>
movsbq (%rbx,%rax,1),%rax
addl   $0x1,-0x184(%rsp,%rax,4)
01
movdqu 0x44(%rsp),%xmm1
movdqu 0x54(%rsp),%xmm4
movdqu 0x4(%rsp),%xmm0
movdqu 0x14(%rsp),%xmm5
movdqu 0x24(%rsp),%xmm2
movdqu 0x34(%rsp),%xmm3
imul   $0x61,(%rsp),%eax
pshufd $0xf5,%xmm5,%xmm6
pmuludq 0xe25(%rip),%xmm6
pshufd $0xf5,%xmm0,%xmm7
pmuludq 0xe28(%rip),%xmm7
pmuludq 0xe30(%rip),%xmm5
shufps $0x88,%xmm6,%xmm7
pmuludq 0xe34(%rip),%xmm0
shufps $0x88,%xmm5,%xmm0
paddd  %xmm7,%xmm0
pshufd $0xf5,%xmm4,%xmm5
pmuludq 0xe2f(%rip),%xmm5
pshufd $0xf5,%xmm1,%xmm6
pmuludq 0xe32(%rip),%xmm6
shufps $0x88,%xmm5,%xmm6
pshufd $0xf5,%xmm3,%xmm5
pmuludq 0xe31(%rip),%xmm5
pshufd $0xf5,%xmm2,%xmm7
pmuludq 0xe34(%rip),%xmm7
pmuludq 0xe3c(%rip),%xmm4
shufps $0x88,%xmm5,%xmm7
pmuludq 0xe40(%rip),%xmm1
shufps $0x88,%xmm4,%xmm1
pmuludq 0xe44(%rip),%xmm3
pmuludq 0xe4c(%rip),%xmm2
paddd  %xmm6,%xmm1
shufps $0x88,%xmm3,%xmm2
paddd  %xmm7,%xmm2
paddd  %xmm1,%xmm2
pshufd $0xee,%xmm2,%xmm1
paddd  %xmm2,%xmm1
pshufd $0x55,%xmm1,%xmm2
paddd  %xmm1,%xmm2
movd   %xmm2,%edx
pshufd $0xee,%xmm0,%xmm1
paddd  %xmm0,%xmm1
pshufd $0x55,%xmm1,%xmm0
paddd  %xmm1,%xmm0
movd   %xmm0,%ecx
add    %edx,%ecx
add    %eax,%ecx
imul   $0x7a,0x64(%rsp),%eax
add    %ecx,%eax
cltd
idiv   %ebp
mov    %edx,%eax
add    $0x68,%rsp
pop    %rbx
pop    %rbp
ret

LLVM IR (-O0):
define i32 @hash(i8* %0, i32 %1) {
%3 = alloca i8*
%4 = alloca i32
%5 = alloca i32
%6 = alloca [26 x i32]
%7 = alloca i32
%8 = alloca i32
%9 = alloca i32
%10 = alloca i32
store i8* %0, i8** %3
store i32 %1, i32* %4
store i32 0, i32* %5
%11 = bitcast [26 x i32]* %6 to i8*
%12 = load i8*, i8** %3
%13 = call i32 @strlen(i8* %12)
store i32 %13, i32* %7
store i32 0, i32* %8
br label %14
14: ; preds = %30, %2
%15 = load i32, i32* %8
%16 = load i32, i32* %7
%17 = icmp slt i32 %15, %16
br i1 %17, label %18, label %33
18: ; preds = %14
%19 = load i8*, i8** %3
%20 = load i32, i32* %8
%21 = sext i32 %20 to i64
%22 = getelementptr inbounds i8, i8* %19, i64 %21
%23 = load i8, i8* %22
%24 = sext i8 %23 to i32
%25 = sub nsw i32 %24, 97
%26 = sext i32 %25 to i64
%27 = getelementptr inbounds [26 x i32], [26 x i32]* %6, i64 0, i64 %26
%28 = load i32, i32* %27
%29 = add nsw i32 %28, 1
store i32 %29, i32* %27
br label %30
30: ; preds = %18
%31 = load i32, i32* %8
%32 = add nsw i32 %31, 1
store i32 %32, i32* %8
br label %14
33: ; preds = %14
store i32 0, i32* %9
br label %34
34: ; preds = %47, %33
%35 = load i32, i32* %9
%36 = icmp slt i32 %35, 26
br i1 %36, label %37, label %50
37: ; preds = %34
%38 = load i32, i32* %9
%39 = add nsw i32 97, %38
%40 = load i32, i32* %9
%41 = sext i32 %40 to i64
%42 = getelementptr inbounds [26 x i32], [26 x i32]* %6, i64 0, i64 %41
%43 = load i32, i32* %42
%44 = mul nsw i32 %39, %43
%45 = load i32, i32* %5
%46 = add nsw i32 %45, %44
store i32 %46, i32* %5
br label %47
47: ; preds = %37
%48 = load i32, i32* %9
%49 = add nsw i32 %48, 1
store i32 %49, i32* %9
br label %34
50: ; preds = %34
%51 = load i32, i32* %5
%52 = load i32, i32* %4
%53 = srem i32 %51, %52
store i32 %53, i32* %10
br label %54
54: ; preds = %50
br label %55
55: ; preds = %54
%56 = load i32, i32* %10
ret i32 %56
}

LLVM IR (-O2):
define i32 @hash(i8* %0, i32 %1) {
%3 = alloca [26 x i32]
%4 = bitcast [26 x i32]* %3 to i8*
%5 = tail call i32 @strlen(i8* %0)
%6 = icmp sgt i32 %5, 0
br i1 %6, label %7, label %40
7: ; preds = %2
%8 = zext i32 %5 to i64
%9 = and i64 %8, 1
%10 = icmp eq i32 %5, 1
br i1 %10, label %13, label %11
11: ; preds = %7
%12 = and i64 %8, 4294967294
br label %47
13: ; preds = %47, %7
%14 = phi i64 [ 0, %7 ], [ %65, %47 ]
%15 = icmp eq i64 %9, 0
br i1 %15, label %24, label %16
16: ; preds = %13
%17 = getelementptr inbounds i8, i8* %0, i64 %14
%18 = load i8, i8* %17
%19 = sext i8 %18 to i64
%20 = add nsw i64 %19, -97
%21 = getelementptr inbounds [26 x i32], [26 x i32]* %3, i64 0, i64 %20
%22 = load i32, i32* %21
%23 = add nsw i32 %22, 1
store i32 %23, i32* %21
br label %24
24: ; preds = %13, %16
%25 = getelementptr inbounds [26 x i32], [26 x i32]* %3, i64 0, i64 0
%26 = load i32, i32* %25
%27 = getelementptr inbounds [26 x i32], [26 x i32]* %3, i64 0, i64 1
%28 = bitcast i32* %27 to <8 x i32>*
%29 = load <8 x i32>, <8 x i32>* %28
%30 = getelementptr inbounds [26 x i32], [26 x i32]* %3, i64 0, i64 9
%31 = bitcast i32* %30 to <16 x i32>*
%32 = load <16 x i32>, <16 x i32>* %31
%33 = mul i32 %26, 97
%34 = mul <8 x i32> %29, <i32 98, i32 99, i32 100, i32 101, i32 102, i32 103, i32 104, i32 105>
%35 = mul <16 x i32> %32, <i32 106, i32 107, i32 108, i32 109, i32 110, i32 111, i32 112, i32 113, i32 114, i32 115, i32 116, i32 117, i32 118, i32 119, i32 120, i32 121>
%36 = call i32 @llvm.vector.reduce.add.v16i32(<16 x i32> %35)
%37 = call i32 @llvm.vector.reduce.add.v8i32(<8 x i32> %34)
%38 = add nsw i32 %36, %37
%39 = add nsw i32 %38, %33
br label %40
40: ; preds = %24, %2
%41 = phi i32 [ %39, %24 ], [ 0, %2 ]
%42 = getelementptr inbounds [26 x i32], [26 x i32]* %3, i64 0, i64 25
%43 = load i32, i32* %42
%44 = mul nsw i32 %43, 122
%45 = add nsw i32 %44, %41
%46 = srem i32 %45, %1
ret i32 %46
47: ; preds = %47, %11
%48 = phi i64 [ 0, %11 ], [ %65, %47 ]
%49 = phi i64 [ 0, %11 ], [ %66, %47 ]
%50 = getelementptr inbounds i8, i8* %0, i64 %48
%51 = load i8, i8* %50
%52 = sext i8 %51 to i64
%53 = add nsw i64 %52, -97
%54 = getelementptr inbounds [26 x i32], [26 x i32]* %3, i64 0, i64 %53
%55 = load i32, i32* %54
%56 = add nsw i32 %55, 1
store i32 %56, i32* %54
%57 = or i64 %48, 1
%58 = getelementptr inbounds i8, i8* %0, i64 %57
%59 = load i8, i8* %58
%60 = sext i8 %59 to i64
%61 = add nsw i64 %60, -97
%62 = getelementptr inbounds [26 x i32], [26 x i32]* %3, i64 0, i64 %61
%63 = load i32, i32* %62
%64 = add nsw i32 %63, 1
store i32 %64, i32* %62
%65 = add nuw nsw i64 %48, 2
%66 = add i64 %49, 2
%67 = icmp eq i64 %66, %12
br i1 %67, label %13, label %47
}