#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 *atoi(char *);
int /*<<< orphan*/ exit(int);
int /*<<< orphan*/ free(int *);
scalar_t__ malloc(int);
int /*<<< orphan*/ permute(int *, int);
int /*<<< orphan*/ printf(char *, ...);
int /*<<< orphan*/ srandom(unsigned int);
int /*<<< orphan*/ strcpy(char *, char *);
char *strrchr(char *, char);
int main(int argc, char *argv[]) {
  char *ptr, program[256], command[256];
  int nseq, i, j, k, c, *seq;
  unsigned int iseed = 0;
  if (!(ptr = strrchr(argv[0], '/')))
    ptr = argv[0];
  else
    ptr++;
  strcpy(program, ptr);
  for (k = 0, i = 1; i < argc; i++) {
    if (*argv[i] == '-') {
      strcpy(command, argv[i]);
      ptr = command;
      while (c = *ptr++)
        switch (c) {
        case 's':
          iseed = atoi(ptr);
          *ptr = '\0';
          break;
        }
    } else
      switch (k) {
      case 0:
        nseq = atoi(argv[i]);
        k++;
        break;
      }
  }
  if (k < 1) {
    printf("Usage: %s <int n>\n", program);
    printf(" e.g., %s 31 -s10\n", program);
    printf("\toption\n");
    printf("\t-s<int>\tspecifcy randomization seed\n");
    printf("N.B.:\tif a seed (option -n) is not specified or if the seed is 0 "
           "permutation is suppressed\n");
    printf("N.B.:\t%s prints to stdout seed-dependent randomly permuted "
           "integers in the range [1 <n>]\n",
           program);
    exit(1);
  }
  seq = (int *)malloc(nseq * sizeof(int));
  if (!seq) {
    printf("%s: memory allocation error\n", program);
    exit(-1);
  }
  if (iseed) {
    srandom(iseed);
    permute(seq, nseq);
  } else {
    for (k = 0; k < nseq; k++)
      seq[k] = k;
  }
  for (k = 0; k < nseq; k++)
    printf("%d ", seq[k] + 1);
  free(seq);
  return 0;
}


