Create a new version of paste:

New Paste
Syntax Highlighting
target datalayout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
target triple = "x86_64-pc-linux-gnu"

%struct.processStruct = type { i32, i32, i32, i32, i32, i32 }
%struct.readyQueue = type { %struct.processStruct*, %struct.processStruct*, i32, i32, i32, i32, i32, i32, [4 x i32] }

@.str = private unnamed_addr constant [12 x i8] c"processes: \00", align 1
@.str.1 = private unnamed_addr constant [3 x i8] c"%d\00", align 1
@.str.2 = private unnamed_addr constant [3 x i8] c" (\00", align 1
@.str.3 = private unnamed_addr constant [5 x i8] c" ms)\00", align 1
@.str.4 = private unnamed_addr constant [2 x i8] c" \00", align 1
@.str.5 = private unnamed_addr constant [44 x i8] c"Enter the number of processes to schedule: \00", align 1
@.str.6 = private unnamed_addr constant [7 x i8] c"%s%d%s\00", align 1
@.str.7 = private unnamed_addr constant [31 x i8] c"Enter the CPU time of process \00", align 1
@.str.8 = private unnamed_addr constant [3 x i8] c": \00", align 1
@.str.9 = private unnamed_addr constant [29 x i8] c"Enter the period of process \00", align 1
@.str.10 = private unnamed_addr constant [6 x i8] c"%s%s\0A\00", align 1
@.str.11 = private unnamed_addr constant [4 x i8] c"0: \00", align 1
@.str.12 = private unnamed_addr constant [10 x i8] c"%d%s%d%s\0A\00", align 1
@.str.13 = private unnamed_addr constant [11 x i8] c": process \00", align 1
@.str.14 = private unnamed_addr constant [6 x i8] c" ends\00", align 1
@.str.15 = private unnamed_addr constant [14 x i8] c"%d%s%d%s%d%s\0A\00", align 1
@.str.16 = private unnamed_addr constant [19 x i8] c" missed deadline (\00", align 1
@.str.17 = private unnamed_addr constant [10 x i8] c" ms left)\00", align 1
@.str.18 = private unnamed_addr constant [8 x i8] c"%d%s%s\0A\00", align 1
@.str.19 = private unnamed_addr constant [12 x i8] c" preempted!\00", align 1
@.str.20 = private unnamed_addr constant [8 x i8] c" starts\00", align 1
@.str.21 = private unnamed_addr constant [6 x i8] c"%d%s\0A\00", align 1
@.str.22 = private unnamed_addr constant [19 x i8] c": Max Time reached\00", align 1
@.str.23 = private unnamed_addr constant [6 x i8] c"%s%d\0A\00", align 1
@.str.24 = private unnamed_addr constant [27 x i8] c"Sum of all waiting times: \00", align 1
@.str.25 = private unnamed_addr constant [30 x i8] c"Number of processes created: \00", align 1
@.str.26 = private unnamed_addr constant [9 x i8] c"%s%.2lf\0A\00", align 1
@.str.27 = private unnamed_addr constant [23 x i8] c"Average Waiting Time: \00", align 1

; Function Attrs: noinline nounwind optnone uwtable
define dso_local i32 @lcm(i32 noundef %0, i32 noundef %1) #0 {
  %3 = alloca i32, align 4
  %4 = alloca i32, align 4
  %5 = alloca i32, align 4
  %6 = alloca i32, align 4
  store i32 %0, i32* %4, align 4
  store i32 %1, i32* %5, align 4
  %7 = load i32, i32* %4, align 4
  %8 = icmp eq i32 %7, 0
  br i1 %8, label %9, label %11

9:                                                ; preds = %2
  %10 = load i32, i32* %5, align 4
  store i32 %10, i32* %3, align 4
  br label %41

11:                                               ; preds = %2
  %12 = load i32, i32* %5, align 4
  %13 = icmp eq i32 %12, 0
  br i1 %13, label %14, label %16

14:                                               ; preds = %11
  %15 = load i32, i32* %4, align 4
  store i32 %15, i32* %3, align 4
  br label %41

16:                                               ; preds = %11
  %17 = load i32, i32* %4, align 4
  %18 = load i32, i32* %5, align 4
  %19 = icmp sgt i32 %17, %18
  br i1 %19, label %20, label %22

20:                                               ; preds = %16
  %21 = load i32, i32* %4, align 4
  br label %24

22:                                               ; preds = %16
  %23 = load i32, i32* %5, align 4
  br label %24

24:                                               ; preds = %22, %20
  %25 = phi i32 [ %21, %20 ], [ %23, %22 ]
  store i32 %25, i32* %6, align 4
  br label %26

26:                                               ; preds = %24, %38
  %27 = load i32, i32* %6, align 4
  %28 = load i32, i32* %4, align 4
  %29 = srem i32 %27, %28
  %30 = icmp eq i32 %29, 0
  br i1 %30, label %31, label %38

31:                                               ; preds = %26
  %32 = load i32, i32* %6, align 4
  %33 = load i32, i32* %5, align 4
  %34 = srem i32 %32, %33
  %35 = icmp eq i32 %34, 0
  br i1 %35, label %36, label %38

36:                                               ; preds = %31
  %37 = load i32, i32* %6, align 4
  store i32 %37, i32* %3, align 4
  br label %41

38:                                               ; preds = %31, %26
  %39 = load i32, i32* %6, align 4
  %40 = add nsw i32 %39, 1
  store i32 %40, i32* %6, align 4
  br label %26

41:                                               ; preds = %36, %14, %9
  %42 = load i32, i32* %3, align 4
  ret i32 %42
}

; Function Attrs: noinline nounwind optnone uwtable
define dso_local i32 @reduce(i32 (i32, i32)* noundef %0, i32* noundef %1, i32 noundef %2) #0 {
  %4 = alloca i32, align 4
  %5 = alloca i32 (i32, i32)*, align 8
  %6 = alloca i32*, align 8
  %7 = alloca i32, align 4
  %8 = alloca i32, align 4
  %9 = alloca i32, align 4
  store i32 (i32, i32)* %0, i32 (i32, i32)** %5, align 8
  store i32* %1, i32** %6, align 8
  store i32 %2, i32* %7, align 4
  %10 = load i32, i32* %7, align 4
  %11 = icmp sle i32 %10, 0
  br i1 %11, label %12, label %13

12:                                               ; preds = %3
  store i32 0, i32* %4, align 4
  br label %42

13:                                               ; preds = %3
  %14 = load i32, i32* %7, align 4
  %15 = icmp eq i32 %14, 1
  br i1 %15, label %16, label %20

16:                                               ; preds = %13
  %17 = load i32*, i32** %6, align 8
  %18 = getelementptr inbounds i32, i32* %17, i64 0
  %19 = load i32, i32* %18, align 4
  store i32 %19, i32* %4, align 4
  br label %42

20:                                               ; preds = %13
  %21 = load i32*, i32** %6, align 8
  %22 = getelementptr inbounds i32, i32* %21, i64 0
  %23 = load i32, i32* %22, align 4
  store i32 %23, i32* %8, align 4
  store i32 1, i32* %9, align 4
  br label %24

24:                                               ; preds = %37, %20
  %25 = load i32, i32* %9, align 4
  %26 = load i32, i32* %7, align 4
  %27 = icmp slt i32 %25, %26
  br i1 %27, label %28, label %40

28:                                               ; preds = %24
  %29 = load i32 (i32, i32)*, i32 (i32, i32)** %5, align 8
  %30 = load i32, i32* %8, align 4
  %31 = load i32*, i32** %6, align 8
  %32 = load i32, i32* %9, align 4
  %33 = sext i32 %32 to i64
  %34 = getelementptr inbounds i32, i32* %31, i64 %33
  %35 = load i32, i32* %34, align 4
  %36 = call i32 %29(i32 noundef %30, i32 noundef %35)
  store i32 %36, i32* %8, align 4
  br label %37

37:                                               ; preds = %28
  %38 = load i32, i32* %9, align 4
  %39 = add nsw i32 %38, 1
  store i32 %39, i32* %9, align 4
  br label %24, !llvm.loop !6

40:                                               ; preds = %24
  %41 = load i32, i32* %8, align 4
  store i32 %41, i32* %4, align 4
  br label %42

42:                                               ; preds = %40, %16, %12
  %43 = load i32, i32* %4, align 4
  ret i32 %43
}

; Function Attrs: noinline nounwind optnone uwtable
define dso_local i32 @comparePid(i8* noundef %0, i8* noundef %1) #0 {
  %3 = alloca i32, align 4
  %4 = alloca i8*, align 8
  %5 = alloca i8*, align 8
  %6 = alloca %struct.processStruct, align 4
  %7 = alloca %struct.processStruct, align 4
  store i8* %0, i8** %4, align 8
  store i8* %1, i8** %5, align 8
  %8 = load i8*, i8** %4, align 8
  %9 = bitcast i8* %8 to %struct.processStruct*
  %10 = bitcast %struct.processStruct* %6 to i8*
  %11 = bitcast %struct.processStruct* %9 to i8*
  call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 4 %10, i8* align 4 %11, i64 24, i1 false)
  %12 = load i8*, i8** %5, align 8
  %13 = bitcast i8* %12 to %struct.processStruct*
  %14 = bitcast %struct.processStruct* %7 to i8*
  %15 = bitcast %struct.processStruct* %13 to i8*
  call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 4 %14, i8* align 4 %15, i64 24, i1 false)
  %16 = getelementptr inbounds %struct.processStruct, %struct.processStruct* %6, i32 0, i32 4
  %17 = load i32, i32* %16, align 4
  %18 = getelementptr inbounds %struct.processStruct, %struct.processStruct* %7, i32 0, i32 4
  %19 = load i32, i32* %18, align 4
  %20 = icmp sgt i32 %17, %19
  br i1 %20, label %21, label %22

21:                                               ; preds = %2
  store i32 1, i32* %3, align 4
  br label %45

22:                                               ; preds = %2
  %23 = getelementptr inbounds %struct.processStruct, %struct.processStruct* %6, i32 0, i32 4
  %24 = load i32, i32* %23, align 4
  %25 = getelementptr inbounds %struct.processStruct, %struct.processStruct* %7, i32 0, i32 4
  %26 = load i32, i32* %25, align 4
  %27 = icmp eq i32 %24, %26
  br i1 %27, label %28, label %44

28:                                               ; preds = %22
  %29 = getelementptr inbounds %struct.processStruct, %struct.processStruct* %6, i32 0, i32 2
  %30 = load i32, i32* %29, align 4
  %31 = getelementptr inbounds %struct.processStruct, %struct.processStruct* %7, i32 0, i32 2
  %32 = load i32, i32* %31, align 4
  %33 = icmp slt i32 %30, %32
  br i1 %33, label %34, label %35

34:                                               ; preds = %28
  store i32 -1, i32* %3, align 4
  br label %45

