void snailArrByUserN(int userLength, int *arr) {
  int i = 0, j = 0;
  int period = userLength - 1;
  int start = 0;
  int count = 1;
  while (period > 0) {
    for (j = start; j < start + period; j++) {
      arr[(i * userLength) + j] = count;
      count++;
    }
    for (i = start; i < start + period; i++) {
      arr[(i * userLength) + j] = count;
      count++;
    }
    for (; j > start; j--) {
      arr[(i * userLength) + j] = count;
      count++;
    }
    for (; i > start; i--) {
      arr[(i * userLength) + j] = count;
      count++;
    }
    i++;
    start++;
    period = period - 2;
  }
  if (period == 0)
    arr[(i * userLength) + (j + 1)] = count;
}


x86 assembly (clang, -O0):
<snailArrByUserN>:
push   %rbp
mov    %rsp,%rbp
mov    %edi,-0x4(%rbp)
mov    %rsi,-0x10(%rbp)
movl   $0x0,-0x14(%rbp)
movl   $0x0,-0x18(%rbp)
mov    -0x4(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x1c(%rbp)
movl   $0x0,-0x20(%rbp)
movl   $0x1,-0x24(%rbp)
cmpl   $0x0,-0x1c(%rbp)
jle    1262 <snailArrByUserN+0x162>
mov    -0x20(%rbp),%eax
mov    %eax,-0x18(%rbp)
mov    -0x18(%rbp),%eax
mov    -0x20(%rbp),%ecx
add    -0x1c(%rbp),%ecx
cmp    %ecx,%eax
jge    117f <snailArrByUserN+0x7f>
mov    -0x24(%rbp),%edx
mov    -0x10(%rbp),%rax
mov    -0x14(%rbp),%ecx
imul   -0x4(%rbp),%ecx
add    -0x18(%rbp),%ecx
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
jmp    1140 <snailArrByUserN+0x40>
mov    -0x20(%rbp),%eax
mov    %eax,-0x14(%rbp)
mov    -0x14(%rbp),%eax
mov    -0x20(%rbp),%ecx
add    -0x1c(%rbp),%ecx
cmp    %ecx,%eax
jge    11c4 <snailArrByUserN+0xc4>
mov    -0x24(%rbp),%edx
mov    -0x10(%rbp),%rax
mov    -0x14(%rbp),%ecx
imul   -0x4(%rbp),%ecx
add    -0x18(%rbp),%ecx
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    1185 <snailArrByUserN+0x85>
jmp    11c9 <snailArrByUserN+0xc9>
mov    -0x18(%rbp),%eax
cmp    -0x20(%rbp),%eax
jle    1203 <snailArrByUserN+0x103>
mov    -0x24(%rbp),%edx
mov    -0x10(%rbp),%rax
mov    -0x14(%rbp),%ecx
imul   -0x4(%rbp),%ecx
add    -0x18(%rbp),%ecx
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
mov    -0x18(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x18(%rbp)
jmp    11c9 <snailArrByUserN+0xc9>
jmp    1208 <snailArrByUserN+0x108>
mov    -0x14(%rbp),%eax
cmp    -0x20(%rbp),%eax
jle    1242 <snailArrByUserN+0x142>
mov    -0x24(%rbp),%edx
mov    -0x10(%rbp),%rax
mov    -0x14(%rbp),%ecx
imul   -0x4(%rbp),%ecx
add    -0x18(%rbp),%ecx
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
mov    -0x14(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x14(%rbp)
jmp    1208 <snailArrByUserN+0x108>
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
mov    -0x1c(%rbp),%eax
sub    $0x2,%eax
mov    %eax,-0x1c(%rbp)
jmp    1130 <snailArrByUserN+0x30>
cmpl   $0x0,-0x1c(%rbp)
jne    1288 <snailArrByUserN+0x188>
mov    -0x24(%rbp),%edx
mov    -0x10(%rbp),%rax
mov    -0x14(%rbp),%ecx
imul   -0x4(%rbp),%ecx
mov    -0x18(%rbp),%esi
add    $0x1,%esi
add    %esi,%ecx
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
pop    %rbp
ret

x86 assembly (clang, -O2):
<snailArrByUserN>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
push   %rax
lea    -0x1(%rdi),%ebp
cmp    $0x2,%edi
jl     170d <snailArrByUserN+0x60d>
mov    %edi,%ecx
mov    %ebp,%edx
lea    0x10(%rsi),%r9
mov    %rcx,%rax
shl    $0x5,%rax
add    %rsi,%rax
add    $0x10,%rax
mov    %rax,-0x30(%rsp)
lea    0x0(,%rcx,4),%r15
mov    %rcx,%rax
shl    $0x6,%rax
mov    %rax,-0x10(%rsp)
lea    -0xc(%rsi),%rax
mov    %rax,-0x20(%rsp)
mov    %r15,%rax
neg    %rax
mov    %rax,-0x8(%rsp)
mov    %rcx,-0x68(%rsp)
shl    $0x4,%rcx
mov    %rcx,-0x18(%rsp)
xor    %eax,%eax
mov    %rax,-0x40(%rsp)
mov    $0x1,%eax
mov    $0x1,%r13d
mov    $0xfffffffffffffff8,%r14
movdqa 0xe77(%rip),%xmm0
movdqa 0xe7f(%rip),%xmm1
movdqa 0xe87(%rip),%xmm2
movdqa 0xe8f(%rip),%xmm3
movdqa 0xe97(%rip),%xmm4
mov    %r9,-0x38(%rsp)
mov    %rdx,%rcx
mov    %rdx,(%rsp)
xor    %r8d,%r8d
xor    %r12d,%r12d
mov    %rsi,-0x80(%rsp)
mov    %rdi,-0x60(%rsp)
jmp    1219 <snailArrByUserN+0x119>
nopw   0x0(%rax,%rax,1)
mov    -0x80(%rsp),%rsi
mov    -0x60(%rsp),%rdi
mov    -0x70(%rsp),%r9
mov    -0x28(%rsp),%r8
add    $0x1,%r12d
lea    -0x2(%rdx),%rbp
add    $0xffffffffffffffff,%rcx
add    $0x1,%r13
add    $0xffffffffffffffff,%r14
addq   $0x4,-0x38(%rsp)
add    %r15,-0x30(%rsp)
add    %r15,%r9
addq   $0xffffffffffffffff,-0x40(%rsp)
cmp    $0x2,%rdx
mov    %rbp,%rdx
jle    1721 <snailArrByUserN+0x621>
mov    %rdx,-0x78(%rsp)
mov    %r9,-0x70(%rsp)
cmp    %r13,%rcx
mov    %r13,-0x48(%rsp)
mov    %rcx,-0x58(%rsp)
cmovg  %rcx,%r13
mov    %r14,-0x50(%rsp)
add    %r14,%r13
shr    $0x3,%r13
add    $0x1,%r13
and    $0xfffffffffffffffe,%r13
mov    (%rsp),%rbp
sub    %r8,%rbp
lea    0x1(%r8),%rcx
cmp    %rcx,%rbp
mov    %rcx,-0x28(%rsp)
cmovle %rcx,%rbp
sub    %r8,%rbp
lea    -0x8(%rbp),%r9
mov    %r9,%r11
shr    $0x3,%r11
add    $0x1,%r11
lea    (%r8,%rdx,1),%r14
imul   %edi,%r12d
movslq %r12d,%rcx
cmp    $0x8,%rbp
jae    1290 <snailArrByUserN+0x190>
mov    %r8,%r10
jmp    1334 <snailArrByUserN+0x234>
nopw   0x0(%rax,%rax,1)
movd   %eax,%xmm5
pshufd $0x0,%xmm5,%xmm5
paddd  %xmm0,%xmm5
cmp    $0x8,%r9
jae    12b0 <snailArrByUserN+0x1b0>
xor    %edi,%edi
jmp    12fd <snailArrByUserN+0x1fd>
nopw   0x0(%rax,%rax,1)
mov    -0x38(%rsp),%rdx
lea    (%rdx,%rcx,4),%rdx
mov    %r13,%rbx
xor    %edi,%edi
xchg   %ax,%ax
movdqa %xmm5,%xmm6
paddd  %xmm1,%xmm6
movdqu %xmm5,-0x10(%rdx,%rdi,4)
movdqu %xmm6,(%rdx,%rdi,4)
movdqa %xmm5,%xmm6
paddd  %xmm2,%xmm6
movdqa %xmm5,%xmm7
paddd  %xmm3,%xmm7
movdqu %xmm6,0x10(%rdx,%rdi,4)
movdqu %xmm7,0x20(%rdx,%rdi,4)
add    $0x10,%rdi
paddd  %xmm4,%xmm5
add    $0xfffffffffffffffe,%rbx
jne    12c0 <snailArrByUserN+0x1c0>
mov    %rbp,%rdx
and    $0xfffffffffffffff8,%rdx
test   $0x1,%r11b
mov    -0x80(%rsp),%rsi
je     1324 <snailArrByUserN+0x224>
add    %r8,%rdi
add    %rcx,%rdi
movdqu %xmm5,(%rsi,%rdi,4)
paddd  %xmm1,%xmm5
movdqu %xmm5,0x10(%rsi,%rdi,4)
lea    (%r8,%rdx,1),%r10
add    %edx,%eax
cmp    %rdx,%rbp
mov    -0x60(%rsp),%rdi
je     1350 <snailArrByUserN+0x250>
lea    (%rsi,%rcx,4),%rdx
nopl   0x0(%rax,%rax,1)
mov    %eax,(%rdx,%r10,4)
add    $0x1,%eax
add    $0x1,%r10
cmp    %r14,%r10
jl     1340 <snailArrByUserN+0x240>
movslq %r10d,%rbx
cmp    $0x8,%rbp
jb     1380 <snailArrByUserN+0x280>
cmp    $0x1,%edi
jne    1380 <snailArrByUserN+0x280>
movd   %eax,%xmm5
pshufd $0x0,%xmm5,%xmm5
paddd  %xmm0,%xmm5
cmp    $0x8,%r9
jae    1390 <snailArrByUserN+0x290>
mov    %rbx,%rsi
xor    %ebx,%ebx
mov    -0x70(%rsp),%r9
jmp    13f1 <snailArrByUserN+0x2f1>
nopl   (%rax)
mov    %r8,%r12
mov    -0x70(%rsp),%r9
jmp    1436 <snailArrByUserN+0x336>
nopl   (%rax)
mov    %rbx,%rsi
lea    0x0(,%rbx,4),%rdx
xor    %ebx,%ebx
mov    -0x70(%rsp),%r9
mov    -0x30(%rsp),%rcx
mov    -0x10(%rsp),%rdi
nopl   0x0(%rax)
movdqa %xmm5,%xmm6
paddd  %xmm1,%xmm6
movdqu %xmm5,-0x10(%r9,%rdx,1)
movdqu %xmm6,(%r9,%rdx,1)
movdqa %xmm5,%xmm6
paddd  %xmm2,%xmm6
movdqa %xmm5,%xmm7
paddd  %xmm3,%xmm7
movdqu %xmm6,-0x10(%rcx,%rdx,1)
movdqu %xmm7,(%rcx,%rdx,1)
add    $0x10,%rbx
paddd  %xmm4,%xmm5
add    %rdi,%rdx
add    $0xfffffffffffffffe,%r13
jne    13b0 <snailArrByUserN+0x2b0>
mov    %rbp,%rcx
and    $0xfffffffffffffff8,%rcx
test   $0x1,%r11b
je     141e <snailArrByUserN+0x31e>
add    %r8,%rbx
imul   -0x68(%rsp),%rbx
add    %rsi,%rbx
mov    -0x80(%rsp),%rdx
movdqu %xmm5,(%rdx,%rbx,4)
paddd  %xmm1,%xmm5
movdqu %xmm5,0x10(%rdx,%rbx,4)
lea    (%r8,%rcx,1),%r12
add    %ecx,%eax
cmp    %rcx,%rbp
mov    -0x60(%rsp),%rdi
mov    %rsi,%rbx
mov    -0x80(%rsp),%rsi
je     1461 <snailArrByUserN+0x361>
mov    -0x68(%rsp),%rcx
imul   %r12,%rcx
add    %rbx,%rcx
lea    (%rsi,%rcx,4),%rcx
cs nopw 0x0(%rax,%rax,1)
mov    %eax,(%rcx)
add    $0x1,%eax
add    $0x1,%r12
add    %r15,%rcx
cmp    %r14,%r12
jl     1450 <snailArrByUserN+0x350>
mov    %rbx,%r13
sub    %r8,%r13
jle    1490 <snailArrByUserN+0x390>
mov    %r12d,%ecx
imul   %edi,%ecx
movslq %ecx,%r11
cmp    $0x8,%r13
jae    14b0 <snailArrByUserN+0x3b0>
mov    -0x48(%rsp),%r13
mov    -0x50(%rsp),%r14
mov    -0x78(%rsp),%rdx
jmp    15b6 <snailArrByUserN+0x4b6>
nopl   0x0(%rax)
mov    -0x48(%rsp),%r13
mov    -0x50(%rsp),%r14
mov    -0x78(%rsp),%rdx
jmp    15d0 <snailArrByUserN+0x4d0>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    %r13,%r14
and    $0xfffffffffffffff8,%r14
movd   %eax,%xmm5
pshufd $0x0,%xmm5,%xmm5
paddd  %xmm0,%xmm5
lea    -0x8(%r14),%rdx
mov    %rdx,%rcx
shr    $0x3,%rcx
add    $0x1,%rcx
test   %rdx,%rdx
je     16f8 <snailArrByUserN+0x5f8>
lea    (%r11,%rbx,1),%rdx
mov    -0x20(%rsp),%rsi
lea    (%rsi,%rdx,4),%rdi
mov    -0x40(%rsp),%rdx
mov    %rbx,%r10
add    %rdx,%rbx
and    $0xfffffffffffffff8,%rbx
add    $0xfffffffffffffff8,%rbx
shr    $0x3,%rbx
add    $0x1,%rbx
and    $0xfffffffffffffffe,%rbx
xor    %ebp,%ebp
nopw   0x0(%rax,%rax,1)
movdqa %xmm5,%xmm6
paddd  %xmm1,%xmm6
pshufd $0x1b,%xmm5,%xmm7
movdqu %xmm7,(%rdi,%rbp,4)
pshufd $0x1b,%xmm6,%xmm6
movdqu %xmm6,-0x10(%rdi,%rbp,4)
movdqa %xmm5,%xmm6
paddd  %xmm2,%xmm6
movdqa %xmm5,%xmm7
paddd  %xmm3,%xmm7
pshufd $0x1b,%xmm6,%xmm6
movdqu %xmm6,-0x20(%rdi,%rbp,4)
pshufd $0x1b,%xmm7,%xmm6
movdqu %xmm6,-0x30(%rdi,%rbp,4)
paddd  %xmm4,%xmm5
add    $0xfffffffffffffff0,%rbp
add    $0xfffffffffffffffe,%rbx
jne    1510 <snailArrByUserN+0x410>
neg    %rbp
mov    -0x80(%rsp),%rsi
mov    -0x60(%rsp),%rdi
mov    -0x78(%rsp),%rdx
mov    %r10,%rbx
test   $0x1,%cl
je     159e <snailArrByUserN+0x49e>
mov    %rbx,%rcx
sub    %rbp,%rcx
add    %r11,%rcx
pshufd $0x1b,%xmm5,%xmm6
paddd  %xmm1,%xmm5
movdqu %xmm6,-0xc(%rsi,%rcx,4)
pshufd $0x1b,%xmm5,%xmm5
movdqu %xmm5,-0x1c(%rsi,%rcx,4)
sub    %r14,%rbx
add    %r14d,%eax
mov    %rbx,%r10
cmp    %r14,%r13
mov    -0x48(%rsp),%r13
mov    -0x50(%rsp),%r14
je     15d0 <snailArrByUserN+0x4d0>
lea    (%rsi,%r11,4),%rcx
mov    %rbx,%r10
nopl   (%rax)
mov    %eax,(%rcx,%r10,4)
add    $0x1,%eax
add    $0xffffffffffffffff,%r10
cmp    %r8,%r10
jg     15c0 <snailArrByUserN+0x4c0>
mov    %r12d,%ebp
cmp    %rbp,%r8
jae    1660 <snailArrByUserN+0x560>
mov    %r8,%r9
not    %r9
movslq %r10d,%rbx
mov    %r12d,%ecx
sub    %r8d,%ecx
add    %rbp,%r9
test   $0x3,%cl
je     166a <snailArrByUserN+0x56a>
mov    -0x68(%rsp),%rcx
imul   %rbp,%rcx
add    %rbx,%rcx
mov    -0x80(%rsp),%rdx
lea    (%rdx,%rcx,4),%rcx
mov    %eax,%r11d
add    %r14b,%r12b
movzbl %r12b,%r14d
and    $0x3,%r14d
xor    %edx,%edx
mov    -0x8(%rsp),%rdi
nopl   (%rax)
lea    (%r11,%rdx,1),%esi
mov    %esi,(%rcx)
add    $0x1,%rdx
add    %rdi,%rcx
cmp    %rdx,%r14
jne    1620 <snailArrByUserN+0x520>
sub    %rdx,%rbp
add    %edx,%eax
mov    %rbp,%r12
mov    -0x50(%rsp),%r14
mov    -0x58(%rsp),%rcx
mov    -0x78(%rsp),%rdx
cmp    $0x3,%r9
jb     11d0 <snailArrByUserN+0xd0>
jmp    1679 <snailArrByUserN+0x579>
cs nopw 0x0(%rax,%rax,1)
nop
mov    -0x58(%rsp),%rcx
jmp    11df <snailArrByUserN+0xdf>
mov    -0x58(%rsp),%rcx
cmp    $0x3,%r9
jb     11d0 <snailArrByUserN+0xd0>
lea    -0x3(%rbp),%rcx
mov    -0x68(%rsp),%rdi
imul   %rdi,%rcx
mov    -0x80(%rsp),%rdx
lea    (%rdx,%rcx,4),%r9
shl    $0x2,%rbx
lea    -0x2(%rbp),%rcx
imul   %rdi,%rcx
lea    (%rdx,%rcx,4),%r11
mov    %rdi,%rcx
imul   %rbp,%rcx
lea    (%rdx,%rcx,4),%rcx
lea    -0x1(%rbp),%rsi
imul   %rdi,%rsi
lea    (%rdx,%rsi,4),%rsi
mov    -0x18(%rsp),%rdi
nopl   0x0(%rax,%rax,1)
mov    %eax,(%rcx,%rbx,1)
lea    0x1(%rax),%edx
mov    %edx,(%rsi,%rbx,1)
lea    0x2(%rax),%edx
mov    %edx,(%r11,%rbx,1)
lea    0x3(%rax),%edx
mov    %edx,(%r9,%rbx,1)
add    $0x4,%eax
add    $0xfffffffffffffffc,%rbp
sub    %rdi,%rbx
cmp    %r8,%rbp
jg     16c0 <snailArrByUserN+0x5c0>
mov    %rbp,%r12
mov    -0x58(%rsp),%rcx
mov    -0x78(%rsp),%rdx
jmp    11d0 <snailArrByUserN+0xd0>
xor    %ebp,%ebp
mov    -0x78(%rsp),%rdx
test   $0x1,%cl
jne    157b <snailArrByUserN+0x47b>
jmp    159e <snailArrByUserN+0x49e>
mov    $0x1,%r10d
xor    %r12d,%r12d
mov    $0x1,%eax
test   %ebp,%ebp
jne    1736 <snailArrByUserN+0x636>
jmp    1729 <snailArrByUserN+0x629>
add    $0x1,%r10d
test   %ebp,%ebp
jne    1736 <snailArrByUserN+0x636>
imul   %edi,%r12d
add    %r12d,%r10d
movslq %r10d,%rcx
mov    %eax,(%rsi,%rcx,4)
add    $0x8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

LLVM IR (-O2):
define void @snailArrByUserN(i32 %0, i32* nocapture writeonly %1) {
%3 = add i32 %0, -1
%4 = icmp sgt i32 %0, 1
br i1 %4, label %5, label %328
5: ; preds = %2
%6 = zext i32 %0 to i64
%7 = zext i32 %3 to i64
%8 = icmp eq i32 %0, 1
br label %9
9: ; preds = %317, %5
%10 = phi i64 [ %7, %5 ], [ %322, %317 ]
%11 = phi i64 [ 0, %5 ], [ %321, %317 ]
%12 = phi i32 [ 1, %5 ], [ %319, %317 ]
%13 = phi i32 [ 0, %5 ], [ %320, %317 ]
%14 = xor i64 %11, -1
%15 = sub nsw i64 %7, %11
%16 = add nuw i64 %11, 1
%17 = call i64 @llvm.smax.i64(i64 %15, i64 %16)
%18 = sub i64 %17, %11
%19 = add i64 %18, -8
%20 = lshr i64 %19, 3
%21 = add nuw nsw i64 %20, 1
%22 = sub nsw i64 %7, %11
%23 = add nuw i64 %11, 1
%24 = call i64 @llvm.smax.i64(i64 %22, i64 %23)
%25 = sub i64 %24, %11
%26 = add i64 %25, -8
%27 = lshr i64 %26, 3
%28 = add nuw nsw i64 %27, 1
%29 = sub nsw i64 %7, %11
%30 = add nuw i64 %11, 1
%31 = call i64 @llvm.smax.i64(i64 %29, i64 %30)
%32 = sub i64 %31, %11
%33 = sub nsw i64 %7, %11
%34 = add nuw i64 %11, 1
%35 = call i64 @llvm.smax.i64(i64 %33, i64 %34)
%36 = sub i64 %35, %11
%37 = add nsw i64 %11, %10
%38 = mul nsw i32 %13, %0
%39 = sext i32 %38 to i64
%40 = icmp ult i64 %32, 8
br i1 %40, label %91, label %41
41: ; preds = %9
%42 = and i64 %32, -8
%43 = add i64 %11, %42
%44 = trunc i64 %42 to i32
%45 = add i32 %12, %44
%46 = insertelement <4 x i32> poison, i32 %12, i64 0
%47 = shufflevector <4 x i32> %46, <4 x i32> poison, <4 x i32> zeroinitializer
%48 = add <4 x i32> %47, <i32 0, i32 1, i32 2, i32 3>
%49 = and i64 %28, 1
%50 = icmp ult i64 %26, 8
br i1 %50, label %77, label %51
51: ; preds = %41
%52 = and i64 %28, 4611686018427387902
br label %53
53: ; preds = %53, %51
%54 = phi i64 [ 0, %51 ], [ %73, %53 ]
%55 = phi <4 x i32> [ %48, %51 ], [ %74, %53 ]
%56 = phi i64 [ 0, %51 ], [ %75, %53 ]
%57 = add i64 %11, %54
%58 = add <4 x i32> %55, <i32 4, i32 4, i32 4, i32 4>
%59 = add nsw i64 %57, %39
%60 = getelementptr inbounds i32, i32* %1, i64 %59
%61 = bitcast i32* %60 to <4 x i32>*
store <4 x i32> %55, <4 x i32>* %61
%62 = getelementptr inbounds i32, i32* %60, i64 4
%63 = bitcast i32* %62 to <4 x i32>*
store <4 x i32> %58, <4 x i32>* %63
%64 = or i64 %54, 8
%65 = add <4 x i32> %55, <i32 8, i32 8, i32 8, i32 8>
%66 = add i64 %11, %64
%67 = add <4 x i32> %55, <i32 12, i32 12, i32 12, i32 12>
%68 = add nsw i64 %66, %39
%69 = getelementptr inbounds i32, i32* %1, i64 %68
%70 = bitcast i32* %69 to <4 x i32>*
store <4 x i32> %65, <4 x i32>* %70
%71 = getelementptr inbounds i32, i32* %69, i64 4
%72 = bitcast i32* %71 to <4 x i32>*
store <4 x i32> %67, <4 x i32>* %72
%73 = add nuw i64 %54, 16
%74 = add <4 x i32> %55, <i32 16, i32 16, i32 16, i32 16>
%75 = add i64 %56, 2
%76 = icmp eq i64 %75, %52
br i1 %76, label %77, label %53
77: ; preds = %53, %41
%78 = phi i64 [ 0, %41 ], [ %73, %53 ]
%79 = phi <4 x i32> [ %48, %41 ], [ %74, %53 ]
%80 = icmp eq i64 %49, 0
br i1 %80, label %89, label %81
81: ; preds = %77
%82 = add i64 %11, %78
%83 = add <4 x i32> %79, <i32 4, i32 4, i32 4, i32 4>
%84 = add nsw i64 %82, %39
%85 = getelementptr inbounds i32, i32* %1, i64 %84
%86 = bitcast i32* %85 to <4 x i32>*
store <4 x i32> %79, <4 x i32>* %86
%87 = getelementptr inbounds i32, i32* %85, i64 4
%88 = bitcast i32* %87 to <4 x i32>*
store <4 x i32> %83, <4 x i32>* %88
br label %89
89: ; preds = %77, %81
%90 = icmp eq i64 %32, %42
br i1 %90, label %94, label %91
91: ; preds = %9, %89
%92 = phi i64 [ %11, %9 ], [ %43, %89 ]
%93 = phi i32 [ %12, %9 ], [ %45, %89 ]
br label %157
94: ; preds = %157, %89
%95 = phi i32 [ %45, %89 ], [ %162, %157 ]
%96 = phi i64 [ %43, %89 ], [ %163, %157 ]
%97 = shl i64 %96, 32
%98 = ashr exact i64 %97, 32
%99 = icmp ugt i64 %36, 7
%100 = and i1 %99, %8
br i1 %100, label %101, label %154
101: ; preds = %94
%102 = and i64 %36, -8
%103 = add i64 %11, %102
%104 = trunc i64 %102 to i32
%105 = add i32 %95, %104
%106 = insertelement <4 x i32> poison, i32 %95, i64 0
%107 = shufflevector <4 x i32> %106, <4 x i32> poison, <4 x i32> zeroinitializer
%108 = add <4 x i32> %107, <i32 0, i32 1, i32 2, i32 3>
%109 = and i64 %21, 1
%110 = icmp ult i64 %19, 8
br i1 %110, label %139, label %111
111: ; preds = %101
%112 = and i64 %21, 4611686018427387902
br label %113
113: ; preds = %113, %111
%114 = phi i64 [ 0, %111 ], [ %135, %113 ]
%115 = phi <4 x i32> [ %108, %111 ], [ %136, %113 ]
%116 = phi i64 [ 0, %111 ], [ %137, %113 ]
%117 = add i64 %11, %114
%118 = add <4 x i32> %115, <i32 4, i32 4, i32 4, i32 4>
%119 = mul nsw i64 %117, %6
%120 = add nsw i64 %119, %98
%121 = getelementptr inbounds i32, i32* %1, i64 %120
%122 = bitcast i32* %121 to <4 x i32>*
store <4 x i32> %115, <4 x i32>* %122
%123 = getelementptr inbounds i32, i32* %121, i64 4
%124 = bitcast i32* %123 to <4 x i32>*
store <4 x i32> %118, <4 x i32>* %124
%125 = or i64 %114, 8
%126 = add <4 x i32> %115, <i32 8, i32 8, i32 8, i32 8>
%127 = add i64 %11, %125
%128 = add <4 x i32> %115, <i32 12, i32 12, i32 12, i32 12>
%129 = mul nsw i64 %127, %6
%130 = add nsw i64 %129, %98
%131 = getelementptr inbounds i32, i32* %1, i64 %130
%132 = bitcast i32* %131 to <4 x i32>*
store <4 x i32> %126, <4 x i32>* %132
%133 = getelementptr inbounds i32, i32* %131, i64 4
%134 = bitcast i32* %133 to <4 x i32>*
store <4 x i32> %128, <4 x i32>* %134
%135 = add nuw i64 %114, 16
%136 = add <4 x i32> %115, <i32 16, i32 16, i32 16, i32 16>
%137 = add i64 %116, 2
%138 = icmp eq i64 %137, %112
br i1 %138, label %139, label %113
139: ; preds = %113, %101
%140 = phi i64 [ 0, %101 ], [ %135, %113 ]
%141 = phi <4 x i32> [ %108, %101 ], [ %136, %113 ]
%142 = icmp eq i64 %109, 0
br i1 %142, label %152, label %143
143: ; preds = %139
%144 = add i64 %11, %140
%145 = add <4 x i32> %141, <i32 4, i32 4, i32 4, i32 4>
%146 = mul nsw i64 %144, %6
%147 = add nsw i64 %146, %98
%148 = getelementptr inbounds i32, i32* %1, i64 %147
%149 = bitcast i32* %148 to <4 x i32>*
store <4 x i32> %141, <4 x i32>* %149
%150 = getelementptr inbounds i32, i32* %148, i64 4
%151 = bitcast i32* %150 to <4 x i32>*
store <4 x i32> %145, <4 x i32>* %151
br label %152
152: ; preds = %139, %143
%153 = icmp eq i64 %36, %102
br i1 %153, label %165, label %154
154: ; preds = %94, %152
%155 = phi i64 [ %11, %94 ], [ %103, %152 ]
%156 = phi i32 [ %95, %94 ], [ %105, %152 ]
br label %243
157: ; preds = %91, %157
%158 = phi i64 [ %163, %157 ], [ %92, %91 ]
%159 = phi i32 [ %162, %157 ], [ %93, %91 ]
%160 = add nsw i64 %158, %39
%161 = getelementptr inbounds i32, i32* %1, i64 %160
store i32 %159, i32* %161
%162 = add nsw i32 %159, 1
%163 = add nuw nsw i64 %158, 1
%164 = icmp slt i64 %163, %37
br i1 %164, label %157, label %94
165: ; preds = %243, %152
%166 = phi i32 [ %105, %152 ], [ %249, %243 ]
%167 = phi i64 [ %103, %152 ], [ %250, %243 ]
%168 = trunc i64 %167 to i32
%169 = icmp sgt i64 %98, %11
br i1 %169, label %170, label %252
170: ; preds = %165
%171 = mul nsw i32 %168, %0
%172 = sext i32 %171 to i64
%173 = sub i64 %98, %11
%174 = icmp ult i64 %173, 8
br i1 %174, label %240, label %175
175: ; preds = %170
%176 = and i64 %173, -8
%177 = sub i64 %98, %176
%178 = trunc i64 %176 to i32
%179 = add i32 %166, %178
%180 = insertelement <4 x i32> poison, i32 %166, i64 0
%181 = shufflevector <4 x i32> %180, <4 x i32> poison, <4 x i32> zeroinitializer
%182 = add <4 x i32> %181, <i32 0, i32 1, i32 2, i32 3>
%183 = add i64 %176, -8
%184 = lshr exact i64 %183, 3
%185 = add nuw nsw i64 %184, 1
%186 = and i64 %185, 1
%187 = icmp eq i64 %183, 0
br i1 %187, label %222, label %188
188: ; preds = %175
%189 = and i64 %185, 4611686018427387902
br label %190
190: ; preds = %190, %188
%191 = phi i64 [ 0, %188 ], [ %218, %190 ]
%192 = phi <4 x i32> [ %182, %188 ], [ %219, %190 ]
%193 = phi i64 [ 0, %188 ], [ %220, %190 ]
%194 = sub i64 %98, %191
%195 = add <4 x i32> %192, <i32 4, i32 4, i32 4, i32 4>
%196 = add nsw i64 %194, %172
%197 = getelementptr inbounds i32, i32* %1, i64 %196
%198 = shufflevector <4 x i32> %192, <4 x i32> poison, <4 x i32> <i32 3, i32 2, i32 1, i32 0>
%199 = getelementptr inbounds i32, i32* %197, i64 -3
%200 = bitcast i32* %199 to <4 x i32>*
store <4 x i32> %198, <4 x i32>* %200
%201 = shufflevector <4 x i32> %195, <4 x i32> poison, <4 x i32> <i32 3, i32 2, i32 1, i32 0>
%202 = getelementptr inbounds i32, i32* %197, i64 -4
%203 = getelementptr inbounds i32, i32* %202, i64 -3
%204 = bitcast i32* %203 to <4 x i32>*
store <4 x i32> %201, <4 x i32>* %204
%205 = or i64 %191, 8
%206 = add <4 x i32> %192, <i32 8, i32 8, i32 8, i32 8>
%207 = sub i64 %98, %205
%208 = add <4 x i32> %192, <i32 12, i32 12, i32 12, i32 12>
%209 = add nsw i64 %207, %172
%210 = getelementptr inbounds i32, i32* %1, i64 %209
%211 = shufflevector <4 x i32> %206, <4 x i32> poison, <4 x i32> <i32 3, i32 2, i32 1, i32 0>
%212 = getelementptr inbounds i32, i32* %210, i64 -3
%213 = bitcast i32* %212 to <4 x i32>*
store <4 x i32> %211, <4 x i32>* %213
%214 = shufflevector <4 x i32> %208, <4 x i32> poison, <4 x i32> <i32 3, i32 2, i32 1, i32 0>
%215 = getelementptr inbounds i32, i32* %210, i64 -4
%216 = getelementptr inbounds i32, i32* %215, i64 -3
%217 = bitcast i32* %216 to <4 x i32>*
store <4 x i32> %214, <4 x i32>* %217
%218 = add nuw i64 %191, 16
%219 = add <4 x i32> %192, <i32 16, i32 16, i32 16, i32 16>
%220 = add i64 %193, 2
%221 = icmp eq i64 %220, %189
br i1 %221, label %222, label %190
222: ; preds = %190, %175
%223 = phi i64 [ 0, %175 ], [ %218, %190 ]
%224 = phi <4 x i32> [ %182, %175 ], [ %219, %190 ]
%225 = icmp eq i64 %186, 0
br i1 %225, label %238, label %226
226: ; preds = %222
%227 = sub i64 %98, %223
%228 = add <4 x i32> %224, <i32 4, i32 4, i32 4, i32 4>
%229 = add nsw i64 %227, %172
%230 = getelementptr inbounds i32, i32* %1, i64 %229
%231 = shufflevector <4 x i32> %224, <4 x i32> poison, <4 x i32> <i32 3, i32 2, i32 1, i32 0>
%232 = getelementptr inbounds i32, i32* %230, i64 -3
%233 = bitcast i32* %232 to <4 x i32>*
store <4 x i32> %231, <4 x i32>* %233
%234 = shufflevector <4 x i32> %228, <4 x i32> poison, <4 x i32> <i32 3, i32 2, i32 1, i32 0>
%235 = getelementptr inbounds i32, i32* %230, i64 -4
%236 = getelementptr inbounds i32, i32* %235, i64 -3
%237 = bitcast i32* %236 to <4 x i32>*
store <4 x i32> %234, <4 x i32>* %237
br label %238
238: ; preds = %222, %226
%239 = icmp eq i64 %173, %176
br i1 %239, label %252, label %240
240: ; preds = %170, %238
%241 = phi i64 [ %98, %170 ], [ %177, %238 ]
%242 = phi i32 [ %166, %170 ], [ %179, %238 ]
br label %281
243: ; preds = %154, %243
%244 = phi i64 [ %250, %243 ], [ %155, %154 ]
%245 = phi i32 [ %249, %243 ], [ %156, %154 ]
%246 = mul nsw i64 %244, %6
%247 = add nsw i64 %246, %98
%248 = getelementptr inbounds i32, i32* %1, i64 %247
store i32 %245, i32* %248
%249 = add nsw i32 %245, 1
%250 = add nuw nsw i64 %244, 1
%251 = icmp slt i64 %250, %37
br i1 %251, label %243, label %165
252: ; preds = %281, %238, %165
%253 = phi i64 [ %96, %165 ], [ %177, %238 ], [ %287, %281 ]
%254 = phi i32 [ %166, %165 ], [ %179, %238 ], [ %286, %281 ]
%255 = and i64 %167, 4294967295
%256 = icmp ult i64 %11, %255
br i1 %256, label %257, label %317
257: ; preds = %252
%258 = shl i64 %253, 32
%259 = ashr exact i64 %258, 32
%260 = sub i64 %167, %11
%261 = add nsw i64 %255, %14
%262 = and i64 %260, 3
%263 = icmp eq i64 %262, 0
br i1 %263, label %275, label %264
264: ; preds = %257, %264
%265 = phi i64 [ %272, %264 ], [ %255, %257 ]
%266 = phi i32 [ %271, %264 ], [ %254, %257 ]
%267 = phi i64 [ %273, %264 ], [ 0, %257 ]
%268 = mul nsw i64 %265, %6
%269 = add nsw i64 %268, %259
%270 = getelementptr inbounds i32, i32* %1, i64 %269
store i32 %266, i32* %270
%271 = add nsw i32 %266, 1
%272 = add nsw i64 %265, -1
%273 = add i64 %267, 1
%274 = icmp eq i64 %273, %262
br i1 %274, label %275, label %264
275: ; preds = %264, %257
%276 = phi i64 [ %255, %257 ], [ %272, %264 ]
%277 = phi i32 [ %254, %257 ], [ %271, %264 ]
%278 = phi i32 [ undef, %257 ], [ %271, %264 ]
%279 = phi i64 [ undef, %257 ], [ %272, %264 ]
%280 = icmp ult i64 %261, 3
br i1 %280, label %313, label %289
281: ; preds = %240, %281
%282 = phi i64 [ %287, %281 ], [ %241, %240 ]
%283 = phi i32 [ %286, %281 ], [ %242, %240 ]
%284 = add nsw i64 %282, %172
%285 = getelementptr inbounds i32, i32* %1, i64 %284
store i32 %283, i32* %285
%286 = add nsw i32 %283, 1
%287 = add nsw i64 %282, -1
%288 = icmp sgt i64 %287, %11
br i1 %288, label %281, label %252
289: ; preds = %275, %289
%290 = phi i64 [ %311, %289 ], [ %276, %275 ]
%291 = phi i32 [ %310, %289 ], [ %277, %275 ]
%292 = mul nsw i64 %290, %6
%293 = add nsw i64 %292, %259
%294 = getelementptr inbounds i32, i32* %1, i64 %293
store i32 %291, i32* %294
%295 = add nsw i32 %291, 1
%296 = add nsw i64 %290, -1
%297 = mul nsw i64 %296, %6
%298 = add nsw i64 %297, %259
%299 = getelementptr inbounds i32, i32* %1, i64 %298
store i32 %295, i32* %299
%300 = add nsw i32 %291, 2
%301 = add nsw i64 %290, -2
%302 = mul nsw i64 %301, %6
%303 = add nsw i64 %302, %259
%304 = getelementptr inbounds i32, i32* %1, i64 %303
store i32 %300, i32* %304
%305 = add nsw i32 %291, 3
%306 = add nsw i64 %290, -3
%307 = mul nsw i64 %306, %6
%308 = add nsw i64 %307, %259
%309 = getelementptr inbounds i32, i32* %1, i64 %308
store i32 %305, i32* %309
%310 = add nsw i32 %291, 4
%311 = add nsw i64 %290, -4
%312 = icmp sgt i64 %311, %11
br i1 %312, label %289, label %313
313: ; preds = %289, %275
%314 = phi i32 [ %278, %275 ], [ %310, %289 ]
%315 = phi i64 [ %279, %275 ], [ %311, %289 ]
%316 = trunc i64 %315 to i32
br label %317
317: ; preds = %313, %252
%318 = phi i32 [ %168, %252 ], [ %316, %313 ]
%319 = phi i32 [ %254, %252 ], [ %314, %313 ]
%320 = add nsw i32 %318, 1
%321 = add nuw nsw i64 %11, 1
%322 = add nsw i64 %10, -2
%323 = icmp sgt i64 %10, 2
br i1 %323, label %9, label %324
324: ; preds = %317
%325 = trunc i64 %253 to i32
%326 = trunc i64 %322 to i32
%327 = add i32 %325, 1
br label %328
328: ; preds = %324, %2
%329 = phi i32 [ 0, %2 ], [ %320, %324 ]
%330 = phi i32 [ 1, %2 ], [ %327, %324 ]
%331 = phi i32 [ %3, %2 ], [ %326, %324 ]
%332 = phi i32 [ 1, %2 ], [ %319, %324 ]
%333 = icmp eq i32 %331, 0
br i1 %333, label %334, label %339
334: ; preds = %328
%335 = mul nsw i32 %329, %0
%336 = add nsw i32 %330, %335
%337 = sext i32 %336 to i64
%338 = getelementptr inbounds i32, i32* %1, i64 %337
store i32 %332, i32* %338
br label %339
339: ; preds = %334, %328
ret void
}