#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 */
typedef int key_t;

/* Variables and functions */
int IPC_CREAT;
int /*<<< orphan*/ exit(int);
scalar_t__ fork();
int getpid();
int getppid();
int /*<<< orphan*/ gets(char *);
int /*<<< orphan*/ printf(char *, ...);
void *shmat(int, int /*<<< orphan*/ *, int /*<<< orphan*/);
int shmget(int, int, int);
int strlen(char *);
int /*<<< orphan*/ waitpid(int, int /*<<< orphan*/ *, int /*<<< orphan*/);
int main() {
  int shmid, shm_size = 30, *shmInt, pid1, i = -1, count1 = 0, count2 = 0;
  int pid2, pid3, len, j;
  char *shm, *temp, rev[30];
  key_t key = 4546, key2 = 6788;
  shmid = shmget(key, shm_size, IPC_CREAT | 0666);
  shm = shmat(shmid, NULL, 0);
  shmid = shmget(key2, 1, IPC_CREAT | 0666);
  shmInt = shmat(shmid, NULL, 0);
  *shmInt = 0;
  if (pid1 = fork() == 0) {
    while (*shmInt == 0)
      ;
    temp = shm;
    if (pid2 = fork() == 0) {
      len = strlen(temp);
      for (i = len - 1, j = 0; j < len; i--, j++)
        rev[j] = *(temp + i);
      rev[j] = '\0';
      printf("Proccess D---- Reverse = %s \n", rev);
      exit(1);
    } else {
      if (pid3 = fork() == 0) {
        printf("Poccess C--- ID of B = %d and ID of C = %d \n", getppid(),
               getpid());
        exit(1);
      } else {
        while (*(temp + (++i)) != '\0')
          if (*(temp + i) >= 'A' && *(temp + i) <= 'Z')
            count1++;
        i = -1;
        while (*(temp + (++i)) != '\0')
          if (*(temp + i) >= 'a' && *(temp + i) <= 'z')
            count2++;
        printf("Poccess B--- No of UpperCase letters = %d \n", count1);
        printf("Poccess B--- No of LowerCase letters = %d \n", count2);
        waitpid(pid2, NULL, 0);
        waitpid(pid3, NULL, 0);
      }
    }
    exit(1);
  } else {
    printf("Enter a sentence ");
    gets(shm);
    *shmInt = 1;
    temp = shm;
    while (*(temp + (++i)) != '\0')
      if (*(temp + i) == 'a' || *(temp + i) == 'e' || *(temp + i) == 'i' ||
          *(temp + i) == 'o' || *(temp + i) == 'u' || *(temp + i) == 'A' ||
          *(temp + i) == 'E' || *(temp + i) == 'I' || *(temp + i) == 'O' ||
          *(temp + i) == 'U')
        count1++;
    printf("Poccess A--- No of Vowels = %d \n", count1);
    waitpid(pid1, NULL, 0);
  }
  return 0;
}