x86 assembly (clang, -O0):
<main>:
push   %rbp
mov    %rsp,%rbp
sub    $0x250,%rsp
movl   $0x0,-0x4(%rbp)
mov    %edi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
movl   $0x0,-0x244(%rbp)
mov    -0x10(%rbp),%rax
mov    (%rax),%rdi
mov    $0x2f,%esi
call   1080 <strrchr@plt>
mov    %rax,-0x18(%rbp)
cmp    $0x0,%rax
jne    11e2 <main+0x52>
mov    -0x10(%rbp),%rax
mov    (%rax),%rax
mov    %rax,-0x18(%rbp)
jmp    11ee <main+0x5e>
mov    -0x18(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x18(%rbp)
lea    -0x120(%rbp),%rdi
mov    -0x18(%rbp),%rsi
call   1050 <strcpy@plt>
movl   $0x0,-0x230(%rbp)
movl   $0x1,-0x228(%rbp)
mov    -0x228(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    1311 <main+0x181>
mov    -0x10(%rbp),%rax
movslq -0x228(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movsbl (%rax),%eax
cmp    $0x2d,%eax
jne    12b7 <main+0x127>
lea    -0x220(%rbp),%rdi
mov    -0x10(%rbp),%rax
movslq -0x228(%rbp),%rcx
mov    (%rax,%rcx,8),%rsi
call   1050 <strcpy@plt>
lea    -0x220(%rbp),%rax
mov    %rax,-0x18(%rbp)
mov    -0x18(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x18(%rbp)
movsbl (%rax),%eax
mov    %eax,-0x234(%rbp)
cmp    $0x0,%eax
je     12b2 <main+0x122>
mov    -0x234(%rbp),%eax
sub    $0x73,%eax
jne    12ad <main+0x11d>
jmp    1297 <main+0x107>
mov    -0x18(%rbp),%rdi
call   10a0 <atoi@plt>
mov    %eax,-0x244(%rbp)
mov    -0x18(%rbp),%rax
movb   $0x0,(%rax)
jmp    1262 <main+0xd2>
jmp    12f8 <main+0x168>
mov    -0x230(%rbp),%eax
test   %eax,%eax
jne    12f3 <main+0x163>
jmp    12ca <main+0x13a>
mov    -0x10(%rbp),%rax
movslq -0x228(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
call   10a0 <atoi@plt>
mov    %eax,-0x224(%rbp)
mov    -0x230(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x230(%rbp)
jmp    12f8 <main+0x168>
jmp    12fd <main+0x16d>
mov    -0x228(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x228(%rbp)
jmp    1212 <main+0x82>
cmpl   $0x1,-0x230(%rbp)
jge    1391 <main+0x201>
lea    -0x120(%rbp),%rsi
lea    0xcd4(%rip),%rdi
mov    $0x0,%al
call   1070 <printf@plt>
lea    -0x120(%rbp),%rsi
lea    0xcd2(%rip),%rdi
mov    $0x0,%al
call   1070 <printf@plt>
lea    0xcd7(%rip),%rdi
mov    $0x0,%al
call   1070 <printf@plt>
lea    0xcd2(%rip),%rdi
mov    $0x0,%al
call   1070 <printf@plt>
lea    0xcea(%rip),%rdi
mov    $0x0,%al
call   1070 <printf@plt>
lea    -0x120(%rbp),%rsi
lea    0xd31(%rip),%rdi
mov    $0x0,%al
call   1070 <printf@plt>
mov    $0x1,%edi
call   10b0 <exit@plt>
movslq -0x224(%rbp),%rax
shl    $0x2,%rax
mov    %eax,%edi
call   1090 <malloc@plt>
mov    %rax,-0x240(%rbp)
cmpq   $0x0,-0x240(%rbp)
jne    13d7 <main+0x247>
lea    -0x120(%rbp),%rsi
lea    0xd45(%rip),%rdi
mov    $0x0,%al
call   1070 <printf@plt>
mov    $0xffffffff,%edi
call   10b0 <exit@plt>
cmpl   $0x0,-0x244(%rbp)
je     1406 <main+0x276>
mov    -0x244(%rbp),%edi
call   1040 <srandom@plt>
mov    -0x240(%rbp),%rdi
mov    -0x224(%rbp),%esi
call   1060 <permute@plt>
jmp    1452 <main+0x2c2>
movl   $0x0,-0x230(%rbp)
mov    -0x230(%rbp),%eax
cmp    -0x224(%rbp),%eax
jge    144d <main+0x2bd>
mov    -0x230(%rbp),%edx
mov    -0x240(%rbp),%rax
movslq -0x230(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x230(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x230(%rbp)
jmp    1410 <main+0x280>
jmp    1452 <main+0x2c2>
movl   $0x0,-0x230(%rbp)
mov    -0x230(%rbp),%eax
cmp    -0x224(%rbp),%eax
jge    14a4 <main+0x314>
mov    -0x240(%rbp),%rax
movslq -0x230(%rbp),%rcx
mov    (%rax,%rcx,4),%esi
add    $0x1,%esi
lea    0xc9f(%rip),%rdi
mov    $0x0,%al
call   1070 <printf@plt>
mov    -0x230(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x230(%rbp)
jmp    145c <main+0x2cc>
mov    -0x240(%rbp),%rdi
call   1030 <free@plt>
xor    %eax,%eax
add    $0x250,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<main>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x218,%rsp
mov    %rsi,%r13
mov    %edi,%ebp
mov    (%rsi),%rbx
mov    %rbx,%rdi
mov    $0x2f,%esi
call   1090 <strrchr@plt>
lea    0x1(%rax),%rsi
test   %rax,%rax
cmove  %rbx,%rsi
lea    0x10(%rsp),%rdi
call   1050 <strcpy@plt>
cmp    $0x2,%ebp
jl     1486 <main+0x2e6>
mov    %ebp,%ebp
xor    %eax,%eax
mov    %rax,0x8(%rsp)
mov    $0x1,%r14d
lea    0x110(%rsp),%r12
mov    %rax,(%rsp)
xor    %r15d,%r15d
jmp    1224 <main+0x84>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
test   %r15d,%r15d
je     1261 <main+0xc1>
mov    $0x1,%r15d
add    $0x1,%r14
cmp    %rbp,%r14
je     126f <main+0xcf>
mov    0x0(%r13,%r14,8),%rsi
cmpb   $0x2d,(%rsi)
jne    1210 <main+0x70>
mov    %r12,%rdi
call   1050 <strcpy@plt>
mov    %r12,%rbx
nopl   0x0(%rax)
movzbl (%rbx),%eax
test   %al,%al
je     121b <main+0x7b>
add    $0x1,%rbx
cmp    $0x73,%al
jne    1240 <main+0xa0>
mov    %rbx,%rdi
call   10b0 <atoi@plt>
mov    %rax,0x8(%rsp)
movb   $0x0,(%rbx)
jmp    1240 <main+0xa0>
mov    %rsi,%rdi
call   10b0 <atoi@plt>
mov    %rax,(%rsp)
jmp    1215 <main+0x75>
test   %r15d,%r15d
jle    1486 <main+0x2e6>
mov    (%rsp),%rbx
lea    0x0(,%rbx,4),%edi
call   10a0 <malloc@plt>
test   %rax,%rax
je     14ec <main+0x34c>
mov    %rax,%r12
mov    0x8(%rsp),%rdi
test   %edi,%edi
je     12b1 <main+0x111>
call   1040 <srandom@plt>
mov    %r12,%rdi
mov    %ebx,%esi
call   1070 <permute@plt>
jmp    143d <main+0x29d>
test   %ebx,%ebx
jle    146a <main+0x2ca>
mov    %ebx,%eax
cmp    $0x8,%ebx
jae    12c7 <main+0x127>
xor    %ecx,%ecx
jmp    1430 <main+0x290>
mov    %eax,%ecx
and    $0xfffffff8,%ecx
lea    -0x8(%rcx),%rdi
mov    %rdi,%rsi
shr    $0x3,%rsi
add    $0x1,%rsi
mov    %esi,%edx
and    $0x3,%edx
cmp    $0x18,%rdi
jae    12f5 <main+0x155>
movdqa 0xd12(%rip),%xmm0
xor    %edi,%edi
jmp    13d0 <main+0x230>
and    $0xfffffffffffffffc,%rsi
movdqa 0xcff(%rip),%xmm0
xor    %edi,%edi
movdqa 0xd04(%rip),%xmm8
movdqa 0xd0b(%rip),%xmm9
movdqa 0xd12(%rip),%xmm10
movdqa 0xd1a(%rip),%xmm4
movdqa 0xd22(%rip),%xmm5
movdqa 0xd2a(%rip),%xmm6
movdqa 0xd32(%rip),%xmm7
movdqa 0xd3a(%rip),%xmm1
cs nopw 0x0(%rax,%rax,1)
movdqa %xmm0,%xmm2
paddd  %xmm8,%xmm2
movdqu %xmm0,(%r12,%rdi,4)
movdqu %xmm2,0x10(%r12,%rdi,4)
movdqa %xmm0,%xmm2
paddd  %xmm9,%xmm2
movdqa %xmm0,%xmm3
paddd  %xmm10,%xmm3
movdqu %xmm2,0x20(%r12,%rdi,4)
movdqu %xmm3,0x30(%r12,%rdi,4)
movdqa %xmm0,%xmm2
paddd  %xmm4,%xmm2
movdqa %xmm0,%xmm3
paddd  %xmm5,%xmm3
movdqu %xmm2,0x40(%r12,%rdi,4)
movdqu %xmm3,0x50(%r12,%rdi,4)
movdqa %xmm0,%xmm2
paddd  %xmm6,%xmm2
movdqa %xmm0,%xmm3
paddd  %xmm7,%xmm3
movdqu %xmm2,0x60(%r12,%rdi,4)
movdqu %xmm3,0x70(%r12,%rdi,4)
add    $0x20,%rdi
paddd  %xmm1,%xmm0
add    $0xfffffffffffffffc,%rsi
jne    1350 <main+0x1b0>
test   %rdx,%rdx
je     1420 <main+0x280>
lea    (%r12,%rdi,4),%rsi
add    $0x10,%rsi
shl    $0x5,%rdx
xor    %edi,%edi
movdqa 0xc25(%rip),%xmm1
movdqa 0xc2d(%rip),%xmm2
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movdqa %xmm0,%xmm3
paddd  %xmm1,%xmm3
movdqu %xmm0,-0x10(%rsi,%rdi,1)
movdqu %xmm3,(%rsi,%rdi,1)
paddd  %xmm2,%xmm0
add    $0x20,%rdi
cmp    %rdi,%rdx
jne    1400 <main+0x260>
cmp    %rax,%rcx
je     143d <main+0x29d>
cs nopw 0x0(%rax,%rax,1)
nop
mov    %ecx,(%r12,%rcx,4)
add    $0x1,%rcx
cmp    %rcx,%rax
jne    1430 <main+0x290>
test   %ebx,%ebx
jle    146a <main+0x2ca>
mov    %ebx,%ebp
lea    0xce3(%rip),%r14
xor    %ebx,%ebx
nopl   0x0(%rax)
mov    (%r12,%rbx,4),%esi
add    $0x1,%esi
mov    %r14,%rdi
xor    %eax,%eax
call   1080 <printf@plt>
add    $0x1,%rbx
cmp    %rbx,%rbp
jne    1450 <main+0x2b0>
mov    %r12,%rdi
call   1030 <free@plt>
xor    %eax,%eax
add    $0x218,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
lea    0xc03(%rip),%rdi
lea    0x10(%rsp),%rbx
mov    %rbx,%rsi
xor    %eax,%eax
call   1080 <printf@plt>
lea    0xc00(%rip),%rdi
mov    %rbx,%rsi
xor    %eax,%eax
call   1080 <printf@plt>
lea    0xc7d(%rip),%rdi
call   1060 <puts@plt>
lea    0xc79(%rip),%rdi
call   1060 <puts@plt>
lea    0xc92(%rip),%rdi
call   1060 <puts@plt>
lea    0xbde(%rip),%rdi
mov    %rbx,%rsi
xor    %eax,%eax
call   1080 <printf@plt>
mov    $0x1,%edi
call   10c0 <exit@plt>
lea    0xc1d(%rip),%rdi
lea    0x10(%rsp),%rsi
xor    %eax,%eax
call   1080 <printf@plt>
mov    $0xffffffff,%edi
call   10c0 <exit@plt>

LLVM IR (-O0):
@.str = [19 x i8] c"Usage: %s <int n>\0A\00"
@.str.1 = [19 x i8] c" e.g., %s 31 -s10\0A\00"
@.str.2 = [9 x i8] c"\09option\0A\00"
@.str.3 = [38 x i8] c"\09-s<int>\09specifcy randomization seed\0A\00"
@.str.4 = [92 x i8] c"N.B.:\09if a seed (option -n) is not specified or if the seed is 0 permutation is suppressed\0A\00"
@.str.5 = [90 x i8] c"N.B.:\09%s prints to stdout seed-dependent randomly permuted integers in the range [1 <n>]\0A\00"
@.str.6 = [29 x i8] c"%s: memory allocation error\0A\00"
@.str.7 = [4 x i8] c"%d \00"
define i32 @main(i32 %0, i8** %1) {
%3 = alloca i32
%4 = alloca i32
%5 = alloca i8**
%6 = alloca i8*
%7 = alloca [256 x i8]
%8 = alloca [256 x i8]
%9 = alloca i32
%10 = alloca i32
%11 = alloca i32
%12 = alloca i32
%13 = alloca i32
%14 = alloca i32*
%15 = alloca i32
store i32 0, i32* %3
store i32 %0, i32* %4
store i8** %1, i8*** %5
store i32 0, i32* %15
%16 = load i8**, i8*** %5
%17 = getelementptr inbounds i8*, i8** %16, i64 0
%18 = load i8*, i8** %17
%19 = call i8* @strrchr(i8* %18, i8 signext 47)
store i8* %19, i8** %6
%20 = icmp ne i8* %19, null
br i1 %20, label %25, label %21
21: ; preds = %2
%22 = load i8**, i8*** %5
%23 = getelementptr inbounds i8*, i8** %22, i64 0
%24 = load i8*, i8** %23
store i8* %24, i8** %6
br label %28
25: ; preds = %2
%26 = load i8*, i8** %6
%27 = getelementptr inbounds i8, i8* %26, i32 1
store i8* %27, i8** %6
br label %28
28: ; preds = %25, %21
%29 = getelementptr inbounds [256 x i8], [256 x i8]* %7, i64 0, i64 0
%30 = load i8*, i8** %6
%31 = call i32 @strcpy(i8* %29, i8* %30)
store i32 0, i32* %12
store i32 1, i32* %10
br label %32
32: ; preds = %83, %28
%33 = load i32, i32* %10
%34 = load i32, i32* %4
%35 = icmp slt i32 %33, %34
br i1 %35, label %36, label %86
36: ; preds = %32
%37 = load i8**, i8*** %5
%38 = load i32, i32* %10
%39 = sext i32 %38 to i64
%40 = getelementptr inbounds i8*, i8** %37, i64 %39
%41 = load i8*, i8** %40
%42 = load i8, i8* %41
%43 = sext i8 %42 to i32
%44 = icmp eq i32 %43, 45
br i1 %44, label %45, label %69
45: ; preds = %36
%46 = getelementptr inbounds [256 x i8], [256 x i8]* %8, i64 0, i64 0
%47 = load i8**, i8*** %5
%48 = load i32, i32* %10
%49 = sext i32 %48 to i64
%50 = getelementptr inbounds i8*, i8** %47, i64 %49
%51 = load i8*, i8** %50
%52 = call i32 @strcpy(i8* %46, i8* %51)
%53 = getelementptr inbounds [256 x i8], [256 x i8]* %8, i64 0, i64 0
store i8* %53, i8** %6
br label %54
54: ; preds = %67, %45
%55 = load i8*, i8** %6
%56 = getelementptr inbounds i8, i8* %55, i32 1
store i8* %56, i8** %6
%57 = load i8, i8* %55
%58 = sext i8 %57 to i32
store i32 %58, i32* %13
%59 = icmp ne i32 %58, 0
br i1 %59, label %60, label %68
60: ; preds = %54
%61 = load i32, i32* %13
switch i32 %61, label %67 [
i32 115, label %62
]
62: ; preds = %60
%63 = load i8*, i8** %6
%64 = call i8* @atoi(i8* %63)
%65 = ptrtoint i8* %64 to i32
store i32 %65, i32* %15
%66 = load i8*, i8** %6
store i8 0, i8* %66
br label %67
67: ; preds = %60, %62
br label %54
68: ; preds = %54
br label %82
69: ; preds = %36
%70 = load i32, i32* %12
switch i32 %70, label %81 [
i32 0, label %71
]
71: ; preds = %69
%72 = load i8**, i8*** %5
%73 = load i32, i32* %10
%74 = sext i32 %73 to i64
%75 = getelementptr inbounds i8*, i8** %72, i64 %74
%76 = load i8*, i8** %75
%77 = call i8* @atoi(i8* %76)
%78 = ptrtoint i8* %77 to i32
store i32 %78, i32* %9
%79 = load i32, i32* %12
%80 = add nsw i32 %79, 1
store i32 %80, i32* %12
br label %81
81: ; preds = %69, %71
br label %82
82: ; preds = %81, %68
br label %83
83: ; preds = %82
%84 = load i32, i32* %10
%85 = add nsw i32 %84, 1
store i32 %85, i32* %10
br label %32
86: ; preds = %32
%87 = load i32, i32* %12
%88 = icmp slt i32 %87, 1
br i1 %88, label %89, label %100
89: ; preds = %86
%90 = getelementptr inbounds [256 x i8], [256 x i8]* %7, i64 0, i64 0
%91 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([19 x i8], [19 x i8]* @.str, i64 0, i64 0), i8* %90)
%92 = getelementptr inbounds [256 x i8], [256 x i8]* %7, i64 0, i64 0
%93 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([19 x i8], [19 x i8]* @.str.1, i64 0, i64 0), i8* %92)
%94 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.2, i64 0, i64 0))
%95 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([38 x i8], [38 x i8]* @.str.3, i64 0, i64 0))
%96 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([92 x i8], [92 x i8]* @.str.4, i64 0, i64 0))
%97 = getelementptr inbounds [256 x i8], [256 x i8]* %7, i64 0, i64 0
%98 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([90 x i8], [90 x i8]* @.str.5, i64 0, i64 0), i8* %97)
%99 = call i32 @exit(i32 1)
unreachable
100: ; preds = %86
%101 = load i32, i32* %9
%102 = sext i32 %101 to i64
%103 = mul i64 %102, 4
%104 = trunc i64 %103 to i32
%105 = call i64 @malloc(i32 %104)
%106 = inttoptr i64 %105 to i32*
store i32* %106, i32** %14
%107 = load i32*, i32** %14
%108 = icmp ne i32* %107, null
br i1 %108, label %113, label %109
109: ; preds = %100
%110 = getelementptr inbounds [256 x i8], [256 x i8]* %7, i64 0, i64 0
%111 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([29 x i8], [29 x i8]* @.str.6, i64 0, i64 0), i8* %110)
%112 = call i32 @exit(i32 -1)
unreachable
113: ; preds = %100
%114 = load i32, i32* %15
%115 = icmp ne i32 %114, 0
br i1 %115, label %116, label %122
116: ; preds = %113
%117 = load i32, i32* %15
%118 = call i32 @srandom(i32 %117)
%119 = load i32*, i32** %14
%120 = load i32, i32* %9
%121 = call i32 @permute(i32* %119, i32 %120)
br label %137
122: ; preds = %113
store i32 0, i32* %12
br label %123
123: ; preds = %133, %122
%124 = load i32, i32* %12
%125 = load i32, i32* %9
%126 = icmp slt i32 %124, %125
br i1 %126, label %127, label %136
127: ; preds = %123
%128 = load i32, i32* %12
%129 = load i32*, i32** %14
%130 = load i32, i32* %12
%131 = sext i32 %130 to i64
%132 = getelementptr inbounds i32, i32* %129, i64 %131
store i32 %128, i32* %132
br label %133
133: ; preds = %127
%134 = load i32, i32* %12
%135 = add nsw i32 %134, 1
store i32 %135, i32* %12
br label %123
136: ; preds = %123
br label %137
137: ; preds = %136, %116
store i32 0, i32* %12
br label %138
138: ; preds = %150, %137
%139 = load i32, i32* %12
%140 = load i32, i32* %9
%141 = icmp slt i32 %139, %140
br i1 %141, label %142, label %153
142: ; preds = %138
%143 = load i32*, i32** %14
%144 = load i32, i32* %12
%145 = sext i32 %144 to i64
%146 = getelementptr inbounds i32, i32* %143, i64 %145
%147 = load i32, i32* %146
%148 = add nsw i32 %147, 1
%149 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.7, i64 0, i64 0), i32 %148)
br label %150
150: ; preds = %142
%151 = load i32, i32* %12
%152 = add nsw i32 %151, 1
store i32 %152, i32* %12
br label %138
153: ; preds = %138
%154 = load i32*, i32** %14
%155 = call i32 @free(i32* %154)
ret i32 0
}