35:                                               ; preds = %28
  %36 = getelementptr inbounds %struct.processStruct, %struct.processStruct* %6, i32 0, i32 2
  %37 = load i32, i32* %36, align 4
  %38 = getelementptr inbounds %struct.processStruct, %struct.processStruct* %7, i32 0, i32 2
  %39 = load i32, i32* %38, align 4
  %40 = icmp sgt i32 %37, %39
  br i1 %40, label %41, label %42

41:                                               ; preds = %35
  store i32 1, i32* %3, align 4
  br label %45

42:                                               ; preds = %35
  br label %43

43:                                               ; preds = %42
  store i32 0, i32* %3, align 4
  br label %45

44:                                               ; preds = %22
  store i32 -1, i32* %3, align 4
  br label %45

45:                                               ; preds = %44, %43, %41, %34, %21
  %46 = load i32, i32* %3, align 4
  ret i32 %46
}

; Function Attrs: argmemonly nofree nounwind willreturn
declare void @llvm.memcpy.p0i8.p0i8.i64(i8* noalias nocapture writeonly, i8* noalias nocapture readonly, i64, i1 immarg) #1

; Function Attrs: noinline nounwind optnone uwtable
define dso_local void @addProcess(%struct.readyQueue* noalias sret(%struct.readyQueue) align 8 %0, %struct.readyQueue* noundef byval(%struct.readyQueue) align 8 %1, i32 noundef %2) #0 {
  %4 = alloca i32, align 4
  store i32 %2, i32* %4, align 4
  %5 = getelementptr inbounds %struct.readyQueue, %struct.readyQueue* %1, i32 0, i32 4
  %6 = load i32, i32* %5, align 8
  %7 = add nsw i32 %6, 1
  store i32 %7, i32* %5, align 8
  %8 = getelementptr inbounds %struct.readyQueue, %struct.readyQueue* %1, i32 0, i32 0
  %9 = load %struct.processStruct*, %struct.processStruct** %8, align 8
  %10 = getelementptr inbounds %struct.readyQueue, %struct.readyQueue* %1, i32 0, i32 4
  %11 = load i32, i32* %10, align 8
  %12 = sub nsw i32 %11, 1
  %13 = sext i32 %12 to i64
  %14 = getelementptr inbounds %struct.processStruct, %struct.processStruct* %9, i64 %13
  %15 = getelementptr inbounds %struct.readyQueue, %struct.readyQueue* %1, i32 0, i32 1
  %16 = load %struct.processStruct*, %struct.processStruct** %15, align 8
  %17 = load i32, i32* %4, align 4
  %18 = sext i32 %17 to i64
  %19 = getelementptr inbounds %struct.processStruct, %struct.processStruct* %16, i64 %18
  %20 = bitcast %struct.processStruct* %14 to i8*
  %21 = bitcast %struct.processStruct* %19 to i8*
  call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 4 %20, i8* align 4 %21, i64 24, i1 false)
  %22 = getelementptr inbounds %struct.readyQueue, %struct.readyQueue* %1, i32 0, i32 6
  %23 = load i32, i32* %22, align 8
  %24 = add nsw i32 %23, 1
  store i32 %24, i32* %22, align 8
  %25 = getelementptr inbounds %struct.readyQueue, %struct.readyQueue* %1, i32 0, i32 5
  %26 = load i32, i32* %25, align 4
  %27 = add nsw i32 %26, 1
  store i32 %27, i32* %25, align 4
  %28 = getelementptr inbounds %struct.readyQueue, %struct.readyQueue* %1, i32 0, i32 5
  %29 = load i32, i32* %28, align 4
  %30 = getelementptr inbounds %struct.readyQueue, %struct.readyQueue* %1, i32 0, i32 3
  %31 = load i32, i32* %30, align 4
  %32 = icmp sge i32 %29, %31
  br i1 %32, label %33, label %35

33:                                               ; preds = %3
  %34 = getelementptr inbounds %struct.readyQueue, %struct.readyQueue* %1, i32 0, i32 5
  store i32 0, i32* %34, align 4
  br label %35

35:                                               ; preds = %33, %3
  %36 = bitcast %struct.readyQueue* %0 to i8*
  %37 = bitcast %struct.readyQueue* %1 to i8*
  call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 8 %36, i8* align 8 %37, i64 56, i1 false)
  ret void
}

; Function Attrs: noinline nounwind optnone uwtable
define dso_local void @scheduleNearestDeadline(%struct.readyQueue* noalias sret(%struct.readyQueue) align 8 %0, %struct.readyQueue* noundef byval(%struct.readyQueue) align 8 %1) #0 {
  %3 = alloca i32, align 4
  %4 = alloca i32, align 4
  %5 = alloca i32, align 4
  %6 = getelementptr inbounds %struct.readyQueue, %struct.readyQueue* %1, i32 0, i32 2
  store i32 0, i32* %6, align 8
  %7 = getelementptr inbounds %struct.readyQueue, %struct.readyQueue* %1, i32 0, i32 0
  %8 = load %struct.processStruct*, %struct.processStruct** %7, align 8
  %9 = getelementptr inbounds %struct.readyQueue, %struct.readyQueue* %1, i32 0, i32 2
  %10 = load i32, i32* %9, align 8
  %11 = sext i32 %10 to i64
  %12 = getelementptr inbounds %struct.processStruct, %struct.processStruct* %8, i64 %11
  %13 = getelementptr inbounds %struct.processStruct, %struct.processStruct* %12, i32 0, i32 3
  %14 = load i32, i32* %13, align 4
  store i32 %14, i32* %3, align 4
  store i32 -1, i32* %4, align 4
  store i32 0, i32* %5, align 4
  br label %15

15:                                               ; preds = %40, %2
  %16 = load i32, i32* %5, align 4
  %17 = getelementptr inbounds %struct.readyQueue, %struct.readyQueue* %1, i32 0, i32 4
  %18 = load i32, i32* %17, align 8
  %19 = icmp slt i32 %16, %18
  br i1 %19, label %20, label %43

20:                                               ; preds = %15
  %21 = getelementptr inbounds %struct.readyQueue, %struct.readyQueue* %1, i32 0, i32 0
  %22 = load %struct.processStruct*, %struct.processStruct** %21, align 8
  %23 = load i32, i32* %5, align 4
  %24 = sext i32 %23 to i64
  %25 = getelementptr inbounds %struct.processStruct, %struct.processStruct* %22, i64 %24
  %26 = getelementptr inbounds %struct.processStruct, %struct.processStruct* %25, i32 0, i32 3
  %27 = load i32, i32* %26, align 4
  %28 = load i32, i32* %3, align 4
  %29 = icmp slt i32 %27, %28
  br i1 %29, label %30, label %39

30:                                               ; preds = %20
  %31 = load i32, i32* %5, align 4
  store i32 %31, i32* %4, align 4
  %32 = getelementptr inbounds %struct.readyQueue, %struct.readyQueue* %1, i32 0, i32 0
  %33 = load %struct.processStruct*, %struct.processStruct** %32, align 8
  %34 = load i32, i32* %5, align 4
  %35 = sext i32 %34 to i64
  %36 = getelementptr inbounds %struct.processStruct, %struct.processStruct* %33, i64 %35
  %37 = getelementptr inbounds %struct.processStruct, %struct.processStruct* %36, i32 0, i32 3
  %38 = load i32, i32* %37, align 4
  store i32 %38, i32* %3, align 4
  br label %39

39:                                               ; preds = %30, %20
  br label %40

40:                                               ; preds = %39
  %41 = load i32, i32* %5, align 4
  %42 = add nsw i32 %41, 1
  store i32 %42, i32* %5, align 4
  br label %15, !llvm.loop !8

43:                                               ; preds = %15
  %44 = load i32, i32* %4, align 4
  %45 = icmp eq i32 %44, -1
  br i1 %45, label %46, label %49

46:                                               ; preds = %43
  %47 = bitcast %struct.readyQueue* %0 to i8*
  %48 = bitcast %struct.readyQueue* %1 to i8*
  call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 8 %47, i8* align 8 %48, i64 56, i1 false)
  br label %54

49:                                               ; preds = %43
  %50 = load i32, i32* %4, align 4
  %51 = getelementptr inbounds %struct.readyQueue, %struct.readyQueue* %1, i32 0, i32 2
  store i32 %50, i32* %51, align 8
  %52 = bitcast %struct.readyQueue* %0 to i8*
  %53 = bitcast %struct.readyQueue* %1 to i8*
  call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 8 %52, i8* align 8 %53, i64 56, i1 false)
  br label %54

54:                                               ; preds = %49, %46
  ret void
}

; Function Attrs: noinline nounwind optnone uwtable
define dso_local void @preempt(%struct.readyQueue* noalias sret(%struct.readyQueue) align 8 %0, %struct.readyQueue* noundef byval(%struct.readyQueue) align 8 %1) #0 {
  %3 = alloca i32, align 4
  %4 = alloca i32, align 4
  %5 = alloca i32, align 4
  %6 = alloca i32, align 4
  %7 = alloca i32, align 4
  store i32 0, i32* %3, align 4
  store i32 0, i32* %4, align 4
  br label %8

8:                                                ; preds = %24, %2
  %9 = load i32, i32* %4, align 4
  %10 = getelementptr inbounds %struct.readyQueue, %struct.readyQueue* %1, i32 0, i32 4
  %11 = load i32, i32* %10, align 8
  %12 = icmp slt i32 %9, %11
  br i1 %12, label %13, label %27

13:                                               ; preds = %8
  %14 = getelementptr inbounds %struct.readyQueue, %struct.readyQueue* %1, i32 0, i32 0
  %15 = load %struct.processStruct*, %struct.processStruct** %14, align 8
  %16 = load i32, i32* %4, align 4
  %17 = sext i32 %16 to i64
  %18 = getelementptr inbounds %struct.processStruct, %struct.processStruct* %15, i64 %17
  %19 = getelementptr inbounds %struct.processStruct, %struct.processStruct* %18, i32 0, i32 5
  %20 = load i32, i32* %19, align 4
  %21 = icmp eq i32 %20, 1
  br i1 %21, label %22, label %23

22:                                               ; preds = %13
  store i32 1, i32* %3, align 4
  br label %23

23:                                               ; preds = %22, %13
  br label %24

24:                                               ; preds = %23
  %25 = load i32, i32* %4, align 4
  %26 = add nsw i32 %25, 1
  store i32 %26, i32* %4, align 4
  br label %8, !llvm.loop !9

