diff --git a/BarChart.java b/BarChart.java
new file mode 100644
index 0000000..17d329c
--- /dev/null
+++ b/BarChart.java
@@ -0,0 +1,43 @@
+import java.util.Scanner;
+
+public class BarChart {
+	
+	public static void main(String[] args) {
+		
+		Scanner scn = new Scanner(System.in);
+		
+		int tc = scn.nextInt();
+		
+		int arr[] = new int[tc];
+		
+		
+		int max = Integer.MIN_VALUE;
+		for (int i = 0; i < arr.length; i++) {
+			arr[i] = scn.nextInt();
+			 if(arr[i]>max)
+			 {
+				 max = arr[i];
+			 }
+		}	
+		
+		for(int floor = max ; floor>=1 ; floor--)
+		{
+			for(int i = 0 ; i<arr.length ; i++)
+			{
+				
+				if(arr[i]>=floor)
+				{
+					System.out.print("*\t");
+				}
+				else
+				{
+					System.out.print("\t");
+				}
+				
+			}
+			System.out.println();
+		}
+		
+	}
+
+}
diff --git a/BinarySearch.java b/BinarySearch.java
new file mode 100644
index 0000000..65804b2
--- /dev/null
+++ b/BinarySearch.java
@@ -0,0 +1,69 @@
+import java.util.Scanner;
+
+public class BinarySearch {
+	
+public static int binarySearch(int[] a,int k){
+	    
+	int low = 0;
+	int high = a.length-1;
+	
+
+	
+	int ans = -1;
+	
+	while(low <= high)
+	{
+		
+		int mid = (low+high)/2;
+		if(k<a[mid])
+		{
+			high = mid -1;
+		}
+		else if(k>a[mid])
+		{
+			low = mid + 1;
+		}
+		else
+		{
+			ans = mid;
+			return ans;
+		}
+		
+	}
+	return ans;
+		
+	  }
+	
+	private static void Display(int arr[])
+	{
+		for (int val : arr) {
+			
+			System.out.println(val);
+			 
+		}	
+	}
+	
+public static void main(String[] args) {
+	
+		
+		Scanner scn = new Scanner(System.in);
+		
+		int tc = scn.nextInt();
+		
+		int arr[] = new int[tc];
+	
+		for (int i = 0; i < arr.length; i++) {
+			
+			arr[i] = scn.nextInt();
+			 
+		}	
+		
+		
+		int k = scn.nextInt();
+		
+		int ans = binarySearch(arr,k);
+		System.out.println(ans);
+		
+	}
+
+}
diff --git a/DifferenceOfTwoArray.java b/DifferenceOfTwoArray.java
new file mode 100644
index 0000000..1e850a2
--- /dev/null
+++ b/DifferenceOfTwoArray.java
@@ -0,0 +1,99 @@
+import java.util.Scanner;
+
+public class DifferenceOfTwoArray {
+	
+	private static void Display(int arr[])
+	{
+		for (int val : arr) {
+			
+			System.out.println(val);
+			 
+		}	
+	}
+	
+	public static void main(String[] args) {
+		
+		Scanner scn = new Scanner(System.in);
+		
+		int tcOne = scn.nextInt();
+		
+		int arrOne[] = new int[tcOne];
+	
+		for (int i = 0; i < arrOne.length; i++) {
+			
+			arrOne[i] = scn.nextInt();
+			 
+		}	
+		
+		int tcTwo = scn.nextInt();
+		
+		int arrTwo[] = new int[tcTwo];
+	
+		for (int i = 0; i < arrTwo.length; i++) {
+			
+			arrTwo[i] = scn.nextInt();
+			 
+		}	
+	
+		
+	
+		
+		int arrDiff[] = new int[tcTwo ];
+		
+		int i = arrOne.length - 1;
+		int j = arrTwo.length - 1;
+		int k = arrDiff.length - 1;
+		
+		
+		int c = 0;
+
+		while(k >= 0)
+		{
+
+	
+		   int d = c;
+		   
+		   int a1v = i >= 0? arrOne[i]:0;
+		   
+		   if( arrTwo[j]+c>=a1v)
+		   {
+		       d = arrTwo[j]+c - a1v;
+		       c = 0;
+		   }
+		   else
+		   {
+		       d = arrTwo[j]+ c + 10 - a1v;
+		       c= -1;
+		   }
+			    	
+			    	arrDiff[k] = d;
+			    	
+			    	i--;
+			    	j--;
+			    	k--;
+			    }
+			
+
+		int idx = 0;
+		while(idx < arrDiff.length)
+		{
+			if(arrDiff[idx] == 0)
+			{
+				idx++;
+			}
+			else
+			{
+				break;
+			}
+		}
+		
+		while(idx < arrDiff.length)
+		{
+			System.out.println(arrDiff[idx]);
+			idx++;
+		}
+
+//		Display(arrDiff);
+	}
+
+}
diff --git a/ExitPointOfMatrix.java b/ExitPointOfMatrix.java
new file mode 100644
index 0000000..5c80dbb
--- /dev/null
+++ b/ExitPointOfMatrix.java
@@ -0,0 +1,89 @@
+import java.util.Scanner;
+
+public class ExitPointOfMatrix {
+	
+	public static void Display(int [][] a)
+	{
+		for (int i = 0; i < a.length; i++) {
+			for (int j = 0; j < a[0].length; j++) {
+				
+				System.out.print(a[i][j]+" "); 
+				
+			}
+			System.out.println();
+		}
+	}
+	
+	public static void main(String[] args) {
+		
+		Scanner scn = new Scanner(System.in);
+		
+		int row = scn.nextInt();
+		int coloumn = scn.nextInt();
+		
+		int [][] matrix = new int[row][coloumn]; 
+		
+		for (int i = 0; i < matrix.length; i++) {
+			for (int j = 0; j < matrix[0].length; j++) {
+				
+				matrix[i][j] = scn.nextInt(); 
+				
+			}
+		}
+		
+//		Display(matrix);
+		
+		int i = 0 , j = 0 , dir = 0;
+		
+		
+		while(true)
+		{
+			
+			dir = (dir + matrix[i][j]) % 4;
+			
+			if(dir == 0)
+			{
+				j++;
+			}
+			else if(dir == 1)
+			{
+				i++;
+			}
+			else if(dir == 2)
+			{
+				j--;
+			}
+			else if(dir == 3)
+			{
+				i--;
+			}
+			
+			if(i < 0)
+			{
+				i++;
+				break;
+			}
+			else if(j < 0)
+			{
+				j++;
+				break;
+			}
+			else if(i == matrix.length)
+			{
+				i--;
+				break;
+			}
+			else if(j == matrix[0].length)
+			{
+				j--;
+				break;
+			}
+			
+		}
+		
+		System.out.println(i);
+		System.out.println(j);
+		
+	}
+
+}
diff --git a/FindElementInArray.java b/FindElementInArray.java
new file mode 100644
index 0000000..8ed77f8
--- /dev/null
+++ b/FindElementInArray.java
@@ -0,0 +1,36 @@
+import java.util.Scanner;
+public class FindElementInArray {
+
+	public static void main(String[] args) {
+		
+		Scanner scn = new Scanner(System.in);
+		
+		int tc = scn.nextInt();
+		
+		int arr[] = new int[tc];
+		
+		
+		
+		for (int i = 0; i < arr.length; i++) {
+			arr[i] = scn.nextInt();
+		}
+		
+		int d = scn.nextInt();
+		
+		int ans = -1;
+		
+		for (int i = 0; i < arr.length; i++) {
+			if(arr[i]==d)
+			{
+				ans = i;
+				break;
+			}
+			
+		}
+		
+		System.out.println(ans);
+		
+		
+	}
+	
+}
diff --git a/FirstAndLastIndex.java b/FirstAndLastIndex.java
new file mode 100644
index 0000000..9fc5283
--- /dev/null
+++ b/FirstAndLastIndex.java
@@ -0,0 +1,103 @@
+import java.util.Scanner;
+
+public class FirstAndLastIndex {
+	
+	public static int firstIndex(int[] a,int k){
+	    
+		int low = 0;
+		int high = a.length-1;
+		
+
+		
+		int fi = -1;
+		
+		while(low <= high)
+		{
+			
+			int mid = (low+high)/2;
+			if(k<a[mid])
+			{
+				high = mid -1;
+			}
+			else if(k>a[mid])
+			{
+				low = mid + 1;
+			}
+			else
+			{
+				fi = mid;
+				high = mid - 1;
+			}
+			
+		}
+		return fi;
+			
+		  }
+		
+public static int lastIndex(int[] a,int k){
+	    
+		int low = 0;
+		int high = a.length-1;
+		
+
+		
+		int li = -1;
+		
+		while(low <= high)
+		{
+			
+			int mid = (low+high)/2;
+			if(k<a[mid])
+			{
+				high = mid -1;
+			}
+			else if(k>a[mid])
+			{
+				low = mid + 1;
+			}
+			else
+			{
+				li = mid;
+				low = mid + 1;
+			}
+			
+		}
+		return li;
+			
+		  }
+		private static void Display(int arr[])
+		{
+			for (int val : arr) {
+				
+				System.out.println(val);
+				 
+			}	
+		}
+		
+	public static void main(String[] args) {
+		
+			
+			Scanner scn = new Scanner(System.in);
+			
+			int tc = scn.nextInt();
+			
+			int arr[] = new int[tc];
+		
+			for (int i = 0; i < arr.length; i++) {
+				
+				arr[i] = scn.nextInt();
+				 
+			}	
+			
+			
+			int k = scn.nextInt();
+			
+			int firstIndex = firstIndex(arr,k);
+			int lastIndex  = lastIndex(arr,k);
+			System.out.println(firstIndex);
+			System.out.println(lastIndex);
+			
+		}
+
+
+}
diff --git a/FloorAndCiel.java b/FloorAndCiel.java
new file mode 100644
index 0000000..db6e04e
--- /dev/null
+++ b/FloorAndCiel.java
@@ -0,0 +1,78 @@
+import java.util.Scanner;
+
+public class FloorAndCiel {
+	
+	public static void floorAndCiel(int[] a,int k){
+	    
+		int low = 0;
+		int high = a.length-1;
+		
+		int ciel = Integer.MIN_VALUE;
+		int floor = Integer.MAX_VALUE;
+		
+		
+		
+		
+		while(low <= high)
+		{
+			
+			int mid = (low+high)/2;
+			if(k<a[mid])
+			{
+				high = mid -1;
+				floor = a[high];
+			}
+			else if(k>a[mid])
+			{
+				low = mid + 1;
+				ciel = a[low];
+			}
+			else
+			{
+			
+				floor = ciel = a[mid];
+				System.out.println(ciel);
+				System.out.println(floor);
+				return ;
+			}
+			
+		}
+		System.out.println(ciel);
+		System.out.println(floor);
+		return ;
+			
+		  }
+		
+		private static void Display(int arr[])
+		{
+			for (int val : arr) {
+				
+				System.out.println(val);
+				 
+			}	
+		}
+		
+		public static void main(String[] args) {
+			
+			
+			Scanner scn = new Scanner(System.in);
+			
+			int tc = scn.nextInt();
+			
+			int arr[] = new int[tc];
+		
+			for (int i = 0; i < arr.length; i++) {
+				
+				arr[i] = scn.nextInt();
+				 
+			}	
+			
+			
+			int k = scn.nextInt();
+			
+			floorAndCiel(arr,k);
+			
+			
+		}
+
+}
diff --git a/InverseOfArray.java b/InverseOfArray.java
new file mode 100644
index 0000000..706f597
--- /dev/null
+++ b/InverseOfArray.java
@@ -0,0 +1,46 @@
+import java.util.Scanner;
+
+public class InverseOfArray {
+	
+	private static void Display(int arr[])
+	{
+		for (int val : arr) {
+			
+			System.out.println(val);
+			 
+		}	
+	}
+	
+	public static int[] inverse(int[] a){
+		
+		int[] inv = new int[a.length]; 
+		
+		for (int i = 0; i < a.length; i++) {
+
+			int num = a[i];
+			inv[num]=i;
+			
+		}
+		return inv;
+	  }
+	
+public static void main(String[] args) {
+		
+		
+		Scanner scn = new Scanner(System.in);
+		
+		int tc = scn.nextInt();
+		
+		int arr[] = new int[tc];
+	
+		for (int i = 0; i < arr.length; i++) {
+			
+			arr[i] = scn.nextInt();
+			 
+		}	
+		
+		int[] inv = inverse(arr);
+		Display(inv);
+	}
+
+}
diff --git a/InvertedBarChart.java b/InvertedBarChart.java
new file mode 100644
index 0000000..50fed40
--- /dev/null
+++ b/InvertedBarChart.java
@@ -0,0 +1,44 @@
+
+import java.util.Scanner;
+
+public class InvertedBarChart {
+	
+	public static void main(String[] args) {
+		
+		Scanner scn = new Scanner(System.in);
+		
+		int tc = scn.nextInt();
+		
+		int arr[] = new int[tc];
+		
+		
+		int max = Integer.MIN_VALUE;
+		for (int i = 0; i < arr.length; i++) {
+			arr[i] = scn.nextInt();
+			 if(arr[i]>max)
+			 {
+				 max = arr[i];
+			 }
+		}	
+		
+		for(int floor = 1 ; floor<=max ; floor++)
+		{
+			for(int i = 0 ; i<arr.length ; i++)
+			{
+				
+				if(arr[i]>=floor)
+				{
+					System.out.print("*\t");
+				}
+				else
+				{
+					System.out.print("\t");
+				}
+				
+			}
+			System.out.println();
+		}
+		
+	}
+
+}
diff --git a/MatrixMultiplication.java b/MatrixMultiplication.java
new file mode 100644
index 0000000..8816fda
--- /dev/null
+++ b/MatrixMultiplication.java
@@ -0,0 +1,72 @@
+import java.util.Scanner;
+
+public class MatrixMultiplication {
+	
+	public static void Display(int [][] a)
+	{
+		for (int i = 0; i < a.length; i++) {
+			for (int j = 0; j < a[0].length; j++) {
+				
+				System.out.print(a[i][j]+" "); 
+				
+			}
+			System.out.println();
+		}
+	}
+	
+public static void main(String[] args) {
+		
+
+		
+		Scanner scn = new Scanner(System.in);
+		
+		int r1 = scn.nextInt();
+		int c1 = scn.nextInt();
+		
+		int [][] oneArray = new int[r1][c1]; 
+		
+		for (int i = 0; i < oneArray.length; i++) {
+			for (int j = 0; j < oneArray[0].length; j++) {
+				
+				oneArray[i][j] = scn.nextInt(); 
+				
+			}
+		}
+		
+		int r2 = scn.nextInt();
+		int c2 = scn.nextInt();
+		
+		int [][] twoArray = new int[r2][c2]; 
+		
+		for (int i = 0; i < twoArray.length; i++) {
+			for (int j = 0; j < twoArray[0].length; j++) {
+				
+				twoArray[i][j] = scn.nextInt(); 
+				
+			}
+		}
+		
+		if(c1 != r2)
+		{
+			System.out.println("Invalid input");
+			return;
+		}
+		
+		int [][] prdArray = new int[r1][c2]; 
+		
+		for (int i = 0; i < prdArray.length; i++) {
+			for (int j = 0; j < prdArray[0].length; j++) {
+				
+				for(int k = 0; k<c1 ; k++)
+				{
+					prdArray[i][j] = prdArray[i][j] + oneArray[i][k] * twoArray[k][j];
+				}
+				
+			}
+		}
+		
+		Display(prdArray);
+	
+}
+
+}
diff --git a/ReverseArray.java b/ReverseArray.java
new file mode 100644
index 0000000..f8f270a
--- /dev/null
+++ b/ReverseArray.java
@@ -0,0 +1,51 @@
+import java.util.Scanner;
+
+public class ReverseArray {
+	
+	public static void reverse(int[] a){
+	    
+		for (int i = 0; i < a.length/2; i++) {
+			
+			int n = a.length;
+			
+		    int tmp;
+		       
+		    tmp = a[i];
+		    
+		    a[i] = a[n-i-1];
+		    
+		    a[n-i-1]=tmp;
+			
+		}
+		
+	  }
+	
+	private static void Display(int arr[])
+	{
+		for (int val : arr) {
+			
+			System.out.println(val);
+			 
+		}	
+	}
+	
+	public static void main(String[] args) {
+		
+		
+		Scanner scn = new Scanner(System.in);
+		
+		int tc = scn.nextInt();
+		
+		int arr[] = new int[tc];
+	
+		for (int i = 0; i < arr.length; i++) {
+			
+			arr[i] = scn.nextInt();
+			 
+		}	
+		Display(arr);
+		reverse(arr);
+		Display(arr);
+	}
+
+}
diff --git a/RotateAnArray.java b/RotateAnArray.java
new file mode 100644
index 0000000..4ec6d05
--- /dev/null
+++ b/RotateAnArray.java
@@ -0,0 +1,129 @@
+import java.util.Scanner;
+
+public class RotateAnArray {
+
+	public static void rotate(int[] a , int k){
+		
+		k = k % a.length;
+	    if(k < 0)
+	    {
+	        k = k + a.length;
+	    }
+	    
+	    //Part 1
+	    reverse(a, 0 , a.length-k-1);
+	    
+	    //Part 2
+	    reverse( a, a.length-k ,a.length-1);
+	    
+	    //Part 1 + Part2
+	    
+	    reverse(a , 0 , a.length-1);
+		
+	  }
+	
+	public static void rotate2(int[] a , int k)
+	{
+		int[] b = new int[a.length];
+	    int j = 0;
+	    
+
+	    if (k > 0) {
+	      k = k % a.length;
+	      if(k == 0){
+	          return;
+	      }
+//	      if(a.length%k!=0 && k!=1)
+//	      {
+//	    	  k=k-1;
+//	      }
+	      for (int i = k-1 ; i < a.length; i++) {
+	        b[j] = a[i];
+	        j++;
+	      }
+	      for (int i = 0; i < k-1 ; i++) {
+	        b[j] = a[i];
+	        j++;
+	      }
+	    }
+	    else if(k < 0) {
+	      k = k * -1;
+	      k = k % a.length;
+	      if(k == 0){
+	          return;
+	      }
+	      if(a.length%k!=0)
+	      {
+	    	  k=k-1;
+	      }
+	      for (int i = k; i < a.length; i++) {
+	        b[j] = a[i];
+	        j++;
+	      }
+	      for (int i = 0; i < k; i++){
+	        b[j] = a[i];
+	        j++;
+	      }
+	    }
+	    else{
+	        return;
+	    }
+	    for(int i = 0;i < a.length;i++){
+	        a[i] = b[i];
+	    }
+	}
+	
+public static void reverse(int[] a,int start , int length){
+	    
+	int low = start;
+    int high = length;
+    
+    while(low < high)
+    {
+        
+        int temp = a[low];
+        a[low] = a[high];
+        a[high] = temp;
+        
+        low++;
+        high--;
+        
+    }
+    
+		
+	  }
+	
+	private static void Display(int arr[])
+	{
+		for (int val : arr) {
+			
+			System.out.print(val+" ");
+			 
+		}	
+	}
+	
+public static void main(String[] args) {
+		
+		
+		Scanner scn = new Scanner(System.in);
+		
+		int tc = scn.nextInt();
+		
+		int arr[] = new int[tc];
+	
+		for (int i = 0; i < arr.length; i++) {
+			
+			arr[i] = scn.nextInt();
+			 
+		}	
+		
+		int k = scn.nextInt();
+		
+//		rotate(arr,k);
+//		Display(arr);
+//		System.out.println();
+		rotate2(arr, k);
+		Display(arr);
+	}
+	
+}
diff --git a/RotateBy90Degree.java b/RotateBy90Degree.java
new file mode 100644
index 0000000..4339934
--- /dev/null
+++ b/RotateBy90Degree.java
@@ -0,0 +1,72 @@
+import java.util.Scanner;
+
+public class RotateBy90Degree {
+	
+	public static void Display(int [][] a)
+	{
+		for (int i = 0; i < a.length; i++) {
+			for (int j = 0; j < a[0].length; j++) {
+				
+				System.out.print(a[i][j]+" "); 
+				
+			}
+			System.out.println();
+		}
+	}
+	
+	public static void main(String[] args) {
+		
+		Scanner scn = new Scanner(System.in);
+		
+		int size = scn.nextInt();
+
+		
+		int [][] image = new int[size][size]; 
+		
+		for (int i = 0; i < image.length; i++) {
+			for (int j = 0; j < image[0].length; j++) {
+				
+				image[i][j] = scn.nextInt(); 
+				
+			}
+		}
+		
+//		Display(image);
+		
+		
+		// Transpose Of A Image
+				
+		for (int i = 0; i < image.length; i++) {
+			for (int j = i; j < image[0].length; j++) {
+				
+				int temp = image[i][j];
+				image[i][j] = image[j][i];
+				image[j][i] = temp;
+				
+			}
+		}
+		
+//		System.out.println();
+//		Display(image);
+		
+		for (int i = 0; i < image.length; i++) {
+			
+			int li = 0;
+			int ri = image.length-1;
+			
+			while(li < ri)
+			{
+				int temp = image[i][li];
+				image[i][li] = image[i][ri];
+				image[i][ri] = temp;
+				
+				li++;
+				ri--;
+			}
+		}
+//		System.out.println();
+//		Display(image);
+	}
+
+}
+
diff --git a/SPIRALDISPLAY.java b/SPIRALDISPLAY.java
new file mode 100644
index 0000000..7b9a5d8
--- /dev/null
+++ b/SPIRALDISPLAY.java
@@ -0,0 +1,109 @@
+import java.util.Scanner;
+
+public class SPIRALDISPLAY {
+	
+	public static void Display(int [][] a)
+	{
+		for (int i = 0; i < a.length; i++) {
+			for (int j = 0; j < a[0].length; j++) {
+				
+				System.out.print(a[i][j]+" "); 
+				
+			}
+			System.out.println();
+		}
+	}
+	
+	public static void main(String[] args) {
+		
+		Scanner scn = new Scanner(System.in);
+		
+		int row = scn.nextInt();
+		int coloumn = scn.nextInt();
+		
+		int [][] spiralArray = new int[row][coloumn]; 
+		
+		for (int i = 0; i < spiralArray.length; i++) {
+			for (int j = 0; j < spiralArray[0].length; j++) {
+				
+				spiralArray[i][j] = scn.nextInt(); 
+				
+			}
+		}
+		
+		
+		
+		int minr = 0;
+		int minc = 0;
+		int maxr = spiralArray.length-1;
+		int maxc = spiralArray[0].length-1;
+		int tne = row * coloumn;
+		int cnt = 0;
+		
+//		Display(spiralArray);
+		
+
+		
+		while(cnt < tne)
+		{
+			
+			// LEFT WALL
+
+			
+			for(int i = minr ,  j=minc ; i <= maxr && cnt < tne;  i++ )
+			{
+				System.out.println(spiralArray[i][j]);
+				cnt++;
+			}
+			
+			minc++;
+			
+			// BOTTOM WALL
+			
+			
+			for(int i = maxr ,  j=minc ; j <= maxc && cnt < tne;  j++ )
+			{
+				System.out.println(spiralArray[i][j]);
+				cnt++;
+			}
+			maxr--;
+			
+			
+			for(int i = maxr ,  j=maxc ; i >= minr && cnt < tne;  i-- )
+			{
+				System.out.println(spiralArray[i][j]);
+				cnt++;
+			}
+			
+			maxc--;
+			
+			for(int i = minr ,  j=maxc ; j >= minc && cnt < tne;  j-- )
+			{
+				System.out.println(spiralArray[i][j]);
+				cnt++;
+			}
+			
+			minr++;
+			
+		}
+		
+	}
+
+}
+
+//11
+//21
+//31
+//32
+//33
+//34
+//35
+//25
+//15
+//14
+//13
+//12
+//22
+//23
+//24
+
diff --git a/SpanOfArray.java b/SpanOfArray.java
new file mode 100644
index 0000000..5b227cf
--- /dev/null
+++ b/SpanOfArray.java
@@ -0,0 +1,36 @@
+import java.util.Scanner;
+
+
+public class SpanOfArray {
+	
+	public static void main(String[] args) {
+		
+		Scanner scn = new Scanner(System.in);
+		
+		int tc = scn.nextInt();
+		
+		int arr[] = new int[tc];
+		
+		int max = Integer.MIN_VALUE;
+		int min = Integer.MAX_VALUE;
+		
+		for (int i = 0; i < arr.length; i++) {
+			 arr[i] = scn.nextInt();
+			 
+			 if(arr[i]>max)
+			 {
+				 max = arr[i];
+			 }
+			 
+			 if(arr[i]<min)
+			 {
+				 min = arr[i];
+			 }
+		}
+		
+		System.out.println(max-min);
+		
+		
+	}
+
+}
diff --git a/SubArray.java b/SubArray.java
new file mode 100644
index 0000000..394c3f0
--- /dev/null
+++ b/SubArray.java
@@ -0,0 +1,52 @@
+import java.util.Scanner;
+public class SubArray {
+	
+public static void subArray(int[] a){
+	    
+		for (int i = 0; i < a.length; i++) {
+			
+			for(int j = i ; j < a.length;j++)
+			{
+				
+				for(int k = i ; k <= j;k++)
+				{
+					System.out.print(a[k]+"\t");
+				}
+				System.out.println();
+			}
+			
+			
+		}
+		
+	  }
+	
+	private static void Display(int arr[])
+	{
+		for (int val : arr) {
+			
+			System.out.println(val);
+			 
+		}	
+	}
+	
+	public static void main(String[] args) {
+		
+		
+		Scanner scn = new Scanner(System.in);
+		
+		int tc = scn.nextInt();
+		
+		int arr[] = new int[tc];
+	
+		for (int i = 0; i < arr.length; i++) {
+			
+			arr[i] = scn.nextInt();
+			 
+		}	
+		
+		subArray(arr);
+		
+	}
+	
+
+}
diff --git a/SubsetOfArray.java b/SubsetOfArray.java
new file mode 100644
index 0000000..907a40c
--- /dev/null
+++ b/SubsetOfArray.java
@@ -0,0 +1,49 @@
+/import java.util.Scanner;
+
+public class SubsetOfArray {
+	
+	public static void subset(int[] a)
+	{
+		int limit = (int)Math.pow(2, a.length);
+		
+		for(int i = 0 ; i<limit ; i++)
+		{
+			String set = "";
+			int temp = i ;
+			for(int j = a.length -1 ; j>= 0 ; j--)
+			{
+				int r = temp % 2;
+				temp = temp / 2;
+				
+				if( r == 0)
+				{
+					set = "-\t" + set;
+				}
+				else
+				{
+					set = a[j] + "\t" + set;
+				}
+			}
+			System.out.println(set);
+		}
+	}
+	
+	public static void main(String[] args) {
+		
+
+		Scanner scn = new Scanner(System.in);
+		
+		int tc = scn.nextInt();
+		
+		int arr[] = new int[tc];
+	
+		for (int i = 0; i < arr.length; i++) {
+			
+			arr[i] = scn.nextInt();
+			 
+		}	
+		
+		subset(arr);
+	}
+
+}
diff --git a/SumOftwoArray.java b/SumOftwoArray.java
new file mode 100644
index 0000000..6f0f970
--- /dev/null
+++ b/SumOftwoArray.java
@@ -0,0 +1,87 @@
+import java.util.Scanner;
+
+public class SumOftwoArray {
+	
+	private static void Display(int arr[])
+	{
+		for (int val : arr) {
+			
+			System.out.println(val);
+			 
+		}	
+	}
+	
+	public static void main(String[] args) {
+		
+		Scanner scn = new Scanner(System.in);
+		
+		int tcOne = scn.nextInt();
+		
+		int arrOne[] = new int[tcOne];
+	
+		for (int i = 0; i < arrOne.length; i++) {
+			
+			arrOne[i] = scn.nextInt();
+			 
+		}	
+		
+		int tcTwo = scn.nextInt();
+		
+		int arrTwo[] = new int[tcTwo];
+	
+		for (int i = 0; i < arrTwo.length; i++) {
+			
+			arrTwo[i] = scn.nextInt();
+			 
+		}	
+	
+		
+	
+		
+		int arrSum[] = new int[tcOne>tcTwo?tcOne : tcTwo ];
+		
+		int i = arrOne.length - 1;
+		int j = arrTwo.length - 1;
+		int k = arrSum.length - 1;
+		
+		
+		int c = 0;
+		
+		while(k >= 0)
+		{
+			 
+			int d = c;
+			
+			if(i >= 0)
+			{
+				d = d + arrOne[i];
+			}
+			
+			if(j >= 0)
+			{
+				d = d + arrTwo[j];
+			}
+			
+			c = c / 10;
+			d = d % 10;
+			
+			arrSum[k] = d;
+			
+		
+			
+			i--;
+			j--;
+			k--;
+			
+		}
+		
+		if(c!=0)
+		{
+			System.out.println(c);
+		}
+		
+		Display(arrSum);
+		
+	}
+
+}
diff --git a/TheStateOfWakanda1.java b/TheStateOfWakanda1.java
new file mode 100644
index 0000000..edb0749
--- /dev/null
+++ b/TheStateOfWakanda1.java
@@ -0,0 +1,55 @@
+import java.util.Scanner;
+
+public class TheStateOfWakanda1 {
+	
+	public static void Display(int [][] a)
+	{
+		for (int i = 0; i < a.length; i++) {
+			for (int j = 0; j < a[0].length; j++) {
+				
+				System.out.print(a[i][j]+" "); 
+				
+			}
+			System.out.println();
+		}
+	}
+	
+	public static void main(String[] args) {
+		
+		Scanner scn = new Scanner(System.in);
+		
+		int row = scn.nextInt();
+		int coloumn = scn.nextInt();
+		
+		int [][] twodArray = new int[row][coloumn]; 
+		
+		for (int i = 0; i < twodArray.length; i++) {
+			for (int j = 0; j < twodArray[0].length; j++) {
+				
+				twodArray[i][j] = scn.nextInt(); 
+				
+			}
+		}
+		
+		for(int j = 0; j<twodArray[0].length;j++)
+		{
+			if(j % 2 == 0)
+			{
+				for (int i = 0; i < twodArray.length; i++)
+				{
+					System.out.println(twodArray[i][j]);
+				}
+			}
+			else
+			{
+				for (int i = twodArray.length-1; i >=0; i--)
+				{
+					System.out.println(twodArray[i][j]);
+				}
+			}
+		}
+		
+		
+	}
+
+}
diff --git a/TwoDArrayDemo.java b/TwoDArrayDemo.java
new file mode 100644
index 0000000..9f7e7c3
--- /dev/null
+++ b/TwoDArrayDemo.java
@@ -0,0 +1,39 @@
+import java.util.Scanner;
+
+public class TwoDArrayDemo {
+	public static void Display(int [][] a)
+	{
+		for (int i = 0; i < a.length; i++) {
+			for (int j = 0; j < a[0].length; j++) {
+				
+				System.out.print(a[i][j]+" "); 
+				
+			}
+			System.out.println();
+		}
+	}
+	
+	public static void main(String[] args) {
+		
+
+		
+		Scanner scn = new Scanner(System.in);
+		
+		int row = scn.nextInt();
+		int coloumn = scn.nextInt();
+		
+		int [][] twodArray = new int[row][coloumn]; 
+		
+		for (int i = 0; i < twodArray.length; i++) {
+			for (int j = 0; j < twodArray[0].length; j++) {
+				
+				twodArray[i][j] = scn.nextInt(); 
+				
+			}
+		}
+		
+		
+		Display(twodArray);
+	}
+
+}
diff --git a/cs.ipynb b/cs.ipynb
new file mode 100644
index 0000000..bd3a8e5
--- /dev/null
+++ b/cs.ipynb
@@ -0,0 +1,492 @@
+{
+  "nbformat": 4,
+  "nbformat_minor": 0,
+  "metadata": {
+    "colab": {
+      "provenance": [],
+      "authorship_tag": "ABX9TyNcQffcoc+LLmXxCAo9Icps",
+      "include_colab_link": true
+    },
+    "kernelspec": {
+      "name": "python3",
+      "display_name": "Python 3"
+    },
+    "language_info": {
+      "name": "python"
+    }
+  },
+  "cells": [
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "view-in-github",
+        "colab_type": "text"
+      },
+      "source": [
+        "<a href=\"https://colab.research.google.com/github/harshita91/DSA-algorithm/blob/main/cs.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 1,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 1000
+        },
+        "id": "7c4O6X3hHLmn",
+        "outputId": "6d608563-58de-4cf2-a09c-c6f709a22921"
+      },
+      "outputs": [
+        {
+          "output_type": "display_data",
+          "data": {
+            "text/plain": [
+              "<Figure size 1170.62x1000 with 20 Axes>"
+            ],
+            "image/png": "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\n"
+          },
+          "metadata": {}
+        },
+        {
+          "output_type": "display_data",
+          "data": {
+            "text/plain": [
+              "<Figure size 640x480 with 2 Axes>"
+            ],
+            "image/png": "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\n"
+          },
+          "metadata": {}
+        }
+      ],
+      "source": [
+        "import numpy as np\n",
+        "import pandas as pd\n",
+        "import matplotlib.pyplot as plt\n",
+        "import seaborn as sns\n",
+        "\n",
+        "potatoes = [0, 2, 9, 2]\n",
+        "vegetables = [4, 3, 4, 1]\n",
+        "meat = [0, 2, 10, 1]\n",
+        "icecream = [0, 8, 4, 0]\n",
+        "labels = ['disagree', 'neutral', 'agree', 'strongly disagree']\n",
+        "\n",
+        "data = pd.DataFrame({'x': potatoes, 'y': vegetables, 'z': meat, 'w': icecream, 'l': labels})\n",
+        "\n",
+        "mean_x = data['x'].mean()\n",
+        "mean_y = data['y'].mean()\n",
+        "mean_z = data['z'].mean()\n",
+        "mean_w = data['w'].mean()\n",
+        "\n",
+        "std_dev_x = data['x'].std()\n",
+        "std_dev_y = data['y'].std()\n",
+        "std_dev_z = data['z'].std()\n",
+        "std_dev_w = data['w'].std()\n",
+        "\n",
+        "# For correlation matrix\n",
+        "correlation_matrix = data[['x', 'y', 'z', 'w']].corr()\n",
+        "\n",
+        "# For Pairplot\n",
+        "sns.pairplot(data, hue='l')\n",
+        "plt.suptitle(\"Scatter Plot Matrix\")\n",
+        "plt.show()\n",
+        "\n",
+        "# For heatmap of the correlation matrix\n",
+        "sns.heatmap(correlation_matrix, annot=True, cmap='coolwarm', fmt='.2f')\n",
+        "plt.title(\"Correlation matrix\")\n",
+        "plt.show()\n"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "import pandas as pd\n",
+        "import numpy as np\n",
+        "import seaborn as sns\n",
+        "import matplotlib.pyplot as plt\n",
+        "\n",
+        "household_id=[1,2,3,4,5,6,7,8,9,10]\n",
+        "household_size=[2,4,4,1,3,5,6,4,7,2]\n",
+        "annual_income=[37000,49000,58000,68000,61000,64000,79000,89000,104000,95000]\n",
+        "no_pets=[0,0,1,3,2,2,1,1,1,0]\n",
+        "\n",
+        "data=pd.DataFrame({'x':household_id,'y':household_size,'z':annual_income,'w':no_pets})\n",
+        "\n",
+        "print(\"Data Information\")\n",
+        "print(data.info())\n",
+        "\n",
+        "print(\"Statistical description of the data\")\n",
+        "print(data.describe())\n",
+        "\n",
+        "\n",
+        "# Visualization of household size\n",
+        "plt.figure(figsize=(10,6))\n",
+        "sns.histplot(data['y'],bins=range(1,8),kde=True,color='red')\n",
+        "plt.title(\"Distribution of Household sizes\")\n",
+        "plt.xlabel(\"Household Size\")\n",
+        "plt.ylabel(\"Frequency\")\n",
+        "plt.show()\n",
+        "\n",
+        "# Visualization for annual income\n",
+        "plt.figure(figsize=(10,6))\n",
+        "sns.histplot(data['z'],bins=range(1,8),kde=True,color='orange')\n",
+        "plt.xtitle(\"Distribution of annual income\")\n",
+        "plt.ytitle(\"Frequency\")\n",
+        "plt.show()\n",
+        "\n",
+        "# It can be observed from the dataset that the household size and annual income can be the related feature. So we need to find the relation between them\n",
+        "plt.figure(figsize=(10,6))\n",
+        "sns.scatterplot(x='y',y='z',data=data,color='orange')\n",
+        "plt.title(\"Realtionship between household size and annual income\")\n",
+        "plt.xlabel(\"Household size\")\n",
+        "plt.ylabel(\"Annual income\")\n",
+        "plt.show()\n",
+        "\n",
+        "# # Visualize the distribution of the number of pets\n",
+        "plt.figure(figsize=(10,6))\n",
+        "sns.countplot(x='w',data=data,color=\"purple\")\n",
+        "plt.title(\"Distribution of number of pets\")\n",
+        "plt.xlabel(\"Number of pets\")\n",
+        "plt.ylabel(\"Count\")\n",
+        "plt.show()"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 1000
+        },
+        "id": "GmUAjDRPLKGq",
+        "outputId": "1f7b333f-42f5-4092-e6a8-18f110c07b19"
+      },
+      "execution_count": 2,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Data Information\n",
+            "<class 'pandas.core.frame.DataFrame'>\n",
+            "RangeIndex: 10 entries, 0 to 9\n",
+            "Data columns (total 4 columns):\n",
+            " #   Column  Non-Null Count  Dtype\n",
+            "---  ------  --------------  -----\n",
+            " 0   x       10 non-null     int64\n",
+            " 1   y       10 non-null     int64\n",
+            " 2   z       10 non-null     int64\n",
+            " 3   w       10 non-null     int64\n",
+            "dtypes: int64(4)\n",
+            "memory usage: 448.0 bytes\n",
+            "None\n",
+            "Statistical description of the data\n",
+            "              x          y              z          w\n",
+            "count  10.00000  10.000000      10.000000  10.000000\n",
+            "mean    5.50000   3.800000   70400.000000   1.100000\n",
+            "std     3.02765   1.873796   21125.024655   0.994429\n",
+            "min     1.00000   1.000000   37000.000000   0.000000\n",
+            "25%     3.25000   2.250000   58750.000000   0.250000\n",
+            "50%     5.50000   4.000000   66000.000000   1.000000\n",
+            "75%     7.75000   4.750000   86500.000000   1.750000\n",
+            "max    10.00000   7.000000  104000.000000   3.000000\n"
+          ]
+        },
+        {
+          "output_type": "display_data",
+          "data": {
+            "text/plain": [
+              "<Figure size 1000x600 with 1 Axes>"
+            ],
+            "image/png": "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\n"
+          },
+          "metadata": {}
+        },
+        {
+          "output_type": "error",
+          "ename": "AttributeError",
+          "evalue": "ignored",
+          "traceback": [
+            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
+            "\u001b[0;31mAttributeError\u001b[0m                            Traceback (most recent call last)",
+            "\u001b[0;32m<ipython-input-2-4b5ab3ac5547>\u001b[0m in \u001b[0;36m<cell line: 31>\u001b[0;34m()\u001b[0m\n\u001b[1;32m     29\u001b[0m \u001b[0mplt\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfigure\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfigsize\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m10\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m6\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     30\u001b[0m \u001b[0msns\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mhistplot\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mdata\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m'z'\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mbins\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mrange\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m8\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mkde\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mTrue\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mcolor\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m'orange'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 31\u001b[0;31m \u001b[0mplt\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mxtitle\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"Distribution of annual income\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     32\u001b[0m \u001b[0mplt\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mytitle\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"Frequency\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     33\u001b[0m \u001b[0mplt\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mshow\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;31mAttributeError\u001b[0m: module 'matplotlib.pyplot' has no attribute 'xtitle'"
+          ]
+        },
+        {
+          "output_type": "display_data",
+          "data": {
+            "text/plain": [
+              "<Figure size 1000x600 with 1 Axes>"
+            ],
+            "image/png": "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\n"
+          },
+          "metadata": {}
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "import pandas as pd\n",
+        "import numpy as np\n",
+        "import matplotlib.pyplot as plt\n",
+        "import seaborn as sns\n",
+        "\n",
+        "temp=[20,25,35,43]\n",
+        "ice_cream_sales=[2000,2500,5000,7800]\n",
+        "\n",
+        "data=pd.DataFrame({'x':temp,'y':ice_cream_sales})\\\n",
+        "\n",
+        "# Univariate analysis for the Temprature feature\n",
+        "plt.figure(figsize=(10,6))\n",
+        "plt.subplot(1,2,1)\n",
+        "sns.histplot(data['x'],bins=10,kde=True,color=\"green\")\n",
+        "plt.title(\"Distribution of the temprature\")\n",
+        "plt.xlabel(\"Temprature\")\n",
+        "plt.ylabel(\"Frequency\")\n",
+        "plt.subplot(1,2,2)\n",
+        "sns.boxplot(x=data['x'],color=\"green\")\n",
+        "plt.title(\"Boxplot of temperature\")\n",
+        "plt.tight_layout\n",
+        "plt.show()\n",
+        "\n",
+        "# Univariate Analysis for Icecream\n",
+        "plt.figure(figsize=(10,6))\n",
+        "plt.subplot(1,2,1)\n",
+        "sns.histplot(data['y'],bins=10,kde=True,color='orange')\n",
+        "plt.title(\"Distribution of Icecream\")\n",
+        "plt.xlabel(\"Icecream\")\n",
+        "plt.ylabel(\"Frequency\")\n",
+        "plt.subplot(1,2,2)\n",
+        "sns.boxplot(data['y'],color=\"orange\")\n",
+        "plt.title(\"Boxplot for Icecream\")\n",
+        "plt.tight_layout\n",
+        "plt.show()\n",
+        "\n",
+        "# Scatterplot for the relationship between temperature and the Icecream\n",
+        "plt.figure(figsize=(8,6))\n",
+        "sns.scatterplot(x='x',y='y',data=data,color='salmon')\n",
+        "plt.title(\"Scatter Plot of temperature vs Icecream \")\n",
+        "plt.xlabel(\"temperature\")\n",
+        "plt.ylabel(\"Ice cream Sales\")\n",
+        "plt.show()"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 1000
+        },
+        "id": "iuyXKq8mLkSc",
+        "outputId": "64a1c4da-586b-4f56-8fcc-3e7db2b6027d"
+      },
+      "execution_count": 3,
+      "outputs": [
+        {
+          "output_type": "display_data",
+          "data": {
+            "text/plain": [
+              "<Figure size 1000x600 with 2 Axes>"
+            ],
+            "image/png": "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\n"
+          },
+          "metadata": {}
+        },
+        {
+          "output_type": "display_data",
+          "data": {
+            "text/plain": [
+              "<Figure size 1000x600 with 2 Axes>"
+            ],
+            "image/png": "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\n"
+          },
+          "metadata": {}
+        },
+        {
+          "output_type": "display_data",
+          "data": {
+            "text/plain": [
+              "<Figure size 800x600 with 1 Axes>"
+            ],
+            "image/png": "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\n"
+          },
+          "metadata": {}
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "import pandas as pd\n",
+        "import numpy as np\n",
+        "import matplotlib.pyplot as plt\n",
+        "import seaborn as sns\n",
+        "\n",
+        "self_esteem=[20,27,30,32,50,55,62,64,77,80,85,90,100]\n",
+        "hrs_insta=[10,9,8,6,4,2,3,2,3,1,1,2,0]\n",
+        "\n",
+        "data=pd.DataFrame({'x':self_esteem,'y': hrs_insta})\n",
+        "\n",
+        "print(\"Data Information\")\n",
+        "print(data.info())\n",
+        "\n",
+        "print(\"Statistical Information\")\n",
+        "print(data.describe())\n",
+        "\n",
+        "#Visualization for self esteem\n",
+        "plt.figure(figsize=(10,6))\n",
+        "sns.histplot(data['x'],bins=range(1,8),kde=True,color=\"green\")\n",
+        "plt.title(\"Distribution for Self esteem\")\n",
+        "plt.xlabel(\"Self esteem\")\n",
+        "plt.ylabel(\"frequency\")\n",
+        "plt.show()\n",
+        "\n",
+        "# Visualization for hrs at insta\n",
+        "plt.figure(figsize=(10,6))\n",
+        "sns.histplot(data['y'],bins=range(1,8),kde=True,color=\"blue\")\n",
+        "plt.title(\"Distribution of Hours soen at Insta\")\n",
+        "plt.xlabel(\"Hours at Insta\")\n",
+        "plt.ylabel(\"Frequency\")\n",
+        "plt.show()\n",
+        "\n",
+        "# Visualization for the relationship between the Self esteem and hrs spen at Insta\n",
+        "plt.figure(figsize=(10,8))\n",
+        "sns.scatterplot(x='x',y='y',data=data,color=\"red\")\n",
+        "plt.title(\"Relationship between Self esteem and nbr of hrs at insta\")\n",
+        "plt.xlabel(\"Self esteem\")\n",
+        "plt.ylabel(\"Hours spend at Insta\")\n",
+        "plt.show()\n"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 1000
+        },
+        "id": "JYCH2yVCLyn9",
+        "outputId": "71e32ecb-5f26-4cf7-ff61-9c101897eb4d"
+      },
+      "execution_count": 4,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Data Information\n",
+            "<class 'pandas.core.frame.DataFrame'>\n",
+            "RangeIndex: 13 entries, 0 to 12\n",
+            "Data columns (total 2 columns):\n",
+            " #   Column  Non-Null Count  Dtype\n",
+            "---  ------  --------------  -----\n",
+            " 0   x       13 non-null     int64\n",
+            " 1   y       13 non-null     int64\n",
+            "dtypes: int64(2)\n",
+            "memory usage: 336.0 bytes\n",
+            "None\n",
+            "Statistical Information\n",
+            "                x          y\n",
+            "count   13.000000  13.000000\n",
+            "mean    59.384615   3.923077\n",
+            "std     26.342420   3.277742\n",
+            "min     20.000000   0.000000\n",
+            "25%     32.000000   2.000000\n",
+            "50%     62.000000   3.000000\n",
+            "75%     80.000000   6.000000\n",
+            "max    100.000000  10.000000\n"
+          ]
+        },
+        {
+          "output_type": "display_data",
+          "data": {
+            "text/plain": [
+              "<Figure size 1000x600 with 1 Axes>"
+            ],
+            "image/png": "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\n"
+          },
+          "metadata": {}
+        },
+        {
+          "output_type": "display_data",
+          "data": {
+            "text/plain": [
+              "<Figure size 1000x600 with 1 Axes>"
+            ],
+            "image/png": "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\n"
+          },
+          "metadata": {}
+        },
+        {
+          "output_type": "display_data",
+          "data": {
+            "text/plain": [
+              "<Figure size 1000x800 with 1 Axes>"
+            ],
+            "image/png": "iVBORw0KGgoAAAANSUhEUgAAA0kAAAK9CAYAAADxDSf7AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAABZbklEQVR4nO3deVxUZf//8fcIsggyoAIuoeKSu5aa+1JKqFlplqZ551J2t1hWlqm3uVVqtpgtpqXdat2alqVZ31TMXVPTXFJzT5PbBTcE0USF6/cHP+Y+E4uMDAzo6/l4zOPBXOfMOZ9zcYaZN+ec69iMMUYAAAAAAElSEU8XAAAAAAAFCSEJAAAAACwISQAAAABgQUgCAAAAAAtCEgAAAABYEJIAAAAAwIKQBAAAAAAWhCQAAAAAsCAkAQAAAIAFIQkogFauXCmbzaaVK1e6dbk2m02jRo1y6zJddfjwYdlsNr3zzjvXnHfUqFGy2WxuW3d6v86bN89ty4Trstq/v/jiC1WvXl1FixZVcHCwR2pD1m7U9+OmTZvUrFkzBQQEyGazadu2bZnON2PGDNlsNm3evDl/C8xjBeFzASiICElALqV/cKY/vL29Va5cOfXp00dHjx7N93p+/PFHPvDy0c8//6xRo0bp3Llzni4lzyQlJWnkyJGqXbu2AgICVLJkSd122216/vnndezYMbesY8+ePerTp48qV66sqVOn6tNPP3XLcq+F98vN7cqVK+ratavOnj2r9957T1988YUqVKjg6bJy5eOPP9aMGTM8XYYk6dixYxo1alSWwRMoyLw9XQBwo3jttdcUGRmpS5cuacOGDZoxY4bWrl2rnTt3ys/PL9/q+PHHHzVp0qRMv/j99ddf8vYuPG/7V199VUOGDPF0Gdn6+eefNXr0aPXp0+eGPPpx5coVtWrVSnv27FHv3r313HPPKSkpSbt27dLs2bP1wAMPqGzZsrlez8qVK5Wamqr3339fVapUcUPlOZPd+wU3voMHD+rPP//U1KlT1a9fP0+X4xYff/yxSpUqpT59+uRo/rz8XDh27JhGjx6tihUr6rbbbsuTdQB5pfB8WwIKuA4dOqhhw4aSpH79+qlUqVIaP368Fi5cqG7dunm4ujT5Gdbcwdvbu1CFuhvRggULtHXrVs2aNUuPPPKI07RLly7p8uXLblnPyZMnJemGDJrIGxcvXlSxYsVytYz82u+MMbp06ZL8/f3zdD3Xo7B9LgD5hdPtgDzSsmVLSWn/qbTas2ePHnroIZUoUUJ+fn5q2LChFi5ceM3lrVmzRl27dlX58uXl6+uriIgIvfjii/rrr78c8/Tp00eTJk2SJKdTANNldu751q1b1aFDBwUFBSkwMFBt27bVhg0bnOZJP6Vw3bp1GjhwoEJDQxUQEKAHHnhAp06dcpp38+bNateunUqVKiV/f39FRkbqsccey3SbPv30U1WuXFm+vr664447tGnTJqfpmV0DYbPZ9Oyzz2rWrFmqVq2a/Pz81KBBA61evfqafZguJSVF//rXv1S6dGkFBATo/vvvV2xsbIb5Nm7cqPbt28tut6tYsWJq3bq11q1b51TfoEGDJEmRkZGO/j58+LC6dOmi+vXrOy3vvvvuk81mc/p9b9y4UTabTYsWLXK0nTt3Ti+88IIiIiLk6+urKlWqaPz48UpNTXVaXmpqqiZOnKhatWrJz89P4eHhevLJJxUfH+80X8WKFXXvvfdq7dq1atSokfz8/FSpUiV9/vnn1+yr9P23efPmGab5+fkpKCjIqe169u+KFStq5MiRkqTQ0NAcXSORk/VcuXJFo0ePVtWqVeXn56eSJUuqRYsWWrp0qaRrv19y2r+StGjRIrVs2VIBAQEqXry4OnbsqF27djnN06dPHwUGBurIkSO69957FRgYqHLlyjlq2LFjh9q0aaOAgABVqFBBs2fPzrYP0r3zzjtq1qyZSpYsKX9/fzVo0CDT63zS3zsLFixQ7dq15evrq1q1amnx4sUZ5l27dq3uuOMO+fn5qXLlyvrkk09yVIsk3Xnnnapdu7Z+//133XXXXSpWrJjKlSunt956K9P5c/J+TF/mr7/+qlatWqlYsWL617/+lW0dy5cvd/xOgoOD1alTJ+3evdsxvU+fPmrdurUkqWvXrrLZbLrzzjuvuX3JycnX/DuY/p5bsmSJGjZsKH9/f0cfLl26VC1atFBwcLACAwNVrVq1a26LJE2fPl1t2rRRWFiYfH19VbNmTU2ePDnDenft2qVVq1Y59udrbdPf32/pf3cPHDjgOEJut9vVt29fXbx40em12W3LypUrdccdd0iS+vbt66gn/VTAnHymAZ7Ev2iBPHL48GFJUkhIiKNt165dat68ucqVK6chQ4YoICBAX331lTp37qxvvvlGDzzwQJbL+/rrr3Xx4kU9/fTTKlmypH755Rd9+OGH+u9//6uvv/5akvTkk0/q2LFjWrp0qb744otr1rhr1y61bNlSQUFBeuWVV1S0aFF98sknuvPOO7Vq1So1btzYaf7nnntOISEhGjlypA4fPqyJEyfq2Wef1dy5cyWl/Vc2OjpaoaGhGjJkiIKDg3X48GF9++23GdY9e/ZsnT9/Xk8++aRsNpveeustdenSRX/88YeKFi2abd2rVq3S3LlzNWDAAPn6+urjjz9W+/bt9csvv6h27drX3O4xY8bIZrNp8ODBOnnypCZOnKioqCht27bN8Z/e5cuXq0OHDmrQoIFGjhypIkWKOL6krFmzRo0aNVKXLl20b98+ffnll3rvvfdUqlQpSWlf9Fu2bKnvvvtOiYmJCgoKkjFG69atU5EiRbRmzRrdf//9ktK+KBQpUsQRQi5evKjWrVvr6NGjevLJJ1W+fHn9/PPPGjp0qI4fP66JEyc6tuPJJ5/UjBkz1LdvXw0YMECHDh3SRx99pK1bt2rdunVO/XjgwAE99NBDevzxx9W7d2/9+9//Vp8+fdSgQQPVqlUry75Kvz7j888/16uvvprthfvXu39PnDhRn3/+uebPn6/JkycrMDBQdevWzfV6Ro0apXHjxqlfv35q1KiREhMTtXnzZm3ZskV33333Nd8vOe3fL774Qr1791a7du00fvx4Xbx4UZMnT1aLFi20detWVaxY0bHMlJQUdejQQa1atdJbb72lWbNm6dlnn1VAQICGDRumnj17qkuXLpoyZYp69eqlpk2bKjIyMsu+kKT3339f999/v3r27KnLly9rzpw56tq1q3744Qd17NjRad61a9fq22+/1TPPPKPixYvrgw8+0IMPPqgjR46oZMmSktLCWvr7eNSoUbp69apGjhyp8PDwbOuwio+PV/v27dWlSxd169ZN8+bN0+DBg1WnTh116NDBad6cvB8l6cyZM+rQoYO6d++uf/zjH9nW89NPP6lDhw6qVKmSRo0apb/++ksffvihmjdvri1btqhixYp68sknVa5cOY0dO1YDBgzQHXfckaNtvNbfwXR79+5Vjx499OSTT+qJJ55QtWrVtGvXLt17772qW7euXnvtNfn6+urAgQNO/3zJyuTJk1WrVi3df//98vb21vfff69nnnlGqamp6t+/v6S099Jzzz2nwMBADRs2TJJc+r1ZdevWTZGRkRo3bpy2bNmiadOmKSwsTOPHj5eka25LjRo19Nprr2nEiBH65z//6fjHYbNmzSTl7DMN8CgDIFemT59uJJmffvrJnDp1ysTGxpp58+aZ0NBQ4+vra2JjYx3ztm3b1tSpU8dcunTJ0ZaammqaNWtmqlat6mhbsWKFkWRWrFjhaLt48WKGdY8bN87YbDbz559/Otr69+9vsnprSzIjR450PO/cubPx8fExBw8edLQdO3bMFC9e3LRq1SrDNkZFRZnU1FRH+4svvmi8vLzMuXPnjDHGzJ8/30gymzZtyrK/Dh06ZCSZkiVLmrNnzzrav/vuOyPJfP/99462kSNHZtgWSUaS2bx5s6Ptzz//NH5+fuaBBx7Icr3G/K9fy5UrZxITEx3tX331lZFk3n//fWNM2u+katWqpl27dk7be/HiRRMZGWnuvvtuR9vbb79tJJlDhw45rWvTpk1Gkvnxxx+NMcb89ttvRpLp2rWrady4sWO++++/39x+++2O56+//roJCAgw+/btc1rekCFDjJeXlzly5Igxxpg1a9YYSWbWrFlO8y1evDhDe4UKFYwks3r1akfbyZMnja+vr3nppZey7bOLFy+aatWqGUmmQoUKpk+fPuazzz4zcXFxGebNzf6d/rs+depUtvW4sp569eqZjh07ZrusrN4vOe3f8+fPm+DgYPPEE084zXfixAljt9ud2nv37m0kmbFjxzra4uPjjb+/v7HZbGbOnDmO9j179mR4v2bl738bLl++bGrXrm3atGnj1C7J+Pj4mAMHDjjatm/fbiSZDz/80NHWuXNn4+fn5/R35ffffzdeXl5Z/m2xat26tZFkPv/8c0dbcnKyKV26tHnwwQcdbTl9P1qXOWXKlGuu3xhjbrvtNhMWFmbOnDnjtK1FihQxvXr1ylDD119/fc1l5vTvoDH/e88tXrzYaRnvvfdejvfzv8vsM6Bdu3amUqVKTm21atUyrVu3zvFy/76fpb8XH3vsMaf5HnjgAVOyZEnH85xsS/rfwenTp2eYltPPNMBTON0OcJOoqCiFhoYqIiJCDz30kAICArRw4ULdcsstkqSzZ89q+fLl6tatm86fP6/Tp0/r9OnTOnPmjNq1a6f9+/dnOxqe9T+qFy5c0OnTp9WsWTMZY7R161aX601JSVFMTIw6d+6sSpUqOdrLlCmjRx55RGvXrlViYqLTa/75z386HUlo2bKlUlJS9Oeff0r633n9P/zwg65cuZLt+h9++GGno2zp/2X8448/rll706ZN1aBBA8fz8uXLq1OnTlqyZIlSUlKu+fpevXqpePHijucPPfSQypQpox9//FGStG3bNu3fv1+PPPKIzpw54/hdXbhwQW3bttXq1asznPr2d7fffrsCAwMdpwGuWbNGt9xyi3r16qUtW7bo4sWLMsZo7dq1jm2X0v672rJlS4WEhDjWe/r0aUVFRSklJcWxvK+//lp2u113332303wNGjRQYGCgVqxY4VRPzZo1ndYTGhqqatWqXbO//f39tXHjRsdphTNmzNDjjz+uMmXK6LnnnlNycrKk3O/fOeXKeoKDg7Vr1y7t37/f5fXktH+XLl2qc+fOqUePHk7zeXl5qXHjxhl+D5KcBggIDg5WtWrVFBAQ4HTtYrVq1RQcHJyj94P1b0N8fLwSEhLUsmVLbdmyJcO8UVFRqly5suN53bp1FRQU5FhPSkqKlixZos6dO6t8+fKO+WrUqKF27dpds5Z0gYGB+sc//uF47uPjo0aNGmW6Pdd6P6bz9fVV3759r7nu48ePa9u2berTp49KlCjhtK133313huW66lp/B9NFRkZm6LP0v5HffffdNf+G/J3195yQkKDTp0+rdevW+uOPP5SQkODiVlzbU0895fS8ZcuWOnPmjONzITfbIrn/Mw1wN0IS4CaTJk3S0qVLNW/ePN1zzz06ffq0fH19HdMPHDggY4yGDx+u0NBQp0f69RjpFxFn5siRI44P/cDAQIWGhjrOp7+eD8hTp07p4sWLqlatWoZpNWrUUGpqaobrAqxfmqT/nUqYfo1G69at9eCDD2r06NEqVaqUOnXqpOnTpzu+SLuyrOxUrVo1Q9utt96qixcvZrg2ICevt9lsqlKliuMUyfQv1b17987wu5o2bZqSk5Ov2edeXl5q2rSp1qxZIyktJLVs2VItWrRQSkqKNmzYoN9//11nz551Ci/79+/X4sWLM6w3KipK0v/2kf379yshIUFhYWEZ5k1KSsqwL/29v6W0Ps9Jf9vtdr311ls6fPiwDh8+rM8++0zVqlXTRx99pNdff11S7vfvnHJlPa+99prOnTunW2+9VXXq1NGgQYP022+/5Wg9Oe3f9H2lTZs2GeaLiYnJsM1+fn4KDQ11arPb7brlllsynMpot9tz9Pv54Ycf1KRJE/n5+alEiRIKDQ3V5MmTM91Hr7UfnDp1Sn/99Vem77HM/lZkJbPtyWp/u9b7MV25cuXk4+NzzXWnh5Ws/ral/8PjeuX0b1dmp0k+/PDDat68ufr166fw8HB1795dX331VY5Cxrp16xQVFeW4xio0NNRx/U9ehKRrbWdutkVy/2ca4G5ckwS4SaNGjRyj23Xu3FktWrTQI488or179yowMNDxwfHyyy9n+R/ZrIY+TklJ0d13362zZ89q8ODBql69ugICAnT06FH16dPnuv6Ldz28vLwybTfGSJLjxpAbNmzQ999/ryVLluixxx7Tu+++qw0bNigwMDDHy/Kk9P58++23sxy21rotWWnRooXGjBmjS5cuac2aNRo2bJiCg4NVu3ZtrVmzxnGtgDUkpaam6u6779Yrr7yS6TJvvfVWx3xhYWGaNWtWpvP9/Yu4u/q7QoUKeuyxx/TAAw+oUqVKmjVrlt54441c7d+ucGU9rVq10sGDB/Xdd98pJiZG06ZN03vvvacpU6Zcc7jnnPZvej1ffPGFSpcunWG+v4/OmNXv4Xp/P+nXt7Vq1Uoff/yxypQpo6JFi2r69OmZDvyQX++7vFhPQRkZLqfbllm9/v7+Wr16tVasWKH/+7//0+LFizV37ly1adNGMTExWS774MGDatu2rapXr64JEyYoIiJCPj4++vHHH/Xee+/lyWfAtbbzerdFKjifaUB2CElAHvDy8tK4ceN011136aOPPtKQIUMcp7QVLVrUcVQgp3bs2KF9+/Zp5syZ6tWrl6M9fZQuq+wurLcKDQ1VsWLFtHfv3gzT9uzZoyJFiigiIsKlOtM1adJETZo00ZgxYzR79mz17NlTc+bMcdt9SDI7fWrfvn0qVqxYhnCQk9cbY3TgwAHHYAHppyMFBQVd83eVXX+3bNlSly9f1pdffqmjR486wlCrVq0cIenWW291urC6cuXKSkpKuuZ6K1eurJ9++knNmzf3yJfHkJAQVa5cWTt37pSkXO3frnB1PSVKlFDfvn3Vt29fJSUlqVWrVho1apRjX8zq95fT/k3fV8LCwvJ0u7PyzTffyM/PT0uWLHE6cj19+vTrWl5oaKj8/f0zfY9l9rfCHa71fnRV+mAjWf1tK1WqlAICAq5r2e5QpEgRtW3bVm3bttWECRM0duxYDRs2TCtWrMhyH/r++++VnJyshQsXOh3hyex0zpx+BrjDtbYlq1pc+UwDPIXT7YA8cuedd6pRo0aaOHGiLl26pLCwMN1555365JNPdPz48QzzZ3eaWPp/5Kz/qTTG6P33388wb/qH/7lz57Ktz8vLS9HR0fruu++cTmuJi4vT7Nmz1aJFiwzDO19LfHx8hv+mph+JyeyUu+u1fv16p+stYmNj9d133yk6Ojrb/16m+/zzz3X+/HnH83nz5un48eOOUbcaNGigypUr65133lFSUlKG11t/V9n1d+PGjVW0aFGNHz9eJUqUcIwi17JlS23YsEGrVq1yOookpY0otX79ei1ZsiTD8s6dO6erV6865ktJSXGc7mZ19erVa/7+c2r79u06ffp0hvY///xTv//+u+OUptzs365wZT1nzpxxmhYYGKgqVao47YtZ/f5y2r/t2rVTUFCQxo4dm+l1eO7a7qx4eXnJZrM5XYt3+PBhLViw4LqX165dOy1YsEBHjhxxtO/evTvTfdIdrvV+dFWZMmV02223aebMmU6/1507dyomJkb33HNPbku+bmfPns3QlpO/kZl9BiQkJGQahgMCAtz2/s9OTrYlq/eXK59pgKdwJAnIQ4MGDVLXrl01Y8YMPfXUU5o0aZJatGihOnXq6IknnlClSpUUFxen9evX67///a+2b9+e6XKqV6+uypUr6+WXX9bRo0cVFBSkb775JtPz+9MHNBgwYIDatWsnLy8vde/ePdPlvvHGG477XDzzzDPy9vbWJ598ouTk5CzvaZKdmTNn6uOPP9YDDzygypUr6/z585o6daqCgoLc+sWkdu3aateundMQ4JI0evToHL2+RIkSatGihfr27au4uDhNnDhRVapU0RNPPCEp7b+j06ZNU4cOHVSrVi317dtX5cqV09GjR7VixQoFBQXp+++/l/S//h42bJi6d++uokWL6r777lNAQICKFSumBg0aaMOGDY57JElpR5IuXLigCxcuZAhJgwYN0sKFC3Xvvfc6hui+cOGCduzYoXnz5unw4cMqVaqUWrdurSeffFLjxo3Ttm3bFB0draJFi2r//v36+uuv9f777+uhhx7KdV8vXbpUI0eO1P33368mTZooMDBQf/zxh/79738rOTnZ6f4q17t/uyqn66lZs6buvPNONWjQQCVKlNDmzZs1b948Pfvss45lZfV+yWn/BgUFafLkyXr00UdVv359de/eXaGhoTpy5Ij+7//+T82bN9dHH33klu3OTMeOHTVhwgS1b99ejzzyiE6ePKlJkyapSpUqOb7+6u9Gjx6txYsXq2XLlnrmmWd09epVffjhh6pVq9Z1LzM713o/Xo+3335bHTp0UNOmTfX44487hgC32+3XvAdXXnrttde0evVqdezYURUqVNDJkyf18ccf65ZbblGLFi2yfF10dLR8fHx033336cknn1RSUpKmTp2qsLCwDP8saNCggSZPnqw33nhDVapUUVhYmNq0aeORbalcubKCg4M1ZcoUFS9eXAEBAWrcuLFLn2mAx+TnUHrAjSh9WNjMhr1OSUkxlStXNpUrVzZXr141xhhz8OBB06tXL1O6dGlTtGhRU65cOXPvvfeaefPmOV6X2RDJv//+u4mKijKBgYGmVKlS5oknnnAM32sdXvXq1avmueeeM6GhocZmszkN2atMhhTesmWLadeunQkMDDTFihUzd911l/n5559ztI1/r3PLli2mR48epnz58sbX19eEhYWZe++912m47vQhwN9+++0M/fX3+rIaArx///7mP//5j6latarx9fU1t99+u1NfZSW93i+//NIMHTrUhIWFGX9/f9OxY8dMh5zdunWr6dKliylZsqTx9fU1FSpUMN26dTPLli1zmu/111835cqVM0WKFMkwHPigQYOMJDN+/Hin11SpUsVIchp+Pd358+fN0KFDTZUqVYyPj48pVaqUadasmXnnnXfM5cuXneb99NNPTYMGDYy/v78pXry4qVOnjnnllVfMsWPHHPNUqFAh06GwW7dufc2hgv/44w8zYsQI06RJExMWFma8vb1NaGio6dixo1m+fHmG+a93/3ZlCPCcrueNN94wjRo1MsHBwcbf399Ur17djBkzxqkPs3u/GJOz/k3fpnbt2hm73W78/PxM5cqVTZ8+fZz2/d69e5uAgIAM29K6dWtTq1atDO1Z/d7+7rPPPnO8F6pXr26mT5+e7Xsns/X07t3bqW3VqlWmQYMGxsfHx1SqVMlMmTIl02VmJqvt6d27t6lQoYLjuSvvx6yWmZ2ffvrJNG/e3Pj7+5ugoCBz3333md9//91pnusZAvxafweNyfp3t2zZMtOpUydTtmxZ4+PjY8qWLWt69OiRYcj/zCxcuNDUrVvX+Pn5mYoVK5rx48ebf//73xn+5pw4ccJ07NjRFC9e3Ei65ns8q7+7f38vpm9/+rpyui3fffedqVmzpvH29nb6vMrpZxrgKTZjCsBV0gCQQzabTf3798/T/84DAICbG9ckAQAAAIAFIQkAAAAALAhJAAAAAGDB6HYAChUuowQAAHmNI0kAAAAAYEFIAgAAAACLG/50u9TUVB07dkzFixd33MgRAAAAwM3HGKPz58+rbNmyKlIk6+NFN3xIOnbsmCIiIjxdBgAAAIACIjY2VrfcckuW02/4kFS8eHFJaR0RFBTk4WoAAAAAeEpiYqIiIiIcGSErN3xISj/FLigoiJAEAAAA4JqX4TBwAwAAAABYEJIAAAAAwIKQBAAAAAAWhCQAAAAAsCAkAQAAAIAFIQkAAAAALAhJAAAAAGBBSAIAAAAAC0ISAAAAAFgQkgAAAADAgpAEAAAAABaEJAAAAACwICQBAAAAgAUhCQAAAAAsCEkAAAAAYEFIAgAAAAALQhIAAAAAWBCSAAAAAMCCkAQAAAAAFoQkAAAAALAgJAEAAACAhUdD0urVq3XfffepbNmystlsWrBggdN0Y4xGjBihMmXKyN/fX1FRUdq/f79nis2t+Hhpzx5p40Zp79605wAAAAAKHI+GpAsXLqhevXqaNGlSptPfeustffDBB5oyZYo2btyogIAAtWvXTpcuXcrnSnMpNlbq3l2qUUNq0kSqXj3teWyspysDAAAA8Dc2Y4zxdBGSZLPZNH/+fHXu3FlS2lGksmXL6qWXXtLLL78sSUpISFB4eLhmzJih7t2752i5iYmJstvtSkhIUFBQUF6Vn7X4+LRAFBOTcVp0tDRnjhQSkv91AQAAADeZnGaDAntN0qFDh3TixAlFRUU52ux2uxo3bqz169dn+brk5GQlJiY6PTwqLi7zgCSltcfF5W89AAAAALJVYEPSiRMnJEnh4eFO7eHh4Y5pmRk3bpzsdrvjERERkad1XlNCQu6mAwAAAMhXBTYkXa+hQ4cqISHB8Yj19HU/dnvupgMAAADIVwU2JJUuXVqSFPe309Hi4uIc0zLj6+uroKAgp4dHhYenXXuUmejotOkAAAAACowCG5IiIyNVunRpLVu2zNGWmJiojRs3qmnTph6szEUhIdK0aRmDUnR0WjuDNgAAAAAFircnV56UlKQDBw44nh86dEjbtm1TiRIlVL58eb3wwgt64403VLVqVUVGRmr48OEqW7asYwS8QiMiIm0Uu7i4tGuQ7Pa0I0gEJAAAAKDA8WhI2rx5s+666y7H84EDB0qSevfurRkzZuiVV17RhQsX9M9//lPnzp1TixYttHjxYvn5+Xmq5OsXEkIoAgAAAAqBAnOfpLzi8fskAQAAACgQCv19kgAAAADAEwhJAAAAAGBBSAIAAAAAC0ISAAAAAFgQkgAAAADAgpAEAAAAABaEJAAAAACwICQBAAAAgAUhCQAAAAAsCEkAAAAAYEFIAgAAAAALQhIAAAAAWBCSAAAAAMCCkAQAAAAAFoQkAAAAALAgJAEAAACABSEJAAAAACwISQAAAABgQUgCAAAAAAtCEgAAAABYEJIAAAAAwIKQBAAAAAAWhCQAAAAAsCAkAQAAAIAFIQkAAAAALAhJAAAAAGBBSAIAAAAAC0ISAAAAAFgQkgAAAADAgpAEAAAAABaEJAAAAACwICQBAAAAgAUhCQAAAAAsCEkAAAAAYEFIAgAAAAALQhIAAAAAWBCSAAAAAMCCkAQAAAAAFoQkAAAAALAgJAEAAACABSEJAAAAACwISQAAAABgQUgCAAAAAAtCEgAAAABYEJIAAAAAwMLb0wXgBhcfL8XFSQkJUnCwFBYmhYR4uioAAAAgSxxJQt6JjZW6d5dq1JCaNJGqV097Hhvr6coAAACALBGSkDfi46V+/aSYGOf2mJi09vh4z9QFAAAAXAMhCXkjLi5jQEoXE5M2HQAAACiACEnIGwkJuZsOAAAAeAghCXnDbs/ddAAAAMBDCEnIG+HhUnR05tOio9OmAwAAAAUQIQl5IyREmjYtY1CKjk5rZxhwAAAAFFDcJwl5JyJCmjPnf/dJstvTjiARkAAAAFCAEZKQt0JCCEUAAAAoVDjdDgAAAAAsCEkAAAAAYEFIAgAAAAALQhIAAAAAWBCSAAAAAMCCkAQAAAAAFoQkAAAAALAgJAEAAACABSEJAAAAACwISQAAAABgQUgCAAAAAAtCEgAAAABYEJIAAAAAwIKQBAAAAAAWhCQAAAAAsCAkAQAAAIAFIQkAAAAALAhJAAAAAGBBSAIAAAAAC0ISAAAAAFgQkgAAAADAgpAEAAAAABaEJAAAAACwICQBAAAAgAUhCQAAAAAsCEkAAAAAYEFIAgAAAAALQhIAAAAAWBCSAAAAAMCCkAQAAAAAFoQkAAAAALAgJAEAAACABSEJAAAAACwISQAAAABgQUgCAAAAAAtCEgAAAABYEJIAAAAAwIKQBAAAAAAWhCQAAAAAsCAkAQAAAIAFIQkAAAAALAhJAAAAAGBBSAIAAAAAC0ISAAAAAFgQkgAAAADAgpAEAAAAABYFOiSlpKRo+PDhioyMlL+/vypXrqzXX39dxhhPl4aCJj5e2rNH2rhR2rs37TkAAABwHbw9XUB2xo8fr8mTJ2vmzJmqVauWNm/erL59+8put2vAgAGeLg8FRWys1K+fFBPzv7boaGnaNCkiwnN1AQAAoFAq0CHp559/VqdOndSxY0dJUsWKFfXll1/ql19+8XBlKDDi4zMGJCnteb9+0pw5UkiIZ2oDAABAoVSgT7dr1qyZli1bpn379kmStm/frrVr16pDhw5ZviY5OVmJiYlOD9zA4uIyBqR0MTFp0wEAAAAXFOgjSUOGDFFiYqKqV68uLy8vpaSkaMyYMerZs2eWrxk3bpxGjx6dj1XCoxIScjcdAAAA+JsCfSTpq6++0qxZszR79mxt2bJFM2fO1DvvvKOZM2dm+ZqhQ4cqISHB8YiNjc3HipHv7PbcTQcAAAD+pkAfSRo0aJCGDBmi7t27S5Lq1KmjP//8U+PGjVPv3r0zfY2vr698fX3zs0x4Unh42iANmZ1yFx2dNh0AAABwQYE+knTx4kUVKeJcopeXl1JTUz1UEQqckJC0Ueyio53b00e3Y9AGAAAAuKhAH0m67777NGbMGJUvX161atXS1q1bNWHCBD322GOeLg0FSURE2ih2cXFp1yDZ7WlHkAhIAAAAuA42U4DvzHr+/HkNHz5c8+fP18mTJ1W2bFn16NFDI0aMkI+PT46WkZiYKLvdroSEBAUFBeVxxQAAAAAKqpxmgwIdktyBkAQAAABAynk2KNDXJAEAAABAfiMkAQAAAIAFIQkAAAAALAhJAAAAAGBBSAIAAAAAC0ISAAAAAFgQkgAAAADAgpAEAAAAABaEJAAAAACwICQBAAAAgAUhCQAAAAAsCEkAAAAAYEFIAgAAAAALQhIAAAAAWBCSAAAAAMCCkAQAAAAAFoQkAAAAALAgJAEAAACABSEJAAAAACwISQAAAABgQUgCAAAAAAtCEgAAAABYEJIAAAAAwIKQBAAAAAAWhCQAAAAAsCAkAQAAAIAFIQkAAAAALAhJAAAAAGBBSAIAAAAAC0ISAAAAAFgQkgAAAADAgpAEAAAAABaEJAAAAACwICQBAAAAgAUhCQAAAAAsCEkAAAAAYEFIAgAAAAALQhIAAAAAWBCSAAAAAMCCkAQAAAAAFoQkAAAAALAgJAEAAACABSEJAAAAACwISQAAAABgQUgCAAAAAAtCEgAAAABYEJIAAAAAwIKQBAAAAAAWhCQAAAAAsCAkAQAAAIAFIQkAAAAALAhJAAAAAGBBSAIAAAAAC0ISAAAAAFgQkgAAAADAgpAEAAAAABaEJAAAAACwICQBAAAAgAUhCQAAAAAsCEkAAAAAYEFIAgAAAAALQhIAAAAAWBCSAAAAAMCCkAQAAAAAFoQkAAAAALAgJAEAAACABSEJAAAAACwISQAAAABgQUgCAAAAAAtCEgAAAABYEJIAAAAAwIKQBAAAAAAWhCQAAAAAsCAkAQAAAIAFIQkAAAAALAhJAAAAAGBBSAIAAAAAC0ISAAAAAFgQkgAAAADAgpAEAAAAABaEJAAAAACwICQBAAAAgAUhCQAAAAAsCEkAAAAAYEFIAgAAAAALQhIAAAAAWBCSAAAAAMCCkAQAAAAAFoQkAAAAALAgJAEAAACABSEJAAAAACy8r+dF//3vf7Vw4UIdOXJEly9fdpo2YcIEtxQGAAAAAJ7gckhatmyZ7r//flWqVEl79uxR7dq1dfjwYRljVL9+/byoEQAAAADyjcun2w0dOlQvv/yyduzYIT8/P33zzTeKjY1V69at1bVr17yoEQAAAADyjcshaffu3erVq5ckydvbW3/99ZcCAwP12muvafz48W4vEAAAAADyk8shKSAgwHEdUpkyZXTw4EHHtNOnT7uvMgAAAADwAJevSWrSpInWrl2rGjVq6J577tFLL72kHTt26Ntvv1WTJk3yokYAAAAAyDcuh6QJEyYoKSlJkjR69GglJSVp7ty5qlq1KiPbAQAAACj0bMYY4+ki8lJiYqLsdrsSEhIUFBTk6XIAAAAAeEhOs4HL1yRVqlRJZ86cydB+7tw5VapUydXFAQAAAECB4nJIOnz4sFJSUjK0Jycn6+jRo24pCgAAAAA8JcfXJC1cuNDx85IlS2S32x3PU1JStGzZMlWsWNGtxUnS0aNHNXjwYC1atEgXL15UlSpVNH36dDVs2NDt6wIUHy/FxUkJCVJwsBQWJoWEeLoqAAAA5KMch6TOnTtLkmw2m3r37u00rWjRoqpYsaLeffddtxYXHx+v5s2b66677tKiRYsUGhqq/fv3K4QvrcgLsbFSv35STMz/2qKjpWnTpIgIz9UFAACAfJXjkJSamipJioyM1KZNm1SqVKk8Kyrd+PHjFRERoenTpzvaIiMj83y9uAnFx2cMSFLa8379pDlzOKIEAABwk3D5mqRDhw5lCEjnzp1zVz1OFi5cqIYNG6pr164KCwvT7bffrqlTp2b7muTkZCUmJjo9gGuKi8sYkNLFxKRNBwAAwE3B5ZA0fvx4zZ071/G8a9euKlGihMqVK6ft27e7tbg//vhDkydPVtWqVbVkyRI9/fTTGjBggGbOnJnla8aNGye73e54RHCaFHIiISF30wEAAHDDcPk+SZGRkZo1a5aaNWumpUuXqlu3bpo7d66++uorHTlyRDFZ/Tf+Ovj4+Khhw4b6+eefHW0DBgzQpk2btH79+kxfk5ycrOTkZMfzxMRERUREcJ8kZG/PHqlGjayn794tVa+ef/UAAADA7XJ6n6QcX5OU7sSJE46jMz/88IO6deum6OhoVaxYUY0bN77+ijNRpkwZ1axZ06mtRo0a+uabb7J8ja+vr3x9fd1aB24C4eFpgzRkFvKjo9OmAwAA4Kbg8ul2ISEhio2NlSQtXrxYUVFRkiRjTKb3T8qN5s2ba+/evU5t+/btU4UKFdy6HkAhIWmj2EVHO7enj27HoA0AAAA3DZePJHXp0kWPPPKIqlatqjNnzqhDhw6SpK1bt6pKlSpuLe7FF19Us2bNNHbsWHXr1k2//PKLPv30U3366aduXQ8gKW2Y7zlz/nefJLs97QgSAQkAAOCm4nJIeu+991SxYkXFxsbqrbfeUmBgoCTp+PHjeuaZZ9xa3B133KH58+dr6NCheu211xQZGamJEyeqZ8+ebl0P4BASQigCAAC4ybk8cENhk9OLswAAAADc2PJs4AZJ2r9/v1asWKGTJ086bjKbbsSIEdezSAAAAAAoEFwOSVOnTtXTTz+tUqVKqXTp0rLZbI5pNpuNkAQAAACgUHM5JL3xxhsaM2aMBg8enBf1AAAAAIBHuTwEeHx8vLp27ZoXtQAAAACAx7kckrp27aqYzG64CQAAAAA3AJdPt6tSpYqGDx+uDRs2qE6dOipatKjT9AEDBritOAAAAADIby4PAR4ZGZn1wmw2/fHHH7kuyp0YAhwAAACAlIdDgB86dChXhQEAAABAQebyNUkAAAAAcCPL8ZGkgQMH5mi+CRMmXHcxAAAAAOBpOQ5JW7duveY81hvLAgAAAEBhlOOQtGLFirysAwAAAAAKBK5JAgAAAAALQhIAAAAAWBCSAAAAAMCCkAQAAAAAFi6HpCNHjsgYk6HdGKMjR464pSgAAAAA8BSXQ1JkZKROnTqVof3s2bOKjIx0S1EAAAAA4CkuhyRjTKb3Q0pKSpKfn59bigIAAAAAT8nxfZIGDhwoKe2GscOHD1exYsUc01JSUrRx40bddtttbi8QAAAAAPJTjkPS1q1bJaUdSdqxY4d8fHwc03x8fFSvXj29/PLL7q8QAAAAAPJRjkPSihUrJEl9+/bV+++/r6CgoDwrCgAAAAA8JcchKd306dPzog4AAAAAKBBcDkmStHnzZn311Vc6cuSILl++7DTt22+/dUthAAAAAOAJLo9uN2fOHDVr1ky7d+/W/PnzdeXKFe3atUvLly+X3W7PixoBAAAAIN+4HJLGjh2r9957T99//718fHz0/vvva8+ePerWrZvKly+fFzUCAAAAQL5xOSQdPHhQHTt2lJQ2qt2FCxdks9n04osv6tNPP3V7gQAAAACQn1wOSSEhITp//rwkqVy5ctq5c6ck6dy5c7p48aJ7qwMAAACAfObywA2tWrXS0qVLVadOHXXt2lXPP/+8li9frqVLl6pt27Z5USMAAAAA5BuXQ9JHH32kS5cuSZKGDRumokWL6ueff9aDDz6oV1991e0FAgAAAEB+shljjKeLyEuJiYmy2+1KSEjgBrgAAADATSyn2cDla5IAAAAA4EZGSAIAAAAAC0ISAAAAAFgQkgAAAADAgpAEAAAAABY5GgK8S5cuOV7gt99+e93FAAAAAICn5ehIkt1udzyCgoK0bNkybd682TH9119/1bJly2S32/OsUAAAAADIDzk6kjR9+nTHz4MHD1a3bt00ZcoUeXl5SZJSUlL0zDPPcB8iAAAAAIWeyzeTDQ0N1dq1a1WtWjWn9r1796pZs2Y6c+aMWwvMLW4mCwAAAEDKw5vJXr16VXv27MnQvmfPHqWmprq6OAAAAAAoUHJ0up1V37599fjjj+vgwYNq1KiRJGnjxo1688031bdvX7cXCAAAAAD5yeWQ9M4776h06dJ69913dfz4cUlSmTJlNGjQIL300ktuLxAAAAAA8pPL1yRZJSYmSlKBvtaHa5IAAAAASDnPBi4fSbIidAAAAAC40bg8cENcXJweffRRlS1bVt7e3vLy8nJ6AAAAAEBh5vKRpD59+ujIkSMaPny4ypQpI5vNlhd1AQAAAIBHuByS1q5dqzVr1ui2227Lg3IAAAAAwLNcPt0uIiJCuRjrAQAAAAAKNJdD0sSJEzVkyBAdPnw4D8oBAAAAAM9y+XS7hx9+WBcvXlTlypVVrFgxFS1a1Gn62bNn3VYcAAAAAOQ3l0PSxIkT86AMAAAAACgYXA5JvXv3zos6AAAAAKBAcPmaJEk6ePCgXn31VfXo0UMnT56UJC1atEi7du1ya3EAAAAAkN9cDkmrVq1SnTp1tHHjRn377bdKSkqSJG3fvl0jR450e4EAAAAAkJ9cDklDhgzRG2+8oaVLl8rHx8fR3qZNG23YsMGtxQEAAABAfnM5JO3YsUMPPPBAhvawsDCdPn3aLUUBAAAAgKe4HJKCg4N1/PjxDO1bt25VuXLl3FIUAAAAAHiKyyGpe/fuGjx4sE6cOCGbzabU1FStW7dOL7/8snr16pUXNQIAAABAvnE5JI0dO1bVq1dXRESEkpKSVLNmTbVq1UrNmjXTq6++mhc1AgAAAEC+sRljzPW88MiRI9q5c6eSkpJ0++23q2rVqu6uzS0SExNlt9uVkJCgoKAgT5cDAAAAwENymg1cvplsuvLlyysiIkKSZLPZrncxAAAAAFCgXNfNZD/77DPVrl1bfn5+8vPzU+3atTVt2jR31wYAAAAA+c7lI0kjRozQhAkT9Nxzz6lp06aSpPXr1+vFF1/UkSNH9Nprr7m9SAAAAADILy5fkxQaGqoPPvhAPXr0cGr/8ssv9dxzzxW4eyVxTRIAAAAAKefZwOXT7a5cuaKGDRtmaG/QoIGuXr3q6uIAAAAAoEBxOSQ9+uijmjx5cob2Tz/9VD179nRLUQAAAADgKdc1ut1nn32mmJgYNWnSRJK0ceNGHTlyRL169dLAgQMd802YMME9VQIAAABAPnE5JO3cuVP169eXJB08eFCSVKpUKZUqVUo7d+50zMew4AAAAAAKI5dD0ooVK/KiDgAAAAAoEK7rPklWiYmJWrBggfbs2eOOegAAAADAo1wOSd26ddNHH30kSfrrr7/UsGFDdevWTXXq1NE333zj9gIBAAAAID+5HJJWr16tli1bSpLmz58vY4zOnTunDz74QG+88YbbCwQAAACA/ORySEpISFCJEiUkSYsXL9aDDz6oYsWKqWPHjtq/f7/bCwQAAACA/ORySIqIiND69et14cIFLV68WNHR0ZKk+Ph4+fn5ub1AAAAAAMhPLo9u98ILL6hnz54KDAxUhQoVdOedd0pKOw2vTp067q4PAAAAAPKVyyHpmWeeUePGjXXkyBHdfffdKlIk7WBUpUqVuCYJAAAAQKFnM8YYTxeRlxITE2W325WQkKCgoCBPlwMAAADAQ3KaDXJ9nyQAAAAAuJEQkgAAAADAgpAEAAAAABaEJAAAAACwcDkkLV68WGvXrnU8nzRpkm677TY98sgjio+Pd2txAAAAAJDfXA5JgwYNUmJioiRpx44deumll3TPPffo0KFDGjhwoNsLBAAAAID85PJ9kg4dOqSaNWtKkr755hvde++9Gjt2rLZs2aJ77rnH7QUCAAAAQH5y+UiSj4+PLl68KEn66aefFB0dLUkqUaKE4wgTAAAAABRWLh9Jat68uQYOHKjmzZvrl19+0dy5cyVJ+/bt0y233OL2AgEAAAAgP7l8JGnSpEkqWrSo5s2bp8mTJ6tcuXKSpEWLFql9+/ZuLxAAAAAA8pPNGGNyOvPVq1c1e/ZsRUdHq3Tp0nlZl9skJibKbrcrISFBQUFBni4HAAAAgIfkNBu4dCTJ29tbTz31lJKTk3NdIAAAAAAURC6fbteoUSNt3bo1L2oBAAAAAI9zeeCGZ555Ri+99JL++9//qkGDBgoICHCaXrduXbcVBwAAAAD5zaVrkiSpSJGMB59sNpuMMbLZbEpJSXFbce7ANUkAAAAApJxng+u6mSwAAAAA3KhcDkkVKlTIizoAAAAAoEBwOSR9/vnn2U7v1avXdRcDAAAAAJ7m8jVJISEhTs+vXLmiixcvysfHR8WKFdPZs2fdWmBucU0SAAAAACmP7pMkSfHx8U6PpKQk7d27Vy1atNCXX36Zq6IBAAAAwNNcDkmZqVq1qt588009//zz7lgcAAAAAHiMW0KSJHl7e+vYsWPuWhwAAAAAeITLAzcsXLjQ6bkxRsePH9dHH32k5s2bu60wAAAAAPAEl0NS586dnZ7bbDaFhoaqTZs2evfdd91VV6befPNNDR06VM8//7wmTpyYp+sCgHwTHy/FxUkJCVJwsBQWJv1tkBwAAJB/XA5JqampeVHHNW3atEmffPKJ6tat65H1A0CeiI2V+vWTYmL+1xYdLU2bJkVEeK4uAABuYrm6JskYIxdHEL8uSUlJ6tmzp6ZOnZphCHIAKLTi4zMGJCnteb9+adMBAEC+u66Q9Pnnn6tOnTry9/eXv7+/6tatqy+++MLdtTn0799fHTt2VFRU1DXnTU5OVmJiotMDAAqkuLiMASldTEzadAAAkO9cPt1uwoQJGj58uJ599lnHQA1r167VU089pdOnT+vFF190a4Fz5szRli1btGnTphzNP27cOI0ePdqtNQBAnkhIyN10AACQJ2zGxfPlIiMjNXr0aPXq1cupfebMmRo1apQOHTrktuJiY2PVsGFDLV261HEt0p133qnbbrsty4EbkpOTlZyc7HiemJioiIiIa95VFwDy3Z49Uo0aWU/fvVuqXj3/6gEA4AaXmJgou91+zWzg8pGk48ePq1mzZhnamzVrpuPHj7u6uGz9+uuvOnnypOrXr+9oS0lJ0erVq/XRRx8pOTlZXl5eTq/x9fWVr6+vW+sAgDwRHp42SENmp9xFR6dNBwAA+c7la5KqVKmir776KkP73LlzVbVqVbcUla5t27basWOHtm3b5ng0bNhQPXv21LZt2zIEJAAoVEJC0kaxi452bk8f3Y6BagAA8AiXjySNHj1aDz/8sFavXu24JmndunVatmxZpuEpN4oXL67atWs7tQUEBKhkyZIZ2gGgUIqIkObM+d99kuz2tCNIBCQAADzG5ZD04IMPauPGjXrvvfe0YMECSVKNGjX0yy+/6Pbbb3d3fQBw4wsJIRQBAFCAuDxwQ2GT04uzAAAAANzY3D5wQ07vN0QQAQAAAFCY5TgkBQcHy2azZTndGCObzaaUlBS3FAYAAAAAnpDjkLRixQrHz8YY3XPPPZo2bZrKlSuXJ4UBAAAAgCfkOCS1bt3a6bmXl5eaNGmiSpUqub0oAAAAAPAUl++TBAAAAAA3MkISAAAAAFjkKiRlN5ADAAAAABRGOb4mqUuXLk7PL126pKeeekoBAQFO7d9++617KgMAAAAAD8hxSLLb7U7P//GPf7i9GAAAAADwtByHpOnTp+dlHQAAAABQIDBwAwAAAABYEJIAAAAAwIKQBAAAAAAWhCQAAAAAsCAkAQAAAIAFIQkAAAAALAhJAAAAAGBBSAIAAAAAC0ISAAAAAFgQkgAAAADAgpAEAAAAABaEJAAAAACwICQBAAAAgAUhCQAAAAAsCEkAAAAAYEFIAgAAAAALQhIAAAAAWBCSAAAAAMCCkAQAAAAAFoQkAAAAALAgJAEAAACABSEJAAAAACwISQAAAABgQUgCAAAAAAtCEgAAAABYEJIAAAAAwIKQBAAAAAAWhCQAAAAAsCAkAQAAAIAFIQkAAAAALAhJAAAAAGBBSAIAAAAAC0ISAAAAAFgQkgAAAADAgpAEAAAAABbeni4AAIBCIT5eiouTEhKk4GApLEwKCfF0VfAU9gfghsaRJAAAriU2VureXapRQ2rSRKpePe15bKynK4MnsD8ANzxCEgAA2YmPl/r1k2JinNtjYtLa4+M9Uxc8g/0BuCkQkgAAyE5cXMYvxOliYtKm4+bB/gDcFAhJAABkJyEhd9NxY2F/AG4KhCQAALJjt+duOm4s7A/ATYGQBABAdsLDpejozKdFR6dNx82D/QG4KRCSAADITkiING1axi/G0dFp7Qz7fHNhfwBuCjZjjPF0EXkpMTFRdrtdCQkJCgoK8nQ5AIDCynpfHLs97YgBX4hvXuwPQKGU02zAzWQBAMiJkBC+BON/2B+AGxqn2wEAAACABSEJAAAAACwISQAAAABgQUgCAAAAAAtCEgAAAABYEJIAAAAAwIKQBAAAAAAWhCQAAAAAsCAkAQAAAIAFIQkAAAAALAhJAAAAAGBBSAIAAAAAC0ISAAAAAFgQkgAAAADAgpAEAAAAABaEJAAAAACwICQBAAAAgAUhCQAAAAAsCEkAAAAAYEFIAgAAAAALQhIAAAAAWBCSAAAAAMCCkAQAAAAAFoQkAAAAALAgJAEAAACABSEJAAAAACwISQAAAABgQUgCAAAAAAtCEgAAAABYEJIAAAAAwIKQBAAAAAAWhCQAAAAAsCAkAQAAAIAFIQkAAAAALAhJAAAAAGBBSAIAAAAAC0ISAAAAAFgQkgAAAADAgpAEAAAAABaEJAAAAACwICQBAAAAgAUhCQAAAAAsCEkAAAAAYEFIAgAAAAALQhIAAAAAWBCSAAAAAMCiQIekcePG6Y477lDx4sUVFhamzp07a+/evZ4uCwBubvHx0p490saN0t69ac+Rc/QfULDwnkQmCnRIWrVqlfr3768NGzZo6dKlunLliqKjo3XhwgVPlwYAN6fYWKl7d6lGDalJE6l69bTnsbGerqxwoP+AgoX3JLJgM8YYTxeRU6dOnVJYWJhWrVqlVq1a5eg1iYmJstvtSkhIUFBQUB5XCAA3sPj4tC8PMTEZp0VHS3PmSCEh+V9XYUH/AQUL78mbUk6zgXc+1pRrCQkJkqQSJUpkOU9ycrKSk5MdzxMTE/O8LgC4KcTFZf5lQkprj4vjC0V26D+gYOE9iWwU6NPtrFJTU/XCCy+oefPmql27dpbzjRs3Tna73fGIiIjIxyoB4Ab2//9Rdd3Tb3b0H1Cw8J5ENgpNSOrfv7927typOXPmZDvf0KFDlZCQ4HjEck4pALiH3Z676Tc7+g8oWHhPIhuFIiQ9++yz+uGHH7RixQrdcsst2c7r6+uroKAgpwcAwA3Cw9PO089MdHTadGSN/gMKFt6TyEaBDknGGD377LOaP3++li9frsjISE+XBAA3r5AQadq0jF8qoqPT2jl3P3v0H1Cw8J5ENgr06HbPPPOMZs+ere+++07VqlVztNvtdvn7++doGYxuBwBuFh+fdkFzQkLa6Sjh4XyZcAX9BxQsvCdvKjnNBgU6JNlstkzbp0+frj59+uRoGYQkAAAAANINMgR4Ac5vAAAAAG5QBfqaJAAAAADIb4QkAAAAALAgJAEAAACABSEJAAAAACwISQAAAABgQUgCAAAAAAtCEgAAAABYEJIAAAAAwIKQBAAAAAAWhCQAAAAAsCAkAQAAAIAFIQkAAAAALAhJAAAAAGBBSAIAAAAAC0ISAAAAAFgQkgAAAADAgpAEAAAAABaEJAAAAACwICQBAAAAgAUhCQAAAAAsCEkAAAAAYEFIAgAAAAALQhIAAAAAWBCSAAAAAMCCkAQAAAAAFoQkAAAAALAgJAEAAACABSEJAAAAACwISQAAAABgQUgCAAAAAAtCEgAAAABYEJIAAAAAwIKQBAAAAAAWhCQAAAAAsCAkAQAAAIAFIQkAAAAALAhJAAAAAGBBSAIAAAAAC0ISAAAAAFgQkgAAAADAgpAEAAAAABaEJAAAAACwICQBAAAAgAUhCQAAAAAsCEkAAAAAYOHt6QIAAACQjfh4KS5OSkiQgoOlsDApJMTTVWWtsNULZIIjSQAAAAVVbKzUvbtUo4bUpIlUvXra89hYT1eWucJWL5AFQhIAAEBBFB8v9esnxcQ4t8fEpLXHx3umrqwUtnqBbBCSAAAACqK4uIyBI11MTNr0gqSw1Qtkg5AEAABQECUk5G56fits9QLZICQBAAAURHZ77qbnt8JWL5ANQhIAAEBBFB4uRUdnPi06Om16QVLY6gWyQUgCAAAoiEJCpGnTMgaP6Oi09oI2rHZhqxfIhs0YYzxdRF5KTEyU3W5XQkKCgoKCPF0OAACAa6z3HbLb047IFOTAUdjqxU0lp9mAm8kCAAAUZCEhhStkFLZ6gUxwuh0AAAAAWBCSAAAAAMCCkAQAAAAAFoQkAAAAALAgJAEAAACABSEJAAAAACwISQAAAABgQUgCAAAAAAtCEgAAAABYEJIAAAAAwIKQBAAAAAAWhCQAAAAAsCAkAQAAAIAFIQkAAAAALAhJAAAAAGBBSAIAAAAAC0ISAAAAAFgQkgAAAADAgpAEAAAAABaEJAAAAACwICQBAAAAgAUhCQAAAAAsCEkAAAAAYEFIAgAAAAALQhIAAAAAWBCSAAAAAMCCkAQAAAAAFoQkAAAAALAgJAEAAACABSEJAAAAACwISQAAAABgQUgCAAAAAAtCEgAAAABYEJIAAAAAwIKQBAAAAAAWhCQAAAAAsCAkAQAAAIAFIQkAAAAALAhJAAAAAGBBSAIAAAAAC0ISAAAAAFgQkgAAAADAgpAEAAAAABaEJAAAAACwICQBAAAAgAUhCQAAAAAsCkVImjRpkipWrCg/Pz81btxYv/zyi6dLAgAAAHAt8fHSnj3Sxo3S3r1pzwuBAh+S5s6dq4EDB2rkyJHasmWL6tWrp3bt2unkyZOeLg0AAABAVmJjpe7dpRo1pCZNpOrV057Hxnq6smsq8CFpwoQJeuKJJ9S3b1/VrFlTU6ZMUbFixfTvf//b06UBAAAAyEx8vNSvnxQT49weE5PWXsCPKBXokHT58mX9+uuvioqKcrQVKVJEUVFRWr9+faavSU5OVmJiotMDAAAAQD6Ki8sYkNLFxKRNL8AKdEg6ffq0UlJSFB4e7tQeHh6uEydOZPqacePGyW63Ox4RERH5USoAAACAdAkJuZvuYQU6JF2PoUOHKiEhwfGILQTnPAIAAAA3FLs9d9M9zNvTBWSnVKlS8vLyUtzfDsfFxcWpdOnSmb7G19dXvr6++VEeAAAAgMyEh0vR0ZmfchcdnTa9ACvQR5J8fHzUoEEDLVu2zNGWmpqqZcuWqWnTph6sDAAAAECWQkKkadPSApFVdHRae0iIZ+rKoQJ9JEmSBg4cqN69e6thw4Zq1KiRJk6cqAsXLqhv376eLg0AAABAViIipDlz0gZpSEhIO8UuPLzABySpEISkhx9+WKdOndKIESN04sQJ3XbbbVq8eHGGwRwAAAAAFDAhIYUiFP2dzRhjPF1EXkpMTJTdbldCQoKCgoI8XQ4AAAAAD8lpNijQ1yQBAAAAQH4jJAEAAACABSEJAAAAACwISQAAAABgQUgCAAAAAAtCEgAAAABYEJIAAAAAwIKQBAAAAAAWhCQAAAAAsCAkAQAAAIAFIQkAAAAALAhJAAAAAGBBSAIAAAAAC0ISAAAAAFgQkgAAAADAgpAEAAAAABaEJAAAAACwICQBAAAAgAUhCQAAAAAsCEkAAAAAYOHt6QLymjFGkpSYmOjhSgAAAAB4UnomSM8IWbnhQ9L58+clSRERER6uBAAAAEBBcP78ednt9iyn28y1YlQhl5qaqmPHjql48eKy2WwerSUxMVERERGKjY1VUFCQR2u5EdG/eYv+zVv0b96if/MW/Zv36OO8Rf/mrYLUv8YYnT9/XmXLllWRIllfeXTDH0kqUqSIbrnlFk+X4SQoKMjjO8iNjP7NW/Rv3qJ/8xb9m7fo37xHH+ct+jdvFZT+ze4IUjoGbgAAAAAAC0ISAAAAAFgQkvKRr6+vRo4cKV9fX0+XckOif/MW/Zu36N+8Rf/mLfo379HHeYv+zVuFsX9v+IEbAAAAAMAVHEkCAAAAAAtCEgAAAABYEJIAAAAAwIKQBAAAAAAWhCQ3GzdunO644w4VL15cYWFh6ty5s/bu3es0z6VLl9S/f3+VLFlSgYGBevDBBxUXF+ehigufyZMnq27duo4bkjVt2lSLFi1yTKd/3efNN9+UzWbTCy+84Gijf3Nn1KhRstlsTo/q1as7ptO/uXf06FH94x//UMmSJeXv7686depo8+bNjunGGI0YMUJlypSRv7+/oqKitH//fg9WXHhUrFgxw/5rs9nUv39/Sey/uZWSkqLhw4crMjJS/v7+qly5sl5//XVZx9hi/82d8+fP64UXXlCFChXk7++vZs2aadOmTY7p9G/OrV69Wvfdd5/Kli0rm82mBQsWOE3PSV+ePXtWPXv2VFBQkIKDg/X4448rKSkpH7cia4QkN1u1apX69++vDRs2aOnSpbpy5Yqio6N14cIFxzwvvviivv/+e3399ddatWqVjh07pi5duniw6sLllltu0Ztvvqlff/1VmzdvVps2bdSpUyft2rVLEv3rLps2bdInn3yiunXrOrXTv7lXq1YtHT9+3PFYu3atYxr9mzvx8fFq3ry5ihYtqkWLFun333/Xu+++q5CQEMc8b731lj744ANNmTJFGzduVEBAgNq1a6dLly55sPLCYdOmTU777tKlSyVJXbt2lcT+m1vjx4/X5MmT9dFHH2n37t0aP3683nrrLX344YeOedh/c6dfv35aunSpvvjiC+3YsUPR0dGKiorS0aNHJdG/rrhw4YLq1aunSZMmZTo9J33Zs2dP7dq1S0uXLtUPP/yg1atX65///Gd+bUL2DPLUyZMnjSSzatUqY4wx586dM0WLFjVff/21Y57du3cbSWb9+vWeKrPQCwkJMdOmTaN/3eT8+fOmatWqZunSpaZ169bm+eefN8aw/7rDyJEjTb169TKdRv/m3uDBg02LFi2ynJ6ammpKly5t3n77bUfbuXPnjK+vr/nyyy/zo8QbyvPPP28qV65sUlNT2X/doGPHjuaxxx5zauvSpYvp2bOnMYb9N7cuXrxovLy8zA8//ODUXr9+fTNs2DD6Nxckmfnz5zue56Qvf//9dyPJbNq0yTHPokWLjM1mM0ePHs232rPCkaQ8lpCQIEkqUaKEJOnXX3/VlStXFBUV5ZinevXqKl++vNavX++RGguzlJQUzZkzRxcuXFDTpk3pXzfp37+/Onbs6NSPEvuvu+zfv19ly5ZVpUqV1LNnTx05ckQS/esOCxcuVMOGDdW1a1eFhYXp9ttv19SpUx3TDx06pBMnTjj1sd1uV+PGjeljF12+fFn/+c9/9Nhjj8lms7H/ukGzZs20bNky7du3T5K0fft2rV27Vh06dJDE/ptbV69eVUpKivz8/Jza/f39tXbtWvrXjXLSl+vXr1dwcLAaNmzomCcqKkpFihTRxo0b873mv/P2dAE3stTUVL3wwgtq3ry5ateuLUk6ceKEfHx8FBwc7DRveHi4Tpw44YEqC6cdO3aoadOmunTpkgIDAzV//nzVrFlT27Zto39zac6cOdqyZYvTOdrp2H9zr3HjxpoxY4aqVaum48ePa/To0WrZsqV27txJ/7rBH3/8ocmTJ2vgwIH617/+pU2bNmnAgAHy8fFR7969Hf0YHh7u9Dr62HULFizQuXPn1KdPH0n8fXCHIUOGKDExUdWrV5eXl5dSUlI0ZswY9ezZU5LYf3OpePHiatq0qV5//XXVqFFD4eHh+vLLL7V+/XpVqVKF/nWjnPTliRMnFBYW5jTd29tbJUqUKBD9TUjKQ/3799fOnTudrjeAe1SrVk3btm1TQkKC5s2bp969e2vVqlWeLqvQi42N1fPPP6+lS5dm+E8b3CP9P8KSVLduXTVu3FgVKlTQV199JX9/fw9WdmNITU1Vw4YNNXbsWEnS7bffrp07d2rKlCnq3bu3h6u7sXz22Wfq0KGDypYt6+lSbhhfffWVZs2apdmzZ6tWrVratm2bXnjhBZUtW5b9102++OILPfbYYypXrpy8vLxUv3599ejRQ7/++qunS0MBw+l2eeTZZ5/VDz/8oBUrVuiWW25xtJcuXVqXL1/WuXPnnOaPi4tT6dKl87nKwsvHx0dVqlRRgwYNNG7cONWrV0/vv/8+/ZtLv/76q06ePKn69evL29tb3t7eWrVqlT744AN5e3srPDyc/nWz4OBg3XrrrTpw4AD7rxuUKVNGNWvWdGqrUaOG45TG9H78+4hr9LFr/vzzT/3000/q16+fo439N/cGDRqkIUOGqHv37qpTp44effRRvfjiixo3bpwk9l93qFy5slatWqWkpCTFxsbql19+0ZUrV1SpUiX6141y0pelS5fWyZMnnaZfvXpVZ8+eLRD9TUhyM2OMnn32Wc2fP1/Lly9XZGSk0/QGDRqoaNGiWrZsmaNt7969OnLkiJo2bZrf5d4wUlNTlZycTP/mUtu2bbVjxw5t27bN8WjYsKF69uzp+Jn+da+kpCQdPHhQZcqUYf91g+bNm2e47cK+fftUoUIFSVJkZKRKly7t1MeJiYnauHEjfeyC6dOnKywsTB07dnS0sf/m3sWLF1WkiPNXMy8vL6Wmpkpi/3WngIAAlSlTRvHx8VqyZIk6depE/7pRTvqyadOmOnfunNNRvOXLlys1NVWNGzfO95oz8PTIETeap59+2tjtdrNy5Upz/Phxx+PixYuOeZ566ilTvnx5s3z5crN582bTtGlT07RpUw9WXbgMGTLErFq1yhw6dMj89ttvZsiQIcZms5mYmBhjDP3rbtbR7Yyhf3PrpZdeMitXrjSHDh0y69atM1FRUaZUqVLm5MmTxhj6N7d++eUX4+3tbcaMGWP2799vZs2aZYoVK2b+85//OOZ58803TXBwsPnuu+/Mb7/9Zjp16mQiIyPNX3/95cHKC4+UlBRTvnx5M3jw4AzT2H9zp3fv3qZcuXLmhx9+MIcOHTLffvutKVWqlHnllVcc87D/5s7ixYvNokWLzB9//GFiYmJMvXr1TOPGjc3ly5eNMfSvK86fP2+2bt1qtm7daiSZCRMmmK1bt5o///zTGJOzvmzfvr25/fbbzcaNG83atWtN1apVTY8ePTy1SU4ISW4mKdPH9OnTHfP89ddf5plnnjEhISGmWLFi5oEHHjDHjx/3XNGFzGOPPWYqVKhgfHx8TGhoqGnbtq0jIBlD/7rb30MS/Zs7Dz/8sClTpozx8fEx5cqVMw8//LA5cOCAYzr9m3vff/+9qV27tvH19TXVq1c3n376qdP01NRUM3z4cBMeHm58fX1N27Ztzd69ez1UbeGzZMkSIynTPmP/zZ3ExETz/PPPm/Llyxs/Pz9TqVIlM2zYMJOcnOyYh/03d+bOnWsqVapkfHx8TOnSpU3//v3NuXPnHNPp35xbsWJFpt95e/fubYzJWV+eOXPG9OjRwwQGBpqgoCDTt29fc/78eQ9sTUY2Yyy3cQYAAACAmxzXJAEAAACABSEJAAAAACwISQAAAABgQUgCAAAAAAtCEgAAAABYEJIAAAAAwIKQBAAAAAAWhCQAAAAAsCAkAQAKjFGjRum2227L0BYeHi6bzaYFCxZ4pC4AwM2FkAQAcItTp07p6aefVvny5eXr66vSpUurXbt2Wrdu3XUvc/fu3Ro9erQ++eQTHT9+XB06dHBjxWn69Omjzp07u325AIDCy9vTBQAAbgwPPvigLl++rJkzZ6pSpUqKi4vTsmXLdObMmete5sGDByVJnTp1ks1mc1epAABkiyNJAIBcO3funNasWaPx48frrrvuUoUKFdSoUSMNHTpU999/v9N8/fr1U2hoqIKCgtSmTRtt374902WOGjVK9913nySpSJEi2YaknTt3qkOHDgoMDFR4eLgeffRRnT592jF93rx5qlOnjvz9/VWyZElFRUXpwoULGjVqlGbOnKnvvvtONptNNptNK1eulCTFxsaqW7duCg4OVokSJdSpUycdPnzYab3Tpk1TjRo15Ofnp+rVq+vjjz92TDt8+LBsNpu++uortWzZUv7+/rrjjju0b98+bdq0SQ0bNlRgYKA6dOigU6dOudrlAIA8REgCAORaYGCgAgMDtWDBAiUnJ2c5X9euXXXy5EktWrRIv/76q+rXr6+2bdvq7NmzGeZ9+eWXNX36dEnS8ePHdfz48UyXee7cObVp00a33367Nm/erMWLFysuLk7dunVzvLZHjx567LHHtHv3bq1cuVJdunSRMUYvv/yyunXrpvbt2zvW0axZM125ckXt2rVT8eLFtWbNGq1bt06BgYFq3769Ll++LEmaNWuWRowYoTFjxmj37t0aO3ashg8frpkzZzrVN3LkSL366qvasmWLvL299cgjj+iVV17R+++/rzVr1ujAgQMaMWLEdfU7ACCPGAAA3GDevHkmJCTE+Pn5mWbNmpmhQ4ea7du3O6avWbPGBAUFmUuXLjm9rnLlyuaTTz4xxhgzcuRIU69ePce0+fPnm2t9VL3++usmOjraqS02NtZIMnv37jW//vqrkWQOHz6c6et79+5tOnXq5NT2xRdfmGrVqpnU1FRHW3JysvH39zdLlixx1D179uwMtTRt2tQYY8yhQ4eMJDNt2jTH9C+//NJIMsuWLXO0jRs3zlSrVi3bbQQA5C+OJAEA3OLBBx/UsWPHtHDhQrVv314rV65U/fr1NWPGDEnS9u3blZSUpJIlSzqOPAUGBurQoUOOa4+ux/bt27VixQqnZVavXl1S2jVN9erVU9u2bVWnTh117dpVU6dOVXx8/DWXeeDAARUvXtyxzBIlSujSpUs6ePCgLly4oIMHD+rxxx93Wu8bb7yRYVvq1q3r+Dk8PFySVKdOHae2kydPXvf2AwDcj4EbAABu4+fnp7vvvlt33323hg8frn79+mnkyJHq06ePkpKSVKZMGcc1P1bBwcHXvc6kpCTdd999Gj9+fIZpZcqUkZeXl5YuXaqff/5ZMTEx+vDDDzVs2DBt3LhRkZGRWS6zQYMGmjVrVoZpoaGhSkpKkiRNnTpVjRs3dpru5eXl9Lxo0aKOn9Ovq/p7W2pqag63FgCQHwhJAIA8U7NmTce9jerXr68TJ07I29tbFStWdNs66tevr2+++UYVK1aUt3fmH2s2m03NmzdX8+bNNWLECFWoUEHz58/XwIED5ePjo5SUlAzLnDt3rsLCwhQUFJRheXa7XWXLltUff/yhnj17um1bAAAFA6fbAQBy7cyZM2rTpo3+85//6LffftOhQ4f09ddf66233lKnTp0kSVFRUWratKk6d+6smJgYHT58WD///LOGDRumzZs3X/e6+/fvr7Nnz6pHjx7atGmTDh48qCVLlqhv375KSUnRxo0bNXbsWG3evFlHjhzRt99+q1OnTqlGjRqSpIoVK+q3337T3r17dfr0aV25ckU9e/ZUqVKl1KlTJ61Zs0aHDh3SypUrNWDAAP33v/+VJI0ePVrjxo3TBx98oH379mnHjh2aPn26JkyYkPsOBQB4FEeSAAC5FhgYqMaNG+u9997TwYMHdeXKFUVEROiJJ57Qv/71L0lpR3N+/PFHDRs2TH379tWpU6dUunRptWrVynGtzvUoW7as1q1bp8GDBys6OlrJycmqUKGC2rdvryJFiigoKEirV6/WxIkTlZiYqAoVKujdd9913Jj2iSee0MqVK9WwYUMlJSVpxYoVuvPOO7V69WoNHjxYXbp00fnz51WuXDm1bdvWcWSpX79+KlasmN5++20NGjRIAQEBqlOnjl544YVc9ycAwLNsxhjj6SIAAAAAoKDgdDsAAAAAsCAkAQAAAIAFIQkAAAAALAhJAAAAAGBBSAIAAAAAC0ISAAAAAFgQkgAAAADAgpAEAAAAABaEJAAAAACwICQBAAAAgAUhCQAAAAAs/h8VxLHJctPClgAAAABJRU5ErkJggg==\n"
+          },
+          "metadata": {}
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "import pandas as pd\n",
+        "import numpy as np\n",
+        "import matplotlib.pyplot as plt\n",
+        "import seaborn as sns\n",
+        "from sklearn.linear_model import LinearRegression\n",
+        "\n",
+        "TV = [42, 34, 25, 35, 37, 38, 31, 33, 19, 29, 38, 28, 29, 36, 18]\n",
+        "overweight = [18, 6, 0, -1, 13, 14, 7, 7, -9, 8, 8, 5, 3, 14, -7]\n",
+        "\n",
+        "data = pd.DataFrame({'TV': TV, 'overweight': overweight})\n",
+        "\n",
+        "# Reshape TV to a 2D array\n",
+        "X = np.array(TV).reshape(-1, 1)\n",
+        "\n",
+        "model = LinearRegression()\n",
+        "model.fit(X, overweight)\n",
+        "\n",
+        "predictions = model.predict(X)\n",
+        "\n",
+        "# Visualize the regression line\n",
+        "plt.figure(figsize=(10, 6))\n",
+        "sns.scatterplot(x='TV', y='overweight', data=data, color=\"green\")\n",
+        "plt.plot(TV, predictions, color=\"red\", linewidth=2)\n",
+        "plt.title(\"Simple Linear Regression: TV with Overweight\")\n",
+        "plt.xlabel(\"TV\")\n",
+        "plt.ylabel(\"Overweight\")\n",
+        "plt.show()\n",
+        "\n",
+        "# Print the regression equation coefficients\n",
+        "print(f'Intercept: {model.intercept_}')\n",
+        "print(f'Coefficient: {model.coef_[0]}')"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 465
+        },
+        "id": "ft_znbdiL1Gq",
+        "outputId": "318c8185-ba07-47ed-b061-74555fa7b166"
+      },
+      "execution_count": 5,
+      "outputs": [
+        {
+          "output_type": "display_data",
+          "data": {
+            "text/plain": [
+              "<Figure size 1000x600 with 1 Axes>"
+            ],
+            "image/png": "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\n"
+          },
+          "metadata": {}
+        },
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Intercept: -24.709011512504958\n",
+            "Coefficient: 0.9674473997618102\n"
+          ]
+        }
+      ]
+    }
+  ]
+}
\ No newline at end of file
diff --git a/cs1.ipynb b/cs1.ipynb
new file mode 100644
index 0000000..66eb8a9
--- /dev/null
+++ b/cs1.ipynb
@@ -0,0 +1,101 @@
+{
+  "nbformat": 4,
+  "nbformat_minor": 0,
+  "metadata": {
+    "colab": {
+      "provenance": [],
+      "authorship_tag": "ABX9TyPdZYa1OM2RThLv8+SJH7It",
+      "include_colab_link": true
+    },
+    "kernelspec": {
+      "name": "python3",
+      "display_name": "Python 3"
+    },
+    "language_info": {
+      "name": "python"
+    }
+  },
+  "cells": [
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "view-in-github",
+        "colab_type": "text"
+      },
+      "source": [
+        "<a href=\"https://colab.research.google.com/github/harshita91/DSA-algorithm/blob/main/cs1.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 1,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 1000
+        },
+        "id": "7c4O6X3hHLmn",
+        "outputId": "6d608563-58de-4cf2-a09c-c6f709a22921"
+      },
+      "outputs": [
+        {
+          "output_type": "display_data",
+          "data": {
+            "text/plain": [
+              "<Figure size 1170.62x1000 with 20 Axes>"
+            ],
+            "image/png": "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\n"
+          },
+          "metadata": {}
+        },
+        {
+          "output_type": "display_data",
+          "data": {
+            "text/plain": [
+              "<Figure size 640x480 with 2 Axes>"
+            ],
+            "image/png": "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\n"
+          },
+          "metadata": {}
+        }
+      ],
+      "source": [
+        "import numpy as np\n",
+        "import pandas as pd\n",
+        "import matplotlib.pyplot as plt\n",
+        "import seaborn as sns\n",
+        "\n",
+        "potatoes = [0, 2, 9, 2]\n",
+        "vegetables = [4, 3, 4, 1]\n",
+        "meat = [0, 2, 10, 1]\n",
+        "icecream = [0, 8, 4, 0]\n",
+        "labels = ['disagree', 'neutral', 'agree', 'strongly disagree']\n",
+        "\n",
+        "data = pd.DataFrame({'x': potatoes, 'y': vegetables, 'z': meat, 'w': icecream, 'l': labels})\n",
+        "\n",
+        "mean_x = data['x'].mean()\n",
+        "mean_y = data['y'].mean()\n",
+        "mean_z = data['z'].mean()\n",
+        "mean_w = data['w'].mean()\n",
+        "\n",
+        "std_dev_x = data['x'].std()\n",
+        "std_dev_y = data['y'].std()\n",
+        "std_dev_z = data['z'].std()\n",
+        "std_dev_w = data['w'].std()\n",
+        "\n",
+        "# For correlation matrix\n",
+        "correlation_matrix = data[['x', 'y', 'z', 'w']].corr()\n",
+        "\n",
+        "# For Pairplot\n",
+        "sns.pairplot(data, hue='l')\n",
+        "plt.suptitle(\"Scatter Plot Matrix\")\n",
+        "plt.show()\n",
+        "\n",
+        "# For heatmap of the correlation matrix\n",
+        "sns.heatmap(correlation_matrix, annot=True, cmap='coolwarm', fmt='.2f')\n",
+        "plt.title(\"Correlation matrix\")\n",
+        "plt.show()\n"
+      ]
+    }
+  ]
+}
\ No newline at end of file