#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 */
scalar_t__ calloc(unsigned short, int);
unsigned short int *map_index(unsigned short int *dst, unsigned short int *src,
                              unsigned short int comp_size) {
  unsigned short int *res =
      (unsigned short int *)calloc(comp_size, sizeof(unsigned short int));
  unsigned short int i, j = 0;
  for (i = 0; i < comp_size; i++) {
    unsigned short int num = dst[i];
    while (src[j] != num) {
      j++;
    }
    res[i] = j;
    j++;
  }
  return res;
}


x86 assembly (clang, -O0):
<map_index>:
push   %rbp
mov    %rsp,%rbp
sub    $0x30,%rsp
mov    %dx,%ax
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %ax,-0x12(%rbp)
mov    $0x2,%esi
movzwl -0x12(%rbp),%edi
call   1030 <calloc@plt>
mov    %rax,-0x20(%rbp)
movw   $0x0,-0x24(%rbp)
movw   $0x0,-0x22(%rbp)
movzwl -0x22(%rbp),%eax
movzwl -0x12(%rbp),%ecx
cmp    %ecx,%eax
jge    11bb <map_index+0xab>
mov    -0x8(%rbp),%rax
movzwl -0x22(%rbp),%ecx
mov    (%rax,%rcx,2),%ax
mov    %ax,-0x26(%rbp)
mov    -0x10(%rbp),%rax
movzwl -0x24(%rbp),%ecx
movzwl (%rax,%rcx,2),%eax
movzwl -0x26(%rbp),%ecx
cmp    %ecx,%eax
je     118e <map_index+0x7e>
mov    -0x24(%rbp),%ax
add    $0x1,%ax
mov    %ax,-0x24(%rbp)
jmp    1165 <map_index+0x55>
mov    -0x24(%rbp),%dx
mov    -0x20(%rbp),%rax
movzwl -0x22(%rbp),%ecx
mov    %dx,(%rax,%rcx,2)
mov    -0x24(%rbp),%ax
add    $0x1,%ax
mov    %ax,-0x24(%rbp)
mov    -0x22(%rbp),%ax
add    $0x1,%ax
mov    %ax,-0x22(%rbp)
jmp    1145 <map_index+0x35>
mov    -0x20(%rbp),%rax
add    $0x30,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<map_index>:
push   %rbp
push   %r14
push   %rbx
mov    %edx,%ebp
mov    %rsi,%rbx
mov    %rdi,%r14
mov    %edx,%edi
mov    $0x2,%esi
call   1030 <calloc@plt>
test   %ebp,%ebp
je     11c3 <map_index+0xb3>
movzwl %bp,%r8d
cmp    $0x1,%r8w
jne    1141 <map_index+0x31>
xor    %ebp,%ebp
xor    %edx,%edx
jmp    119c <map_index+0x8c>
mov    %r8d,%r9d
and    $0xfffffffe,%r9d
xor    %ebp,%ebp
xor    %edx,%edx
nopl   0x0(%rax)
movzwl (%r14,%rbp,2),%ecx
cs nopw 0x0(%rax,%rax,1)
nop
movzwl %dx,%esi
add    $0x1,%edx
cmp    %cx,(%rbx,%rsi,2)
jne    1160 <map_index+0x50>
lea    -0x1(%rdx),%ecx
mov    %cx,(%rax,%rbp,2)
mov    %rbp,%rcx
or     $0x1,%rcx
movzwl (%r14,%rcx,2),%esi
nop
movzwl %dx,%edi
add    $0x1,%edx
cmp    %si,(%rbx,%rdi,2)
jne    1180 <map_index+0x70>
lea    -0x1(%rdx),%esi
mov    %si,(%rax,%rcx,2)
add    $0x2,%rbp
cmp    %r9,%rbp
jne    1150 <map_index+0x40>
test   $0x1,%r8b
je     11c3 <map_index+0xb3>
movzwl (%r14,%rbp,2),%ecx
nopw   0x0(%rax,%rax,1)
movzwl %dx,%esi
add    $0x1,%edx
cmp    %cx,(%rbx,%rsi,2)
jne    11b0 <map_index+0xa0>
add    $0xffffffff,%edx
mov    %dx,(%rax,%rbp,2)
pop    %rbx
pop    %r14
pop    %rbp
ret