27:                                               ; preds = %8
  %28 = getelementptr inbounds %struct.readyQueue, %struct.readyQueue* %1, i32 0, i32 0
  %29 = load %struct.processStruct*, %struct.processStruct** %28, align 8
  %30 = getelementptr inbounds %struct.readyQueue, %struct.readyQueue* %1, i32 0, i32 2
  %31 = load i32, i32* %30, align 8
  %32 = sext i32 %31 to i64
  %33 = getelementptr inbounds %struct.processStruct, %struct.processStruct* %29, i64 %32
  %34 = getelementptr inbounds %struct.processStruct, %struct.processStruct* %33, i32 0, i32 3
  %35 = load i32, i32* %34, align 4
  store i32 %35, i32* %5, align 4
  store i32 -1, i32* %6, align 4
  store i32 0, i32* %7, align 4
  br label %36

36:                                               ; preds = %61, %27
  %37 = load i32, i32* %7, align 4
  %38 = getelementptr inbounds %struct.readyQueue, %struct.readyQueue* %1, i32 0, i32 4
  %39 = load i32, i32* %38, align 8
  %40 = icmp slt i32 %37, %39
  br i1 %40, label %41, label %64

41:                                               ; preds = %36
  %42 = getelementptr inbounds %struct.readyQueue, %struct.readyQueue* %1, i32 0, i32 0
  %43 = load %struct.processStruct*, %struct.processStruct** %42, align 8
  %44 = load i32, i32* %7, align 4
  %45 = sext i32 %44 to i64
  %46 = getelementptr inbounds %struct.processStruct, %struct.processStruct* %43, i64 %45
  %47 = getelementptr inbounds %struct.processStruct, %struct.processStruct* %46, i32 0, i32 3
  %48 = load i32, i32* %47, align 4
  %49 = load i32, i32* %5, align 4
  %50 = icmp slt i32 %48, %49
  br i1 %50, label %51, label %60

51:                                               ; preds = %41
  %52 = load i32, i32* %7, align 4
  store i32 %52, i32* %6, align 4
  %53 = getelementptr inbounds %struct.readyQueue, %struct.readyQueue* %1, i32 0, i32 0
  %54 = load %struct.processStruct*, %struct.processStruct** %53, align 8
  %55 = load i32, i32* %7, align 4
  %56 = sext i32 %55 to i64
  %57 = getelementptr inbounds %struct.processStruct, %struct.processStruct* %54, i64 %56
  %58 = getelementptr inbounds %struct.processStruct, %struct.processStruct* %57, i32 0, i32 3
  %59 = load i32, i32* %58, align 4
  store i32 %59, i32* %5, align 4
  br label %60

60:                                               ; preds = %51, %41
  br label %61

61:                                               ; preds = %60
  %62 = load i32, i32* %7, align 4
  %63 = add nsw i32 %62, 1
  store i32 %63, i32* %7, align 4
  br label %36, !llvm.loop !10

64:                                               ; preds = %36
  %65 = load i32, i32* %6, align 4
  %66 = icmp eq i32 %65, -1
  br i1 %66, label %67, label %74

67:                                               ; preds = %64
  %68 = getelementptr inbounds %struct.readyQueue, %struct.readyQueue* %1, i32 0, i32 8
  %69 = getelementptr inbounds [4 x i32], [4 x i32]* %68, i64 0, i64 0
  store i32 -1, i32* %69, align 8
  %70 = getelementptr inbounds %struct.readyQueue, %struct.readyQueue* %1, i32 0, i32 8
  %71 = getelementptr inbounds [4 x i32], [4 x i32]* %70, i64 0, i64 1
  store i32 -1, i32* %71, align 4
  %72 = bitcast %struct.readyQueue* %0 to i8*
  %73 = bitcast %struct.readyQueue* %1 to i8*
  call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 8 %72, i8* align 8 %73, i64 56, i1 false)
  br label %110

74:                                               ; preds = %64
  %75 = getelementptr inbounds %struct.readyQueue, %struct.readyQueue* %1, i32 0, i32 0
  %76 = load %struct.processStruct*, %struct.processStruct** %75, align 8
  %77 = getelementptr inbounds %struct.readyQueue, %struct.readyQueue* %1, i32 0, i32 2
  %78 = load i32, i32* %77, align 8
  %79 = sext i32 %78 to i64
  %80 = getelementptr inbounds %struct.processStruct, %struct.processStruct* %76, i64 %79
  %81 = getelementptr inbounds %struct.processStruct, %struct.processStruct* %80, i32 0, i32 4
  %82 = load i32, i32* %81, align 4
  %83 = getelementptr inbounds %struct.readyQueue, %struct.readyQueue* %1, i32 0, i32 8
  %84 = getelementptr inbounds [4 x i32], [4 x i32]* %83, i64 0, i64 0
  store i32 %82, i32* %84, align 8
  %85 = getelementptr inbounds %struct.readyQueue, %struct.readyQueue* %1, i32 0, i32 0
  %86 = load %struct.processStruct*, %struct.processStruct** %85, align 8
  %87 = load i32, i32* %6, align 4
  %88 = sext i32 %87 to i64
  %89 = getelementptr inbounds %struct.processStruct, %struct.processStruct* %86, i64 %88
  %90 = getelementptr inbounds %struct.processStruct, %struct.processStruct* %89, i32 0, i32 4
  %91 = load i32, i32* %90, align 4
  %92 = getelementptr inbounds %struct.readyQueue, %struct.readyQueue* %1, i32 0, i32 8
  %93 = getelementptr inbounds [4 x i32], [4 x i32]* %92, i64 0, i64 1
  store i32 %91, i32* %93, align 4
  %94 = getelementptr inbounds %struct.readyQueue, %struct.readyQueue* %1, i32 0, i32 8
  %95 = getelementptr inbounds [4 x i32], [4 x i32]* %94, i64 0, i64 2
  store i32 1, i32* %95, align 8
  %96 = load i32, i32* %3, align 4
  %97 = getelementptr inbounds %struct.readyQueue, %struct.readyQueue* %1, i32 0, i32 8
  %98 = getelementptr inbounds [4 x i32], [4 x i32]* %97, i64 0, i64 3
  store i32 %96, i32* %98, align 4
  %99 = load i32, i32* %6, align 4
  %100 = getelementptr inbounds %struct.readyQueue, %struct.readyQueue* %1, i32 0, i32 2
  store i32 %99, i32* %100, align 8
  %101 = getelementptr inbounds %struct.readyQueue, %struct.readyQueue* %1, i32 0, i32 0
  %102 = load %struct.processStruct*, %struct.processStruct** %101, align 8
  %103 = getelementptr inbounds %struct.readyQueue, %struct.readyQueue* %1, i32 0, i32 2
  %104 = load i32, i32* %103, align 8
  %105 = sext i32 %104 to i64
  %106 = getelementptr inbounds %struct.processStruct, %struct.processStruct* %102, i64 %105
  %107 = getelementptr inbounds %struct.processStruct, %struct.processStruct* %106, i32 0, i32 5
  store i32 0, i32* %107, align 4
  %108 = bitcast %struct.readyQueue* %0 to i8*
  %109 = bitcast %struct.readyQueue* %1 to i8*
  call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 8 %108, i8* align 8 %109, i64 56, i1 false)
  br label %110

110:                                              ; preds = %74, %67
  ret void
}

; Function Attrs: noinline nounwind optnone uwtable
define dso_local void @removeProcess(%struct.readyQueue* noalias sret(%struct.readyQueue) align 8 %0, %struct.readyQueue* noundef byval(%struct.readyQueue) align 8 %1, i32 noundef %2) #0 {
  %4 = alloca i32, align 4
  %5 = alloca %struct.processStruct*, align 8
  %6 = alloca i32, align 4
  %7 = alloca i32, align 4
  store i32 %2, i32* %4, align 4
  %8 = getelementptr inbounds %struct.readyQueue, %struct.readyQueue* %1, i32 0, i32 4
  %9 = load i32, i32* %8, align 8
  %10 = sub nsw i32 %9, 1
  %11 = sext i32 %10 to i64
  %12 = mul i64 %11, 24
  %13 = call noalias i8* @malloc(i64 noundef %12) #7
  %14 = bitcast i8* %13 to %struct.processStruct*
  store %struct.processStruct* %14, %struct.processStruct** %5, align 8
  store i32 0, i32* %6, align 4
  br label %15

15:                                               ; preds = %31, %3
  %16 = load i32, i32* %6, align 4
  %17 = load i32, i32* %4, align 4
  %18 = icmp slt i32 %16, %17
  br i1 %18, label %19, label %34

19:                                               ; preds = %15
  %20 = load %struct.processStruct*, %struct.processStruct** %5, align 8
  %21 = load i32, i32* %6, align 4
  %22 = sext i32 %21 to i64
  %23 = getelementptr inbounds %struct.processStruct, %struct.processStruct* %20, i64 %22
  %24 = getelementptr inbounds %struct.readyQueue, %struct.readyQueue* %1, i32 0, i32 0
  %25 = load %struct.processStruct*, %struct.processStruct** %24, align 8
  %26 = load i32, i32* %6, align 4
  %27 = sext i32 %26 to i64
  %28 = getelementptr inbounds %struct.processStruct, %struct.processStruct* %25, i64 %27
  %29 = bitcast %struct.processStruct* %23 to i8*
  %30 = bitcast %struct.processStruct* %28 to i8*
  call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 4 %29, i8* align 4 %30, i64 24, i1 false)
  br label %31

31:                                               ; preds = %19
  %32 = load i32, i32* %6, align 4
  %33 = add nsw i32 %32, 1
  store i32 %33, i32* %6, align 4
  br label %15, !llvm.loop !11

34:                                               ; preds = %15
  %35 = load i32, i32* %4, align 4
  %36 = add nsw i32 %35, 1
  store i32 %36, i32* %7, align 4
  br label %37

37:                                               ; preds = %55, %34
  %38 = load i32, i32* %7, align 4
  %39 = getelementptr inbounds %struct.readyQueue, %struct.readyQueue* %1, i32 0, i32 4
  %40 = load i32, i32* %39, align 8
  %41 = icmp slt i32 %38, %40
  br i1 %41, label %42, label %58

42:                                               ; preds = %37
  %43 = load %struct.processStruct*, %struct.processStruct** %5, align 8
  %44 = load i32, i32* %7, align 4
  %45 = sub nsw i32 %44, 1
  %46 = sext i32 %45 to i64
  %47 = getelementptr inbounds %struct.processStruct, %struct.processStruct* %43, i64 %46
  %48 = getelementptr inbounds %struct.readyQueue, %struct.readyQueue* %1, i32 0, i32 0
  %49 = load %struct.processStruct*, %struct.processStruct** %48, align 8
  %50 = load i32, i32* %7, align 4
  %51 = sext i32 %50 to i64
  %52 = getelementptr inbounds %struct.processStruct, %struct.processStruct* %49, i64 %51
  %53 = bitcast %struct.processStruct* %47 to i8*
  %54 = bitcast %struct.processStruct* %52 to i8*
  call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 4 %53, i8* align 4 %54, i64 24, i1 false)
  br label %55

