diff --git a/Algorithm/all_possible_permutation b/Algorithm/all_possible_permutation
new file mode 100755
index 0000000..00ebfba
Binary files /dev/null and b/Algorithm/all_possible_permutation differ
diff --git a/Algorithm/all_possible_permutation.cpp b/Algorithm/all_possible_permutation.cpp
new file mode 100644
index 0000000..7de90bb
--- /dev/null
+++ b/Algorithm/all_possible_permutation.cpp
@@ -0,0 +1,11 @@
+#include <bits/stdc++.h>
+
+using namespace std;
+
+int main(){
+	char ex[]="abc";
+	do{
+
+		cout<<ex<<endl;
+	}while(next_permutation(ex,ex+3));
+}
diff --git a/Algorithm/combination_taking_r_at_a_time b/Algorithm/combination_taking_r_at_a_time
new file mode 100755
index 0000000..afbb70e
Binary files /dev/null and b/Algorithm/combination_taking_r_at_a_time differ
diff --git a/Algorithm/combination_taking_r_at_a_time.cpp b/Algorithm/combination_taking_r_at_a_time.cpp
new file mode 100644
index 0000000..e3038f3
--- /dev/null
+++ b/Algorithm/combination_taking_r_at_a_time.cpp
@@ -0,0 +1,26 @@
+#include <iostream>
+#include <algorithm>
+#include <vector>
+
+
+using namespace std;
+int main() {
+   int n, r;
+   std::cin >> n;
+   std::cin >> r;
+   string ex="abcd";
+   std::vector<bool> v(n);
+   std::fill(v.begin(), v.begin() + r, true);
+
+   do {
+       for (int i = 0; i < n; ++i) {
+           if (v[i]) {
+                cout<<ex[i];
+               //std::cout << (i + 1) << " ";
+           }
+       }
+       cout<<endl;
+       std::cout << "\n";
+   } while (std::prev_permutation(v.begin(), v.end()));
+   return 0;
+}
diff --git a/Algorithm/geek_permutation b/Algorithm/geek_permutation
new file mode 100755
index 0000000..b7c4a0b
Binary files /dev/null and b/Algorithm/geek_permutation differ
diff --git a/Algorithm/geek_permutation.cpp b/Algorithm/geek_permutation.cpp
new file mode 100644
index 0000000..63bf9b8
--- /dev/null
+++ b/Algorithm/geek_permutation.cpp
@@ -0,0 +1,42 @@
+// C program to print all permutations with duplicates allowed
+#include <stdio.h>
+#include <string.h>
+ 
+/* Function to swap values at two pointers */
+void swap(char *x, char *y)
+{
+    char temp;
+    temp = *x;
+    *x = *y;
+    *y = temp;
+}
+ 
+/* Function to print permutations of string
+   This function takes three parameters:
+   1. String
+   2. Starting index of the string
+   3. Ending index of the string. */
+void permute(char *a, int l, int r)
+{
+   int i;
+   if (l == r)
+     printf("%s\n", a);
+   else
+   {
+       for (i = l; i <= r; i++)
+       {
+          swap((a+l), (a+i));
+          permute(a, l+1, r);
+          swap((a+l), (a+i)); //backtrack
+       }
+   }
+}
+ 
+/* Driver program to test above functions */
+int main()
+{
+    char str[] = "ABC";
+    int n = strlen(str);
+    permute(str, 0, n-1);
+    return 0;
+}
\ No newline at end of file
diff --git a/My-Solved-Problem/Topcoder/SRM647/PeacefulLine.cpp b/My-Solved-Problem/Topcoder/SRM647/PeacefulLine.cpp
new file mode 100644
index 0000000..19442d5
--- /dev/null
+++ b/My-Solved-Problem/Topcoder/SRM647/PeacefulLine.cpp
@@ -0,0 +1,32 @@
+#include <bits/stdc++.h>
+using namespace std;
+
+class PeacefulLine{
+    public:
+	string makeLine(vector <int> x){
+        int m=-1,ex[26]={};
+        for(int i=0;i<x.size();i++){
+            ex[x[i]]++;
+        }
+        for(int i=0;i<26;i++){
+            if(ex[i]>m)
+                m=ex[i];
+        }
+        int r= x.size()-m*2 ;
+        if(r >= -1)
+            return "possible";
+        else
+            return "impossible";
+        
+    }
+};
+
+    int main(){
+
+        vector <int> x = {
+            1,2,3,4
+        };
+
+        PeacefulLine t;
+       cout<< t.makeLine(x)<<endl;
+    }
diff --git a/My-Solved-Problem/Topcoder/SRM647/PeacefulLine.out b/My-Solved-Problem/Topcoder/SRM647/PeacefulLine.out
new file mode 100755
index 0000000..e617af0
Binary files /dev/null and b/My-Solved-Problem/Topcoder/SRM647/PeacefulLine.out differ
diff --git a/My-Solved-Problem/Topcoder/SRM647/input b/My-Solved-Problem/Topcoder/SRM647/input
new file mode 100644
index 0000000..e69de29
diff --git a/My-Solved-Problem/Topcoder/SRM650/d2_250_TaroJiroDividing.cpp b/My-Solved-Problem/Topcoder/SRM650/d2_250_TaroJiroDividing.cpp
index 18b6626..13d6c90 100755
--- a/My-Solved-Problem/Topcoder/SRM650/d2_250_TaroJiroDividing.cpp
+++ b/My-Solved-Problem/Topcoder/SRM650/d2_250_TaroJiroDividing.cpp
@@ -5,20 +5,31 @@ using namespace std;
 
 class TaroJiroDividing{
  	public:	
-	int gcd(int x,int y);
  	int getNumber(int a,int b);	   
 };
 
