CD3281 DSA (1)
CD3281 DSA (1)
LAB MANUAL
Semester: V
Regulation: 2021
Prepared By,
lOMoARcPSD|274 323 48
DEPARTMENT OF IT
AIM:
To Implement simple ADTs as Python classes using Stack,Queue,List using python.
ALGORITHM:
1. Create a Stack[ ],Queue[],List[] with MAX size as your wish.
2. Write function for all the basic operations of stack,Queue,List - PUSH(), POP() and
DISPLAY(),append(),Extend().
3. Close the program
POGRAM :
Stack:
stack = []
stack.append('a')
stack.append('b')
stack.append('c')
print('Initial stack')
print(stack)
print('\nElements poped from stack:')
print(stack.pop())
print(stack.pop())
print(stack.pop())
print('\nStack after elements are poped:')
print(stack)
Queue:
queue = []
queue.append('a')
queue.append('b')
queue.append('c')
print("Initial queue")
print(queue)
print("\nElements dequeued from queue")
print(queue.pop(0))
print(queue.pop(0))
print(queue.pop(0))
print("\nQueue after removing elements")
print(queue)
lOMoARcPSD|274 323 48
DEPARTMENT OF IT
List:
List = [1,2,3,4]
print("Initial List: ")
print(List)
List.extend([8, 'Geeks', 'Always'])
print("\nList after performing Extend Operation: ")
print(List)
OUTPUT:
Stack:
Initial stack
['a', 'b', 'c']
Elements poped from stack:
c
b
a
Stack after elements are poped:
[]
Queue:
['a', 'b', 'c']
Elements dequeued from queue
a
b
c
Queue after removing elements
[]
List:
Initial List:
[1, 2, 3, 4]
List after performing Extend Operation:
[1, 2, 3, 4, 8, 'Geeks', 'Always']
RESULT:
Thus the Implementation of simple ADTs as Python classes was executed successfully.
2
lOMoARcPSD|274 323 48
DEPARTMENT OF IT
AIM:
To Implement a recursive algorithms in Python using Fibonacci Series
ALGORITHM:
Step 1:Input the 'n' value until which the Fibonacci series has to be generated.
Step 7:sum = a + b
Step 10:Else
PROGRAM:
No = 10
num1, num2 = 0, 1
count = 0
if No <= 0:
print("Invalid Number")
elif No == 1:
print("Fibonacci sequence for limit of ",No,":")
print(num1)
else:
print("Fibonacci sequence:")
while count < No:
print(num1)
3
lOMoARcPSD|274 323 48
DEPARTMENT OF IT
OUTPUT:
Fibonacci sequence:
0
1
1
2
3
5
8
13
21
34
RESULT:
Thus the Implementation of recursive algorithms in Python using Fibonacci series was
executed successfully.
4
lOMoARcPSD|274 323 48
DEPARTMENT OF IT
AIM:
DEPARTMENT OF IT
index=0 cur=head
while(cur!=None): arr.append(cur.data) cur=cur.next
printarray(arr, len) head=node(0) head=add(6)
head.next = add(4) head.next.next = add(3) head.next.next.next = add(4) convertarr(head)
Output:
[6,4,3,4]
[6 4 3 4]
RESULT:
Thus the implementation of List in arrays was executed successfully.
6
lOMoARcPSD|274 323 48
DEPARTMENT OF IT
AIM:
To Implement the Linked list implementations of List using python.
ALGORITHM:
Step 1:Create a list[ ] with MAX size as your wish.
Step 2:Write function for all the basic operations of list - create(), insert(), deletion(),
display().
Step 3:Using append() to extend the elements, removal() to delete the elements
Step :Close the program.
PROGRAM:
List = [1,2,3,4]
print("Initial List: ")
print(List)
List.extend([8, 'Geeks', 'Always'])
print("\nList after performing Extend Operation: ")
print(List)
List = []
print("Blank List: ")
print(List)
List = [10, 20, 14]
print("\nList of numbers: ")
print(List)
List = ["Geeks", "For", "Geeks"]
print("\nList Items: ")
print(List[0])
print(List[2])
Adding the elements:
List = [1,2,3,4]
print("Initial List: ")
print(List)
List.insert(3, 12)
List.insert(0, 'Geeks')
print("\nList after performing Insert Operation: ")
print(List)
List = [1, 2, 3, 4, 5, 6,
7, 8, 9, 10, 11, 12]
7
lOMoARcPSD|274 323 48
DEPARTMENT OF IT
List.remove(5)
List.remove(6)
print("\nList after Removal of two elements: ")
print(List)
for i in range(1, 5):
List.remove(i)
print("\nList after Removing a range of elements: ")
print(List)
List = [['Geeks', 'For'] , ['Geeks']]
print("\nMulti-Dimensional List: ")
print(List)
OUTPUT:
Initial blank List:
[]
List after Addition of Three elements:
[1, 2, 4]
List after Addition of elements from 1-3:
[1, 2, 4, 1, 2, 3]
>>>
===================== RESTART: Z:/New folder/queue 1.py
=====================
Initial List:
[1, 2, 3, 4]
List after performing Insert Operation:
['Geeks', 1, 2, 3, 12, 4]
>>>
===================== RESTART: Z:/New folder/queue 1.py
=====================
Intial List:
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]
List after Removal of two elements:
[1, 2, 3, 4, 7, 8, 9, 10, 11, 12]
List after Removing a range of elements:
[7, 8, 9, 10, 11, 12]
RESULT:
Thus the list was created, inserted, removed and extend the element was executed successfully
lOMoARcPSD|274 323 48
DEPARTMENT OF IT
AIM:
To Implement of Stack and Queue ADTs in python.
ALGORITHM:
Queue:
queue = []
queue.append('a')
queue.append('b')
queue.append('c')
print("Initial queue")
print(queue)
print("\nElements dequeued from queue")
print(queue.pop(0))
print(queue.pop(0))
print(queue.pop(0))
print("\nQueue after removing elements")
print(queue)
lOMoARcPSD|274 323 48
DEPARTMENT OF IT
Output:
Initial stack
['a', 'b', 'c']
Elements poped from stack:
c
b
a
Stack after elements are poped:
[]
Result:
Thus the program was executed successfully.
lOMoARcPSD|274 323 48
DEPARTMENT OF IT
AIM:
To implement list application using Polynomial Addition in python.
ALGORITHM:
Step 1: Using the define function intial elements will be
declared.
Step 2: for loop gives the output of sum of the elements
Step 3: print[poly] statement have the sum of two polynomial
elements.
Step 4: Close the program.
PROGRAM:
def add(A, B, m, n):
size = max(m, n);
sum = [0 for i in range(size)]
for i in range(0, m, 1):
sum[i] = A[i]
for i in range(n):
sum[i] += B[i]
return sum
def printPoly(poly, n):
for i in range(n):
print(poly[i], end = "")
if (i != 0):
print("x^", i, end = "")
if (i != n - 1):
print(" + ", end = "")
if name == ' main ':
A = [5, 0, 10, 6]
B = [1, 2, 4]
lOMoARcPSD|274 323 48
DEPARTMENT OF IT
m = len(A)
n = len(B)
print("First polynomial is")
printPoly(A, m)
print("\n", end = "")
print("Second polynomial is")
printPoly(B, n)
print("\n", end = "")
sum = add(A, B, m, n)
size = max(m, n)
print("sum polynomial is")
printPoly(sum, size)
OUTPUT:
First polynomial is
5 + 0x^1 + 10x^2 + 6x^3
Second polynomial is
1 + 2x^1 + 4x^2
Sum polynomial is
RESULT:
Thus the program was executed successfully.
.
lOMoARcPSD|274 323 48
DEPARTMENT OF IT
AIM:
To implement the conversion of infix to postfix in stack.
ALGORITHM:
Step 1: Read the given expression
Step 2: check if empty or not ,the stack will insert the elements.
Step 3: Using push(),pop() to insert the element or remove the
element.
Step 4: Check the operator based on the precedence the expression will be
evaluated.
Step 5: Close the program
PROGRAM:
class Conversion:
self.array = []
self.output = []
self.precedence = {'+':1, '-':1, '*':2, '/':2, '^':3}
def isEmpty(self):
return True if self.top == -1 else False
def peek(self):
return self.array[-1]
def pop(self):
if not self.isEmpty():
self.top -= 1
return self.array.pop()
else:
return "$"
DEPARTMENT OF IT
for i in exp:
if self.isOperand(i):
self.output.append(i)
elif i == '(':
self.push(i)
elif i == ')':
while( (not self.isEmpty()) and
self.peek() != '('):
a = self.pop()
self.output.append(a)
if (not self.isEmpty() and self.peek() !=
'('): return -1
else:
self.pop()
else:
while(not self.isEmpty() and self.notGreater(i)):
self.output.append(self.pop())
self.push(i)
exp = "a+b*(c^d-e)^(f+g*h)-i"
obj = Conversion(len(exp))
obj.infixToPostfix(exp)
OUTPUT:
abcd^e-fgh*+^*+i-
RESULT:
Thus the conversion can be successfully executed
lOMoARcPSD|274 323 48
DEPARTMENT OF IT
2. Calculate the Finish Time, Turn Around Time and Waiting Time for each process which
in turn help to calculate Average Waiting Time and Average Turn Around Time required
by CPU to schedule given set of process using FCFS.
3. Process with less arrival time comes first and gets scheduled first by the CPU.
4. Calculate the Average Waiting Time and Average Turn Around Time.
5. Stop the program
PROGRAM:
def findWaitingTime(processes, n,bt, wt):
wt[0] = 0
for i in range(1, n ):
wt[i] = bt[i - 1] + wt[i - 1]
turnaround
# time by adding bt[i] + wt[i]
for i in range(n):
tat[i] = bt[i] + wt[i]
wt = [0] * n
tat = [0] * n
total_wt = 0
lOMoARcPSD|274 323 48
DEPARTMENT OF IT
total_tat = 0
for i in range(n):
total_wt = total_wt + wt[i]
total_tat = total_tat + tat[i]
print(" " + str(i + 1) + "\t\t" +str(bt[i]) + "\t "
str(wt[i]) + "\t\t " +str(tat[i]))
processes = [ 1, 2, 3]
n = len(processes)
burst_time = [10, 5, 8]
findavgTime(processes, n, burst_time)
Output:
Processes Burst time Waiting time Turn around time
1 10 0 10
2 5 10 15
3 8 15 23
RESULT:
Thus the FCFS CPU Scheduling was Executed Successfully.
lOMoARcPSD|274 323 48
DEPARTMENT OF IT
AIM:
To implement the linear search program using python.
ALGORITHM:
Step 1: Start
Step 2: Call Sequential _Search() with list of arguments. Step 3:
Assign pos=0
Step 4: Assign found=False
Step 5: Repeat step 5 to 7 until pos<len (dlist) occur false
Step 6: Check if dlist[pos]==item then go to step 6 otherwise go
to step 7. Step 7: Assign found = True
Step 8: Calculate pos =pos + 1
Step 9: Return and print found ,pos to Sequential_Search. Step
10: Stop.
PROGRAM:
list_of_elements = [4, 3, 8, 9, 2, 7] x=int (input ("Enter no to
search :")) found = False
for i in range (len(list_of_elements)): if (list_of_elements[i] ==
x):
found = True
print ("%d found at %dth position"%( x,i)) break
if (found == False):
print ("%d is not in list"%x)
OUTPUT:
Enter no to search:4
4 found at 0th position
RESULT:
Thus the python program for the implementation
of linear search was executed and the output was obtained.
lOMoARcPSD|274 323 48
DEPARTMENT OF IT
AIM:
To implement the binary search program using
python.
lOMoARcPSD|274 323 48
DEPARTMENT OF IT
ALGORITHM:
STEP 1: Start
STEP 2: Call binary_search() with list of arguments. STEP 3:
Assign first=0.
STEP 4: Calculate last = len(item_list)-1 STEP 5: Assign
found =False
STEP 6: Repeat step 7 to 12 until first <=last and not to found
occur false. STEP 7: Calculate mid = (first + last)/ / 2
STEP 8: Check if item_list[mid]==item then go to step 9
otherwise go to step 10. STEP 9: Assign found=True
STEP 10: Check if then < item_list[mid]then go to step 11
otherwise go to step 12. STEP 11: Calculate last=mid – 1
STEP 12: Calculate first=mid + 1
STEP 13: Repeat found to binary_search() and print the value.
STEP 14: Repeat the step 2 to 13 for binary_search()
STEP 15: Repeat the step 2 to 13 for binary_search() STEP
16: Stop.
print(binary_search([1,82,3,5,8], 9))
print(binary_search([1,2,3,5,8], 5))
lOMoARcPSD|274 323 48
DEPARTMENT OF IT
OUTPUT:
False
True
RESULT:
Thus the python program for the implementation of binary search was executed
and output was obtained.
lOMoARcPSD|274 323 48
DEPARTMENT OF IT
ALGORITHM:
STEP 1: Start
STEP 2: Call selection sort() with list of arguments.
STEP 3: Repeat step 4 to step 5 until range occur false.
STEP 4: Check nlist[location]>nlist[maxpos] then go to step 5 otherwise go to step 6.
STEP 5: Assign maxpos = location
STEP 6: Assign temp = nlist[fillslot]
STEP 7: Assign nlist[fillslot]=nlist[maxpos]
STEP 8: Assign nlist[maxpos]=temp
STEP 9: Return and print the sorted numbers.
def selectionSort(alist):
for fillslot in range(len(alist)-1,0,-1):
positionOfMax=0
for location in range(1,fillslot+1):
if alist[location]>alist[positionOfMax]:
positionOfMax = location
temp = alist[fillslot]
alist[fillslot] = alist[positionOfMax] alist[positionOfMax] = temp
alist = [45,62,13,71,77,31,49,53,20]
selectionSort (alist) print(alist)
OUTPUT:
13,20,31,45,49,53,62,71,77
RESULT
Thus the python program for the implementation of selection sort was executed and the output was
obtained.
lOMoARcPSD|274 323 48
DEPARTMENT OF IT
AIM:
ALGORITHM:
STEP 1: Start
STEP 2: Call insertion Sort() with list of
arguments. STEP 3: Repeat the step 4 to
step 8 until range occur false STEP 4:
Assign current value = alist[index]
STEP 5:Assign position = index
def insertionSort(alist):
DEPARTMENT OF IT
currentvalue = alist[index]
position = index
while position > 0 and alist[position - 1] > currentvalue:
alist[position] = alist[position - 1]
position = position - 1
alist[position] = currentvalue
alist = [15, 22, 39,41 , 67, 73, 85, 86, 90]
insertionSort(alist)
print(alist)
OUTPUT:
15,22,39,41,67,73,58,56,90
RESULT:
Thus the python program for the implementation of insertion sort was executed
and output was obtained.
lOMoARcPSD|274 323 48
DEPARTMENT OF IT
AIM:
To Implement the Hash tables using python
ALGORITHM:
1.Create a structure, data (hash table item) with key and value as data.
2.for loops to define the range within the set of elements.
3. hashfunction(key) for the size of capacity
4. Using insert(),removal() data to be presented or removed.
5. Stop the program
Coding:
hashTable = [[],] * 10
def checkPrime(n):
if n == 1 or n == 0:
return 0
for i in range(2, n//2):
if n % i == 0:
return 0
return 1
def getPrime(n):
if n % 2 == 0:
n=n+1
while not checkPrime(n):
n += 2
return n
def hashFunction(key):
capacity = getPrime(10)
return key % capacity
def insertData(key, data):
index = hashFunction(key)
hashTable[index] = [key, data]
def removeData(key):
index = hashFunction(key)
hashTable[index] = 0
insertData(123, "apple")
insertData(432, "mango")
insertData(213, "banana")
insertData(654, "guava")
print(hashTable)
removeData(123)
lOMoARcPSD|274 323 48
DEPARTMENT OF IT
print(hashTable)
OUTPUT:
[[], [], [123, 'apple'], [432, 'mango'], [213, 'banana'], [654, 'guava'], [], [], [], []]
[[], [], 0, [432, 'mango'], [213, 'banana'], [654, 'guava'], [], [], [], []]
RESULT:
Thus the Implementation of hashing was executed successfully
lOMoARcPSD|274 323 48
DEPARTMENT OF IT
DEPARTMENT OF IT
root.PrintTree()
Output:
3
6
12
14
Result:
Thus the binary tree was successfully created
lOMoARcPSD|274 323 48
DEPARTMENT OF IT
DEPARTMENT OF IT
root = Node(1)
root.left = Node(2)
root.right = Node(3)
root.left.left = Node(4)
root.left.right = Node(5)
print ("\nPreorder traversal of binary tree is")
printPreorder(root)
print ("\nInorder traversal of binary tree is")
printInorder(root)
print ("\nPostorder traversal of binary tree is")
printPostorder(root)
Output:
Preorder traversal of binary tree is
1
2
4
5
3
Inorder traversal of binary tree is
4
2
5
1
3
Postorder traversal of binary tree is
4
5
2
3
1
Result:
Thus the Implementation of traversal using Inorder,Preorder,Postorder techniques was executed
successfully
lOMoARcPSD|274 323 48
DEPARTMENT OF IT
Step 2 - Compare the search element with the value of root node in the tree.
Step 3 - If both are matched, then display "Given node is found!!!" and terminate the function
Step 4 - If both are not matched, then check whether search element is smaller or larger than that
node value.
Step 5 - If search element is smaller, then continue the search process in left subtree.
Step 6- If search element is larger, then continue the search process in right subtree.
Step 7 - Repeat the same until we find the exact element or until the search element is compared
with the leaf node
Step 8 - If we reach to the node having the value equal to the search value then display "Element
is found" and terminate the function.
Coding:
class Node:
def init (self, data):
self.left = None
self.right = None
self.data = data
DEPARTMENT OF IT
self.right.insert(data)
else:
self.data = data
def PrintTree(self):
if self.left:
self.left.PrintTree()
print( self.data),
if self.right:
self.right.PrintTree()
root = Node(12)
root.insert(6)
root.insert(14)
root.insert(3)
print(root.findval(7))
Output:
7 Not Found
14 is found
Result:
Thus the Implementation of Binary Search Trees using python was executed successfully.
lOMoARcPSD|274 323 48
DEPARTMENT OF IT
Output:
1, 3, 5, 78, 21, 45
[1, 3, 5, 78, 21, 45, 8]
[3, 8, 5, 78, 21, 45]
Result:
Thus the Implementation of the Heap algorithm was executed succeefully.
lOMoARcPSD|274 323 48
DEPARTMENT OF IT
Aim:
To implement the graph representation using python
Algorithm:
DEPARTMENT OF IT
"e" : ["d"]
}
g = graph(graph_elements)
print(g.edges())
Output:
DISPLAYING VERTICES
['a', 'b', 'c', 'd', 'e']
DISPLAYING EDGES
[{'a', 'b'}, {'a', 'c'}, {'d', 'b'}, {'c', 'd'}, {'d', 'e'}]
Result:
Thus the implementation of graphs was executed successfully.
lOMoARcPSD|274 323 48
DEPARTMENT OF IT
Step 2 - Select any vertex as starting point for traversal. Visit that vertex and push it on to the
Stack.
Step 3 - Visit any one of the non-visited adjacent vertices of a vertex which is at the top of stack
and push it on to the stack.
Step 4 - Repeat step 3 until there is no new vertex to be visited from the vertex which is at the
top of the stack.
Step 5 - When there is no new vertex to visit then use back tracking and pop one vertex from the
stack.
Step 7 - When stack becomes Empty, then produce final spanning tree by removing unused edges
from the graph
BFS:
Step 2 - Select any vertex as starting point for traversal. Visit that vertex and insert it into the
Queue.
Step 3 - Visit all the non-visited adjacent vertices of the vertex which is at front of the Queue and
insert them into the Queue.
Step 4 - When there is no new vertex to be visited from the vertex which is at front of the Queue
then delete that vertex.
Step 6 - When queue becomes empty, then produce final spanning tree by removing unused edges
from the graph
lOMoARcPSD|274 323 48
DEPARTMENT OF IT
Coding:
BFS
import collections
def bfs(graph, root):
visited, queue = set(), collections.deque([root])
visited.add(root)
while queue:
vertex = queue.popleft()
print(str(vertex) + " ", end="")
for neighbour in graph[vertex]:
if neighbour not in visited:
visited.add(neighbour)
queue.append(neighbour)
if name == ' main ':
graph = {0: [1, 2], 1: [2], 2: [3], 3: [1, 2]}
print("Following is Breadth First Traversal: ")
bfs(graph, 0)
Output:
Following is Breadth First Traversal:
0123
DFS Coding:
import sys
def ret_graph():
return {
'A': {'B':5.5, 'C':2, 'D':6},
'B': {'A':5.5, 'E':3},
'C': {'A':2, 'F':2.5},
'D': {'A':6, 'F':1.5},
'E': {'B':3, 'J':7},
'F': {'C':2.5, 'D':1.5, 'K':1.5, 'G':3.5},
'G': {'F':3.5, 'I':4},
'H': {'J':2},
'I': {'G':4, 'J':4},
'J': {'H':2, 'I':4},
'K': {'F':1.5}
}
start = 'A'
dest = 'J'
visited = []
lOMoARcPSD|274 323 48
DEPARTMENT OF IT
stack = []
graph = ret_graph()
path = []
stack.append(start)
visited.append(start)
while stack:
curr = stack.pop()
path.append(curr)
for neigh in graph[curr]:
if neigh not in visited:
visited.append(neigh)
stack.append(neigh)
if neigh == dest :
print("FOUND:", neigh)
print(path)
sys.exit(0)
print("Not found")
print(path)
Output:
FOUND: J
['A', 'D', 'F', 'G', 'I']
Result:
Thus the implementation of using BFS,DFS graph can be traversed.
lOMoARcPSD|274 323 48
DEPARTMENT OF IT
1) This step initializes distances from source to all vertices as infinite and distance to source
itself as 0. Create an array dist[] of size |V| with all values as infinite except dist[src] where src
is source vertex.
2) This step calculates shortest distances. Do following |V|-1 times where |V| is the number of
vertices in given graph.
a) Do following for each edge u-v
If dist[v] > dist[u] + weight of edge uv, then update dist[v]
dist[v] = dist[u] + weight of edge uv
3) This step reports if there is a negative weight cycle in graph. Do following for each edge u-v
If dist[v] > dist[u] + weight of edge uv, then “Graph contains negative weight cycle”
The idea of step 3 is, step 2 guarantees shortest distances if graph doesn’t contain negative
weight cycle. If we iterate through all edges one more time and get a shorter path for any vertex,
then there is a negative weight cycle
Coding:
from sys import maxsize
def BellmanFord(graph, V, E, src):
dis = [maxsize] * V
dis[src] = 0
for i in range(V - 1):
for j in range(E):
if dis[graph[j][0]] + \
graph[j][2] < dis[graph[j][1]]:
dis[graph[j][1]] = dis[graph[j][0]] + \
graph[j][2]
for i in range(E):
x = graph[i][0]
y = graph[i][1]
weight = graph[i][2]
if dis[x] != maxsize and dis[x] + \
weight < dis[y]:
print("Graph contains negative weight cycle")
print("Vertex Distance from Source")
for i in range(V): print("%d\t\t
%d" % (i, dis[i]))
lOMoARcPSD|274 323 48
DEPARTMENT OF IT
Output:
Vertex Distance from Source
0 0
1 -1
2 2
3 -2
Result:
Thus the Implementation of single source shortest path algorithm was successfully executed.
lOMoARcPSD|274 323 48
DEPARTMENT OF IT
DEPARTMENT OF IT
Output:
1 - 2: 2
2 - 5: 2
2 - 3: 3
3 - 4: 3
0 - 1: 4
Result:
Thus the program was executed successfully.
lOMoARcPSD|274 323 48
DEPARTMENT OF IT
lOMoARcPSD|274 323 48
DEPARTMENT OF IT
lOMoARcPSD|274 323 48
DEPARTMENT OF IT
lOMoARcPSD|274 323 48
DEPARTMENT OF IT
lOMoARcPSD|274 323 48
DEPARTMENT OF IT
lOMoARcPSD|274 323 48
DEPARTMENT OF IT
lOMoARcPSD|274 323 48
DEPARTMENT OF IT
lOMoARcPSD|274 323 48
DEPARTMENT OF IT
lOMoARcPSD|274 323 48
DEPARTMENT OF IT
lOMoARcPSD|274 323 48
DEPARTMENT OF IT
lOMoARcPSD|274 323 48
DEPARTMENT OF IT
lOMoARcPSD|274 323 48
DEPARTMENT OF IT
lOMoARcPSD|274 323 48
DEPARTMENT OF IT
lOMoARcPSD|274 323 48
DEPARTMENT OF IT
lOMoARcPSD|274 323 48
DEPARTMENT OF IT
lOMoARcPSD|274 323 48
DEPARTMENT OF IT
lOMoARcPSD|274 323 48
DEPARTMENT OF IT