55:                                               ; preds = %42
  %56 = load i32, i32* %7, align 4
  %57 = add nsw i32 %56, 1
  store i32 %57, i32* %7, align 4
  br label %37, !llvm.loop !12

58:                                               ; preds = %37
  %59 = getelementptr inbounds %struct.readyQueue, %struct.readyQueue* %1, i32 0, i32 4
  %60 = load i32, i32* %59, align 8
  %61 = add nsw i32 %60, -1
  store i32 %61, i32* %59, align 8
  %62 = getelementptr inbounds %struct.readyQueue, %struct.readyQueue* %1, i32 0, i32 0
  %63 = load %struct.processStruct*, %struct.processStruct** %62, align 8
  %64 = bitcast %struct.processStruct* %63 to i8*
  %65 = load %struct.processStruct*, %struct.processStruct** %5, align 8
  %66 = bitcast %struct.processStruct* %65 to i8*
  %67 = getelementptr inbounds %struct.readyQueue, %struct.readyQueue* %1, i32 0, i32 4
  %68 = load i32, i32* %67, align 8
  %69 = sext i32 %68 to i64
  %70 = mul i64 %69, 24
  call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 4 %64, i8* align 4 %66, i64 %70, i1 false)
  %71 = load %struct.processStruct*, %struct.processStruct** %5, align 8
  %72 = bitcast %struct.processStruct* %71 to i8*
  call void @free(i8* noundef %72) #7
  %73 = bitcast %struct.readyQueue* %0 to i8*
  %74 = bitcast %struct.readyQueue* %1 to i8*
  call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 8 %73, i8* align 8 %74, i64 56, i1 false)
  ret void
}

; Function Attrs: nounwind
declare noalias i8* @malloc(i64 noundef) #2

; Function Attrs: nounwind
declare void @free(i8* noundef) #2

; Function Attrs: noinline nounwind optnone uwtable
define dso_local i8* @buildString(i8* noundef %0, %struct.readyQueue* noundef byval(%struct.readyQueue) align 8 %1) #0 {
  %3 = alloca i8*, align 8
  %4 = alloca [20 x i8], align 16
  %5 = alloca i32, align 4
  store i8* %0, i8** %3, align 8
  %6 = load i8*, i8** %3, align 8
  %7 = call i8* @strcat(i8* noundef %6, i8* noundef getelementptr inbounds ([12 x i8], [12 x i8]* @.str, i64 0, i64 0)) #7
  store i32 0, i32* %5, align 4
  br label %8

8:                                                ; preds = %52, %2
  %9 = load i32, i32* %5, align 4
  %10 = getelementptr inbounds %struct.readyQueue, %struct.readyQueue* %1, i32 0, i32 4
  %11 = load i32, i32* %10, align 8
  %12 = icmp slt i32 %9, %11
  br i1 %12, label %13, label %55

13:                                               ; preds = %8
  %14 = getelementptr inbounds [20 x i8], [20 x i8]* %4, i64 0, i64 0
  %15 = getelementptr inbounds %struct.readyQueue, %struct.readyQueue* %1, i32 0, i32 0
  %16 = load %struct.processStruct*, %struct.processStruct** %15, align 8
  %17 = load i32, i32* %5, align 4
  %18 = sext i32 %17 to i64
  %19 = getelementptr inbounds %struct.processStruct, %struct.processStruct* %16, i64 %18
  %20 = getelementptr inbounds %struct.processStruct, %struct.processStruct* %19, i32 0, i32 4
  %21 = load i32, i32* %20, align 4
  %22 = call i32 (i8*, i8*, ...) @sprintf(i8* noundef %14, i8* noundef getelementptr inbounds ([3 x i8], [3 x i8]* @.str.1, i64 0, i64 0), i32 noundef %21) #7
  %23 = load i8*, i8** %3, align 8
  %24 = getelementptr inbounds [20 x i8], [20 x i8]* %4, i64 0, i64 0
  %25 = call i8* @strcat(i8* noundef %23, i8* noundef %24) #7
  %26 = load i8*, i8** %3, align 8
  %27 = call i8* @strcat(i8* noundef %26, i8* noundef getelementptr inbounds ([3 x i8], [3 x i8]* @.str.2, i64 0, i64 0)) #7
  %28 = bitcast [20 x i8]* %4 to i8*
  call void @llvm.memset.p0i8.i64(i8* align 16 %28, i8 0, i64 20, i1 false)
  %29 = getelementptr inbounds [20 x i8], [20 x i8]* %4, i64 0, i64 0
  %30 = getelementptr inbounds %struct.readyQueue, %struct.readyQueue* %1, i32 0, i32 0
  %31 = load %struct.processStruct*, %struct.processStruct** %30, align 8
  %32 = load i32, i32* %5, align 4
  %33 = sext i32 %32 to i64
  %34 = getelementptr inbounds %struct.processStruct, %struct.processStruct* %31, i64 %33
  %35 = getelementptr inbounds %struct.processStruct, %struct.processStruct* %34, i32 0, i32 2
  %36 = load i32, i32* %35, align 4
  %37 = call i32 (i8*, i8*, ...) @sprintf(i8* noundef %29, i8* noundef getelementptr inbounds ([3 x i8], [3 x i8]* @.str.1, i64 0, i64 0), i32 noundef %36) #7
  %38 = load i8*, i8** %3, align 8
  %39 = getelementptr inbounds [20 x i8], [20 x i8]* %4, i64 0, i64 0
  %40 = call i8* @strcat(i8* noundef %38, i8* noundef %39) #7
  %41 = load i8*, i8** %3, align 8
  %42 = call i8* @strcat(i8* noundef %41, i8* noundef getelementptr inbounds ([5 x i8], [5 x i8]* @.str.3, i64 0, i64 0)) #7
  %43 = load i32, i32* %5, align 4
  %44 = getelementptr inbounds %struct.readyQueue, %struct.readyQueue* %1, i32 0, i32 4
  %45 = load i32, i32* %44, align 8
  %46 = sub nsw i32 %45, 1
  %47 = icmp ne i32 %43, %46
  br i1 %47, label %48, label %51

48:                                               ; preds = %13
  %49 = load i8*, i8** %3, align 8
  %50 = call i8* @strcat(i8* noundef %49, i8* noundef getelementptr inbounds ([2 x i8], [2 x i8]* @.str.4, i64 0, i64 0)) #7
  br label %51

51:                                               ; preds = %48, %13
  br label %52

52:                                               ; preds = %51
  %53 = load i32, i32* %5, align 4
  %54 = add nsw i32 %53, 1
  store i32 %54, i32* %5, align 4
  br label %8, !llvm.loop !13

55:                                               ; preds = %8
  %56 = load i8*, i8** %3, align 8
  ret i8* %56
}

; Function Attrs: nounwind
declare i8* @strcat(i8* noundef, i8* noundef) #2

; Function Attrs: nounwind
declare i32 @sprintf(i8* noundef, i8* noundef, ...) #2

; Function Attrs: argmemonly nofree nounwind willreturn writeonly
declare void @llvm.memset.p0i8.i64(i8* nocapture writeonly, i8, i64, i1 immarg) #3

; Function Attrs: noinline nounwind optnone uwtable
define dso_local i32 @main(i32 noundef %0, i8** noundef %1) #0 {
  %3 = alloca i32, align 4
  %4 = alloca i32, align 4
  %5 = alloca i8**, align 8
  %6 = alloca i32, align 4
  %7 = alloca i8*, align 8
  %8 = alloca i64, align 8
  %9 = alloca i64, align 8
  %10 = alloca i64, align 8
  %11 = alloca i64, align 8
  %12 = alloca %struct.readyQueue, align 8
  %13 = alloca i32, align 4
  %14 = alloca i32, align 4
  %15 = alloca [50000 x i8], align 16
  %16 = alloca i32, align 4
  %17 = alloca i32, align 4
  %18 = alloca %struct.readyQueue, align 8
  %19 = alloca i8*, align 8
  %20 = alloca i64, align 8
  %21 = alloca i32, align 4
  %22 = alloca i64, align 8
  %23 = alloca i32, align 4
  %24 = alloca i32, align 4
  %25 = alloca i32, align 4
  %26 = alloca %struct.readyQueue, align 8
  %27 = alloca i32, align 4
  %28 = alloca %struct.readyQueue, align 8
  %29 = alloca %struct.readyQueue, align 8
  %30 = alloca float, align 4
  store i32 0, i32* %3, align 4
  store i32 %0, i32* %4, align 4
  store i8** %1, i8*** %5, align 8
  %31 = call i32 (i8*, ...) @printf(i8* noundef getelementptr inbounds ([44 x i8], [44 x i8]* @.str.5, i64 0, i64 0))
  %32 = call i32 (i8*, ...) @__isoc99_scanf(i8* noundef getelementptr inbounds ([3 x i8], [3 x i8]* @.str.1, i64 0, i64 0), i32* noundef %6)
  %33 = load i32, i32* %6, align 4
  %34 = mul nsw i32 %33, 1000
  %35 = zext i32 %34 to i64
  %36 = call i8* @llvm.stacksave()
  store i8* %36, i8** %7, align 8
  %37 = alloca %struct.processStruct, i64 %35, align 16
  store i64 %35, i64* %8, align 8
  %38 = load i32, i32* %6, align 4
  %39 = zext i32 %38 to i64
  %40 = alloca %struct.processStruct, i64 %39, align 16
  store i64 %39, i64* %9, align 8
  %41 = load i32, i32* %6, align 4
  %42 = zext i32 %41 to i64
  %43 = alloca i32, i64 %42, align 16
  store i64 %42, i64* %10, align 8
  %44 = load i32, i32* %6, align 4
  %45 = zext i32 %44 to i64
  %46 = alloca i32, i64 %45, align 16
  store i64 %45, i64* %11, align 8
  %47 = getelementptr inbounds %struct.readyQueue, %struct.readyQueue* %12, i32 0, i32 0
  store %struct.processStruct* %37, %struct.processStruct** %47, align 8
  %48 = load i32, i32* %6, align 4
  %49 = getelementptr inbounds %struct.readyQueue, %struct.readyQueue* %12, i32 0, i32 4
  store i32 %48, i32* %49, align 8
  store i32 0, i32* %13, align 4
  br label %50

50:                                               ; preds = %129, %2
  %51 = load i32, i32* %13, align 4
  %52 = load i32, i32* %6, align 4
  %53 = icmp slt i32 %51, %52
  br i1 %53, label %54, label %132