x86 assembly (clang, -O0):
<main>:
push   %rbp
mov    %rsp,%rbp
sub    $0x80,%rsp
movl   $0x0,-0x4(%rbp)
movl   $0x1e,-0xc(%rbp)
movl   $0xffffffff,-0x20(%rbp)
movl   $0x0,-0x24(%rbp)
movl   $0x0,-0x28(%rbp)
movl   $0x11c2,-0x74(%rbp)
movl   $0x1a84,-0x78(%rbp)
mov    -0x74(%rbp),%edi
mov    -0xc(%rbp),%esi
mov    0x2df7(%rip),%rax
mov    (%rax),%edx
or     $0x1b6,%edx
call   1090 <shmget@plt>
mov    %eax,-0x8(%rbp)
mov    -0x8(%rbp),%edi
xor    %eax,%eax
mov    %eax,%esi
xor    %edx,%edx
call   1080 <shmat@plt>
mov    %rax,-0x40(%rbp)
mov    -0x78(%rbp),%edi
mov    0x2dcb(%rip),%rax
mov    (%rax),%edx
or     $0x1b6,%edx
mov    $0x1,%esi
call   1090 <shmget@plt>
mov    %eax,-0x8(%rbp)
mov    -0x8(%rbp),%edi
xor    %eax,%eax
mov    %eax,%esi
xor    %edx,%edx
call   1080 <shmat@plt>
mov    %rax,-0x18(%rbp)
mov    -0x18(%rbp),%rax
movl   $0x0,(%rax)
mov    $0x0,%al
call   10c0 <fork@plt>
cmp    $0x0,%rax
sete   %al
mov    %al,%cl
and    $0x1,%cl
movzbl %cl,%ecx
mov    %ecx,-0x1c(%rbp)
test   $0x1,%al
jne    126c <main+0xcc>
jmp    147f <main+0x2df>
jmp    1271 <main+0xd1>
mov    -0x18(%rbp),%rax
cmpl   $0x0,(%rax)
jne    1283 <main+0xe3>
jmp    1271 <main+0xd1>
mov    -0x40(%rbp),%rax
mov    %rax,-0x48(%rbp)
mov    $0x0,%al
call   10c0 <fork@plt>
cmp    $0x0,%rax
sete   %al
mov    %al,%cl
and    $0x1,%cl
movzbl %cl,%ecx
mov    %ecx,-0x2c(%rbp)
test   $0x1,%al
jne    12b1 <main+0x111>
jmp    1328 <main+0x188>
mov    -0x48(%rbp),%rdi
call   1040 <strlen@plt>
mov    %eax,-0x34(%rbp)
mov    -0x34(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x20(%rbp)
movl   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x34(%rbp),%eax
jge    1303 <main+0x163>
mov    -0x48(%rbp),%rax
movslq -0x20(%rbp),%rcx
mov    (%rax,%rcx,1),%cl
movslq -0x38(%rbp),%rax
mov    %cl,-0x70(%rbp,%rax,1)
mov    -0x20(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x20(%rbp)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    12cd <main+0x12d>
movslq -0x38(%rbp),%rax
movb   $0x0,-0x70(%rbp,%rax,1)
lea    -0x70(%rbp),%rsi
lea    0xce9(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
mov    $0x1,%edi
call   10b0 <exit@plt>
mov    $0x0,%al
call   10c0 <fork@plt>
cmp    $0x0,%rax
sete   %al
mov    %al,%cl
and    $0x1,%cl
movzbl %cl,%ecx
mov    %ecx,-0x30(%rbp)
test   $0x1,%al
jne    134e <main+0x1ae>
jmp    137c <main+0x1dc>
mov    $0x0,%al
call   10a0 <getppid@plt>
mov    %eax,-0x7c(%rbp)
mov    $0x0,%al
call   1030 <getpid@plt>
mov    -0x7c(%rbp),%esi
mov    %eax,%edx
lea    0xcb3(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
mov    $0x1,%edi
call   10b0 <exit@plt>
jmp    1381 <main+0x1e1>
mov    -0x48(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
mov    %ecx,-0x20(%rbp)
movslq %ecx,%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x0,%eax
je     13d6 <main+0x236>
mov    -0x48(%rbp),%rax
movslq -0x20(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x41,%eax
jl     13d1 <main+0x231>
mov    -0x48(%rbp),%rax
movslq -0x20(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x5a,%eax
jg     13d1 <main+0x231>
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    1381 <main+0x1e1>
movl   $0xffffffff,-0x20(%rbp)
mov    -0x48(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
mov    %ecx,-0x20(%rbp)
movslq %ecx,%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x0,%eax
je     1432 <main+0x292>
mov    -0x48(%rbp),%rax
movslq -0x20(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x61,%eax
jl     142d <main+0x28d>
mov    -0x48(%rbp),%rax
movslq -0x20(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x7a,%eax
jg     142d <main+0x28d>
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    13dd <main+0x23d>
mov    -0x24(%rbp),%esi
lea    0xc0f(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
mov    -0x28(%rbp),%esi
lea    0xc2a(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
mov    -0x2c(%rbp),%edi
xor    %eax,%eax
mov    %eax,%esi
xor    %edx,%edx
call   1070 <waitpid@plt>
mov    -0x30(%rbp),%edi
xor    %eax,%eax
mov    %eax,%esi
xor    %edx,%edx
call   1070 <waitpid@plt>
jmp    1475 <main+0x2d5>
mov    $0x1,%edi
call   10b0 <exit@plt>
lea    0xc1d(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
mov    -0x40(%rbp),%rdi
call   1060 <gets@plt>
mov    -0x18(%rbp),%rax
movl   $0x1,(%rax)
mov    -0x40(%rbp),%rax
mov    %rax,-0x48(%rbp)
mov    -0x48(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
mov    %ecx,-0x20(%rbp)
movslq %ecx,%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x0,%eax
je     15a5 <main+0x405>
mov    -0x48(%rbp),%rax
movslq -0x20(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x61,%eax
je     1597 <main+0x3f7>
mov    -0x48(%rbp),%rax
movslq -0x20(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x65,%eax
je     1597 <main+0x3f7>
mov    -0x48(%rbp),%rax
movslq -0x20(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x69,%eax
je     1597 <main+0x3f7>
mov    -0x48(%rbp),%rax
movslq -0x20(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x6f,%eax
je     1597 <main+0x3f7>
mov    -0x48(%rbp),%rax
movslq -0x20(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x75,%eax
je     1597 <main+0x3f7>
mov    -0x48(%rbp),%rax
movslq -0x20(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x41,%eax
je     1597 <main+0x3f7>
mov    -0x48(%rbp),%rax
movslq -0x20(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x45,%eax
je     1597 <main+0x3f7>
mov    -0x48(%rbp),%rax
movslq -0x20(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x49,%eax
je     1597 <main+0x3f7>
mov    -0x48(%rbp),%rax
movslq -0x20(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x4f,%eax
je     1597 <main+0x3f7>
mov    -0x48(%rbp),%rax
movslq -0x20(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x55,%eax
jne    15a0 <main+0x400>
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    14a8 <main+0x308>
mov    -0x24(%rbp),%esi
lea    0xb06(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
mov    -0x1c(%rbp),%edi
xor    %eax,%eax
mov    %eax,%esi
xor    %edx,%edx
call   1070 <waitpid@plt>
xor    %eax,%eax
add    $0x80,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<main>:
push   %rbp
push   %r15
push   %r14
push   %rbx
sub    $0x28,%rsp
mov    0x2e2f(%rip),%r15
mov    $0x1b6,%ebp
mov    (%r15),%edx
or     %ebp,%edx
mov    $0x11c2,%edi
mov    $0x1e,%esi
call   1090 <shmget@plt>
xor    %ebx,%ebx
mov    %eax,%edi
xor    %esi,%esi
xor    %edx,%edx
call   1080 <shmat@plt>
mov    %rax,%r14
or     (%r15),%ebp
mov    $0x1a84,%edi
mov    $0x1,%esi
mov    %ebp,%edx
call   1090 <shmget@plt>
mov    %eax,%edi
xor    %esi,%esi
xor    %edx,%edx
call   1080 <shmat@plt>
mov    %rax,%rbp
movl   $0x0,(%rax)
xor    %eax,%eax
call   10c0 <fork@plt>
test   %rax,%rax
je     129e <main+0xfe>
lea    0xe8a(%rip),%rdi
xor    %eax,%eax
call   1050 <printf@plt>
mov    %r14,%rdi
call   1060 <gets@plt>
movl   $0x1,0x0(%rbp)
mov    $0xffffffffffffffff,%rax
movabs $0x10411100104111,%rcx
jmp    1254 <main+0xb4>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
test   %dl,%dl
je     1276 <main+0xd6>
movzbl 0x1(%r14,%rax,1),%edx
add    $0x1,%rax
lea    -0x41(%rdx),%esi
cmp    $0x34,%sil
ja     1250 <main+0xb0>
movzbl %sil,%esi
bt     %rsi,%rcx
jae    1250 <main+0xb0>
add    $0x1,%ebx
jmp    1254 <main+0xb4>
lea    0xe38(%rip),%rdi
mov    %ebx,%esi
xor    %eax,%eax
call   1050 <printf@plt>
xor    %edi,%edi
xor    %esi,%esi
xor    %edx,%edx
call   1070 <waitpid@plt>
xor    %eax,%eax
add    $0x28,%rsp
pop    %rbx
pop    %r14
pop    %r15
pop    %rbp
ret
xor    %eax,%eax
call   10c0 <fork@plt>
test   %rax,%rax
jne    134a <main+0x1aa>
mov    %r14,%rdi
call   1040 <strlen@plt>
test   %eax,%eax
jle    1384 <main+0x1e4>
mov    %eax,%ecx
cmp    $0x8,%eax
jb     12e2 <main+0x142>
lea    (%r14,%rcx,1),%rdx
mov    %rsp,%rsi
cmp    %rdx,%rsi
jae    142c <main+0x28c>
lea    (%rsp,%rcx,1),%rdx
cmp    %rdx,%r14
jae    142c <main+0x28c>
xor    %eax,%eax
mov    %rcx,%rdx
mov    %rax,%rsi
not    %rsi
add    %rcx,%rsi
mov    %rcx,%rdi
and    $0x3,%rdi
je     1310 <main+0x170>
movzbl -0x1(%r14,%rdx,1),%ebx
add    $0xffffffffffffffff,%rdx
mov    %bl,(%rsp,%rax,1)
add    $0x1,%rax
add    $0xffffffffffffffff,%rdi
jne    12f9 <main+0x159>
cmp    $0x3,%rsi
jb     1386 <main+0x1e6>
add    %r14,%rdx
add    $0xffffffffffffffff,%rdx
movzbl (%rdx),%ebx
mov    %bl,(%rsp,%rax,1)
movzbl -0x1(%rdx),%ebx
mov    %bl,0x1(%rsp,%rax,1)
movzbl -0x2(%rdx),%ebx
mov    %bl,0x2(%rsp,%rax,1)
movzbl -0x3(%rdx),%ebx
mov    %bl,0x3(%rsp,%rax,1)
add    $0x4,%rax
add    $0xfffffffffffffffc,%rdx
cmp    %rax,%rcx
jne    131d <main+0x17d>
jmp    1386 <main+0x1e6>
xor    %ebx,%ebx
xor    %eax,%eax
call   10c0 <fork@plt>
test   %rax,%rax
jne    13a5 <main+0x205>
xor    %eax,%eax
call   10a0 <getppid@plt>
mov    %eax,%ebx
xor    %eax,%eax
call   1030 <getpid@plt>
lea    0xcaf(%rip),%rdi
mov    %ebx,%esi
mov    %eax,%edx
xor    %eax,%eax
call   1050 <printf@plt>
mov    $0x1,%edi
call   10b0 <exit@plt>
xor    %ecx,%ecx
movb   $0x0,(%rsp,%rcx,1)
lea    0xc6f(%rip),%rdi
mov    %rsp,%rsi
xor    %eax,%eax
call   1050 <printf@plt>
mov    $0x1,%edi
call   10b0 <exit@plt>
mov    (%r14),%al
mov    $0x0,%ebp
test   %al,%al
je     13ec <main+0x24c>
lea    0x1(%r14),%rcx
xor    %ebx,%ebx
mov    %eax,%edx
add    $0xbf,%dl
cmp    $0x1a,%dl
adc    $0x0,%ebx
movzbl (%rcx),%edx
add    $0x1,%rcx
test   %dl,%dl
jne    13b9 <main+0x219>
xor    %ebp,%ebp
test   %al,%al
je     13ec <main+0x24c>
add    $0x1,%r14
xor    %ebp,%ebp
add    $0x9f,%al
cmp    $0x1a,%al
adc    $0x0,%ebp
movzbl (%r14),%eax
add    $0x1,%r14
test   %al,%al
jne    13d9 <main+0x239>
lea    0xc58(%rip),%rdi
mov    %ebx,%esi
xor    %eax,%eax
call   1050 <printf@plt>
lea    0xc74(%rip),%rdi
mov    %ebp,%esi
xor    %eax,%eax
call   1050 <printf@plt>
xor    %edi,%edi
xor    %esi,%esi
xor    %edx,%edx
call   1070 <waitpid@plt>
xor    %edi,%edi
xor    %esi,%esi
xor    %edx,%edx
call   1070 <waitpid@plt>
mov    $0x1,%edi
call   10b0 <exit@plt>
cmp    $0x20,%eax
jae    148d <main+0x2ed>
xor    %eax,%eax
mov    %rax,%rsi
mov    %ecx,%eax
and    $0xfffffff8,%eax
mov    %rcx,%rdx
sub    %rax,%rdx
mov    %rcx,%rdi
sub    %rsi,%rdi
add    %r14,%rdi
add    $0xfffffffffffffff8,%rdi
pxor   %xmm0,%xmm0
movq   (%rdi),%xmm1
punpcklbw %xmm0,%xmm1
pshufd $0x4e,%xmm1,%xmm1
pshuflw $0x1b,%xmm1,%xmm1
pshufhw $0x1b,%xmm1,%xmm1
packuswb %xmm1,%xmm1
movq   %xmm1,(%rsp,%rsi,1)
add    $0x8,%rsi
add    $0xfffffffffffffff8,%rdi
cmp    %rsi,%rax
jne    1452 <main+0x2b2>
cmp    %rcx,%rax
jne    12e7 <main+0x147>
jmp    1386 <main+0x1e6>
mov    %ecx,%eax
and    $0xffffffe0,%eax
lea    (%rcx,%r14,1),%rdx
add    $0xfffffffffffffff0,%rdx
xor    %esi,%esi
pxor   %xmm0,%xmm0
movdqu -0x10(%rdx),%xmm1
movdqu (%rdx),%xmm2
movdqa %xmm2,%xmm3
punpcklbw %xmm0,%xmm3
pshufd $0x4e,%xmm3,%xmm3
pshuflw $0x1b,%xmm3,%xmm3
pshufhw $0x1b,%xmm3,%xmm3
punpckhbw %xmm0,%xmm2
pshufd $0x4e,%xmm2,%xmm2
pshuflw $0x1b,%xmm2,%xmm2
pshufhw $0x1b,%xmm2,%xmm2
packuswb %xmm3,%xmm2
movdqa %xmm1,%xmm3
punpcklbw %xmm0,%xmm3
pshufd $0x4e,%xmm3,%xmm3
pshuflw $0x1b,%xmm3,%xmm3
pshufhw $0x1b,%xmm3,%xmm3
punpckhbw %xmm0,%xmm1
pshufd $0x4e,%xmm1,%xmm1
pshuflw $0x1b,%xmm1,%xmm1
pshufhw $0x1b,%xmm1,%xmm1
packuswb %xmm3,%xmm1
movdqa %xmm2,(%rsp,%rsi,1)
movdqa %xmm1,0x10(%rsp,%rsi,1)
add    $0x20,%rsi
add    $0xffffffffffffffe0,%rdx
cmp    %rsi,%rax
jne    14a0 <main+0x300>
cmp    %rcx,%rax
je     1386 <main+0x1e6>
test   $0x18,%cl
jne    1433 <main+0x293>
mov    %rcx,%rdx
sub    %rax,%rdx
jmp    12e7 <main+0x147>

LLVM IR (-O0):
@IPC_CREAT = global i32 0
@.str = [30 x i8] c"Proccess D---- Reverse = %s \0A\00"
@.str.1 = [45 x i8] c"Poccess C--- ID of B = %d and ID of C = %d \0A\00"
@.str.2 = [44 x i8] c"Poccess B--- No of UpperCase letters = %d \0A\00"
@.str.3 = [44 x i8] c"Poccess B--- No of LowerCase letters = %d \0A\00"
@.str.4 = [18 x i8] c"Enter a sentence \00"
@.str.5 = [33 x i8] c"Poccess A--- No of Vowels = %d \0A\00"
define i32 @main() {
%1 = alloca i32
%2 = alloca i32
%3 = alloca i32
%4 = alloca i32*
%5 = alloca i32
%6 = alloca i32
%7 = alloca i32
%8 = alloca i32
%9 = alloca i32
%10 = alloca i32
%11 = alloca i32
%12 = alloca i32
%13 = alloca i8*
%14 = alloca i8*
%15 = alloca [30 x i8]
%16 = alloca i32
%17 = alloca i32
store i32 0, i32* %1
store i32 30, i32* %3
store i32 -1, i32* %6
store i32 0, i32* %7
store i32 0, i32* %8
store i32 4546, i32* %16
store i32 6788, i32* %17
%18 = load i32, i32* %16
%19 = load i32, i32* %3
%20 = load i32, i32* @IPC_CREAT
%21 = or i32 %20, 438
%22 = call i32 @shmget(i32 %18, i32 %19, i32 %21)
store i32 %22, i32* %2
%23 = load i32, i32* %2
%24 = call i8* @shmat(i32 %23, i32* null, i32 0)
store i8* %24, i8** %13
%25 = load i32, i32* %17
%26 = load i32, i32* @IPC_CREAT
%27 = or i32 %26, 438
%28 = call i32 @shmget(i32 %25, i32 1, i32 %27)
store i32 %28, i32* %2
%29 = load i32, i32* %2
%30 = call i8* @shmat(i32 %29, i32* null, i32 0)
%31 = bitcast i8* %30 to i32*
store i32* %31, i32** %4
%32 = load i32*, i32** %4
store i32 0, i32* %32
%33 = call i64 (...) @fork()
%34 = icmp eq i64 %33, 0
%35 = zext i1 %34 to i32
store i32 %35, i32* %5
br i1 %34, label %36, label %158
36: ; preds = %0
br label %37
37: ; preds = %41, %36
%38 = load i32*, i32** %4
%39 = load i32, i32* %38
%40 = icmp eq i32 %39, 0
br i1 %40, label %41, label %42
41: ; preds = %37
br label %37
42: ; preds = %37
%43 = load i8*, i8** %13
store i8* %43, i8** %14
%44 = call i64 (...) @fork()
%45 = icmp eq i64 %44, 0
%46 = zext i1 %45 to i32
store i32 %46, i32* %9
br i1 %45, label %47, label %77
47: ; preds = %42
%48 = load i8*, i8** %14
%49 = call i32 @strlen(i8* %48)
store i32 %49, i32* %11
%50 = load i32, i32* %11
%51 = sub nsw i32 %50, 1
store i32 %51, i32* %6
store i32 0, i32* %12
br label %52
52: ; preds = %65, %47
%53 = load i32, i32* %12
%54 = load i32, i32* %11
%55 = icmp slt i32 %53, %54
br i1 %55, label %56, label %70
56: ; preds = %52
%57 = load i8*, i8** %14
%58 = load i32, i32* %6
%59 = sext i32 %58 to i64
%60 = getelementptr inbounds i8, i8* %57, i64 %59
%61 = load i8, i8* %60
%62 = load i32, i32* %12
%63 = sext i32 %62 to i64
%64 = getelementptr inbounds [30 x i8], [30 x i8]* %15, i64 0, i64 %63
store i8 %61, i8* %64
br label %65
65: ; preds = %56
%66 = load i32, i32* %6
%67 = add nsw i32 %66, -1
store i32 %67, i32* %6
%68 = load i32, i32* %12
%69 = add nsw i32 %68, 1
store i32 %69, i32* %12
br label %52
70: ; preds = %52
%71 = load i32, i32* %12
%72 = sext i32 %71 to i64
%73 = getelementptr inbounds [30 x i8], [30 x i8]* %15, i64 0, i64 %72
store i8 0, i8* %73
%74 = getelementptr inbounds [30 x i8], [30 x i8]* %15, i64 0, i64 0
%75 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([30 x i8], [30 x i8]* @.str, i64 0, i64 0), i8* %74)
%76 = call i32 @exit(i32 1)
unreachable
77: ; preds = %42
%78 = call i64 (...) @fork()
%79 = icmp eq i64 %78, 0
%80 = zext i1 %79 to i32
store i32 %80, i32* %10
br i1 %79, label %81, label %86
81: ; preds = %77
%82 = call i32 (...) @getppid()
%83 = call i32 (...) @getpid()
%84 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([45 x i8], [45 x i8]* @.str.1, i64 0, i64 0), i32 %82, i32 %83)
%85 = call i32 @exit(i32 1)
unreachable
86: ; preds = %77
br label %87
87: ; preds = %115, %86
%88 = load i8*, i8** %14
%89 = load i32, i32* %6
%90 = add nsw i32 %89, 1
store i32 %90, i32* %6
%91 = sext i32 %90 to i64
%92 = getelementptr inbounds i8, i8* %88, i64 %91
%93 = load i8, i8* %92
%94 = sext i8 %93 to i32
%95 = icmp ne i32 %94, 0
br i1 %95, label %96, label %116
96: ; preds = %87
%97 = load i8*, i8** %14
%98 = load i32, i32* %6
%99 = sext i32 %98 to i64
%100 = getelementptr inbounds i8, i8* %97, i64 %99
%101 = load i8, i8* %100
%102 = sext i8 %101 to i32
%103 = icmp sge i32 %102, 65
br i1 %103, label %104, label %115
104: ; preds = %96
%105 = load i8*, i8** %14
%106 = load i32, i32* %6
%107 = sext i32 %106 to i64
%108 = getelementptr inbounds i8, i8* %105, i64 %107
%109 = load i8, i8* %108
%110 = sext i8 %109 to i32
%111 = icmp sle i32 %110, 90
br i1 %111, label %112, label %115
112: ; preds = %104
%113 = load i32, i32* %7
%114 = add nsw i32 %113, 1
store i32 %114, i32* %7
br label %115
115: ; preds = %112, %104, %96
br label %87
116: ; preds = %87
store i32 -1, i32* %6
br label %117
117: ; preds = %145, %116
%118 = load i8*, i8** %14
%119 = load i32, i32* %6
%120 = add nsw i32 %119, 1
store i32 %120, i32* %6
%121 = sext i32 %120 to i64
%122 = getelementptr inbounds i8, i8* %118, i64 %121
%123 = load i8, i8* %122
%124 = sext i8 %123 to i32
%125 = icmp ne i32 %124, 0
br i1 %125, label %126, label %146
126: ; preds = %117
%127 = load i8*, i8** %14
%128 = load i32, i32* %6
%129 = sext i32 %128 to i64
%130 = getelementptr inbounds i8, i8* %127, i64 %129
%131 = load i8, i8* %130
%132 = sext i8 %131 to i32
%133 = icmp sge i32 %132, 97
br i1 %133, label %134, label %145
134: ; preds = %126
%135 = load i8*, i8** %14
%136 = load i32, i32* %6
%137 = sext i32 %136 to i64
%138 = getelementptr inbounds i8, i8* %135, i64 %137
%139 = load i8, i8* %138
%140 = sext i8 %139 to i32
%141 = icmp sle i32 %140, 122
br i1 %141, label %142, label %145
142: ; preds = %134
%143 = load i32, i32* %8
%144 = add nsw i32 %143, 1
store i32 %144, i32* %8
br label %145
145: ; preds = %142, %134, %126
br label %117
146: ; preds = %117
%147 = load i32, i32* %7
%148 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([44 x i8], [44 x i8]* @.str.2, i64 0, i64 0), i32 %147)
%149 = load i32, i32* %8
%150 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([44 x i8], [44 x i8]* @.str.3, i64 0, i64 0), i32 %149)
%151 = load i32, i32* %9
%152 = call i32 @waitpid(i32 %151, i32* null, i32 0)
%153 = load i32, i32* %10
%154 = call i32 @waitpid(i32 %153, i32* null, i32 0)
br label %155
155: ; preds = %146
br label %156
156: ; preds = %155
%157 = call i32 @exit(i32 1)
unreachable
158: ; preds = %0
%159 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([18 x i8], [18 x i8]* @.str.4, i64 0, i64 0))
%160 = load i8*, i8** %13
%161 = call i32 @gets(i8* %160)
%162 = load i32*, i32** %4
store i32 1, i32* %162
%163 = load i8*, i8** %13
store i8* %163, i8** %14
br label %164
164: ; preds = %256, %158
%165 = load i8*, i8** %14
%166 = load i32, i32* %6
%167 = add nsw i32 %166, 1
store i32 %167, i32* %6
%168 = sext i32 %167 to i64
%169 = getelementptr inbounds i8, i8* %165, i64 %168
%170 = load i8, i8* %169
%171 = sext i8 %170 to i32
%172 = icmp ne i32 %171, 0
br i1 %172, label %173, label %257
173: ; preds = %164
%174 = load i8*, i8** %14
%175 = load i32, i32* %6
%176 = sext i32 %175 to i64
%177 = getelementptr inbounds i8, i8* %174, i64 %176
%178 = load i8, i8* %177
%179 = sext i8 %178 to i32
%180 = icmp eq i32 %179, 97
br i1 %180, label %253, label %181
181: ; preds = %173
%182 = load i8*, i8** %14
%183 = load i32, i32* %6
%184 = sext i32 %183 to i64
%185 = getelementptr inbounds i8, i8* %182, i64 %184
%186 = load i8, i8* %185
%187 = sext i8 %186 to i32
%188 = icmp eq i32 %187, 101
br i1 %188, label %253, label %189
189: ; preds = %181
%190 = load i8*, i8** %14
%191 = load i32, i32* %6
%192 = sext i32 %191 to i64
%193 = getelementptr inbounds i8, i8* %190, i64 %192
%194 = load i8, i8* %193
%195 = sext i8 %194 to i32
%196 = icmp eq i32 %195, 105
br i1 %196, label %253, label %197
197: ; preds = %189
%198 = load i8*, i8** %14
%199 = load i32, i32* %6
%200 = sext i32 %199 to i64
%201 = getelementptr inbounds i8, i8* %198, i64 %200
%202 = load i8, i8* %201
%203 = sext i8 %202 to i32
%204 = icmp eq i32 %203, 111
br i1 %204, label %253, label %205
205: ; preds = %197
%206 = load i8*, i8** %14
%207 = load i32, i32* %6
%208 = sext i32 %207 to i64
%209 = getelementptr inbounds i8, i8* %206, i64 %208
%210 = load i8, i8* %209
%211 = sext i8 %210 to i32
%212 = icmp eq i32 %211, 117
br i1 %212, label %253, label %213
213: ; preds = %205
%214 = load i8*, i8** %14
%215 = load i32, i32* %6
%216 = sext i32 %215 to i64
%217 = getelementptr inbounds i8, i8* %214, i64 %216
%218 = load i8, i8* %217
%219 = sext i8 %218 to i32
%220 = icmp eq i32 %219, 65
br i1 %220, label %253, label %221
221: ; preds = %213
%222 = load i8*, i8** %14
%223 = load i32, i32* %6
%224 = sext i32 %223 to i64
%225 = getelementptr inbounds i8, i8* %222, i64 %224
%226 = load i8, i8* %225
%227 = sext i8 %226 to i32
%228 = icmp eq i32 %227, 69
br i1 %228, label %253, label %229
229: ; preds = %221
%230 = load i8*, i8** %14
%231 = load i32, i32* %6
%232 = sext i32 %231 to i64
%233 = getelementptr inbounds i8, i8* %230, i64 %232
%234 = load i8, i8* %233
%235 = sext i8 %234 to i32
%236 = icmp eq i32 %235, 73
br i1 %236, label %253, label %237
237: ; preds = %229
%238 = load i8*, i8** %14
%239 = load i32, i32* %6
%240 = sext i32 %239 to i64
%241 = getelementptr inbounds i8, i8* %238, i64 %240
%242 = load i8, i8* %241
%243 = sext i8 %242 to i32
%244 = icmp eq i32 %243, 79
br i1 %244, label %253, label %245
245: ; preds = %237
%246 = load i8*, i8** %14
%247 = load i32, i32* %6
%248 = sext i32 %247 to i64
%249 = getelementptr inbounds i8, i8* %246, i64 %248
%250 = load i8, i8* %249
%251 = sext i8 %250 to i32
%252 = icmp eq i32 %251, 85
br i1 %252, label %253, label %256
253: ; preds = %245, %237, %229, %221, %213, %205, %197, %189, %181, %173
%254 = load i32, i32* %7
%255 = add nsw i32 %254, 1
store i32 %255, i32* %7
br label %256
256: ; preds = %253, %245
br label %164
257: ; preds = %164
%258 = load i32, i32* %7
%259 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([33 x i8], [33 x i8]* @.str.5, i64 0, i64 0), i32 %258)
%260 = load i32, i32* %5
%261 = call i32 @waitpid(i32 %260, i32* null, i32 0)
br label %262
262: ; preds = %257
ret i32 0
}

LLVM IR (-O2):
@IPC_CREAT = global i32 0
@.str = [30 x i8] c"Proccess D---- Reverse = %s \0A\00"
@.str.1 = [45 x i8] c"Poccess C--- ID of B = %d and ID of C = %d \0A\00"
@.str.2 = [44 x i8] c"Poccess B--- No of UpperCase letters = %d \0A\00"
@.str.3 = [44 x i8] c"Poccess B--- No of LowerCase letters = %d \0A\00"
@.str.4 = [18 x i8] c"Enter a sentence \00"
@.str.5 = [33 x i8] c"Poccess A--- No of Vowels = %d \0A\00"
define i32 @main() {
%1 = alloca [30 x i8]
%2 = getelementptr inbounds [30 x i8], [30 x i8]* %1, i64 0, i64 0
%3 = getelementptr inbounds [30 x i8], [30 x i8]* %1, i64 0, i64 0
%4 = load i32, i32* @IPC_CREAT
%5 = or i32 %4, 438
%6 = tail call i32 @shmget(i32 4546, i32 30, i32 %5)
%7 = tail call i8* @shmat(i32 %6, i32* null, i32 0)
%8 = load i32, i32* @IPC_CREAT
%9 = or i32 %8, 438
%10 = tail call i32 @shmget(i32 6788, i32 1, i32 %9)
%11 = tail call i8* @shmat(i32 %10, i32* null, i32 0)
%12 = bitcast i8* %11 to i32*
store i32 0, i32* %12
%13 = tail call i64 (...) @fork()
%14 = icmp eq i64 %13, 0
br i1 %14, label %15, label %177
15: ; preds = %0
%16 = tail call i64 (...) @fork()
%17 = icmp eq i64 %16, 0
br i1 %17, label %18, label %133
18: ; preds = %15
%19 = tail call i32 @strlen(i8* %7)
%20 = icmp sgt i32 %19, 0
br i1 %20, label %21, label %128
21: ; preds = %18
%22 = zext i32 %19 to i64
%23 = zext i32 %19 to i64
%24 = icmp ult i32 %19, 8
br i1 %24, label %80, label %25
25: ; preds = %21
%26 = getelementptr [30 x i8], [30 x i8]* %1, i64 0, i64 %23
%27 = getelementptr i8, i8* %7, i64 %23
%28 = icmp ult i8* %2, %27
%29 = icmp ult i8* %7, %26
%30 = and i1 %28, %29
br i1 %30, label %80, label %31
31: ; preds = %25
%32 = icmp ult i32 %19, 32
br i1 %32, label %61, label %33
33: ; preds = %31
%34 = and i64 %23, 4294967264
br label %35
35: ; preds = %35, %33
%36 = phi i64 [ 0, %33 ], [ %53, %35 ]
%37 = xor i64 %36, -1
%38 = add i64 %37, %22
%39 = getelementptr inbounds i8, i8* %7, i64 %38
%40 = getelementptr inbounds i8, i8* %39, i64 -15
%41 = bitcast i8* %40 to <16 x i8>*
%42 = load <16 x i8>, <16 x i8>* %41
%43 = shufflevector <16 x i8> %42, <16 x i8> poison, <16 x i32> <i32 15, i32 14, i32 13, i32 12, i32 11, i32 10, i32 9, i32 8, i32 7, i32 6, i32 5, i32 4, i32 3, i32 2, i32 1, i32 0>
%44 = getelementptr inbounds i8, i8* %39, i64 -16
%45 = getelementptr inbounds i8, i8* %44, i64 -15
%46 = bitcast i8* %45 to <16 x i8>*
%47 = load <16 x i8>, <16 x i8>* %46
%48 = shufflevector <16 x i8> %47, <16 x i8> poison, <16 x i32> <i32 15, i32 14, i32 13, i32 12, i32 11, i32 10, i32 9, i32 8, i32 7, i32 6, i32 5, i32 4, i32 3, i32 2, i32 1, i32 0>
%49 = getelementptr inbounds [30 x i8], [30 x i8]* %1, i64 0, i64 %36
%50 = bitcast i8* %49 to <16 x i8>*
store <16 x i8> %43, <16 x i8>* %50
%51 = getelementptr inbounds i8, i8* %49, i64 16
%52 = bitcast i8* %51 to <16 x i8>*
store <16 x i8> %48, <16 x i8>* %52
%53 = add nuw i64 %36, 32
%54 = icmp eq i64 %53, %34
br i1 %54, label %55, label %35
55: ; preds = %35
%56 = icmp eq i64 %34, %23
br i1 %56, label %126, label %57
57: ; preds = %55
%58 = sub nsw i64 %22, %34
%59 = and i64 %23, 24
%60 = icmp eq i64 %59, 0
br i1 %60, label %80, label %61
61: ; preds = %31, %57
%62 = phi i64 [ %34, %57 ], [ 0, %31 ]
%63 = and i64 %23, 4294967288
%64 = sub nsw i64 %22, %63
%65 = getelementptr inbounds i8, i8* %7, i64 -7
br label %66
66: ; preds = %66, %61
%67 = phi i64 [ %62, %61 ], [ %76, %66 ]
%68 = xor i64 %67, -1
%69 = add i64 %68, %22
%70 = getelementptr inbounds i8, i8* %65, i64 %69
%71 = bitcast i8* %70 to <8 x i8>*
%72 = load <8 x i8>, <8 x i8>* %71
%73 = shufflevector <8 x i8> %72, <8 x i8> poison, <8 x i32> <i32 7, i32 6, i32 5, i32 4, i32 3, i32 2, i32 1, i32 0>
%74 = getelementptr inbounds [30 x i8], [30 x i8]* %1, i64 0, i64 %67
%75 = bitcast i8* %74 to <8 x i8>*
store <8 x i8> %73, <8 x i8>* %75
%76 = add nuw i64 %67, 8
%77 = icmp eq i64 %76, %63
br i1 %77, label %78, label %66
78: ; preds = %66
%79 = icmp eq i64 %63, %23
br i1 %79, label %126, label %80
80: ; preds = %25, %21, %57, %78
%81 = phi i64 [ 0, %21 ], [ 0, %25 ], [ %34, %57 ], [ %63, %78 ]
%82 = phi i64 [ %22, %21 ], [ %22, %25 ], [ %58, %57 ], [ %64, %78 ]
%83 = xor i64 %81, -1
%84 = add nsw i64 %83, %23
%85 = and i64 %23, 3
%86 = icmp eq i64 %85, 0
br i1 %86, label %98, label %87
87: ; preds = %80, %87
%88 = phi i64 [ %95, %87 ], [ %81, %80 ]
%89 = phi i64 [ %91, %87 ], [ %82, %80 ]
%90 = phi i64 [ %96, %87 ], [ 0, %80 ]
%91 = add nsw i64 %89, -1
%92 = getelementptr inbounds i8, i8* %7, i64 %91
%93 = load i8, i8* %92
%94 = getelementptr inbounds [30 x i8], [30 x i8]* %1, i64 0, i64 %88
store i8 %93, i8* %94
%95 = add nuw nsw i64 %88, 1
%96 = add i64 %90, 1
%97 = icmp eq i64 %96, %85
br i1 %97, label %98, label %87
98: ; preds = %87, %80
%99 = phi i64 [ %81, %80 ], [ %95, %87 ]
%100 = phi i64 [ %82, %80 ], [ %91, %87 ]
%101 = icmp ult i64 %84, 3
br i1 %101, label %126, label %102
102: ; preds = %98, %102
%103 = phi i64 [ %124, %102 ], [ %99, %98 ]
%104 = phi i64 [ %120, %102 ], [ %100, %98 ]
%105 = add nsw i64 %104, -1
%106 = getelementptr inbounds i8, i8* %7, i64 %105
%107 = load i8, i8* %106
%108 = getelementptr inbounds [30 x i8], [30 x i8]* %1, i64 0, i64 %103
store i8 %107, i8* %108
%109 = add nuw nsw i64 %103, 1
%110 = add nsw i64 %104, -2
%111 = getelementptr inbounds i8, i8* %7, i64 %110
%112 = load i8, i8* %111
%113 = getelementptr inbounds [30 x i8], [30 x i8]* %1, i64 0, i64 %109
store i8 %112, i8* %113
%114 = add nuw nsw i64 %103, 2
%115 = add nsw i64 %104, -3
%116 = getelementptr inbounds i8, i8* %7, i64 %115
%117 = load i8, i8* %116
%118 = getelementptr inbounds [30 x i8], [30 x i8]* %1, i64 0, i64 %114
store i8 %117, i8* %118
%119 = add nuw nsw i64 %103, 3
%120 = add nsw i64 %104, -4
%121 = getelementptr inbounds i8, i8* %7, i64 %120
%122 = load i8, i8* %121
%123 = getelementptr inbounds [30 x i8], [30 x i8]* %1, i64 0, i64 %119
store i8 %122, i8* %123
%124 = add nuw nsw i64 %103, 4
%125 = icmp eq i64 %124, %23
br i1 %125, label %126, label %102
126: ; preds = %98, %102, %78, %55
%127 = zext i32 %19 to i64
br label %128
128: ; preds = %18, %126
%129 = phi i64 [ %127, %126 ], [ 0, %18 ]
%130 = getelementptr inbounds [30 x i8], [30 x i8]* %1, i64 0, i64 %129
store i8 0, i8* %130
%131 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([30 x i8], [30 x i8]* @.str, i64 0, i64 0), i8* %3)
%132 = call i32 @exit(i32 1)
unreachable
133: ; preds = %15
%134 = tail call i64 (...) @fork()
%135 = icmp eq i64 %134, 0
br i1 %135, label %139, label %136
136: ; preds = %133
%137 = load i8, i8* %7
%138 = icmp eq i8 %137, 0
br i1 %138, label %169, label %145
139: ; preds = %133
%140 = tail call i32 (...) @getppid()
%141 = tail call i32 (...) @getpid()
%142 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([45 x i8], [45 x i8]* @.str.1, i64 0, i64 0), i32 %140, i32 %141)
%143 = tail call i32 @exit(i32 1)
unreachable
144: ; preds = %145
br i1 %138, label %169, label %157
145: ; preds = %136, %145
%146 = phi i64 [ %153, %145 ], [ 0, %136 ]
%147 = phi i8 [ %155, %145 ], [ %137, %136 ]
%148 = phi i32 [ %152, %145 ], [ 0, %136 ]
%149 = add i8 %147, -65
%150 = icmp ult i8 %149, 26
%151 = zext i1 %150 to i32
%152 = add nuw nsw i32 %148, %151
%153 = add nuw nsw i64 %146, 1
%154 = getelementptr inbounds i8, i8* %7, i64 %153
%155 = load i8, i8* %154
%156 = icmp eq i8 %155, 0
br i1 %156, label %144, label %145
157: ; preds = %144, %157
%158 = phi i64 [ %165, %157 ], [ 0, %144 ]
%159 = phi i8 [ %167, %157 ], [ %137, %144 ]
%160 = phi i32 [ %164, %157 ], [ 0, %144 ]
%161 = add i8 %159, -97
%162 = icmp ult i8 %161, 26
%163 = zext i1 %162 to i32
%164 = add nuw nsw i32 %160, %163
%165 = add nuw nsw i64 %158, 1
%166 = getelementptr inbounds i8, i8* %7, i64 %165
%167 = load i8, i8* %166
%168 = icmp eq i8 %167, 0
br i1 %168, label %169, label %157
169: ; preds = %157, %136, %144
%170 = phi i32 [ %152, %144 ], [ 0, %136 ], [ %152, %157 ]
%171 = phi i32 [ 0, %144 ], [ 0, %136 ], [ %164, %157 ]
%172 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([44 x i8], [44 x i8]* @.str.2, i64 0, i64 0), i32 %170)
%173 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([44 x i8], [44 x i8]* @.str.3, i64 0, i64 0), i32 %171)
%174 = tail call i32 @waitpid(i32 0, i32* null, i32 0)
%175 = tail call i32 @waitpid(i32 0, i32* null, i32 0)
%176 = tail call i32 @exit(i32 1)
unreachable
177: ; preds = %0
%178 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([18 x i8], [18 x i8]* @.str.4, i64 0, i64 0))
%179 = tail call i32 @gets(i8* %7)
store i32 1, i32* %12
br label %180
180: ; preds = %188, %177
%181 = phi i64 [ %185, %188 ], [ -1, %177 ]
%182 = phi i32 [ %189, %188 ], [ 0, %177 ]
br label %183
183: ; preds = %180, %183
%184 = phi i64 [ %185, %183 ], [ %181, %180 ]
%185 = add nsw i64 %184, 1
%186 = getelementptr inbounds i8, i8* %7, i64 %185
%187 = load i8, i8* %186
switch i8 %187, label %183 [
i8 0, label %190
i8 97, label %188
i8 101, label %188
i8 105, label %188
i8 111, label %188
i8 117, label %188
i8 65, label %188
i8 69, label %188
i8 73, label %188
i8 79, label %188
i8 85, label %188
]
188: ; preds = %183, %183, %183, %183, %183, %183, %183, %183, %183, %183
%189 = add nuw nsw i32 %182, 1
br label %180
190: ; preds = %183
%191 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([33 x i8], [33 x i8]* @.str.5, i64 0, i64 0), i32 %182)
%192 = tail call i32 @waitpid(i32 0, i32* null, i32 0)
ret i32 0
}