-int TaroJiroDividing::gcd(int x,int y){
-	return 5;
-}
 
 int TaroJiroDividing::getNumber(int a, int b){
-	return gcd(3,4);
+
+        if(a>b){
+            int t=b;
+            b=a;
+            a=t;
+        }
+	int l=log2(b/a);
+        cout<<"l :"<<l<<endl;
+        if(pow(2,l)*a==b){
+            int c=0;
+            while(!(1<<c & a)){
+                c++;
+            }
+            return ++c;
+        }
 }
 
 int main(){
 	TaroJiroDividing t;
 	int a,b;
-	cout<<t.getNumber(a,b);
-}
\ No newline at end of file
+        while(cin>>a>>b)
+        	cout<<t.getNumber(a,b)<<endl;
+}
diff --git a/My-Solved-Problem/Topcoder/SRM650/d2_250_TaroJiroDividing.out b/My-Solved-Problem/Topcoder/SRM650/d2_250_TaroJiroDividing.out
new file mode 100755
index 0000000..0274994
Binary files /dev/null and b/My-Solved-Problem/Topcoder/SRM650/d2_250_TaroJiroDividing.out differ
diff --git a/My-Solved-Problem/Topcoder/SRM650/input b/My-Solved-Problem/Topcoder/SRM650/input
new file mode 100644
index 0000000..cd14a47
--- /dev/null
+++ b/My-Solved-Problem/Topcoder/SRM650/input
@@ -0,0 +1,6 @@
+8 4
+4 7
+12 12
+24 96
+1000000000
+999999999
diff --git a/SRC/1's_Cluster.exe b/SRC/1's_Cluster.exe
new file mode 100755
index 0000000..1bba09a
Binary files /dev/null and b/SRC/1's_Cluster.exe differ
diff --git a/SRC/1's_Cluster.o b/SRC/1's_Cluster.o
new file mode 100755
index 0000000..a6658ca
Binary files /dev/null and b/SRC/1's_Cluster.o differ
diff --git a/SRC/Basic_string b/SRC/Basic_string
new file mode 100755
index 0000000..64e572c
Binary files /dev/null and b/SRC/Basic_string differ
diff --git a/SRC/Basic_string.cpp b/SRC/Basic_string.cpp
new file mode 100755
index 0000000..3298461
--- /dev/null
+++ b/SRC/Basic_string.cpp
@@ -0,0 +1,21 @@
+#include <bits/stdc++.h>
+using namespace std;
+
+int main() {
+  string s(10u, ' ');           // Create a string of ten blanks.
+
+  const char* A = "this is a test";
+  s += A;
+  cout<<s<<endl;
+  cout << "s = " << (s + '\n');
+  cout << "As a null-terminated sequence: " << s.c_str() << endl;
+  cout << "The sixteenth character is " << s[15] << endl;
+
+  reverse(s.begin(), s.end());
+  s.push_back('\n');
+  string name="Ashik ";
+  name.pop_back();
+  name.pop_back();
+  cout<<"|"<<name<<"|"<<endl;
+  cout << s;
+}
diff --git a/SRC/Basic_string.exe b/SRC/Basic_string.exe
new file mode 100755
index 0000000..ec14dd9
Binary files /dev/null and b/SRC/Basic_string.exe differ
diff --git a/SRC/Basic_string.o b/SRC/Basic_string.o
new file mode 100755
index 0000000..d558cfa
Binary files /dev/null and b/SRC/Basic_string.o differ
diff --git a/SRC/Binary_search_tree.cpp b/SRC/Binary_search_tree.cpp
new file mode 100755
index 0000000..27bc58d
--- /dev/null
+++ b/SRC/Binary_search_tree.cpp
@@ -0,0 +1,184 @@
+#include <iostream>
+#include <vector>
+
+using namespace std;
+
+template<class T>
+struct Node{
+	T value;
+	Node<T>* left;
+	Node<T>* right;
+
+	Node(T _value){
+		value = _value;
+		left = NULL;
+		right = NULL;
+	}
+};
+
+template<class T>
+class BST{
+	private:
+		Node<T>* root;
+	public:
+		BST(){
+			root = NULL;
+		}
+
+		void insertHelper(Node<T>* &current, T value){
+			if(current==NULL){ // We have reached bottom of the tree
+				// Base case
+				current = new Node<T>(value);
+			}else{
+				if(value<current->value){
+					insertHelper(current->left, value); // going to the left
+				}else if(value>current->value){
+					insertHelper(current->right, value); // going to the right
+				}
+			}
+		}
+
+		void insert(T value){
+			if(isEmpty()) root = new Node<T>(value);  // tree is empty
+			else{
+				// the tree is not empty
+				insertHelper(root, value);
+			}
+		}
+
+		bool hasHelper(Node<T>* current, T value){
+			bool f = false;
+			if(current!=NULL){
+				if(current->value == value) return true; // match found
+				else{
+					if(value<current->value){ // search in the left side
+						f = hasHelper(current->left, value);
+					}else{ // search in the right side
+						f = hasHelper(current->right, value);
+					}
+				}
+			}
+			return f;
+		}
+
+		bool has(T value){
+			// return true if the value is in the tree, else return false
+			return hasHelper(root, value);
+		}
+
+		bool isEmpty(){
+			return (root==NULL);
+		}
+
+		void prefix(Node<T>* current){
+			if(current!=NULL){
+				cout<<current->value<<" ";
+				prefix(current->left);
+				prefix(current->right);
+			}
+		}
+
+		void infix(Node<T>* current){
+			if(current!=NULL){
+				infix(current->left);
+				cout<<current->value<<" ";
+				infix(current->right);
+			}
+		}
+
+		void postfix(Node<T>* current){
+			if(current!=NULL){
+				postfix(current->left);
+				postfix(current->right);
+				cout<<current->value<<" ";
+			}
+		}
+
+		void display(int order=0){
+			if(order==0) prefix(root);
+			else if(order==1) infix(root);
+			else if(order==2) postfix(root);
+			cout<<endl;
+		}
+
+		bool deleteValueHelper(Node<T>* parent, Node<T>* current, T value) {
+		    //cout<<current->value<<endl;
+            if (!current) return false;
+            if (current->value == value) {
+
+                //if(current)cout<<"ff"<<current->value<<endl;
+                if (current->left == NULL || current->right == NULL) {
+
+                    Node<T>* temp = current->left;
+                    if (current->right) temp = current->right;
+
+
+                    if (parent) {
+
+                        if (parent->left == current) {
+                            parent->left = temp;
+
+                        } else {
+                            parent->right = temp;
+                        }
+                    } else {
+                        root = temp;
+                    }
+
+
+                } else {
+                    Node<T>* validSubs = current->right;
+                    while (validSubs->left) {
+                        validSubs = validSubs->left;
+                    }
+                    T temp = current->value;
+                    current->value = validSubs->value;
+                    validSubs->value = temp;
+                    return deleteValueHelper(current, current->right, temp);
+                }
+                //if(current)cout<<"ff"<<current->value<<endl;
+                delete current;
+                //cout<<parent->left->value<<endl;
+                return true;
+            }
+            if(current->value > value)
+                return deleteValueHelper(current, current->left, value);
+            return deleteValueHelper(current, current->right, value);
+       }
+
+
+       bool deleteValue(T value) {
+            Node<T>* parent=NULL;
+            return deleteValueHelper(parent, root, value);
+       }
+};
+
+
+int main(){
+	BST<int> firstTree; // We are creating the binary tree, it is empty
+	//BST<string> tree2;
+	//BST<double> tree3;
+	//BST<char> tree4;
+	//BST<Student> tree5;
+	//BST<List<int>> tree6;
+	//List<BST<int>> tree7;
+	int nums[] = {10, 7, 5, 6, 12, 11, 15};
+	int c = 7;
+
+	for(int i=0;i<c;i++){
+		firstTree.insert(nums[i]);
+	}
+
+	firstTree.display(1);
+	firstTree.deleteValue(15);
+    firstTree.display(1);
+    firstTree.deleteValue(5);
+    firstTree.display(1);
+    firstTree.deleteValue(10);
+    firstTree.display(1);
+    firstTree.deleteValue(7);
+    firstTree.display(1);
+	cout<<firstTree.has(999999)<<endl;
+
+	return 0;
+}
diff --git a/SRC/Binary_search_tree.exe b/SRC/Binary_search_tree.exe
new file mode 100755
index 0000000..bf8d771
Binary files /dev/null and b/SRC/Binary_search_tree.exe differ
diff --git a/SRC/Binary_search_tree.o b/SRC/Binary_search_tree.o
new file mode 100755
index 0000000..d4d948e
Binary files /dev/null and b/SRC/Binary_search_tree.o differ
diff --git a/SRC/Bitset.cpp b/SRC/Bitset.cpp
new file mode 100755
index 0000000..cc74ef4
--- /dev/null
+++ b/SRC/Bitset.cpp
@@ -0,0 +1,17 @@
+#include <bits/stdc++.h>
+using namespace std;
+
+int main() {
+  const bitset<12> mask(2730);
+  cout << "mask =      " << mask << endl;
+
+  bitset<12> x(8);
+  cout<<x.to_ulong()<<endl;
+  cout << "Enter a 12-bit bitset in binary: ";
+  if (cin >> x) {
+    cout << "x =        " << x << endl;
+    cout << "As ulong:  " << x.to_ulong() << endl;
+    cout << "And with mask: " << (x & mask) << endl;
+    cout << "Or with mask:  " << (x | mask) << endl;
+  }
+}
diff --git a/SRC/Bitset.exe b/SRC/Bitset.exe
new file mode 100755
index 0000000..f751e65
Binary files /dev/null and b/SRC/Bitset.exe differ
diff --git a/SRC/Bitset.o b/SRC/Bitset.o
new file mode 100755
index 0000000..e4887aa
Binary files /dev/null and b/SRC/Bitset.o differ
diff --git a/SRC/Count b/SRC/Count
new file mode 100755
index 0000000..59e9f16
Binary files /dev/null and b/SRC/Count differ
diff --git a/SRC/Count.cpp b/SRC/Count.cpp
new file mode 100755
index 0000000..ba94380
--- /dev/null
+++ b/SRC/Count.cpp
@@ -0,0 +1,11 @@
+#include <bits/stdc++.h>
+using namespace std;
+
+int main() {
+  int A[] = { 2, 0, 2, 6, 0, 3, 1, -7 };
+  const int N = sizeof(A) / sizeof(int);
+
+  cout << "Number of zeros: "
+       << count(A, A + N, 2)
+       << endl;
+}
diff --git a/SRC/Fibonicci b/SRC/Fibonicci
new file mode 100755
index 0000000..5379c57
Binary files /dev/null and b/SRC/Fibonicci differ
diff --git a/SRC/Fibonicci.cpp b/SRC/Fibonicci.cpp
new file mode 100755
index 0000000..c6e079b
--- /dev/null
+++ b/SRC/Fibonicci.cpp
@@ -0,0 +1,19 @@
+#include <bits/stdc++.h>
+using namespace std;
+
+int main(){
+    long long n;
+    int t=0;
+    cin>>n;
+    while(n!=0){
+        t++;
+        long long count=0;
+        for(long long i=1;3*i+3<=n;i++){
+            for(long long j=i+1;j*2+1<=n-i;j++){
+                count++;
+            }
+        }
+        cout<<"Case #"<<t<<": "<<n<<":"<<count<<endl;
+        cin>>n;
+    }
+}
diff --git a/SRC/Fibonicci.exe b/SRC/Fibonicci.exe
new file mode 100755
index 0000000..5aff635
Binary files /dev/null and b/SRC/Fibonicci.exe differ
diff --git a/SRC/Fibonicci.o b/SRC/Fibonicci.o
new file mode 100755
index 0000000..8c4f838
Binary files /dev/null and b/SRC/Fibonicci.o differ
diff --git a/SRC/HAsh b/SRC/HAsh
new file mode 100755
index 0000000..9d7013d
Binary files /dev/null and b/SRC/HAsh differ
diff --git a/SRC/HAsh.cpp b/SRC/HAsh.cpp
new file mode 100755
index 0000000..70cadc7
--- /dev/null
+++ b/SRC/HAsh.cpp
@@ -0,0 +1,8 @@
+#include <iostream>
+using namespace std;
+int main()
+{
+  hash<const char*> H;
+  cout << "foo -> " << H("foo") << endl;
+  cout << "bar -> " << H("bar") << endl;
+}
diff --git a/SRC/HAsh.exe b/SRC/HAsh.exe
new file mode 100755
index 0000000..a69db31
Binary files /dev/null and b/SRC/HAsh.exe differ
diff --git a/SRC/HAsh.o b/SRC/HAsh.o
new file mode 100755
index 0000000..385d293
Binary files /dev/null and b/SRC/HAsh.o differ
diff --git a/SRC/Implace_marge.cpp b/SRC/Implace_marge.cpp
new file mode 100755
index 0000000..49a92ae
--- /dev/null
+++ b/SRC/Implace_marge.cpp
@@ -0,0 +1,8 @@
+int main()
+{
+  int A[] = { 1, 3, 5, 7, 2, 4, 6, 8 };
+
+  inplace_merge(A, A + 4, A + 8);
+  copy(A, A + 8, ostream_iterator<int>(cout, " "));
+  // The output is "1 2 3 4 5 6 7 8".
+}
diff --git a/SRC/LeapYear.cpp b/SRC/LeapYear.cpp
new file mode 100755
index 0000000..aa325e1
--- /dev/null
+++ b/SRC/LeapYear.cpp
@@ -0,0 +1,7 @@
+bool isALeapYear( int year )
+{
+	/* Check if the year is divisible by 4 or
+	is divisible by 400 */
+	return ((year % 4 == 0 && year % 100 != 0) || ( year % 400 == 0));
+}
+-
diff --git a/SRC/Seive_Prime b/SRC/Seive_Prime
new file mode 100755
index 0000000..8bf6b1c
Binary files /dev/null and b/SRC/Seive_Prime differ
diff --git a/SRC/Seive_Prime.cpp b/SRC/Seive_Prime.cpp
new file mode 100755
index 0000000..538daf7
--- /dev/null
+++ b/SRC/Seive_Prime.cpp
@@ -0,0 +1,63 @@
+#include <bits/stdc++.h>
+using namespace std;
+
+
+const int n=1000000;
+bool prime[n+1];
+
+
+void primeGen()
+{
+    memset(prime,true,sizeof prime);
+
+    for (int p=2; p*p<=n; p++)
+    {
+        if (prime[p])
+        {
+            for (int i=p*2; i<=n; i += p)
+                prime[i] = false;
+        }
+    }
+}
+
+
+int main(){
+    primeGen();
+    prime[1]=0;
+    prime[0]=0;
+    int a,b;
+    while(cin>>a>>b){
+        int bg=-1,en=-1,ma=-1,mb=-1,min=1000001,i;
+        for(i=a;i<b;i++){
+            if(prime[i]){
+                bg=i;
+                ma=i;
+                break;
+            }
+        }
+        if(bg!=-1){
+            int last=ma;
+            for(i++;i<=b;i++){
+                if(prime[i]){
+                    en=i;
+                    if(i-last<min){
+                        min=i-last;
+                        mb=i;
+                        ma=last;
+                    }
+                    last=i;
+                }
+            }
+            if(en!=-1){
+                cout<<"Closest = "<<ma<<","<<mb<<" and Furthest: "<<bg<<","<<en<<endl;
+            }
+            else{
+                cout<<"No two primes exist"<<endl;
+            }
+        }
+        else{
+            cout<<"No two primes exist"<<endl;
+        }
+    }
+
+}
diff --git a/SRC/Seive_Prime.exe b/SRC/Seive_Prime.exe
new file mode 100755
index 0000000..0ba5268
Binary files /dev/null and b/SRC/Seive_Prime.exe differ
diff --git a/SRC/Seive_Prime.o b/SRC/Seive_Prime.o
new file mode 100755
index 0000000..8868767
Binary files /dev/null and b/SRC/Seive_Prime.o differ
diff --git a/SRC/Set_union b/SRC/Set_union
new file mode 100755
index 0000000..20317b7
Binary files /dev/null and b/SRC/Set_union differ
diff --git a/SRC/Set_union.cpp b/SRC/Set_union.cpp
new file mode 100755
index 0000000..96ae319
--- /dev/null
+++ b/SRC/Set_union.cpp
@@ -0,0 +1,30 @@
+#include <bits/stdc++.h>
+using namespace std;
+
+inline bool lt_nocase(char c1, char c2) { return tolower(c1) < tolower(c2); }
+
+int main()
+{
+  int A1[] = {1, 3, 5, 7, 9, 11};
+  int A2[] = {1, 1, 2, 3, 5, 8, 13};
+  char A3[] = {'a', 'b', 'B', 'B', 'f', 'H'};
+  char A4[] = {'A', 'B', 'b', 'C', 'D', 'F', 'F', 'h', 'h'};
+
+  const int N1 = sizeof(A1) / sizeof(int);
+  const int N2 = sizeof(A2) / sizeof(int);
+  const int N3 = sizeof(A3);
+  const int N4 = sizeof(A4);
+
+  cout << "Union of A1 and A2: ";
+  int x[100];
+  int *it= set_union(A1, A1 + N1, A2, A2 + N2,x);
+  for(int i=0;i<it-x;i++)
+    cout<<x[i]<<" ";
+  cout<<endl;
+  cout << endl
+       << "Union of A3 and A4: ";
+  set_union(A3, A3 + N3, A4, A4 + N4,
+            ostream_iterator<char>(cout, " "),
+            lt_nocase);
+  cout << endl;
+}
diff --git a/SRC/Set_union.exe b/SRC/Set_union.exe
new file mode 100755
index 0000000..10b1ee2
Binary files /dev/null and b/SRC/Set_union.exe differ
diff --git a/SRC/Set_union.o b/SRC/Set_union.o
new file mode 100755
index 0000000..24e4a13
Binary files /dev/null and b/SRC/Set_union.o differ
diff --git a/SRC/Upper_bound b/SRC/Upper_bound
new file mode 100755
index 0000000..6834792
Binary files /dev/null and b/SRC/Upper_bound differ
diff --git a/SRC/Upper_bound.cpp b/SRC/Upper_bound.cpp
new file mode 100755
index 0000000..4f1288e
--- /dev/null
+++ b/SRC/Upper_bound.cpp
@@ -0,0 +1,43 @@
+#include <bits/stdc++.h>
+using namespace std;
+int main()
+{
+  int A[] = { 1, 2, 3, 3, 3, 5, 8 };
+  const int N = sizeof(A) / sizeof(int);
+
+  for (int i = 1; i <= 10; ++i) {
+    int* p = lower_bound(A, A + N, i);
+    int* p = upper_bound(A, A + N, i);
+    cout << "Searching for " << i << ".  ";
+    cout << "Result: index = " << p - A << ", ";
+    if (p != A + N)
+      cout << "A[" << p - A << "] == " << *p << endl;
+    else
+      cout << "which is off-the-end." << endl;
+  }
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+//google i talee 1536427 Abd.jalil.921 i taleem i taleem fb abd.jalil.165 abd&jalil921 `italeem
diff --git a/SRC/Upper_bound.exe b/SRC/Upper_bound.exe
new file mode 100755
index 0000000..c4e15d6
Binary files /dev/null and b/SRC/Upper_bound.exe differ
diff --git a/SRC/Upper_bound.o b/SRC/Upper_bound.o
new file mode 100755
index 0000000..eb692d4
Binary files /dev/null and b/SRC/Upper_bound.o differ
diff --git a/SRC/adjacent_diff b/SRC/adjacent_diff
new file mode 100755
index 0000000..5a0c2a7
Binary files /dev/null and b/SRC/adjacent_diff differ
diff --git a/SRC/adjacent_diff.cpp b/SRC/adjacent_diff.cpp
new file mode 100755
index 0000000..32beda2
--- /dev/null
+++ b/SRC/adjacent_diff.cpp
@@ -0,0 +1,31 @@
+#include <bits/stdc++.h>
+using namespace std;
+
+int main()
+{
+  int A[] = {1, 4, 9, 16, 25, 36, 49, 64, 81, 100};
+  const int N = sizeof(A) / sizeof(int);
+  int B[N];
+  int c[N];
+  memset(c,0,sizeof c);
+  c[0]=1;
+
+  cout << "A[]:         ";
+  copy(A, A + N, B);
+  copy(B, B + N, ostream_iterator<int>(cout," "));
+  cout << endl;
+
+  adjacent_difference(A, A + N, B);
+  cout << "Differences: ";
+  copy(B, B + N, ostream_iterator<int>(cout, " "));
+  cout << endl;
+
+  cout << "Reconstruct: ";
+  partial_sum(B, B + N, ostream_iterator<int>(cout, " "));
+  cout << endl;
+
+cout << "Reconstruct: ";
+  partial_sum(c, c + N, ostream_iterator<int>(cout, " "));
+  cout << endl;
+}
+
diff --git a/SRC/adjacent_diff.exe b/SRC/adjacent_diff.exe
new file mode 100755
index 0000000..1ece515
Binary files /dev/null and b/SRC/adjacent_diff.exe differ
diff --git a/SRC/adjacent_diff.o b/SRC/adjacent_diff.o
new file mode 100755
index 0000000..42619e0
Binary files /dev/null and b/SRC/adjacent_diff.o differ
diff --git a/SRC/adjacent_find b/SRC/adjacent_find
new file mode 100755
index 0000000..518cf3b
Binary files /dev/null and b/SRC/adjacent_find differ
diff --git a/SRC/adjacent_find.cpp b/SRC/adjacent_find.cpp
new file mode 100755
index 0000000..69ebb65
--- /dev/null
+++ b/SRC/adjacent_find.cpp
@@ -0,0 +1,12 @@
+#include <bits/stdc++.h>
+using namespace std;
+
+int main(){
+    int A[] = {1, 2, 3, 4, 6, 5, 7, 8};
+const int N = sizeof(A) / sizeof(int);
+
+const int* p = adjacent_find(A, A + N, greater<int>());
+
+cout << "Element " << p - A << " is out of order: "
+     << *p << " > " << *(p + 1) << "." << endl;
+}
diff --git a/SRC/adjacent_find.exe b/SRC/adjacent_find.exe
new file mode 100755
index 0000000..a2ce6de
Binary files /dev/null and b/SRC/adjacent_find.exe differ
diff --git a/SRC/adjacent_find.o b/SRC/adjacent_find.o
new file mode 100755
index 0000000..109cf78
Binary files /dev/null and b/SRC/adjacent_find.o differ
diff --git a/SRC/advance_Iterator b/SRC/advance_Iterator
new file mode 100755
index 0000000..d258c0b
Binary files /dev/null and b/SRC/advance_Iterator differ
diff --git a/SRC/advance_Iterator.cpp b/SRC/advance_Iterator.cpp
new file mode 100755
index 0000000..93c5d2b
--- /dev/null
+++ b/SRC/advance_Iterator.cpp
@@ -0,0 +1,12 @@
+#include <bits/stdc++.h>
+using namespace std;
+int main(){
+    list<int> L;
+    L.push_back(0);
+    L.push_back(1);
+
+    list<int>::iterator i = L.begin();
+    advance(i, 2);
+    assert(i == L.end());
+
+}
diff --git a/SRC/advance_Iterator.exe b/SRC/advance_Iterator.exe
new file mode 100755
index 0000000..a6b28b3
Binary files /dev/null and b/SRC/advance_Iterator.exe differ
diff --git a/SRC/advance_Iterator.o b/SRC/advance_Iterator.o
new file mode 100755
index 0000000..7a4a83f
Binary files /dev/null and b/SRC/advance_Iterator.o differ
diff --git a/SRC/gcd.cpp b/SRC/gcd.cpp
new file mode 100755
index 0000000..fae5f33
--- /dev/null
+++ b/SRC/gcd.cpp
@@ -0,0 +1,12 @@
+#include <bits/stdc++.h>
+using namespace std;
+
+long long gcd(long long a, long long b){
+    if(a==0 || b==0)return a+b;
+    return gcd(b, a % b);
+}
+
+int main(){
+
+}
+
diff --git a/SRC/includes.cpp b/SRC/includes.cpp
new file mode 100755
index 0000000..8d70716
--- /dev/null
+++ b/SRC/includes.cpp
@@ -0,0 +1,22 @@
+int A1[] = { 1, 2, 3, 4, 5, 6, 7 };
+int A2[] = { 1, 4, 7 };
+int A3[] = { 2, 7, 9 };
+int A4[] = { 1, 1, 2, 3, 5, 8, 13, 21 };
+int A5[] = { 1, 2, 13, 13 };
+int A6[] = { 1, 1, 3, 21 };
+
+const int N1 = sizeof(A1) / sizeof(int);
+const int N2 = sizeof(A2) / sizeof(int);
+const int N3 = sizeof(A3) / sizeof(int);
+const int N4 = sizeof(A4) / sizeof(int);
+const int N5 = sizeof(A5) / sizeof(int);
+const int N6 = sizeof(A6) / sizeof(int);
+
+cout << "A2 contained in A1: "
+     << (includes(A1, A1 + N1, A2, A2 + N2) ? "true" : "false") << endl;
+cout << "A3 contained in A1: "
+     << (includes(A1, A1 + N2, A3, A3 + N3) ? "true" : "false") << endl;
+cout << "A5 contained in A4: "
+     << (includes(A4, A4 + N4, A5, A5 + N5) ? "true" : "false") << endl;
+cout << "A6 contained in A4: "
+     << (includes(A4, A4 + N4, A6, A6 + N6) ? "true" : "false") << endl;
diff --git a/SRC/inner_product b/SRC/inner_product
new file mode 100755
index 0000000..d6ee291
Binary files /dev/null and b/SRC/inner_product differ
diff --git a/SRC/inner_product.cpp b/SRC/inner_product.cpp
new file mode 100755
index 0000000..028808e
--- /dev/null
+++ b/SRC/inner_product.cpp
@@ -0,0 +1,13 @@
+#include <bits/stdc++.h>
+using namespace std;
+
+int main()
+{
+  int A1[] = {1, 2, 3};
+  int A2[] = {4, 1, -2};
+  const int N1 = sizeof(A1) / sizeof(int);
+
+  cout << "The inner product of A1 and A2 is "
+       << inner_product(A1, A1 + N1, A2, 0)
+       << endl;
+}
diff --git a/SRC/inner_product.exe b/SRC/inner_product.exe
new file mode 100755
index 0000000..b77c0a0
Binary files /dev/null and b/SRC/inner_product.exe differ
diff --git a/SRC/inner_product.o b/SRC/inner_product.o
new file mode 100755
index 0000000..3502a18
Binary files /dev/null and b/SRC/inner_product.o differ
diff --git a/SRC/iota b/SRC/iota
new file mode 100755
index 0000000..adf991a
Binary files /dev/null and b/SRC/iota differ
diff --git a/SRC/iota.cpp b/SRC/iota.cpp
new file mode 100755
index 0000000..e6bbe86
--- /dev/null
+++ b/SRC/iota.cpp
@@ -0,0 +1,11 @@
+#include <bits/stdc++.h>
+using namespace std;
+
+int main()
+{
+  vector<int> V(10);
+
+  iota(V.begin(), V.end(), 7);
+  copy(V.begin(), V.end(), ostream_iterator<int>(cout, " "));
+  cout << endl;
+}
diff --git a/SRC/iota.exe b/SRC/iota.exe
new file mode 100755
index 0000000..fa9f7cb
Binary files /dev/null and b/SRC/iota.exe differ
diff --git a/SRC/iota.o b/SRC/iota.o
new file mode 100755
index 0000000..f521b89
Binary files /dev/null and b/SRC/iota.o differ
diff --git a/SRC/itter_swap b/SRC/itter_swap
new file mode 100755
index 0000000..cf08a4e
Binary files /dev/null and b/SRC/itter_swap differ
diff --git a/SRC/itter_swap.cpp b/SRC/itter_swap.cpp
new file mode 100755
index 0000000..fc7943d
--- /dev/null
+++ b/SRC/itter_swap.cpp
@@ -0,0 +1,10 @@
+#include <bits/stdc++.h>
+using  namespace std;
+
+int main(){
+    int x = 1;
+int y = 2;
+//assert(x == 2 && y == 2);
+iter_swap(&x, &y);
+cout<<x<<y<<endl;
+}
diff --git a/SRC/itter_swap.exe b/SRC/itter_swap.exe
new file mode 100755
index 0000000..1be7ca0
Binary files /dev/null and b/SRC/itter_swap.exe differ
diff --git a/SRC/itter_swap.o b/SRC/itter_swap.o
new file mode 100755
index 0000000..5e4727a
Binary files /dev/null and b/SRC/itter_swap.o differ
diff --git a/SRC/ncr.cpp b/SRC/ncr.cpp
new file mode 100755
index 0000000..62669a6
--- /dev/null
+++ b/SRC/ncr.cpp
@@ -0,0 +1,11 @@
+#include <bits/stdc++.h>
+using namespace std;
+
+long long ncr(long long n,long long r){
+    long long ans=1;
+    for(int i=1;i<=r;i++){
+        ans*=(n-r+i);
+        ans/=i;
+    }
+    return ans;
+}
diff --git a/SRC/next_permutation b/SRC/next_permutation
new file mode 100755
index 0000000..3d0e8ac
Binary files /dev/null and b/SRC/next_permutation differ
diff --git a/SRC/next_permutation.cpp b/SRC/next_permutation.cpp
new file mode 100755
index 0000000..ea83128
--- /dev/null
+++ b/SRC/next_permutation.cpp
@@ -0,0 +1,17 @@
+#include <bits/stdc++.h>
+using namespace std;
+
+int main() {
+
+    int p[10], N = 5; for (int i = 0; i < N; i++) p[i] = i;
+    //char ex[10]="ASH";
+    //sort(ex,ex+3);
+    do {
+        for (int i = 0; i < N; i++)
+            printf("%c ", 'A' + p[i]);
+        printf("\n");
+        //cout<<ex<<endl;
+    }
+    while (next_permutation(p, p + 5));
+}
+
diff --git a/SRC/next_permutation.exe b/SRC/next_permutation.exe
new file mode 100755
index 0000000..5df618e
Binary files /dev/null and b/SRC/next_permutation.exe differ
diff --git a/SRC/next_permutation.o b/SRC/next_permutation.o
new file mode 100755
index 0000000..9a3d887
Binary files /dev/null and b/SRC/next_permutation.o differ
diff --git a/SRC/ones_Cluster b/SRC/ones_Cluster
new file mode 100755
index 0000000..1355569
Binary files /dev/null and b/SRC/ones_Cluster differ
diff --git a/SRC/ones_Cluster.cpp b/SRC/ones_Cluster.cpp
new file mode 100755
index 0000000..abade5f
--- /dev/null
+++ b/SRC/ones_Cluster.cpp
@@ -0,0 +1,57 @@
+#include <bits/stdc++.h>
+using namespace std;
+
+const int ROW=6;
+const int COL=6;
+const int offSet[]={-1,0,1};
+
+bool neighborExist(int ex[][COL],int i,int j){
+    if(i>=0 && i<ROW && j>=0 && j<COL)
+        if(ex[i][j]==1)
+            return true;
+    return false;
+}
+void doDFS(int ex[][COL],int i,int j,bool visited[][COL]){
+    if(visited[i][j])
+        return;
+    visited[i][j]=true;
+    //cout<<i<<" dfs "<<j<<endl;
+    for(int x=0;x<3;x++){
+        for(int y=0;y<3;y++){
+            if(x==1 && y==1)
+                continue;
+            //cout<<"OD ss "<<offSet[x]<<" "<<offSet[y]<<endl;
+            if(neighborExist(ex,i+offSet[x],j+offSet[y]))
+                doDFS(ex,i+offSet[x],j+offSet[y],visited);
+        }
+    }
+}
+
+int numberOfCluster(int ex[][COL]){
+    int count=0;
+    bool visited[6][6]={};
+    for(int i=0;i<ROW;i++){
+        for(int j=0;j<COL;j++){
+            if(ex[i][j]==1 && !visited[i][j]){
+                count++;
+                doDFS(ex,i,j,visited);
+            }
+
+        }
+    }
+    return count;
+}
+
+int main(){
+    int ex[][COL]={
+                1,0,0,0,1,0,
+                0,1,1,0,0,1,
+                1,0,0,0,0,1,
+                0,1,0,1,0,1,
+                0,0,0,1,0,0,
+                1,0,0,0,1,0
+               };
+
+    cout<<numberOfCluster(ex)<<endl;
+
+}
diff --git a/SRC/pi b/SRC/pi
new file mode 100755
index 0000000..9b045df
Binary files /dev/null and b/SRC/pi differ
diff --git a/SRC/pi.cpp b/SRC/pi.cpp
new file mode 100755
index 0000000..bfdbd09
--- /dev/null
+++ b/SRC/pi.cpp
@@ -0,0 +1,10 @@
+#include <bits/stdc++.h>
+using namespace std;
+
+int main() {
+
+    //double pi=2*acos(0.0);
+  	double pi=acos(-1);
+    printf("%13.*lf\n",10,pi);
+}
+ 
\ No newline at end of file
diff --git a/SRC/pi.exe b/SRC/pi.exe
new file mode 100755
index 0000000..2b8f402
Binary files /dev/null and b/SRC/pi.exe differ
diff --git a/SRC/pi.o b/SRC/pi.o
new file mode 100755
index 0000000..b58e401
Binary files /dev/null and b/SRC/pi.o differ
diff --git a/SRC/set_intersection.cpp b/SRC/set_intersection.cpp
new file mode 100755
index 0000000..d1dd6bc
--- /dev/null
+++ b/SRC/set_intersection.cpp
@@ -0,0 +1,24 @@
+inline bool lt_nocase(char c1, char c2) { return tolower(c1) < tolower(c2); }
+
+int main()
+{
+  int A1[] = {1, 3, 5, 7, 9, 11};
+  int A2[] = {1, 1, 2, 3, 5, 8, 13};
+  char A3[] = {'a', 'b', 'b', 'B', 'B', 'f', 'h', 'H'};
+  char A4[] = {'A', 'B', 'B', 'C', 'D', 'F', 'F', 'H' };
+
+  const int N1 = sizeof(A1) / sizeof(int);
+  const int N2 = sizeof(A2) / sizeof(int);
+  const int N3 = sizeof(A3);
+  const int N4 = sizeof(A4);
+
+  cout << "Intersection of A1 and A2: ";
+  set_intersection(A1, A1 + N1, A2, A2 + N2,
+                   ostream_iterator<int>(cout, " "));
+  cout << endl
+       << "Intersection of A3 and A4: ";
+  set_intersection(A3, A3 + N3, A4, A4 + N4,
+                   ostream_iterator<char>(cout, " "),
+                   lt_nocase);
+  cout << endl;
+}
diff --git a/SRC/simpleSumming b/SRC/simpleSumming
new file mode 100755
index 0000000..7745947
Binary files /dev/null and b/SRC/simpleSumming differ
diff --git a/SRC/simpleSumming.cpp b/SRC/simpleSumming.cpp
new file mode 100755
index 0000000..5747929
--- /dev/null
+++ b/SRC/simpleSumming.cpp
@@ -0,0 +1,16 @@
+#include <bits/stdc++.h>
+using namespace std;
+
+int main()
+{
+  int A[] = {1, 2, 3, 4, 5};
+  const int N = sizeof(A) / sizeof(int);
+
+  cout << "The sum of all elements in A is "
+       << accumulate(A, A + N, 0)
+       << endl;
+
+  cout << "The product of all elements in A is "
+       << accumulate(A, A + N, 1,multiplies<int>())
+       << endl;
+}
diff --git a/SRC/simpleSumming.exe b/SRC/simpleSumming.exe
new file mode 100755
index 0000000..7928446
Binary files /dev/null and b/SRC/simpleSumming.exe differ
diff --git a/SRC/simpleSumming.o b/SRC/simpleSumming.o
new file mode 100755
index 0000000..f6e3197
Binary files /dev/null and b/SRC/simpleSumming.o differ
diff --git a/SRC/sortCOmaparison_try.cpp b/SRC/sortCOmaparison_try.cpp
new file mode 100755
index 0000000..2af32b3
--- /dev/null
+++ b/SRC/sortCOmaparison_try.cpp
@@ -0,0 +1,63 @@
+#include <bits/stdc++.h>
+
+using namespace std;
+
+#define eps 0.001
+
+struct Frog{
+    double h,w,j;
+    int i;
+    Frog(){}
+    Frog(double _h, double _w, double _j, int _i ){
+        h=_h; w=_w; j=_j; i=_i;
+    }
+    /*bool operator()(const Frog& a, const Frog& b){
+        if(a.h < b.h)
+            return false;
+        else if(abs(a.h-b.h)<eps){
+            if(a.w>b.w)
+                return false;
+            else if(abs(a.w-b.w)<eps){
+                if(a.j<b.j)
+                    return false;
+                else if(abs(a.j-b.j)<eps){
+                    return a.i<b.i;
+                }
+
+            }
+        }
+        return true;
+    }*/
+};
+
+bool compare(const Frog& a, const Frog& b){
+        if(a.h < b.h)
+            return false;
+        else if(abs(a.h-b.h)<eps){
+            if(a.w>b.w)
+                return false;
+            else if(abs(a.w-b.w)<eps){
+                if(a.j<b.j)
+                    return false;
+                else if(abs(a.j-b.j)<eps){
+                    return a.i<b.i;
+                }
+
+            }
+        }
+        return true;
+}
+int main(){
+    int n;
+    cin>>n;
+    vector<Frog> ex;
+    for(int i=0;i<n;i++){
+        double h,w,j;
+        cin>>h>>w>>j;
+        ex.push_back(Frog(h,w,j,i+1));
+    }
+    sort(ex.begin(),ex.end(),compare);
+    for(int i=0;i<ex.size();i++){
+        printf("ID:%d H:%.2f W:%.2f L:%.2f\n", ex[i].i,ex[i].h,ex[i].w,ex[i].j);
+    }
+}
diff --git a/SRC/sortCOmaparison_try.exe b/SRC/sortCOmaparison_try.exe
new file mode 100755
index 0000000..1ccb920
Binary files /dev/null and b/SRC/sortCOmaparison_try.exe differ
diff --git a/SRC/sortCOmaparison_try.o b/SRC/sortCOmaparison_try.o
new file mode 100755
index 0000000..0d9537d
Binary files /dev/null and b/SRC/sortCOmaparison_try.o differ
diff --git a/SRC/sort_comparision.cpp b/SRC/sort_comparision.cpp
new file mode 100755
index 0000000..7814efa
--- /dev/null
+++ b/SRC/sort_comparision.cpp
@@ -0,0 +1,49 @@
+#include <bits/stdc++.h>
+
+using namespace std;
+
+#define eps 0.001
+
+// This is the custom data container for this solution
+struct Frog{
+    double h,w,l; // h->height, w->weight, l->length of jump
+    int i; // i-> position in the original list
+    Frog(){} // Empty Constructor, it is needed for sorting using sort function
+    Frog(double _h, double _w, double _l, int _i){ h = _h; w = _w; l = _l; i = _i;} // Constructor for initializing
+    // The following function defines the nature of the operator overloading
+    // In this case the operator is the comparison function, defined by "()" symbol
+    bool operator()(const Frog& a, const Frog& b){
+        // The follwing conditions decides whether 'a' should go before 'b' or not
+        if(a.h<b.h){
+            return false;
+        }else if(abs(a.h-b.h)<eps){
+            if(a.w>b.w){
+                return false;
+            }else if(abs(a.w-b.w)<eps){
+                if(a.l<b.l){
+                    return false;
+                }else if(abs(a.l-b.l)<eps){
+                    return a.i<b.i;
+                }
+            }
+        }
+        return true;
+    }
+};
+
+int main(){
+    int n;
+    scanf("%d",&n);
+    vector<Frog> frogs;
+    double h,w,l;
+    for(int i=0;i<n;i++){
+        scanf("%lf %lf %lf",&h,&w,&l);
+        frogs.push_back(Frog(h,w,l,i+1)); // We store the list in a vector
+    }
+    sort(frogs.begin(), frogs.end(), Frog()); // We use the built-in sort function with our custom comparator to sort the list
+    // Now we just simply print out the while list
+    for(int i=0;i<frogs.size();i++){
+        printf("ID:%d H:%.2f W:%.2f L:%.2f\n",frogs[i].i,frogs[i].h,frogs[i].w,frogs[i].l);
+    }
+    return 0;
+}
diff --git a/SRC/sort_comparision.exe b/SRC/sort_comparision.exe
new file mode 100755
index 0000000..fcfeca4
Binary files /dev/null and b/SRC/sort_comparision.exe differ
diff --git a/SRC/sort_comparision.o b/SRC/sort_comparision.o
new file mode 100755
index 0000000..6ee0d34
Binary files /dev/null and b/SRC/sort_comparision.o differ
diff --git a/SRC/sorting 2d Array.cpp b/SRC/sorting 2d Array.cpp
new file mode 100755
index 0000000..f5841dc
--- /dev/null
+++ b/SRC/sorting 2d Array.cpp	
@@ -0,0 +1,57 @@
+
+#include <bits/stdc++.h>
+using namespace std;
+/*
+int compare (const void * a, const void * b)
+{
+  return ( *(int*)a - *(int*)b );
+}
+*/
+int compare( const void *aa, const void  *bb)
+{
+    const int col=1;//will sort base on third element
+    int *a=(int *)aa;
+    int *b=(int *)bb;
+    if (a[col]<b[col])//a[col]>a[col] for descending order
+        return -1;
+    else if (a[col]==b[col])
+        return 0;
+    else
+        return 1;
+
+}
+
+int cmp( const void * aa, const void * bb)
+{
+    int *a=(int * )aa;
+    int *b=(int *)bb;
+    const int col=0;//will sort base on third element
+    cout<<a[col]<<" --- "<<b[col]<<endl;
+    if (a[col]>b[col])//a[col]>a[col] for descending order
+        return 1;
+    else if (a[col]==b[col])
+        return 0;
+    else
+        return -1;
+
+}
+int main()
+{
+    const int row=3,col=5;
+    int ex[row][col]={2,5,1,4,7,7,2,5,3,4,4,41,32,5,3};
+    for(int i=0;i<3;i++){
+        for(int j=0;j<5;j++)
+            cout<<ex[i][j]<<" ";
+        cout<<endl;
+    }
+    cout<<endl;
+    qsort(ex,row,sizeof(ex[0]),cmp);
+    cout<<"After"<<endl;
+    for(int i=0;i<row;i++){
+        for(int j=0;j<col;j++)
+            cout<<ex[i][j]<<" ";
+        cout<<endl;
+    }
+
+    return 0;
+}
diff --git a/SRC/sorting 2d Array.exe b/SRC/sorting 2d Array.exe
new file mode 100755
index 0000000..6e1d206
Binary files /dev/null and b/SRC/sorting 2d Array.exe differ
diff --git a/SRC/sorting 2d Array.o b/SRC/sorting 2d Array.o
new file mode 100755
index 0000000..6ff0d00
Binary files /dev/null and b/SRC/sorting 2d Array.o differ
diff --git a/SRC/special_Cout.cpp b/SRC/special_Cout.cpp
new file mode 100755
index 0000000..f1e310f
--- /dev/null
+++ b/SRC/special_Cout.cpp
@@ -0,0 +1,11 @@
+#include <bits/stdc++.h>
+using  namespace std;
+
+int main(){
+    int A[] = {1, 4, 2, 8, 5, 7};
+    const int N = sizeof(A) / sizeof(int);
+    sort(A, A + N);
+    string ex[]={"sa","fes","fef"};
+    copy(ex,ex+3,ostream_iterator<string>(cout," "));
+    //copy(ex, ex + 3, ostream_iterator<string>(cout, " "));
+}
diff --git a/SRC/special_Cout.exe b/SRC/special_Cout.exe
new file mode 100755
index 0000000..158d8e6
Binary files /dev/null and b/SRC/special_Cout.exe differ
diff --git a/SRC/special_Cout.o b/SRC/special_Cout.o
new file mode 100755
index 0000000..527573c
Binary files /dev/null and b/SRC/special_Cout.o differ
diff --git a/SRC/subset b/SRC/subset
new file mode 100755
index 0000000..e8f8c1d
Binary files /dev/null and b/SRC/subset differ
diff --git a/SRC/subset.cpp b/SRC/subset.cpp
new file mode 100755
index 0000000..37fbe16
--- /dev/null
+++ b/SRC/subset.cpp
@@ -0,0 +1,17 @@
+#include <bits/stdc++.h>
+using namespace std;
+
+const int n=3;
+int main(){
+
+    int ex[n];
+    for(int i=0;i<n;i++)
+        ex[i]=i;
+    for(int i=0;i < (1<<n) ; i++){
+        for(int j=0;j<n;j++)
+            if(i & (1<<j))
+                cout<<ex[j];
+        cout<<endl;
+    }
+
+}
diff --git a/SRC/subset.exe b/SRC/subset.exe
new file mode 100755
index 0000000..ef1260d
Binary files /dev/null and b/SRC/subset.exe differ
diff --git a/SRC/subset.o b/SRC/subset.o
new file mode 100755
index 0000000..82d2520
Binary files /dev/null and b/SRC/subset.o differ
diff --git a/SRC/try b/SRC/try
new file mode 100755
index 0000000..a30f629
Binary files /dev/null and b/SRC/try differ
diff --git a/SRC/try.cpp b/SRC/try.cpp
new file mode 100644
index 0000000..2a23b9a
--- /dev/null
+++ b/SRC/try.cpp
@@ -0,0 +1,14 @@
+#include <iostream>
+ 
+using namespace std;
+ 
+int main() {
+    
+    int a,b,x;
+    cin>>a>>b;
+    x=a+b;
+    cout<<"X = "<<x<<endl;
+
+    
+    return 0;
+}
\ No newline at end of file
diff --git a/SRC/try.o b/SRC/try.o
new file mode 100755
index 0000000..ebd7066
Binary files /dev/null and b/SRC/try.o differ
diff --git a/competition_note.odt b/competition_note.odt
new file mode 100644
index 0000000..cb61eae
Binary files /dev/null and b/competition_note.odt differ
diff --git a/faltu/try b/faltu/try
new file mode 100755
index 0000000..92df8be
Binary files /dev/null and b/faltu/try differ
diff --git a/faltu/try.cpp b/faltu/try.cpp
new file mode 100644
index 0000000..33058d9
--- /dev/null
+++ b/faltu/try.cpp
@@ -0,0 +1,10 @@
+#include <bits/stdc++.h>
+
+using namespace std;
+
+int main(){
+
+	string ex="ashik";
+	string fx=string(ex.rbegin(),ex.rend());
+	cout<<fx<<endl;
+}
\ No newline at end of file
diff --git a/helloWorld.asm b/helloWorld.asm
new file mode 100644
index 0000000..9407b9d
--- /dev/null
+++ b/helloWorld.asm
@@ -0,0 +1,13 @@
+	.data
+msg: .asciiz "Hello  World"
+	.extern foobar 4
+
+
+	.text
+	.global main
+main: li $v0,4
+	la $a0,msg
+	syscall
+	lw $t1,foobar
+	jr $ra
+	
\ No newline at end of file
diff --git a/test b/test
new file mode 100644
index 0000000..e69de29