54:                                               ; preds = %50
  %55 = load i32, i32* %13, align 4
  %56 = add nsw i32 %55, 1
  %57 = call i32 (i8*, ...) @printf(i8* noundef getelementptr inbounds ([7 x i8], [7 x i8]* @.str.6, i64 0, i64 0), i8* noundef getelementptr inbounds ([31 x i8], [31 x i8]* @.str.7, i64 0, i64 0), i32 noundef %56, i8* noundef getelementptr inbounds ([3 x i8], [3 x i8]* @.str.8, i64 0, i64 0))
  %58 = load i32, i32* %13, align 4
  %59 = sext i32 %58 to i64
  %60 = getelementptr inbounds i32, i32* %43, i64 %59
  %61 = call i32 (i8*, ...) @__isoc99_scanf(i8* noundef getelementptr inbounds ([3 x i8], [3 x i8]* @.str.1, i64 0, i64 0), i32* noundef %60)
  %62 = load i32, i32* %13, align 4
  %63 = sext i32 %62 to i64
  %64 = getelementptr inbounds i32, i32* %43, i64 %63
  %65 = load i32, i32* %64, align 4
  %66 = load i32, i32* %13, align 4
  %67 = sext i32 %66 to i64
  %68 = getelementptr inbounds %struct.processStruct, %struct.processStruct* %37, i64 %67
  %69 = getelementptr inbounds %struct.processStruct, %struct.processStruct* %68, i32 0, i32 0
  store i32 %65, i32* %69, align 8
  %70 = load i32, i32* %13, align 4
  %71 = sext i32 %70 to i64
  %72 = getelementptr inbounds i32, i32* %43, i64 %71
  %73 = load i32, i32* %72, align 4
  %74 = load i32, i32* %13, align 4
  %75 = sext i32 %74 to i64
  %76 = getelementptr inbounds %struct.processStruct, %struct.processStruct* %37, i64 %75
  %77 = getelementptr inbounds %struct.processStruct, %struct.processStruct* %76, i32 0, i32 2
  store i32 %73, i32* %77, align 8
  %78 = load i32, i32* %13, align 4
  %79 = add nsw i32 %78, 1
  %80 = call i32 (i8*, ...) @printf(i8* noundef getelementptr inbounds ([7 x i8], [7 x i8]* @.str.6, i64 0, i64 0), i8* noundef getelementptr inbounds ([29 x i8], [29 x i8]* @.str.9, i64 0, i64 0), i32 noundef %79, i8* noundef getelementptr inbounds ([3 x i8], [3 x i8]* @.str.8, i64 0, i64 0))
  %81 = load i32, i32* %13, align 4
  %82 = sext i32 %81 to i64
  %83 = getelementptr inbounds i32, i32* %46, i64 %82
  %84 = call i32 (i8*, ...) @__isoc99_scanf(i8* noundef getelementptr inbounds ([3 x i8], [3 x i8]* @.str.1, i64 0, i64 0), i32* noundef %83)
  %85 = load i32, i32* %13, align 4
  %86 = sext i32 %85 to i64
  %87 = getelementptr inbounds i32, i32* %46, i64 %86
  %88 = load i32, i32* %87, align 4
  %89 = load i32, i32* %13, align 4
  %90 = sext i32 %89 to i64
  %91 = getelementptr inbounds %struct.processStruct, %struct.processStruct* %37, i64 %90
  %92 = getelementptr inbounds %struct.processStruct, %struct.processStruct* %91, i32 0, i32 1
  store i32 %88, i32* %92, align 4
  %93 = load i32, i32* %13, align 4
  %94 = sext i32 %93 to i64
  %95 = getelementptr inbounds %struct.processStruct, %struct.processStruct* %37, i64 %94
  %96 = getelementptr inbounds %struct.processStruct, %struct.processStruct* %95, i32 0, i32 5
  store i32 0, i32* %96, align 4
  %97 = load i32, i32* %13, align 4
  %98 = sext i32 %97 to i64
  %99 = getelementptr inbounds i32, i32* %46, i64 %98
  %100 = load i32, i32* %99, align 4
  %101 = load i32, i32* %13, align 4
  %102 = sext i32 %101 to i64
  %103 = getelementptr inbounds %struct.processStruct, %struct.processStruct* %37, i64 %102
  %104 = getelementptr inbounds %struct.processStruct, %struct.processStruct* %103, i32 0, i32 3
  store i32 %100, i32* %104, align 4
  %105 = load i32, i32* %13, align 4
  %106 = add nsw i32 %105, 1
  %107 = load i32, i32* %13, align 4
  %108 = sext i32 %107 to i64
  %109 = getelementptr inbounds %struct.processStruct, %struct.processStruct* %37, i64 %108
  %110 = getelementptr inbounds %struct.processStruct, %struct.processStruct* %109, i32 0, i32 4
  store i32 %106, i32* %110, align 8
  %111 = getelementptr inbounds %struct.readyQueue, %struct.readyQueue* %12, i32 0, i32 0
  %112 = load %struct.processStruct*, %struct.processStruct** %111, align 8
  %113 = load i32, i32* %13, align 4
  %114 = sext i32 %113 to i64
  %115 = getelementptr inbounds %struct.processStruct, %struct.processStruct* %112, i64 %114
  %116 = load i32, i32* %13, align 4
  %117 = sext i32 %116 to i64
  %118 = getelementptr inbounds %struct.processStruct, %struct.processStruct* %37, i64 %117
  %119 = bitcast %struct.processStruct* %115 to i8*
  %120 = bitcast %struct.processStruct* %118 to i8*
  call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 4 %119, i8* align 8 %120, i64 24, i1 false)
  %121 = load i32, i32* %13, align 4
  %122 = sext i32 %121 to i64
  %123 = getelementptr inbounds %struct.processStruct, %struct.processStruct* %40, i64 %122
  %124 = load i32, i32* %13, align 4
  %125 = sext i32 %124 to i64
  %126 = getelementptr inbounds %struct.processStruct, %struct.processStruct* %37, i64 %125
  %127 = bitcast %struct.processStruct* %123 to i8*
  %128 = bitcast %struct.processStruct* %126 to i8*
  call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 8 %127, i8* align 8 %128, i64 24, i1 false)
  br label %129

129:                                              ; preds = %54
  %130 = load i32, i32* %13, align 4
  %131 = add nsw i32 %130, 1
  store i32 %131, i32* %13, align 4
  br label %50, !llvm.loop !14

132:                                              ; preds = %50
  %133 = getelementptr inbounds %struct.readyQueue, %struct.readyQueue* %12, i32 0, i32 1
  store %struct.processStruct* %40, %struct.processStruct** %133, align 8
  %134 = getelementptr inbounds %struct.readyQueue, %struct.readyQueue* %12, i32 0, i32 5
  store i32 0, i32* %134, align 4
  %135 = getelementptr inbounds %struct.readyQueue, %struct.readyQueue* %12, i32 0, i32 2
  store i32 0, i32* %135, align 8
  %136 = load i32, i32* %6, align 4
  %137 = getelementptr inbounds %struct.readyQueue, %struct.readyQueue* %12, i32 0, i32 6
  store i32 %136, i32* %137, align 8
  %138 = getelementptr inbounds %struct.readyQueue, %struct.readyQueue* %12, i32 0, i32 7
  store i32 0, i32* %138, align 4
  %139 = getelementptr inbounds %struct.readyQueue, %struct.readyQueue* %12, i32 0, i32 8
  %140 = getelementptr inbounds [4 x i32], [4 x i32]* %139, i64 0, i64 0
  store i32 -1, i32* %140, align 8
  %141 = getelementptr inbounds %struct.readyQueue, %struct.readyQueue* %12, i32 0, i32 8
  %142 = getelementptr inbounds [4 x i32], [4 x i32]* %141, i64 0, i64 1
  store i32 -1, i32* %142, align 4
  %143 = getelementptr inbounds %struct.readyQueue, %struct.readyQueue* %12, i32 0, i32 8
  %144 = getelementptr inbounds [4 x i32], [4 x i32]* %143, i64 0, i64 2
  store i32 0, i32* %144, align 8
  %145 = load i32, i32* %6, align 4
  %146 = getelementptr inbounds %struct.readyQueue, %struct.readyQueue* %12, i32 0, i32 3
  store i32 %145, i32* %146, align 4
  %147 = load i32, i32* %6, align 4
  %148 = call i32 @reduce(i32 (i32, i32)* noundef @lcm, i32* noundef %46, i32 noundef %147)
  store i32 %148, i32* %14, align 4
  %149 = bitcast [50000 x i8]* %15 to i8*
  call void @llvm.memset.p0i8.i64(i8* align 16 %149, i8 0, i64 50000, i1 false)
  %150 = getelementptr inbounds [50000 x i8], [50000 x i8]* %15, i64 0, i64 0
  %151 = call i8* @buildString(i8* noundef %150, %struct.readyQueue* noundef byval(%struct.readyQueue) align 8 %12)
  %152 = getelementptr inbounds [50000 x i8], [50000 x i8]* %15, i64 0, i64 0
  %153 = call i32 (i8*, ...) @printf(i8* noundef getelementptr inbounds ([6 x i8], [6 x i8]* @.str.10, i64 0, i64 0), i8* noundef getelementptr inbounds ([4 x i8], [4 x i8]* @.str.11, i64 0, i64 0), i8* noundef %152)
  store i32 0, i32* %16, align 4
  br label %154

154:                                              ; preds = %461, %132
  %155 = load i32, i32* %16, align 4
  %156 = load i32, i32* %14, align 4
  %157 = icmp slt i32 %155, %156
  br i1 %157, label %158, label %464

158:                                              ; preds = %154
  store i32 0, i32* %17, align 4
  %159 = getelementptr inbounds %struct.readyQueue, %struct.readyQueue* %12, i32 0, i32 0
  %160 = load %struct.processStruct*, %struct.processStruct** %159, align 8
  %161 = getelementptr inbounds %struct.readyQueue, %struct.readyQueue* %12, i32 0, i32 2
  %162 = load i32, i32* %161, align 8
  %163 = sext i32 %162 to i64
  %164 = getelementptr inbounds %struct.processStruct, %struct.processStruct* %160, i64 %163
  %165 = getelementptr inbounds %struct.processStruct, %struct.processStruct* %164, i32 0, i32 2
  %166 = load i32, i32* %165, align 4
  %167 = icmp eq i32 %166, 0
  br i1 %167, label %168, label %185

