#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 */
char *malloc(int);
char *get_current_sudoku(int sudoku[], int field, int val) {
  int i;
  int temp = sudoku[field];
  char *buffer = malloc((sizeof(char) * 9 * 9) + sizeof(char));
  sudoku[field] = val;
  for (i = 0; i < (9 * 9); i++) {
    buffer[i] = (char)(sudoku[i] + '0');
  }
  buffer[9 * 9] = '\0';
  sudoku[field] = temp;
  return buffer;
}


x86 assembly (clang, -O0):
<get_current_sudoku>:
push   %rbp
mov    %rsp,%rbp
sub    $0x20,%rsp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %edx,-0x10(%rbp)
mov    -0x8(%rbp),%rax
movslq -0xc(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x18(%rbp)
mov    $0x52,%edi
call   1030 <malloc@plt>
mov    %rax,-0x20(%rbp)
mov    -0x10(%rbp),%edx
mov    -0x8(%rbp),%rax
movslq -0xc(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
movl   $0x0,-0x14(%rbp)
cmpl   $0x51,-0x14(%rbp)
jge    1186 <get_current_sudoku+0x76>
mov    -0x8(%rbp),%rax
movslq -0x14(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
add    $0x30,%eax
mov    %al,%dl
mov    -0x20(%rbp),%rax
movslq -0x14(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    1153 <get_current_sudoku+0x43>
mov    -0x20(%rbp),%rax
movb   $0x0,0x51(%rax)
mov    -0x18(%rbp),%edx
mov    -0x8(%rbp),%rax
movslq -0xc(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x20(%rbp),%rax
add    $0x20,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<get_current_sudoku>:
push   %rbp
push   %r15
push   %r14
push   %rbx
push   %rax
mov    %edx,%ebp
mov    %rdi,%rbx
movslq %esi,%r14
mov    (%rdi,%r14,4),%r15d
mov    $0x52,%edi
call   1030 <malloc@plt>
mov    %ebp,(%rbx,%r14,4)
movdqu (%rbx),%xmm2
movdqa 0xec3(%rip),%xmm0
pand   %xmm0,%xmm2
packuswb %xmm2,%xmm2
packuswb %xmm2,%xmm2
movdqa 0xebf(%rip),%xmm1
paddb  %xmm1,%xmm2
movd   %xmm2,(%rax)
movdqu 0x10(%rbx),%xmm2
pand   %xmm0,%xmm2
packuswb %xmm2,%xmm2
packuswb %xmm2,%xmm2
paddb  %xmm1,%xmm2
movd   %xmm2,0x4(%rax)
movdqu 0x20(%rbx),%xmm2
pand   %xmm0,%xmm2
packuswb %xmm2,%xmm2
packuswb %xmm2,%xmm2
paddb  %xmm1,%xmm2
movd   %xmm2,0x8(%rax)
movdqu 0x30(%rbx),%xmm2
pand   %xmm0,%xmm2
packuswb %xmm2,%xmm2
packuswb %xmm2,%xmm2
paddb  %xmm1,%xmm2
movd   %xmm2,0xc(%rax)
movdqu 0x40(%rbx),%xmm2
pand   %xmm0,%xmm2
packuswb %xmm2,%xmm2
packuswb %xmm2,%xmm2
paddb  %xmm1,%xmm2
movd   %xmm2,0x10(%rax)
movdqu 0x50(%rbx),%xmm2
pand   %xmm0,%xmm2
packuswb %xmm2,%xmm2
packuswb %xmm2,%xmm2
paddb  %xmm1,%xmm2
movd   %xmm2,0x14(%rax)
movdqu 0x60(%rbx),%xmm2
pand   %xmm0,%xmm2
packuswb %xmm2,%xmm2
packuswb %xmm2,%xmm2
paddb  %xmm1,%xmm2
movd   %xmm2,0x18(%rax)
movdqu 0x70(%rbx),%xmm2
pand   %xmm0,%xmm2
packuswb %xmm2,%xmm2
packuswb %xmm2,%xmm2
paddb  %xmm1,%xmm2
movd   %xmm2,0x1c(%rax)
movdqu 0x80(%rbx),%xmm2
pand   %xmm0,%xmm2
packuswb %xmm2,%xmm2
packuswb %xmm2,%xmm2
paddb  %xmm1,%xmm2
movd   %xmm2,0x20(%rax)
movdqu 0x90(%rbx),%xmm2
pand   %xmm0,%xmm2
packuswb %xmm2,%xmm2
packuswb %xmm2,%xmm2
paddb  %xmm1,%xmm2
movd   %xmm2,0x24(%rax)
movdqu 0xa0(%rbx),%xmm2
pand   %xmm0,%xmm2
packuswb %xmm2,%xmm2
packuswb %xmm2,%xmm2
paddb  %xmm1,%xmm2
movd   %xmm2,0x28(%rax)
movdqu 0xb0(%rbx),%xmm2
pand   %xmm0,%xmm2
packuswb %xmm2,%xmm2
packuswb %xmm2,%xmm2
paddb  %xmm1,%xmm2
movd   %xmm2,0x2c(%rax)
movdqu 0xc0(%rbx),%xmm2
pand   %xmm0,%xmm2
packuswb %xmm2,%xmm2
packuswb %xmm2,%xmm2
paddb  %xmm1,%xmm2
movd   %xmm2,0x30(%rax)
movdqu 0xd0(%rbx),%xmm2
pand   %xmm0,%xmm2
packuswb %xmm2,%xmm2
packuswb %xmm2,%xmm2
paddb  %xmm1,%xmm2
movd   %xmm2,0x34(%rax)
movdqu 0xe0(%rbx),%xmm2
pand   %xmm0,%xmm2
packuswb %xmm2,%xmm2
packuswb %xmm2,%xmm2
paddb  %xmm1,%xmm2
movd   %xmm2,0x38(%rax)
movdqu 0xf0(%rbx),%xmm2
pand   %xmm0,%xmm2
packuswb %xmm2,%xmm2
packuswb %xmm2,%xmm2
paddb  %xmm1,%xmm2
movd   %xmm2,0x3c(%rax)
movdqu 0x100(%rbx),%xmm2
pand   %xmm0,%xmm2
packuswb %xmm2,%xmm2
packuswb %xmm2,%xmm2
paddb  %xmm1,%xmm2
movd   %xmm2,0x40(%rax)
movdqu 0x110(%rbx),%xmm2
pand   %xmm0,%xmm2
packuswb %xmm2,%xmm2
packuswb %xmm2,%xmm2
paddb  %xmm1,%xmm2
movd   %xmm2,0x44(%rax)
movdqu 0x120(%rbx),%xmm2
pand   %xmm0,%xmm2
packuswb %xmm2,%xmm2
packuswb %xmm2,%xmm2
paddb  %xmm1,%xmm2
movd   %xmm2,0x48(%rax)
movdqu 0x130(%rbx),%xmm2
pand   %xmm0,%xmm2
packuswb %xmm2,%xmm2
packuswb %xmm2,%xmm2
paddb  %xmm1,%xmm2
movd   %xmm2,0x4c(%rax)
mov    0x140(%rbx),%cl
add    $0x30,%cl
mov    %cl,0x50(%rax)
movb   $0x0,0x51(%rax)
mov    %r15d,(%rbx,%r14,4)
add    $0x8,%rsp
pop    %rbx
pop    %r14
pop    %r15
pop    %rbp
ret

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

LLVM IR (-O2):
define noalias i8* @get_current_sudoku(i32* nocapture %0, i32 %1, i32 %2) {
%4 = sext i32 %1 to i64
%5 = getelementptr inbounds i32, i32* %0, i64 %4
%6 = load i32, i32* %5
%7 = tail call dereferenceable_or_null(82) i8* @malloc(i32 82)
store i32 %2, i32* %5
%8 = bitcast i32* %0 to <4 x i32>*
%9 = load <4 x i32>, <4 x i32>* %8
%10 = trunc <4 x i32> %9 to <4 x i8>
%11 = add <4 x i8> %10, <i8 48, i8 48, i8 48, i8 48>
%12 = bitcast i8* %7 to <4 x i8>*
store <4 x i8> %11, <4 x i8>* %12
%13 = getelementptr inbounds i32, i32* %0, i64 4
%14 = bitcast i32* %13 to <4 x i32>*
%15 = load <4 x i32>, <4 x i32>* %14
%16 = trunc <4 x i32> %15 to <4 x i8>
%17 = add <4 x i8> %16, <i8 48, i8 48, i8 48, i8 48>
%18 = getelementptr inbounds i8, i8* %7, i64 4
%19 = bitcast i8* %18 to <4 x i8>*
store <4 x i8> %17, <4 x i8>* %19
%20 = getelementptr inbounds i32, i32* %0, i64 8
%21 = bitcast i32* %20 to <4 x i32>*
%22 = load <4 x i32>, <4 x i32>* %21
%23 = trunc <4 x i32> %22 to <4 x i8>
%24 = add <4 x i8> %23, <i8 48, i8 48, i8 48, i8 48>
%25 = getelementptr inbounds i8, i8* %7, i64 8
%26 = bitcast i8* %25 to <4 x i8>*
store <4 x i8> %24, <4 x i8>* %26
%27 = getelementptr inbounds i32, i32* %0, i64 12
%28 = bitcast i32* %27 to <4 x i32>*
%29 = load <4 x i32>, <4 x i32>* %28
%30 = trunc <4 x i32> %29 to <4 x i8>
%31 = add <4 x i8> %30, <i8 48, i8 48, i8 48, i8 48>
%32 = getelementptr inbounds i8, i8* %7, i64 12
%33 = bitcast i8* %32 to <4 x i8>*
store <4 x i8> %31, <4 x i8>* %33
%34 = getelementptr inbounds i32, i32* %0, i64 16
%35 = bitcast i32* %34 to <4 x i32>*
%36 = load <4 x i32>, <4 x i32>* %35
%37 = trunc <4 x i32> %36 to <4 x i8>
%38 = add <4 x i8> %37, <i8 48, i8 48, i8 48, i8 48>
%39 = getelementptr inbounds i8, i8* %7, i64 16
%40 = bitcast i8* %39 to <4 x i8>*
store <4 x i8> %38, <4 x i8>* %40
%41 = getelementptr inbounds i32, i32* %0, i64 20
%42 = bitcast i32* %41 to <4 x i32>*
%43 = load <4 x i32>, <4 x i32>* %42
%44 = trunc <4 x i32> %43 to <4 x i8>
%45 = add <4 x i8> %44, <i8 48, i8 48, i8 48, i8 48>
%46 = getelementptr inbounds i8, i8* %7, i64 20
%47 = bitcast i8* %46 to <4 x i8>*
store <4 x i8> %45, <4 x i8>* %47
%48 = getelementptr inbounds i32, i32* %0, i64 24
%49 = bitcast i32* %48 to <4 x i32>*
%50 = load <4 x i32>, <4 x i32>* %49
%51 = trunc <4 x i32> %50 to <4 x i8>
%52 = add <4 x i8> %51, <i8 48, i8 48, i8 48, i8 48>
%53 = getelementptr inbounds i8, i8* %7, i64 24
%54 = bitcast i8* %53 to <4 x i8>*
store <4 x i8> %52, <4 x i8>* %54
%55 = getelementptr inbounds i32, i32* %0, i64 28
%56 = bitcast i32* %55 to <4 x i32>*
%57 = load <4 x i32>, <4 x i32>* %56
%58 = trunc <4 x i32> %57 to <4 x i8>
%59 = add <4 x i8> %58, <i8 48, i8 48, i8 48, i8 48>
%60 = getelementptr inbounds i8, i8* %7, i64 28
%61 = bitcast i8* %60 to <4 x i8>*
store <4 x i8> %59, <4 x i8>* %61
%62 = getelementptr inbounds i32, i32* %0, i64 32
%63 = bitcast i32* %62 to <4 x i32>*
%64 = load <4 x i32>, <4 x i32>* %63
%65 = trunc <4 x i32> %64 to <4 x i8>
%66 = add <4 x i8> %65, <i8 48, i8 48, i8 48, i8 48>
%67 = getelementptr inbounds i8, i8* %7, i64 32
%68 = bitcast i8* %67 to <4 x i8>*
store <4 x i8> %66, <4 x i8>* %68
%69 = getelementptr inbounds i32, i32* %0, i64 36
%70 = bitcast i32* %69 to <4 x i32>*
%71 = load <4 x i32>, <4 x i32>* %70
%72 = trunc <4 x i32> %71 to <4 x i8>
%73 = add <4 x i8> %72, <i8 48, i8 48, i8 48, i8 48>
%74 = getelementptr inbounds i8, i8* %7, i64 36
%75 = bitcast i8* %74 to <4 x i8>*
store <4 x i8> %73, <4 x i8>* %75
%76 = getelementptr inbounds i32, i32* %0, i64 40
%77 = bitcast i32* %76 to <4 x i32>*
%78 = load <4 x i32>, <4 x i32>* %77
%79 = trunc <4 x i32> %78 to <4 x i8>
%80 = add <4 x i8> %79, <i8 48, i8 48, i8 48, i8 48>
%81 = getelementptr inbounds i8, i8* %7, i64 40
%82 = bitcast i8* %81 to <4 x i8>*
store <4 x i8> %80, <4 x i8>* %82
%83 = getelementptr inbounds i32, i32* %0, i64 44
%84 = bitcast i32* %83 to <4 x i32>*
%85 = load <4 x i32>, <4 x i32>* %84
%86 = trunc <4 x i32> %85 to <4 x i8>
%87 = add <4 x i8> %86, <i8 48, i8 48, i8 48, i8 48>
%88 = getelementptr inbounds i8, i8* %7, i64 44
%89 = bitcast i8* %88 to <4 x i8>*
store <4 x i8> %87, <4 x i8>* %89
%90 = getelementptr inbounds i32, i32* %0, i64 48
%91 = bitcast i32* %90 to <4 x i32>*
%92 = load <4 x i32>, <4 x i32>* %91
%93 = trunc <4 x i32> %92 to <4 x i8>
%94 = add <4 x i8> %93, <i8 48, i8 48, i8 48, i8 48>
%95 = getelementptr inbounds i8, i8* %7, i64 48
%96 = bitcast i8* %95 to <4 x i8>*
store <4 x i8> %94, <4 x i8>* %96
%97 = getelementptr inbounds i32, i32* %0, i64 52
%98 = bitcast i32* %97 to <4 x i32>*
%99 = load <4 x i32>, <4 x i32>* %98
%100 = trunc <4 x i32> %99 to <4 x i8>
%101 = add <4 x i8> %100, <i8 48, i8 48, i8 48, i8 48>
%102 = getelementptr inbounds i8, i8* %7, i64 52
%103 = bitcast i8* %102 to <4 x i8>*
store <4 x i8> %101, <4 x i8>* %103
%104 = getelementptr inbounds i32, i32* %0, i64 56
%105 = bitcast i32* %104 to <4 x i32>*
%106 = load <4 x i32>, <4 x i32>* %105
%107 = trunc <4 x i32> %106 to <4 x i8>
%108 = add <4 x i8> %107, <i8 48, i8 48, i8 48, i8 48>
%109 = getelementptr inbounds i8, i8* %7, i64 56
%110 = bitcast i8* %109 to <4 x i8>*
store <4 x i8> %108, <4 x i8>* %110
%111 = getelementptr inbounds i32, i32* %0, i64 60
%112 = bitcast i32* %111 to <4 x i32>*
%113 = load <4 x i32>, <4 x i32>* %112
%114 = trunc <4 x i32> %113 to <4 x i8>
%115 = add <4 x i8> %114, <i8 48, i8 48, i8 48, i8 48>
%116 = getelementptr inbounds i8, i8* %7, i64 60
%117 = bitcast i8* %116 to <4 x i8>*
store <4 x i8> %115, <4 x i8>* %117
%118 = getelementptr inbounds i32, i32* %0, i64 64
%119 = bitcast i32* %118 to <4 x i32>*
%120 = load <4 x i32>, <4 x i32>* %119
%121 = trunc <4 x i32> %120 to <4 x i8>
%122 = add <4 x i8> %121, <i8 48, i8 48, i8 48, i8 48>
%123 = getelementptr inbounds i8, i8* %7, i64 64
%124 = bitcast i8* %123 to <4 x i8>*
store <4 x i8> %122, <4 x i8>* %124
%125 = getelementptr inbounds i32, i32* %0, i64 68
%126 = bitcast i32* %125 to <4 x i32>*
%127 = load <4 x i32>, <4 x i32>* %126
%128 = trunc <4 x i32> %127 to <4 x i8>
%129 = add <4 x i8> %128, <i8 48, i8 48, i8 48, i8 48>
%130 = getelementptr inbounds i8, i8* %7, i64 68
%131 = bitcast i8* %130 to <4 x i8>*
store <4 x i8> %129, <4 x i8>* %131
%132 = getelementptr inbounds i32, i32* %0, i64 72
%133 = bitcast i32* %132 to <4 x i32>*
%134 = load <4 x i32>, <4 x i32>* %133
%135 = trunc <4 x i32> %134 to <4 x i8>
%136 = add <4 x i8> %135, <i8 48, i8 48, i8 48, i8 48>
%137 = getelementptr inbounds i8, i8* %7, i64 72
%138 = bitcast i8* %137 to <4 x i8>*
store <4 x i8> %136, <4 x i8>* %138
%139 = getelementptr inbounds i32, i32* %0, i64 76
%140 = bitcast i32* %139 to <4 x i32>*
%141 = load <4 x i32>, <4 x i32>* %140
%142 = trunc <4 x i32> %141 to <4 x i8>
%143 = add <4 x i8> %142, <i8 48, i8 48, i8 48, i8 48>
%144 = getelementptr inbounds i8, i8* %7, i64 76
%145 = bitcast i8* %144 to <4 x i8>*
store <4 x i8> %143, <4 x i8>* %145
%146 = getelementptr inbounds i32, i32* %0, i64 80
%147 = load i32, i32* %146
%148 = trunc i32 %147 to i8
%149 = add i8 %148, 48
%150 = getelementptr inbounds i8, i8* %7, i64 80
store i8 %149, i8* %150
%151 = getelementptr inbounds i8, i8* %7, i64 81
store i8 0, i8* %151
store i32 %6, i32* %5
ret i8* %7
}