LLVM IR (-O0):
define i16* @map_index(i16* %0, i16* %1, i16 zeroext %2) {
%4 = alloca i16*
%5 = alloca i16*
%6 = alloca i16
%7 = alloca i16*
%8 = alloca i16
%9 = alloca i16
%10 = alloca i16
store i16* %0, i16** %4
store i16* %1, i16** %5
store i16 %2, i16* %6
%11 = load i16, i16* %6
%12 = call i64 @calloc(i16 zeroext %11, i32 2)
%13 = inttoptr i64 %12 to i16*
store i16* %13, i16** %7
store i16 0, i16* %9
store i16 0, i16* %8
br label %14
14: ; preds = %47, %3
%15 = load i16, i16* %8
%16 = zext i16 %15 to i32
%17 = load i16, i16* %6
%18 = zext i16 %17 to i32
%19 = icmp slt i32 %16, %18
br i1 %19, label %20, label %50
20: ; preds = %14
%21 = load i16*, i16** %4
%22 = load i16, i16* %8
%23 = zext i16 %22 to i64
%24 = getelementptr inbounds i16, i16* %21, i64 %23
%25 = load i16, i16* %24
store i16 %25, i16* %10
br label %26
26: ; preds = %36, %20
%27 = load i16*, i16** %5
%28 = load i16, i16* %9
%29 = zext i16 %28 to i64
%30 = getelementptr inbounds i16, i16* %27, i64 %29
%31 = load i16, i16* %30
%32 = zext i16 %31 to i32
%33 = load i16, i16* %10
%34 = zext i16 %33 to i32
%35 = icmp ne i32 %32, %34
br i1 %35, label %36, label %39
36: ; preds = %26
%37 = load i16, i16* %9
%38 = add i16 %37, 1
store i16 %38, i16* %9
br label %26
39: ; preds = %26
%40 = load i16, i16* %9
%41 = load i16*, i16** %7
%42 = load i16, i16* %8
%43 = zext i16 %42 to i64
%44 = getelementptr inbounds i16, i16* %41, i64 %43
store i16 %40, i16* %44
%45 = load i16, i16* %9
%46 = add i16 %45, 1
store i16 %46, i16* %9
br label %47
47: ; preds = %39
%48 = load i16, i16* %8
%49 = add i16 %48, 1
store i16 %49, i16* %8
br label %14
50: ; preds = %14
%51 = load i16*, i16** %7
ret i16* %51
}

LLVM IR (-O2):
define i16* @map_index(i16* nocapture %0, i16* nocapture %1, i16 zeroext %2) {
%4 = tail call i64 @calloc(i16 zeroext %2, i32 2)
%5 = inttoptr i64 %4 to i16*
%6 = icmp eq i16 %2, 0
br i1 %6, label %59, label %7
7: ; preds = %3
%8 = zext i16 %2 to i64
%9 = and i64 %8, 1
%10 = icmp eq i16 %2, 1
br i1 %10, label %43, label %11
11: ; preds = %7
%12 = and i64 %8, 65534
br label %13
13: ; preds = %38, %11
%14 = phi i64 [ 0, %11 ], [ %40, %38 ]
%15 = phi i16 [ 0, %11 ], [ %37, %38 ]
%16 = phi i64 [ 0, %11 ], [ %41, %38 ]
%17 = getelementptr inbounds i16, i16* %0, i64 %14
%18 = load i16, i16* %17
br label %19
19: ; preds = %19, %13
%20 = phi i16 [ %15, %13 ], [ %25, %19 ]
%21 = zext i16 %20 to i64
%22 = getelementptr inbounds i16, i16* %1, i64 %21
%23 = load i16, i16* %22
%24 = icmp eq i16 %23, %18
%25 = add i16 %20, 1
br i1 %24, label %26, label %19
26: ; preds = %19
%27 = getelementptr inbounds i16, i16* %5, i64 %14
store i16 %20, i16* %27
%28 = or i64 %14, 1
%29 = getelementptr inbounds i16, i16* %0, i64 %28
%30 = load i16, i16* %29
br label %31
31: ; preds = %31, %26
%32 = phi i16 [ %25, %26 ], [ %37, %31 ]
%33 = zext i16 %32 to i64
%34 = getelementptr inbounds i16, i16* %1, i64 %33
%35 = load i16, i16* %34
%36 = icmp eq i16 %35, %30
%37 = add i16 %32, 1
br i1 %36, label %38, label %31
38: ; preds = %31
%39 = getelementptr inbounds i16, i16* %5, i64 %28
store i16 %32, i16* %39
%40 = add nuw nsw i64 %14, 2
%41 = add nuw i64 %16, 2
%42 = icmp eq i64 %41, %12
br i1 %42, label %43, label %13
43: ; preds = %38, %7
%44 = phi i64 [ 0, %7 ], [ %40, %38 ]
%45 = phi i16 [ 0, %7 ], [ %37, %38 ]
%46 = icmp eq i64 %9, 0
br i1 %46, label %59, label %47
47: ; preds = %43
%48 = getelementptr inbounds i16, i16* %0, i64 %44
%49 = load i16, i16* %48
br label %50
50: ; preds = %50, %47
%51 = phi i16 [ %45, %47 ], [ %56, %50 ]
%52 = zext i16 %51 to i64
%53 = getelementptr inbounds i16, i16* %1, i64 %52
%54 = load i16, i16* %53
%55 = icmp eq i16 %54, %49
%56 = add i16 %51, 1
br i1 %55, label %57, label %50
57: ; preds = %50
%58 = getelementptr inbounds i16, i16* %5, i64 %44
store i16 %51, i16* %58
br label %59
59: ; preds = %57, %43, %3
ret i16* %5
}