168:                                              ; preds = %158
  %169 = load i32, i32* %16, align 4
  %170 = getelementptr inbounds %struct.readyQueue, %struct.readyQueue* %12, i32 0, i32 0
  %171 = load %struct.processStruct*, %struct.processStruct** %170, align 8
  %172 = getelementptr inbounds %struct.readyQueue, %struct.readyQueue* %12, i32 0, i32 2
  %173 = load i32, i32* %172, align 8
  %174 = sext i32 %173 to i64
  %175 = getelementptr inbounds %struct.processStruct, %struct.processStruct* %171, i64 %174
  %176 = getelementptr inbounds %struct.processStruct, %struct.processStruct* %175, i32 0, i32 4
  %177 = load i32, i32* %176, align 4
  %178 = call i32 (i8*, ...) @printf(i8* noundef getelementptr inbounds ([10 x i8], [10 x i8]* @.str.12, i64 0, i64 0), i32 noundef %169, i8* noundef getelementptr inbounds ([11 x i8], [11 x i8]* @.str.13, i64 0, i64 0), i32 noundef %177, i8* noundef getelementptr inbounds ([6 x i8], [6 x i8]* @.str.14, i64 0, i64 0))
  %179 = getelementptr inbounds %struct.readyQueue, %struct.readyQueue* %12, i32 0, i32 2
  %180 = load i32, i32* %179, align 8
  call void @removeProcess(%struct.readyQueue* sret(%struct.readyQueue) align 8 %18, %struct.readyQueue* noundef byval(%struct.readyQueue) align 8 %12, i32 noundef %180)
  %181 = bitcast %struct.readyQueue* %12 to i8*
  %182 = bitcast %struct.readyQueue* %18 to i8*
  call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 8 %181, i8* align 8 %182, i64 56, i1 false)
  store i32 1, i32* %17, align 4
  %183 = getelementptr inbounds %struct.readyQueue, %struct.readyQueue* %12, i32 0, i32 8
  %184 = getelementptr inbounds [4 x i32], [4 x i32]* %183, i64 0, i64 3
  store i32 0, i32* %184, align 4
  br label %185

185:                                              ; preds = %168, %158
  %186 = getelementptr inbounds %struct.readyQueue, %struct.readyQueue* %12, i32 0, i32 4
  %187 = load i32, i32* %186, align 8
  %188 = zext i32 %187 to i64
  %189 = call i8* @llvm.stacksave()
  store i8* %189, i8** %19, align 8
  %190 = alloca %struct.processStruct, i64 %188, align 16
  store i64 %188, i64* %20, align 8
  store i32 0, i32* %21, align 4
  %191 = getelementptr inbounds %struct.readyQueue, %struct.readyQueue* %12, i32 0, i32 4
  %192 = load i32, i32* %191, align 8
  %193 = zext i32 %192 to i64
  %194 = alloca i32, i64 %193, align 16
  store i64 %193, i64* %22, align 8
  store i32 0, i32* %23, align 4
  br label %195

195:                                              ; preds = %253, %185
  %196 = load i32, i32* %23, align 4
  %197 = getelementptr inbounds %struct.readyQueue, %struct.readyQueue* %12, i32 0, i32 4
  %198 = load i32, i32* %197, align 8
  %199 = icmp slt i32 %196, %198
  br i1 %199, label %200, label %256

200:                                              ; preds = %195
  %201 = getelementptr inbounds %struct.readyQueue, %struct.readyQueue* %12, i32 0, i32 0
  %202 = load %struct.processStruct*, %struct.processStruct** %201, align 8
  %203 = load i32, i32* %23, align 4
  %204 = sext i32 %203 to i64
  %205 = getelementptr inbounds %struct.processStruct, %struct.processStruct* %202, i64 %204
  %206 = getelementptr inbounds %struct.processStruct, %struct.processStruct* %205, i32 0, i32 3
  %207 = load i32, i32* %206, align 4
  %208 = add nsw i32 %207, -1
  store i32 %208, i32* %206, align 4
  %209 = getelementptr inbounds %struct.readyQueue, %struct.readyQueue* %12, i32 0, i32 0
  %210 = load %struct.processStruct*, %struct.processStruct** %209, align 8
  %211 = load i32, i32* %23, align 4
  %212 = sext i32 %211 to i64
  %213 = getelementptr inbounds %struct.processStruct, %struct.processStruct* %210, i64 %212
  %214 = getelementptr inbounds %struct.processStruct, %struct.processStruct* %213, i32 0, i32 3
  %215 = load i32, i32* %214, align 4
  %216 = icmp eq i32 %215, 0
  br i1 %216, label %226, label %217

217:                                              ; preds = %200
  %218 = getelementptr inbounds %struct.readyQueue, %struct.readyQueue* %12, i32 0, i32 0
  %219 = load %struct.processStruct*, %struct.processStruct** %218, align 8
  %220 = load i32, i32* %23, align 4
  %221 = sext i32 %220 to i64
  %222 = getelementptr inbounds %struct.processStruct, %struct.processStruct* %219, i64 %221
  %223 = getelementptr inbounds %struct.processStruct, %struct.processStruct* %222, i32 0, i32 3
  %224 = load i32, i32* %223, align 4
  %225 = icmp eq i32 %224, -1
  br i1 %225, label %226, label %252

226:                                              ; preds = %217, %200
  %227 = getelementptr inbounds %struct.readyQueue, %struct.readyQueue* %12, i32 0, i32 0
  %228 = load %struct.processStruct*, %struct.processStruct** %227, align 8
  %229 = load i32, i32* %23, align 4
  %230 = sext i32 %229 to i64
  %231 = getelementptr inbounds %struct.processStruct, %struct.processStruct* %228, i64 %230
  %232 = getelementptr inbounds %struct.processStruct, %struct.processStruct* %231, i32 0, i32 2
  %233 = load i32, i32* %232, align 4
  %234 = icmp sgt i32 %233, 0
  br i1 %234, label %235, label %252

235:                                              ; preds = %226
  %236 = load i32, i32* %23, align 4
  %237 = load i32, i32* %21, align 4
  %238 = sext i32 %237 to i64
  %239 = getelementptr inbounds i32, i32* %194, i64 %238
  store i32 %236, i32* %239, align 4
  %240 = load i32, i32* %21, align 4
  %241 = sext i32 %240 to i64
  %242 = getelementptr inbounds %struct.processStruct, %struct.processStruct* %190, i64 %241
  %243 = getelementptr inbounds %struct.readyQueue, %struct.readyQueue* %12, i32 0, i32 0
  %244 = load %struct.processStruct*, %struct.processStruct** %243, align 8
  %245 = load i32, i32* %23, align 4
  %246 = sext i32 %245 to i64
  %247 = getelementptr inbounds %struct.processStruct, %struct.processStruct* %244, i64 %246
  %248 = bitcast %struct.processStruct* %242 to i8*
  %249 = bitcast %struct.processStruct* %247 to i8*
  call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 8 %248, i8* align 4 %249, i64 24, i1 false)
  %250 = load i32, i32* %21, align 4
  %251 = add nsw i32 %250, 1
  store i32 %251, i32* %21, align 4
  br label %252

252:                                              ; preds = %235, %226, %217
  br label %253

253:                                              ; preds = %252
  %254 = load i32, i32* %23, align 4
  %255 = add nsw i32 %254, 1
  store i32 %255, i32* %23, align 4
  br label %195, !llvm.loop !15

256:                                              ; preds = %195
  store i32 0, i32* %24, align 4
  store i32 0, i32* %25, align 4
  br label %257

257:                                              ; preds = %393, %256
  %258 = load i32, i32* %25, align 4
  %259 = load i32, i32* %6, align 4
  %260 = icmp slt i32 %258, %259
  br i1 %260, label %261, label %396

261:                                              ; preds = %257
  %262 = load i32, i32* %16, align 4
  %263 = icmp ne i32 %262, 0
  br i1 %263, label %264, label %279

264:                                              ; preds = %261
  %265 = load i32, i32* %16, align 4
  %266 = getelementptr inbounds %struct.readyQueue, %struct.readyQueue* %12, i32 0, i32 1
  %267 = load %struct.processStruct*, %struct.processStruct** %266, align 8
  %268 = load i32, i32* %25, align 4
  %269 = sext i32 %268 to i64
  %270 = getelementptr inbounds %struct.processStruct, %struct.processStruct* %267, i64 %269
  %271 = getelementptr inbounds %struct.processStruct, %struct.processStruct* %270, i32 0, i32 1
  %272 = load i32, i32* %271, align 4
  %273 = srem i32 %265, %272
  %274 = icmp eq i32 %273, 0
  br i1 %274, label %275, label %279

275:                                              ; preds = %264
  %276 = load i32, i32* %25, align 4
  call void @addProcess(%struct.readyQueue* sret(%struct.readyQueue) align 8 %26, %struct.readyQueue* noundef byval(%struct.readyQueue) align 8 %12, i32 noundef %276)
  %277 = bitcast %struct.readyQueue* %12 to i8*
  %278 = bitcast %struct.readyQueue* %26 to i8*
  call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 8 %277, i8* align 8 %278, i64 56, i1 false)
  store i32 1, i32* %24, align 4
  br label %279

279:                                              ; preds = %275, %264, %261
  %280 = load i32, i32* %25, align 4
  %281 = load i32, i32* %6, align 4
  %282 = sub nsw i32 %281, 1
  %283 = icmp eq i32 %280, %282
  br i1 %283, label %284, label %392

284:                                              ; preds = %279
  %285 = load i32, i32* %24, align 4
  %286 = icmp eq i32 %285, 1
  br i1 %286, label %287, label %392

287:                                              ; preds = %284
  %288 = bitcast %struct.processStruct* %190 to i8*
  %289 = load i32, i32* %21, align 4
  %290 = sext i32 %289 to i64
  call void @qsort(i8* noundef %288, i64 noundef %290, i64 noundef 24, i32 (i8*, i8*)* noundef @comparePid)
  store i32 0, i32* %27, align 4
  br label %291

291:                                              ; preds = %343, %287
  %292 = load i32, i32* %27, align 4
  %293 = load i32, i32* %21, align 4
  %294 = icmp slt i32 %292, %293
  br i1 %294, label %295, label %346