LLVM IR (-O2):
@.str = [19 x i8] c"Usage: %s <int n>\0A\00"
@.str.1 = [19 x i8] c" e.g., %s 31 -s10\0A\00"
@.str.5 = [90 x i8] c"N.B.:\09%s prints to stdout seed-dependent randomly permuted integers in the range [1 <n>]\0A\00"
@.str.6 = [29 x i8] c"%s: memory allocation error\0A\00"
@.str.7 = [4 x i8] c"%d \00"
@str = [8 x i8] c"\09option\00"
@str.8 = [37 x i8] c"\09-s<int>\09specifcy randomization seed\00"
@str.9 = [91 x i8] c"N.B.:\09if a seed (option -n) is not specified or if the seed is 0 permutation is suppressed\00"
define i32 @main(i32 %0, i8** nocapture %1) {
%3 = alloca [256 x i8]
%4 = alloca [256 x i8]
%5 = getelementptr inbounds [256 x i8], [256 x i8]* %3, i64 0, i64 0
%6 = getelementptr inbounds [256 x i8], [256 x i8]* %4, i64 0, i64 0
%7 = load i8*, i8** %1
%8 = tail call i8* @strrchr(i8* dereferenceable(1) %7, i8 signext 47)
%9 = icmp eq i8* %8, null
%10 = getelementptr inbounds i8, i8* %8, i64 1
%11 = select i1 %9, i8* %7, i8* %10
%12 = call i32 @strcpy(i8* %5, i8* %11)
%13 = icmp sgt i32 %0, 1
br i1 %13, label %14, label %52
14: ; preds = %2
%15 = zext i32 %0 to i64
br label %16
16: ; preds = %14, %44
%17 = phi i64 [ 1, %14 ], [ %48, %44 ]
%18 = phi i32 [ 0, %14 ], [ %47, %44 ]
%19 = phi i32 [ undef, %14 ], [ %46, %44 ]
%20 = phi i32 [ 0, %14 ], [ %45, %44 ]
%21 = getelementptr inbounds i8*, i8** %1, i64 %17
%22 = load i8*, i8** %21
%23 = load i8, i8* %22
%24 = icmp eq i8 %23, 45
br i1 %24, label %25, label %38
25: ; preds = %16
%26 = call i32 @strcpy(i8* %6, i8* %22)
br label %27
27: ; preds = %34, %25
%28 = phi i8* [ %32, %34 ], [ %6, %25 ]
%29 = phi i32 [ %37, %34 ], [ %18, %25 ]
br label %30
30: ; preds = %27, %30
%31 = phi i8* [ %32, %30 ], [ %28, %27 ]
%32 = getelementptr inbounds i8, i8* %31, i64 1
%33 = load i8, i8* %31
switch i8 %33, label %30 [
i8 0, label %44
i8 115, label %34
]
34: ; preds = %30
%35 = call i8* @atoi(i8* %32)
%36 = ptrtoint i8* %35 to i64
%37 = trunc i64 %36 to i32
store i8 0, i8* %32
br label %27
38: ; preds = %16
%39 = icmp eq i32 %20, 0
br i1 %39, label %40, label %44
40: ; preds = %38
%41 = call i8* @atoi(i8* %22)
%42 = ptrtoint i8* %41 to i64
%43 = trunc i64 %42 to i32
br label %44
44: ; preds = %30, %38, %40
%45 = phi i32 [ 1, %40 ], [ 1, %38 ], [ %20, %30 ]
%46 = phi i32 [ %43, %40 ], [ %19, %38 ], [ %19, %30 ]
%47 = phi i32 [ %18, %40 ], [ %18, %38 ], [ %29, %30 ]
%48 = add nuw nsw i64 %17, 1
%49 = icmp eq i64 %48, %15
br i1 %49, label %50, label %16
50: ; preds = %44
%51 = icmp slt i32 %45, 1
br i1 %51, label %52, label %60
52: ; preds = %2, %50
%53 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([19 x i8], [19 x i8]* @.str, i64 0, i64 0), i8* %5)
%54 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([19 x i8], [19 x i8]* @.str.1, i64 0, i64 0), i8* %5)
%55 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([8 x i8], [8 x i8]* @str, i64 0, i64 0))
%56 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([37 x i8], [37 x i8]* @str.8, i64 0, i64 0))
%57 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([91 x i8], [91 x i8]* @str.9, i64 0, i64 0))
%58 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([90 x i8], [90 x i8]* @.str.5, i64 0, i64 0), i8* %5)
%59 = call i32 @exit(i32 1)
unreachable
60: ; preds = %50
%61 = shl i32 %46, 2
%62 = call i64 @malloc(i32 %61)
%63 = inttoptr i64 %62 to i32*
%64 = icmp eq i64 %62, 0
br i1 %64, label %65, label %68
65: ; preds = %60
%66 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([29 x i8], [29 x i8]* @.str.6, i64 0, i64 0), i8* %5)
%67 = call i32 @exit(i32 -1)
unreachable
68: ; preds = %60
%69 = icmp eq i32 %47, 0
br i1 %69, label %70, label %139
70: ; preds = %68
%71 = icmp sgt i32 %46, 0
br i1 %71, label %72, label %160
72: ; preds = %70
%73 = zext i32 %46 to i64
%74 = icmp ult i32 %46, 8
br i1 %74, label %137, label %75
75: ; preds = %72
%76 = and i64 %73, 4294967288
%77 = add nsw i64 %76, -8
%78 = lshr exact i64 %77, 3
%79 = add nuw nsw i64 %78, 1
%80 = and i64 %79, 3
%81 = icmp ult i64 %77, 24
br i1 %81, label %118, label %82
82: ; preds = %75
%83 = and i64 %79, 4611686018427387900
br label %84
84: ; preds = %84, %82
%85 = phi i64 [ 0, %82 ], [ %114, %84 ]
%86 = phi <4 x i32> [ <i32 0, i32 1, i32 2, i32 3>, %82 ], [ %115, %84 ]
%87 = phi i64 [ 0, %82 ], [ %116, %84 ]
%88 = add <4 x i32> %86, <i32 4, i32 4, i32 4, i32 4>
%89 = getelementptr inbounds i32, i32* %63, i64 %85
%90 = bitcast i32* %89 to <4 x i32>*
store <4 x i32> %86, <4 x i32>* %90
%91 = getelementptr inbounds i32, i32* %89, i64 4
%92 = bitcast i32* %91 to <4 x i32>*
store <4 x i32> %88, <4 x i32>* %92
%93 = or i64 %85, 8
%94 = add <4 x i32> %86, <i32 8, i32 8, i32 8, i32 8>
%95 = add <4 x i32> %86, <i32 12, i32 12, i32 12, i32 12>
%96 = getelementptr inbounds i32, i32* %63, i64 %93
%97 = bitcast i32* %96 to <4 x i32>*
store <4 x i32> %94, <4 x i32>* %97
%98 = getelementptr inbounds i32, i32* %96, i64 4
%99 = bitcast i32* %98 to <4 x i32>*
store <4 x i32> %95, <4 x i32>* %99
%100 = or i64 %85, 16
%101 = add <4 x i32> %86, <i32 16, i32 16, i32 16, i32 16>
%102 = add <4 x i32> %86, <i32 20, i32 20, i32 20, i32 20>
%103 = getelementptr inbounds i32, i32* %63, i64 %100
%104 = bitcast i32* %103 to <4 x i32>*
store <4 x i32> %101, <4 x i32>* %104
%105 = getelementptr inbounds i32, i32* %103, i64 4
%106 = bitcast i32* %105 to <4 x i32>*
store <4 x i32> %102, <4 x i32>* %106
%107 = or i64 %85, 24
%108 = add <4 x i32> %86, <i32 24, i32 24, i32 24, i32 24>
%109 = add <4 x i32> %86, <i32 28, i32 28, i32 28, i32 28>
%110 = getelementptr inbounds i32, i32* %63, i64 %107
%111 = bitcast i32* %110 to <4 x i32>*
store <4 x i32> %108, <4 x i32>* %111
%112 = getelementptr inbounds i32, i32* %110, i64 4
%113 = bitcast i32* %112 to <4 x i32>*
store <4 x i32> %109, <4 x i32>* %113
%114 = add nuw i64 %85, 32
%115 = add <4 x i32> %86, <i32 32, i32 32, i32 32, i32 32>
%116 = add i64 %87, 4
%117 = icmp eq i64 %116, %83
br i1 %117, label %118, label %84
118: ; preds = %84, %75
%119 = phi i64 [ 0, %75 ], [ %114, %84 ]
%120 = phi <4 x i32> [ <i32 0, i32 1, i32 2, i32 3>, %75 ], [ %115, %84 ]
%121 = icmp eq i64 %80, 0
br i1 %121, label %135, label %122
122: ; preds = %118, %122
%123 = phi i64 [ %131, %122 ], [ %119, %118 ]
%124 = phi <4 x i32> [ %132, %122 ], [ %120, %118 ]
%125 = phi i64 [ %133, %122 ], [ 0, %118 ]
%126 = add <4 x i32> %124, <i32 4, i32 4, i32 4, i32 4>
%127 = getelementptr inbounds i32, i32* %63, i64 %123
%128 = bitcast i32* %127 to <4 x i32>*
store <4 x i32> %124, <4 x i32>* %128
%129 = getelementptr inbounds i32, i32* %127, i64 4
%130 = bitcast i32* %129 to <4 x i32>*
store <4 x i32> %126, <4 x i32>* %130
%131 = add nuw i64 %123, 8
%132 = add <4 x i32> %124, <i32 8, i32 8, i32 8, i32 8>
%133 = add i64 %125, 1
%134 = icmp eq i64 %133, %80
br i1 %134, label %135, label %122
135: ; preds = %122, %118
%136 = icmp eq i64 %76, %73
br i1 %136, label %148, label %137
137: ; preds = %72, %135
%138 = phi i64 [ 0, %72 ], [ %76, %135 ]
br label %142
139: ; preds = %68
%140 = call i32 @srandom(i32 %47)
%141 = call i32 @permute(i32* %63, i32 %46)
br label %148
142: ; preds = %137, %142
%143 = phi i64 [ %146, %142 ], [ %138, %137 ]
%144 = getelementptr inbounds i32, i32* %63, i64 %143
%145 = trunc i64 %143 to i32
store i32 %145, i32* %144
%146 = add nuw nsw i64 %143, 1
%147 = icmp eq i64 %146, %73
br i1 %147, label %148, label %142
148: ; preds = %142, %135, %139
%149 = icmp sgt i32 %46, 0
br i1 %149, label %150, label %160
150: ; preds = %148
%151 = zext i32 %46 to i64
br label %152
152: ; preds = %150, %152
%153 = phi i64 [ 0, %150 ], [ %158, %152 ]
%154 = getelementptr inbounds i32, i32* %63, i64 %153
%155 = load i32, i32* %154
%156 = add nsw i32 %155, 1
%157 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([4 x i8], [4 x i8]* @.str.7, i64 0, i64 0), i32 %156)
%158 = add nuw nsw i64 %153, 1
%159 = icmp eq i64 %158, %151
br i1 %159, label %160, label %152
160: ; preds = %152, %70, %148
%161 = call i32 @free(i32* %63)
ret i32 0
}