295:                                              ; preds = %291
  %296 = load i32, i32* %16, align 4
  %297 = load i32, i32* %27, align 4
  %298 = sext i32 %297 to i64
  %299 = getelementptr inbounds %struct.processStruct, %struct.processStruct* %190, i64 %298
  %300 = getelementptr inbounds %struct.processStruct, %struct.processStruct* %299, i32 0, i32 4
  %301 = load i32, i32* %300, align 8
  %302 = load i32, i32* %27, align 4
  %303 = sext i32 %302 to i64
  %304 = getelementptr inbounds %struct.processStruct, %struct.processStruct* %190, i64 %303
  %305 = getelementptr inbounds %struct.processStruct, %struct.processStruct* %304, i32 0, i32 2
  %306 = load i32, i32* %305, align 8
  %307 = call i32 (i8*, ...) @printf(i8* noundef getelementptr inbounds ([14 x i8], [14 x i8]* @.str.15, i64 0, i64 0), i32 noundef %296, i8* noundef getelementptr inbounds ([11 x i8], [11 x i8]* @.str.13, i64 0, i64 0), i32 noundef %301, i8* noundef getelementptr inbounds ([19 x i8], [19 x i8]* @.str.16, i64 0, i64 0), i32 noundef %306, i8* noundef getelementptr inbounds ([10 x i8], [10 x i8]* @.str.17, i64 0, i64 0))
  %308 = load i32, i32* %16, align 4
  %309 = getelementptr inbounds %struct.readyQueue, %struct.readyQueue* %12, i32 0, i32 0
  %310 = load %struct.processStruct*, %struct.processStruct** %309, align 8
  %311 = load i32, i32* %27, align 4
  %312 = sext i32 %311 to i64
  %313 = getelementptr inbounds i32, i32* %194, i64 %312
  %314 = load i32, i32* %313, align 4
  %315 = sext i32 %314 to i64
  %316 = getelementptr inbounds %struct.processStruct, %struct.processStruct* %310, i64 %315
  %317 = getelementptr inbounds %struct.processStruct, %struct.processStruct* %316, i32 0, i32 1
  %318 = load i32, i32* %317, align 4
  %319 = sdiv i32 %308, %318
  %320 = add nsw i32 %319, 1
  %321 = getelementptr inbounds %struct.readyQueue, %struct.readyQueue* %12, i32 0, i32 0
  %322 = load %struct.processStruct*, %struct.processStruct** %321, align 8
  %323 = load i32, i32* %27, align 4
  %324 = sext i32 %323 to i64
  %325 = getelementptr inbounds i32, i32* %194, i64 %324
  %326 = load i32, i32* %325, align 4
  %327 = sext i32 %326 to i64
  %328 = getelementptr inbounds %struct.processStruct, %struct.processStruct* %322, i64 %327
  %329 = getelementptr inbounds %struct.processStruct, %struct.processStruct* %328, i32 0, i32 1
  %330 = load i32, i32* %329, align 4
  %331 = mul nsw i32 %320, %330
  %332 = load i32, i32* %16, align 4
  %333 = sub nsw i32 %331, %332
  %334 = getelementptr inbounds %struct.readyQueue, %struct.readyQueue* %12, i32 0, i32 0
  %335 = load %struct.processStruct*, %struct.processStruct** %334, align 8
  %336 = load i32, i32* %27, align 4
  %337 = sext i32 %336 to i64
  %338 = getelementptr inbounds i32, i32* %194, i64 %337
  %339 = load i32, i32* %338, align 4
  %340 = sext i32 %339 to i64
  %341 = getelementptr inbounds %struct.processStruct, %struct.processStruct* %335, i64 %340
  %342 = getelementptr inbounds %struct.processStruct, %struct.processStruct* %341, i32 0, i32 3
  store i32 %333, i32* %342, align 4
  br label %343

343:                                              ; preds = %295
  %344 = load i32, i32* %27, align 4
  %345 = add nsw i32 %344, 1
  store i32 %345, i32* %27, align 4
  br label %291, !llvm.loop !16

346:                                              ; preds = %291
  %347 = getelementptr inbounds [50000 x i8], [50000 x i8]* %15, i64 0, i64 0
  %348 = getelementptr inbounds [50000 x i8], [50000 x i8]* %15, i64 0, i64 0
  %349 = call i64 @strlen(i8* noundef %348) #8
  call void @llvm.memset.p0i8.i64(i8* align 16 %347, i8 0, i64 %349, i1 false)
  %350 = getelementptr inbounds [50000 x i8], [50000 x i8]* %15, i64 0, i64 0
  %351 = call i8* @buildString(i8* noundef %350, %struct.readyQueue* noundef byval(%struct.readyQueue) align 8 %12)
  %352 = load i32, i32* %16, align 4
  %353 = getelementptr inbounds [50000 x i8], [50000 x i8]* %15, i64 0, i64 0
  %354 = call i32 (i8*, ...) @printf(i8* noundef getelementptr inbounds ([8 x i8], [8 x i8]* @.str.18, i64 0, i64 0), i32 noundef %352, i8* noundef getelementptr inbounds ([3 x i8], [3 x i8]* @.str.8, i64 0, i64 0), i8* noundef %353)
  call void @preempt(%struct.readyQueue* sret(%struct.readyQueue) align 8 %28, %struct.readyQueue* noundef byval(%struct.readyQueue) align 8 %12)
  %355 = bitcast %struct.readyQueue* %12 to i8*
  %356 = bitcast %struct.readyQueue* %28 to i8*
  call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 8 %355, i8* align 8 %356, i64 56, i1 false)
  %357 = getelementptr inbounds %struct.readyQueue, %struct.readyQueue* %12, i32 0, i32 8
  %358 = getelementptr inbounds [4 x i32], [4 x i32]* %357, i64 0, i64 2
  %359 = load i32, i32* %358, align 8
  %360 = icmp eq i32 %359, 1
  br i1 %360, label %361, label %391

361:                                              ; preds = %346
  %362 = getelementptr inbounds %struct.readyQueue, %struct.readyQueue* %12, i32 0, i32 8
  %363 = getelementptr inbounds [4 x i32], [4 x i32]* %362, i64 0, i64 0
  %364 = load i32, i32* %363, align 8
  %365 = icmp ne i32 %364, -1
  br i1 %365, label %366, label %391

366:                                              ; preds = %361
  %367 = getelementptr inbounds %struct.readyQueue, %struct.readyQueue* %12, i32 0, i32 8
  %368 = getelementptr inbounds [4 x i32], [4 x i32]* %367, i64 0, i64 1
  %369 = load i32, i32* %368, align 4
  %370 = icmp ne i32 %369, -1
  br i1 %370, label %371, label %391

371:                                              ; preds = %366
  %372 = getelementptr inbounds %struct.readyQueue, %struct.readyQueue* %12, i32 0, i32 8
  %373 = getelementptr inbounds [4 x i32], [4 x i32]* %372, i64 0, i64 3
  %374 = load i32, i32* %373, align 4
  %375 = icmp eq i32 %374, 1
  br i1 %375, label %376, label %391

376:                                              ; preds = %371
  %377 = load i32, i32* %17, align 4
  %378 = icmp eq i32 %377, 0
  br i1 %378, label %379, label %391

379:                                              ; preds = %376
  %380 = load i32, i32* %16, align 4
  %381 = getelementptr inbounds %struct.readyQueue, %struct.readyQueue* %12, i32 0, i32 8
  %382 = getelementptr inbounds [4 x i32], [4 x i32]* %381, i64 0, i64 0
  %383 = load i32, i32* %382, align 8
  %384 = call i32 (i8*, ...) @printf(i8* noundef getelementptr inbounds ([10 x i8], [10 x i8]* @.str.12, i64 0, i64 0), i32 noundef %380, i8* noundef getelementptr inbounds ([11 x i8], [11 x i8]* @.str.13, i64 0, i64 0), i32 noundef %383, i8* noundef getelementptr inbounds ([12 x i8], [12 x i8]* @.str.19, i64 0, i64 0))
  %385 = getelementptr inbounds %struct.readyQueue, %struct.readyQueue* %12, i32 0, i32 8
  %386 = getelementptr inbounds [4 x i32], [4 x i32]* %385, i64 0, i64 0
  store i32 -1, i32* %386, align 8
  %387 = getelementptr inbounds %struct.readyQueue, %struct.readyQueue* %12, i32 0, i32 8
  %388 = getelementptr inbounds [4 x i32], [4 x i32]* %387, i64 0, i64 1
  store i32 -1, i32* %388, align 4
  %389 = getelementptr inbounds %struct.readyQueue, %struct.readyQueue* %12, i32 0, i32 8
  %390 = getelementptr inbounds [4 x i32], [4 x i32]* %389, i64 0, i64 2
  store i32 0, i32* %390, align 8
  br label %391

391:                                              ; preds = %379, %376, %371, %366, %361, %346
  br label %392

392:                                              ; preds = %391, %284, %279
  br label %393

393:                                              ; preds = %392
  %394 = load i32, i32* %25, align 4
  %395 = add nsw i32 %394, 1
  store i32 %395, i32* %25, align 4
  br label %257, !llvm.loop !17

396:                                              ; preds = %257
  call void @scheduleNearestDeadline(%struct.readyQueue* sret(%struct.readyQueue) align 8 %29, %struct.readyQueue* noundef byval(%struct.readyQueue) align 8 %12)
  %397 = bitcast %struct.readyQueue* %12 to i8*
  %398 = bitcast %struct.readyQueue* %29 to i8*
  call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 8 %397, i8* align 8 %398, i64 56, i1 false)
  %399 = getelementptr inbounds %struct.readyQueue, %struct.readyQueue* %12, i32 0, i32 0
  %400 = load %struct.processStruct*, %struct.processStruct** %399, align 8
  %401 = getelementptr inbounds %struct.readyQueue, %struct.readyQueue* %12, i32 0, i32 2
  %402 = load i32, i32* %401, align 8
  %403 = sext i32 %402 to i64
  %404 = getelementptr inbounds %struct.processStruct, %struct.processStruct* %400, i64 %403
  %405 = getelementptr inbounds %struct.processStruct, %struct.processStruct* %404, i32 0, i32 5
  %406 = load i32, i32* %405, align 4
  %407 = icmp eq i32 %406, 0
  br i1 %407, label %415, label %408

408:                                              ; preds = %396
  %409 = load i32, i32* %17, align 4
  %410 = icmp eq i32 %409, 1
  br i1 %410, label %411, label %435

411:                                              ; preds = %408
  %412 = getelementptr inbounds %struct.readyQueue, %struct.readyQueue* %12, i32 0, i32 4
  %413 = load i32, i32* %412, align 8
  %414 = icmp sgt i32 %413, 0
  br i1 %414, label %415, label %435

415:                                              ; preds = %411, %396
  %416 = load i32, i32* %16, align 4
  %417 = getelementptr inbounds %struct.readyQueue, %struct.readyQueue* %12, i32 0, i32 0
  %418 = load %struct.processStruct*, %struct.processStruct** %417, align 8
  %419 = getelementptr inbounds %struct.readyQueue, %struct.readyQueue* %12, i32 0, i32 2
  %420 = load i32, i32* %419, align 8
  %421 = sext i32 %420 to i64
  %422 = getelementptr inbounds %struct.processStruct, %struct.processStruct* %418, i64 %421
  %423 = getelementptr inbounds %struct.processStruct, %struct.processStruct* %422, i32 0, i32 4
  %424 = load i32, i32* %423, align 4
  %425 = call i32 (i8*, ...) @printf(i8* noundef getelementptr inbounds ([10 x i8], [10 x i8]* @.str.12, i64 0, i64 0), i32 noundef %416, i8* noundef getelementptr inbounds ([11 x i8], [11 x i8]* @.str.13, i64 0, i64 0), i32 noundef %424, i8* noundef getelementptr inbounds ([8 x i8], [8 x i8]* @.str.20, i64 0, i64 0))
  %426 = getelementptr inbounds %struct.readyQueue, %struct.readyQueue* %12, i32 0, i32 0
  %427 = load %struct.processStruct*, %struct.processStruct** %426, align 8
  %428 = getelementptr inbounds %struct.readyQueue, %struct.readyQueue* %12, i32 0, i32 2
  %429 = load i32, i32* %428, align 8
  %430 = sext i32 %429 to i64
  %431 = getelementptr inbounds %struct.processStruct, %struct.processStruct* %427, i64 %430
  %432 = getelementptr inbounds %struct.processStruct, %struct.processStruct* %431, i32 0, i32 5
  store i32 1, i32* %432, align 4
  store i32 0, i32* %17, align 4
  %433 = getelementptr inbounds %struct.readyQueue, %struct.readyQueue* %12, i32 0, i32 8
  %434 = getelementptr inbounds [4 x i32], [4 x i32]* %433, i64 0, i64 3
  store i32 1, i32* %434, align 4
  br label %435

435:                                              ; preds = %415, %411, %408
  %436 = bitcast %struct.processStruct* %190 to i8*
  %437 = load i32, i32* %21, align 4
  %438 = sext i32 %437 to i64
  %439 = mul i64 %438, 24
  call void @llvm.memset.p0i8.i64(i8* align 16 %436, i8 0, i64 %439, i1 false)
  %440 = getelementptr inbounds %struct.readyQueue, %struct.readyQueue* %12, i32 0, i32 0
  %441 = load %struct.processStruct*, %struct.processStruct** %440, align 8
  %442 = getelementptr inbounds %struct.readyQueue, %struct.readyQueue* %12, i32 0, i32 2
  %443 = load i32, i32* %442, align 8
  %444 = sext i32 %443 to i64
  %445 = getelementptr inbounds %struct.processStruct, %struct.processStruct* %441, i64 %444
  %446 = getelementptr inbounds %struct.processStruct, %struct.processStruct* %445, i32 0, i32 2
  %447 = load i32, i32* %446, align 4
  %448 = add nsw i32 %447, -1
  store i32 %448, i32* %446, align 4
  %449 = getelementptr inbounds %struct.readyQueue, %struct.readyQueue* %12, i32 0, i32 4
  %450 = load i32, i32* %449, align 8
  %451 = icmp sgt i32 %450, 0
  br i1 %451, label %452, label %459

452:                                              ; preds = %435
  %453 = getelementptr inbounds %struct.readyQueue, %struct.readyQueue* %12, i32 0, i32 4
  %454 = load i32, i32* %453, align 8
  %455 = sub nsw i32 %454, 1
  %456 = getelementptr inbounds %struct.readyQueue, %struct.readyQueue* %12, i32 0, i32 7
  %457 = load i32, i32* %456, align 4
  %458 = add nsw i32 %457, %455
  store i32 %458, i32* %456, align 4
  br label %459

459:                                              ; preds = %452, %435
  %460 = load i8*, i8** %19, align 8
  call void @llvm.stackrestore(i8* %460)
  br label %461

461:                                              ; preds = %459
  %462 = load i32, i32* %16, align 4
  %463 = add nsw i32 %462, 1
  store i32 %463, i32* %16, align 4
  br label %154, !llvm.loop !18

464:                                              ; preds = %154
  %465 = getelementptr inbounds %struct.readyQueue, %struct.readyQueue* %12, i32 0, i32 0
  %466 = load %struct.processStruct*, %struct.processStruct** %465, align 8
  %467 = getelementptr inbounds %struct.readyQueue, %struct.readyQueue* %12, i32 0, i32 2
  %468 = load i32, i32* %467, align 8
  %469 = sext i32 %468 to i64
  %470 = getelementptr inbounds %struct.processStruct, %struct.processStruct* %466, i64 %469
  %471 = getelementptr inbounds %struct.processStruct, %struct.processStruct* %470, i32 0, i32 2
  %472 = load i32, i32* %471, align 4
  %473 = icmp eq i32 %472, 0
  br i1 %473, label %474, label %486

474:                                              ; preds = %464
  %475 = load i32, i32* %14, align 4
  %476 = getelementptr inbounds %struct.readyQueue, %struct.readyQueue* %12, i32 0, i32 0
  %477 = load %struct.processStruct*, %struct.processStruct** %476, align 8
  %478 = getelementptr inbounds %struct.readyQueue, %struct.readyQueue* %12, i32 0, i32 2
  %479 = load i32, i32* %478, align 8
  %480 = sext i32 %479 to i64
  %481 = getelementptr inbounds %struct.processStruct, %struct.processStruct* %477, i64 %480
  %482 = getelementptr inbounds %struct.processStruct, %struct.processStruct* %481, i32 0, i32 4
  %483 = load i32, i32* %482, align 4
  %484 = call i32 (i8*, ...) @printf(i8* noundef getelementptr inbounds ([10 x i8], [10 x i8]* @.str.12, i64 0, i64 0), i32 noundef %475, i8* noundef getelementptr inbounds ([11 x i8], [11 x i8]* @.str.13, i64 0, i64 0), i32 noundef %483, i8* noundef getelementptr inbounds ([6 x i8], [6 x i8]* @.str.14, i64 0, i64 0))
  %485 = getelementptr inbounds %struct.readyQueue, %struct.readyQueue* %12, i32 0, i32 2
  store i32 0, i32* %485, align 8
  br label %486

486:                                              ; preds = %474, %464
  %487 = load i32, i32* %14, align 4
  %488 = call i32 (i8*, ...) @printf(i8* noundef getelementptr inbounds ([6 x i8], [6 x i8]* @.str.21, i64 0, i64 0), i32 noundef %487, i8* noundef getelementptr inbounds ([19 x i8], [19 x i8]* @.str.22, i64 0, i64 0))
  %489 = getelementptr inbounds %struct.readyQueue, %struct.readyQueue* %12, i32 0, i32 7
  %490 = load i32, i32* %489, align 4
  %491 = call i32 (i8*, ...) @printf(i8* noundef getelementptr inbounds ([6 x i8], [6 x i8]* @.str.23, i64 0, i64 0), i8* noundef getelementptr inbounds ([27 x i8], [27 x i8]* @.str.24, i64 0, i64 0), i32 noundef %490)
  %492 = getelementptr inbounds %struct.readyQueue, %struct.readyQueue* %12, i32 0, i32 6
  %493 = load i32, i32* %492, align 8
  %494 = call i32 (i8*, ...) @printf(i8* noundef getelementptr inbounds ([6 x i8], [6 x i8]* @.str.23, i64 0, i64 0), i8* noundef getelementptr inbounds ([30 x i8], [30 x i8]* @.str.25, i64 0, i64 0), i32 noundef %493)
  %495 = getelementptr inbounds %struct.readyQueue, %struct.readyQueue* %12, i32 0, i32 7
  %496 = load i32, i32* %495, align 4
  %497 = sitofp i32 %496 to float
  %498 = getelementptr inbounds %struct.readyQueue, %struct.readyQueue* %12, i32 0, i32 6
  %499 = load i32, i32* %498, align 8
  %500 = sitofp i32 %499 to float
  %501 = fdiv float %497, %500
  store float %501, float* %30, align 4
  %502 = load float, float* %30, align 4
  %503 = fpext float %502 to double
  %504 = call i32 (i8*, ...) @printf(i8* noundef getelementptr inbounds ([9 x i8], [9 x i8]* @.str.26, i64 0, i64 0), i8* noundef getelementptr inbounds ([23 x i8], [23 x i8]* @.str.27, i64 0, i64 0), double noundef %503)
  store i32 0, i32* %3, align 4
  %505 = load i8*, i8** %7, align 8
  call void @llvm.stackrestore(i8* %505)
  %506 = load i32, i32* %3, align 4
  ret i32 %506
}

declare i32 @printf(i8* noundef, ...) #4

declare i32 @__isoc99_scanf(i8* noundef, ...) #4

; Function Attrs: nofree nosync nounwind willreturn
declare i8* @llvm.stacksave() #5

declare void @qsort(i8* noundef, i64 noundef, i64 noundef, i32 (i8*, i8*)* noundef) #4

; Function Attrs: nounwind readonly willreturn
declare i64 @strlen(i8* noundef) #6

; Function Attrs: nofree nosync nounwind willreturn
declare void @llvm.stackrestore(i8*) #5

attributes #0 = { noinline nounwind optnone uwtable "frame-pointer"="all" "min-legal-vector-width"="0" "no-trapping-math"="true" "stack-protector-buffer-size"="8" "target-cpu"="x86-64" "target-features"="+cx8,+fxsr,+mmx,+sse,+sse2,+x87" "tune-cpu"="generic" }
attributes #1 = { argmemonly nofree nounwind willreturn }
attributes #2 = { nounwind "frame-pointer"="all" "no-trapping-math"="true" "stack-protector-buffer-size"="8" "target-cpu"="x86-64" "target-features"="+cx8,+fxsr,+mmx,+sse,+sse2,+x87" "tune-cpu"="generic" }
attributes #3 = { argmemonly nofree nounwind willreturn writeonly }
attributes #4 = { "frame-pointer"="all" "no-trapping-math"="true" "stack-protector-buffer-size"="8" "target-cpu"="x86-64" "target-features"="+cx8,+fxsr,+mmx,+sse,+sse2,+x87" "tune-cpu"="generic" }
attributes #5 = { nofree nosync nounwind willreturn }
attributes #6 = { nounwind readonly willreturn "frame-pointer"="all" "no-trapping-math"="true" "stack-protector-buffer-size"="8" "target-cpu"="x86-64" "target-features"="+cx8,+fxsr,+mmx,+sse,+sse2,+x87" "tune-cpu"="generic" }
attributes #7 = { nounwind }
attributes #8 = { nounwind readonly willreturn }

!llvm.module.flags = !{!0, !1, !2, !3, !4}
!llvm.ident = !{!5}

!0 = !{i32 1, !"wchar_size", i32 4}
!1 = !{i32 7, !"PIC Level", i32 2}
!2 = !{i32 7, !"PIE Level", i32 2}
!3 = !{i32 7, !"uwtable", i32 1}
!4 = !{i32 7, !"frame-pointer", i32 2}
!5 = !{!"Ubuntu clang version 14.0.0-1ubuntu1"}
!6 = distinct !{!6, !7}
!7 = !{!"llvm.loop.mustprogress"}
!8 = distinct !{!8, !7}
!9 = distinct !{!9, !7}
!10 = distinct !{!10, !7}
!11 = distinct !{!11, !7}
!12 = distinct !{!12, !7}
!13 = distinct !{!13, !7}
!14 = distinct !{!14, !7}
!15 = distinct !{!15, !7}
!16 = distinct !{!16, !7}
!17 = distinct !{!17, !7}
!18 = distinct !{!18, !7}
Optional Paste Settings
Category:
Tags:
Syntax Highlighting:
Paste Expiration:
Paste Exposure:
Folder:
PasswordNEW
Disabled
Burn after read NEW
Paste Name / Title:
Hello Guest
You are currently not logged in, this means you can not edit or delete anything you paste. Sign Up or Login