diff --git a/.gitignore b/.gitignore
index fc5d1da..7e56cda 100644
--- a/.gitignore
+++ b/.gitignore
@@ -2,3 +2,9 @@ bin
 Debug
 .settings
 *.txt
+data.in
+data.out
+Makefile
+test
+tags
+*.o
diff --git a/AllYourBase/Solution.cpp b/AllYourBase/Solution.cpp
new file mode 100644
index 0000000..379f612
--- /dev/null
+++ b/AllYourBase/Solution.cpp
@@ -0,0 +1,87 @@
+#include <vector>
+#include <list>
+#include <map>
+#include <set>
+#include <queue>
+#include <deque>
+#include <stack>
+#include <bitset>
+#include <algorithm>
+#include <functional>
+#include <numeric>
+#include <utility>
+#include <sstream>
+#include <iostream>
+#include <iomanip>
+#include <cstdio>
+#include <cmath>
+#include <cstdlib>
+#include <ctime>
+#include <fstream>
+
+using namespace std;
+
+class Solution {
+public:
+    Solution() {
+        input = freopen("data.in" , "r" , stdin);
+        output = freopen("data.out" , "w" , stdout);
+    }
+
+    ~Solution() {
+        fclose(input);
+        fclose(output);
+    }
+    void solve() {
+        int T;
+        cin >> T;
+        for(int i = 1; i <= T; i++)  {
+            cout << "Case #" << i << ": " << solveCase() << endl;
+        }
+    }
+
+private:
+    unsigned long long solveCase() {
+        string str;
+        cin >> str;
+        //cout << str << endl;
+        int N = str.size();
+        if (N == 1) return 1;
+        vector<int> hash(256, -1);
+        int count = 0;
+        for (int i = 0; i < N; i++) {
+            int j = str[i];
+            if (hash[j] == -1)
+                hash[j] = count++;
+        }
+        //cout << count << endl;
+        if (count == 1) count = 2;
+
+        unsigned long long digits = 1;
+        for (int i = 1; i < N; i++) {
+            digits *= count;
+        }
+        //cout << digits << endl;
+
+        unsigned long long res = 0;
+        for (int i = 0; i < N; i++) {
+            int j = str[i];
+            unsigned long long num = hash[j];
+            if (num == 0) num = 1;
+            else if (num == 1) num = 0;
+            res += num * digits;
+            digits /= count;
+        }
+        
+        return res;
+    }
+
+     
+    FILE * input;
+    FILE * output;
+};
+
+int main() {
+    Solution sol;
+    sol.solve();
+}
diff --git a/BabyHeight/Solution.cpp b/BabyHeight/Solution.cpp
new file mode 100644
index 0000000..843aad6
--- /dev/null
+++ b/BabyHeight/Solution.cpp
@@ -0,0 +1,107 @@
+#include <vector>
+#include <list>
+#include <map>
+#include <set>
+#include <queue>
+#include <deque>
+#include <stack>
+#include <bitset>
+#include <algorithm>
+#include <functional>
+#include <numeric>
+#include <utility>
+#include <sstream>
+#include <iostream>
+#include <iomanip>
+#include <cstdio>
+#include <cmath>
+#include <cstdlib>
+#include <ctime>
+#include <fstream>
+
+using namespace std;
+
+template< typename T>
+T next(istream & is) {
+    T t;
+    is >> t;
+    return t;
+}
+
+template< typename T>
+void print(ostream & os, int i, T t) {
+    os << "Case #" << i << ": " << t << endl;  
+}
+
+template< typename T>
+vector<T> tokenize(string str, string ch) {
+    vector<T> res;
+    for(int p1 = 0, p2; p1 < (int)str.size(); p1 = p2+1) {
+        p2 = str.find_first_of(ch, p1);
+        if(p2 == -1) p2 = str.size();
+        if(p2-p1 > 0) {
+            T t;
+            istringstream is(str.substr(p1, p2-p1));
+            is >> t;
+            res.push_back(t);
+        }
+    }
+    return res;
+}
+
+class Solution {
+    public:
+        Solution() {
+            input.open("data.in", ios::in);
+            output.open("data.out", ios::out);
+        }
+
+        ~Solution() {
+            input.close();
+            output.close();
+        }
+
+        void solve() {
+            int T = next<int>(input);
+            for (int i = 1; i <= T; i++) {
+                print(output, i, solveCase());
+                //print(cout, i, solveCase());
+            } 
+        }
+
+    private:
+        string solveCase() {
+            float height = (next<char>(input) == 'B') ? 5.f :-5.f;
+            vector<int> tokens;
+            tokens = tokenize<int>(next<string>(input), "\'\"");
+            height += 12 * tokens[0] + tokens[1];
+            tokens = tokenize<int>(next<string>(input), "\'\"");
+            height += 12 * tokens[0] + tokens[1];
+            height /= 2.0;
+
+            ostringstream os;
+            height -= 4;
+            //cout << "lower: " << height << endl;
+            int feet = (int)height/12;
+            int inches = (int)ceil(height - 12*feet);
+            if (inches == 12) 
+                feet +=1, inches = 0;
+            os << feet << "\'" << inches << "\"";
+            os << " to ";
+            height += 8;
+            //cout << "upper: " << height << endl;
+            feet = (int)height/12;
+            inches = (int)floor(height - 12*feet);
+            os << feet << "\'" << inches << "\"";
+            return os.str();
+        }
+
+        ifstream input;
+        ofstream output;
+};
+
+
+int main() {
+    Solution sol;
+    sol.solve();
+}
diff --git a/Bullseye/Solution.cpp b/Bullseye/Solution.cpp
new file mode 100644
index 0000000..8518bd8
--- /dev/null
+++ b/Bullseye/Solution.cpp
@@ -0,0 +1,74 @@
+#include <vector>
+#include <list>
+#include <map>
+#include <set>
+#include <queue>
+#include <deque>
+#include <stack>
+#include <bitset>
+#include <algorithm>
+#include <functional>
+#include <numeric>
+#include <utility>
+#include <sstream>
+#include <iostream>
+#include <iomanip>
+#include <cstdio>
+#include <cmath>
+#include <cstdlib>
+#include <ctime>
+#include <fstream>
+
+using namespace std;
+
+class Solution {
+public:
+    Solution() {
+        input = freopen("data.in" , "r" , stdin);
+        output = freopen("data.out" , "w" , stdout);
+    }
+
+    ~Solution() {
+        fclose(input);
+        fclose(output);
+    }
+
+    void solve() {
+        int T;
+        cin >> T;
+        for(int i = 1; i <= T; i++)  {
+            cout << "Case #" << i << ": " << solveCase() << endl;
+        }
+    }
+
+private:
+    long long solveCase() {
+        long long r, t;
+        cin >> r >> t;
+        //cout << r << "," << t << endl;
+        long long l = 0, u = t, m;
+        while (l+1 < u) {
+            m = l + (u-l)/2;
+            if (check(r, m, t))
+                l = m;
+            else
+                u = m;
+            //cout << l << "," << u << endl;
+        }
+        return l;
+    }
+
+    bool check(long long r, long long n, long long t) {
+        long long s = 2*r+2*n-1;
+        if (s > 2e18 || 2e18 / s < n) return false;
+        return s*n <= t;
+    }
+
+    FILE * input;
+    FILE * output;
+};
+
+int main() {
+    Solution sol;
+    sol.solve();
+}
diff --git a/FairandSquare/Solution.cpp b/FairandSquare/Solution.cpp
new file mode 100644
index 0000000..1bcbb87
--- /dev/null
+++ b/FairandSquare/Solution.cpp
@@ -0,0 +1,143 @@
+#include <vector>
+#include <list>
+#include <map>
+#include <set>
+#include <queue>
+#include <deque>
+#include <stack>
+#include <bitset>
+#include <algorithm>
+#include <functional>
+#include <numeric>
+#include <utility>
+#include <sstream>
+#include <iostream>
+#include <iomanip>
+#include <cstdio>
+#include <cmath>
+#include <cstdlib>
+#include <ctime>
+#include <fstream>
+
+using namespace std;
+
+class Solution {
+public:
+    Solution() {
+        input = freopen("data.in", "r" , stdin);
+        output = freopen("data.out", "w" , stdout);
+    }
+
+    void solve() {
+        int T;
+        cin >> T;
+        for(int i = 1; i <= T; i++)  {
+            cout << "Case #" << i << ": " << solveCase() << endl;
+        }
+    }
+
+private:
+    int solveCase() {
+        long long A, B;
+        cin >> A >> B;
+
+        int res = 0;
+        
+        long long root = sqrt(A);
+        if (isPalindrome(root) && isPalindrome(A) && root*root == A)
+            res++;
+       
+        ostringstream os;
+        os << root;
+        string str = os.str();
+        while (true) {
+            nextPalindrome(str);
+            istringstream is(str);
+            is >> root;
+            long long prod = root*root;
+            if (prod > B)
+                break;
+            if (isPalindrome(prod))
+                res++;
+        }
+
+        return res;
+    }
+   
+    long long sqrt(long long x) {
+        if(x < 2) return x;
+        long long l = 0;
+        long long u = 1 + (x / 2); 
+        while(l+1 < u) {
+            long long m = l + (u - l) / 2;
+            long long p = m * m;
+            if (p == x) 
+                return m;
+            if(p > x)
+                u = m;
+            else
+                l = m;
+        }
+        return l;
+    } 
+    
+    bool isPalindrome(long long x) {
+        if (x < 0) return false;
+        long long d = 1;
+        while (x / d >= 10) d *= 10; 
+        while (x != 0) {
+            long long l = x / d;
+            long long r = x % 10; 
+            if (l != r) return false;
+            x = (x % d) / 10; 
+            d /= 100;
+        }   
+        return true;
+    }   
+
+    void nextPalindrome(string & num) {   
+        string org(num);
+        int begin = 0;
+        int end = num.size() - 1;
+        while (begin < end)
+            num[end--] = num[begin++];
+        if (begin > end)
+            begin--, end++;
+        if (!isGreater(num, org))
+            increase(num, begin, end);
+    }   
+
+    bool isGreater(string & v1, string & v2) {
+        if (v1.size() != v2.size())
+            return v1.size() > v2.size();
+        for (size_t i = 0; i < v1.size(); i++)
+            if (v1[i] != v2[i])
+                return v1[i] > v2[i];
+        return false;
+    }   
+
+    void increase(string & num, int begin, int end) {
+        if (begin < 0) {   
+            num[num.size() - 1] = '1';
+            num.insert(num.begin(), '1'); 
+            return;
+        }
+
+        if (num[begin] < '9') {   
+            num[begin] = num[end] = num[begin] + 1;
+            return;
+        }
+
+        num[begin] = num[end] = '0';
+        increase(num, begin-1, end+1);
+        return;
+    }
+
+    FILE * input;
+    FILE * output;
+};
+
+int main() {
+    Solution sol;
+    sol.solve();
+}
diff --git a/FileFixit/Solution.cpp b/FileFixit/Solution.cpp
new file mode 100644
index 0000000..62fd6fb
--- /dev/null
+++ b/FileFixit/Solution.cpp
@@ -0,0 +1,114 @@
+#include <vector>
+#include <list>
+#include <map>
+#include <set>
+#include <queue>
+#include <deque>
+#include <stack>
+#include <bitset>
+#include <algorithm>
+#include <functional>
+#include <numeric>
+#include <utility>
+#include <sstream>
+#include <iostream>
+#include <iomanip>
+#include <cstdio>
+#include <cmath>
+#include <cstdlib>
+#include <ctime>
+#include <fstream>
+
+using namespace std;
+
+template< typename T>
+T next(istream & is) {
+    T t;
+    is >> t;
+    return t;
+}
+
+template< typename T>
+void print(ostream & os, int i, T t) {
+    os << "Case #" << i << ": " << t << endl;  
+}
+
+template< typename T>
+vector<T> tokenize(string str, string ch) {
+    vector<T> res;
+    for(int p1 = 0, p2; p1 < (int)str.size(); p1 = p2+1) {
+        p2 = str.find_first_of(ch, p1);
+        if(p2 == -1) p2 = str.size();
+        if(p2-p1 > 0) {
+            T t;
+            istringstream is(str.substr(p1, p2-p1));
+            is >> t;
+            res.push_back(t);
+        }
+    }
+    return res;
+}
+
+class Solution {
+public:
+    Solution() {
+        input.open("data.in", ios::in);
+        output.open("data.out", ios::out);
+    }
+
+    ~Solution() {
+        input.close();
+        output.close();
+    }
+
+    void solve() {
+        int T = next<int>(input);
+        for (int i = 1; i <= T; i++) {
+            print(output, i, solveCase());
+            //print(cout, i, solveCase());
+        } 
+    }
+
+private:
+    int solveCase() {
+        int N = next<int>(input);
+        int M = next<int>(input);
+        Node root;
+        int res = 0;
+        for (int i = 0; i < N; i++) {
+            vector<string> path = tokenize<string>(next<string>(input), "/");
+            Node::addNode(root, path, 0, res, false); 
+        }
+
+        for (int i = 0; i < M; i++) {
+            vector<string> path = tokenize<string>(next<string>(input), "/");
+            Node::addNode(root, path, 0, res, true);
+        }
+
+        return res;
+    }
+    
+    class Node {
+    public:
+        static void addNode(Node & node, vector<string> & path, size_t i, int & res, bool make) {
+            if (i == path.size())
+                return;
+            if (node.next.find(path[i]) == node.next.end()) {
+                node.next[path[i]] = Node();
+                if (make) res++;
+            }
+            addNode(node.next[path[i]], path, i+1, res, make);
+        }
+    private:
+        map<string, Node> next;
+    };
+
+    ifstream input;
+    ofstream output;
+};
+
+
+int main() {
+    Solution sol;
+    sol.solve();
+}
diff --git a/Hedgemony/Solution.cpp b/Hedgemony/Solution.cpp
new file mode 100644
index 0000000..2e28b07
--- /dev/null
+++ b/Hedgemony/Solution.cpp
@@ -0,0 +1,83 @@
+#include <vector>
+#include <list>
+#include <map>
+#include <set>
+#include <queue>
+#include <deque>
+#include <stack>
+#include <bitset>
+#include <algorithm>
+#include <functional>
+#include <numeric>
+#include <utility>
+#include <sstream>
+#include <iostream>
+#include <iomanip>
+#include <cstdio>
+#include <cmath>
+#include <cstdlib>
+#include <ctime>
+#include <fstream>
+
+using namespace std;
+
+template< typename T>
+T next(istream & is) {
+    T t;
+    is >> t;
+    return t;
+}
+
+template< typename T>
+void print(ostream & os, int i, T t) {
+    os << "Case #" << i << ": " << t << endl;  
+}
+
+class Solution {
+public:
+    Solution() {
+        input.open("data.in", ios::in);
+        output.open("data.out", ios::out);
+        output << fixed << setprecision(6);
+        //cout << fixed << setprecision(6);  
+    }
+
+    ~Solution() {
+        input.close();
+        output.close();
+    }
+
+    void solve() {
+        int T = next<int>(input);
+        for (int i = 1; i <= T; i++) {
+            print(output, i, solveCase());
+            //print(cout, i, solveCase());
+        } 
+    }
+
+private:
+    float solveCase() {
+        int N = next<int>(input);
+        float left = next<float>(input);
+        float curr = next<float>(input);
+        for (int i = 1; i < N-1; i++) {
+            float right = next<float>(input);
+            float avg = (left + right) / 2.0;
+            if (curr > avg) curr = avg;
+            left = curr;
+            curr = right;
+        }
+
+        return left; 
+    }
+
+    ifstream input;
+    ofstream output;
+};
+
+
+int main() {
+    Solution sol;
+    sol.solve();
+    return 0;
+}
diff --git a/Lawnmower/Solution.cpp b/Lawnmower/Solution.cpp
new file mode 100644
index 0000000..7419694
--- /dev/null
+++ b/Lawnmower/Solution.cpp
@@ -0,0 +1,110 @@
+#include <vector>
+#include <list>
+#include <map>
+#include <set>
+#include <queue>
+#include <deque>
+#include <stack>
+#include <bitset>
+#include <algorithm>
+#include <functional>
+#include <numeric>
+#include <utility>
+#include <sstream>
+#include <iostream>
+#include <iomanip>
+#include <cstdio>
+#include <cmath>
+#include <cstdlib>
+#include <ctime>
+#include <fstream>
+
+using namespace std;
+
+class Solution {
+public:
+    Solution() {
+        input = freopen("data.in" , "r" , stdin);
+        output = freopen("data.out" , "w" , stdout);
+    }
+
+    void solve() {
+        int T;
+        cin >> T;
+        for(int i = 1; i <= T; i++)  {
+            cout << "Case #" << i << ": " << solveCase() << endl;
+        }
+    }
+
+private:
+    string solveCase() {
+        int N, M;
+        cin >> N >> M;
+        vector<vector<int> > board;
+        for (int i = 0; i < N; i++) {
+            vector<int> row;
+            for (int j = 0; j < M; j++) {
+                int num;
+                cin >> num;
+                //cout << num << " ";
+                row.push_back(num);
+            }
+            //cout << endl;
+            board.push_back(row);
+        }
+       
+        if (N == 1 || M == 1) return "YES";
+        
+        vector<int> rows(N, 0);
+        for (int i = 0; i < N; i++) {
+            for (int j = 0; j < M; j++) {
+                if (board[i][j] > rows[i]) rows[i] = board[i][j];
+            }
+        }
+        vector<int> cols(M, 0);
+        for (int j = 0; j < M; j++) {
+            for (int i = 0; i < N; i++) {
+                if (board[i][j] > cols[j]) cols[j] = board[i][j];
+            }
+        }
+
+        for (int i = 0; i < N; i++) {
+            for (int j = 0; j < M; j++) {
+                if (board[i][j] < rows[i] && board[i][j] < cols[j])
+                    return "NO";
+            }
+        }
+        return "YES";
+    }
+
+    bool check(vector<vector<int> > board, int x, int y) {
+        int N = board.size();
+        int M = board[0].size();
+        int i, j;
+        i = x, j = 0;;
+        for (; j < M; j++) {
+            if (board[i][j] > board[x][y]) {
+                break;
+            }
+        }
+        if (j == M) return true;
+        
+        i = 0, j = y;
+        for (; i < N; i++) {
+            if (board[i][j] > board[x][y]) {
+                break;
+            }
+        }
+        if (i == N) return true;
+
+        return false;
+    }
+
+    FILE * input;
+    FILE * output;
+};
+
+int main() {
+    Solution sol;
+    sol.solve();
+}
diff --git a/ManageYourEnergy/Solution.cpp b/ManageYourEnergy/Solution.cpp
new file mode 100644
index 0000000..a8a3d97
--- /dev/null
+++ b/ManageYourEnergy/Solution.cpp
@@ -0,0 +1,121 @@
+#include <vector>
+#include <list>
+#include <map>
+#include <set>
+#include <queue>
+#include <deque>
+#include <stack>
+#include <bitset>
+#include <algorithm>
+#include <functional>
+#include <numeric>
+#include <utility>
+#include <sstream>
+#include <iostream>
+#include <iomanip>
+#include <cstdio>
+#include <cmath>
+#include <cstdlib>
+#include <ctime>
+#include <fstream>
+
+using namespace std;
+
+class Solution {
+public:
+    Solution() {
+        input = freopen("data.in" , "r" , stdin);
+        output = freopen("data1.out" , "w" , stdout);
+    }
+    
+    void solve() {
+        int T;
+        cin >> T;
+        for(int i = 1; i <= T; i++)  {
+            cout << "Case #" << i << ": " << solveCase1() << endl;
+        }
+    }
+
+private:
+    long long solveCase1() {
+        int E, R, N;
+        cin >> E >> R >> N;
+        vector<int> v(N, 0);
+        for (int i = 0; i < N; ++i) {
+            cin >> v[i];
+        }
+    
+        if (R > E) R = E;
+        vector<int> u(N, 0);
+        u[0] = E;
+        for (int i = 1; i < N; ++i) {
+            u[i] = R;
+            for (int j = i-1; j >= 0; --j) {
+                if (v[j] >= v[i]) break;
+                if (u[i] + u[j] <= E) {
+                    u[i] += u[j];
+                    u[j] = 0;
+                }
+                else {
+                    u[j] -= E-u[i];
+                    u[i] = E;
+                    break;
+                }
+            }
+        }
+        //for (int i = 0; i < N; ++i)
+        //    cout << u[i] << " ";
+        //cout << endl;
+        long long res = 0;
+        for (int i = 0; i < N; ++i)
+            res += (long long)v[i]*u[i];
+        return res;
+    }
+        
+    long long solveCase2() {
+        int E, R, N;
+        cin >> E >> R >> N;
+        vector<int> v(N, 0);
+        for (int i = 0; i < N; ++i) {
+            cin >> v[i];
+        }
+    
+        if (R > E) R = E;
+        vector<int> u(N, 0);
+        stack<int> stk;
+        stk.push(0);
+        u[0] = E;
+        for (int i = 1; i < N; ++i) {
+            u[i] = R;
+            while (!stk.empty() && v[stk.top()] < v[i]) {
+                int j = stk.top();
+                stk.pop();
+                if (u[i] + u[j] <= E) {
+                    u[i] += u[j];
+                    u[j] = 0;
+                }
+                else {
+                    u[j] -= E-u[i];
+                    u[i] = E;
+                    break;
+                }
+            }
+            stk.push(i);
+        }
+        //for (int i = 0; i < N; ++i)
+        //    cout << u[i] << " ";
+        //cout << endl;
+        long long res = 0;
+        for (int i = 0; i < N; ++i)
+            res += (long long)v[i]*u[i];
+        return res;
+    }
+
+    FILE * input;
+    FILE * output;
+};
+
+int main() {
+    Solution sol;
+    sol.solve();
+}
diff --git a/OceanView/Solution.cpp b/OceanView/Solution.cpp
new file mode 100644
index 0000000..66ecb79
--- /dev/null
+++ b/OceanView/Solution.cpp
@@ -0,0 +1,84 @@
+#include <vector>
+#include <list>
+#include <map>
+#include <set>
+#include <queue>
+#include <deque>
+#include <stack>
+#include <bitset>
+#include <algorithm>
+#include <functional>
+#include <numeric>
+#include <utility>
+#include <sstream>
+#include <iostream>
+#include <iomanip>
+#include <cstdio>
+#include <cmath>
+#include <cstdlib>
+#include <ctime>
+#include <fstream>
+
+using namespace std;
+
+template< typename T>
+T next(istream & is) {
+    T t;
+    is >> t;
+    return t;
+}
+
+template< typename T>
+void print(ostream & os, int i, T t) {
+    os << "Case #" << i << ": " << t << endl;  
+}
+
+class Solution {
+public:
+    Solution() {
+        input.open("data.in", ios::in);
+        output.open("data.out", ios::out);
+    }
+
+    ~Solution() {
+        input.close();
+        output.close();
+    }
+
+    void solve() {
+        int T = next<int>(input);
+        for (int i = 1; i <= T; i++) {
+            print(output, i, solveCase());
+            //print(cout, i, solveCase());
+        } 
+    }
+
+private:
+    int solveCase() {
+        int N = next<int>(input);
+        vector<int> num;
+        num.reserve(N);
+        for (int i = 0; i < N; i++)
+            num.push_back(next<int>(input));
+        vector<int> dp(N, 1);
+        for (int i = 1; i < N; i++)
+            for (int j = 0; j < i; j++)
+                if (num[i] > num[j] && dp[i] < dp[j] + 1)
+                    dp[i] = dp[j] + 1;
+        int res = 0;
+        for (int i = 0; i < N; i++)
+            if (dp[i] > res)
+                res = dp[i];
+        res = N-res;
+        return res;
+    }
+
+    ifstream input;
+    ofstream output;
+};
+
+
+int main() {
+    Solution sol;
+    sol.solve();
+}
diff --git a/README b/README
index e69de29..3ba1e7f 100644
--- a/README
+++ b/README
@@ -0,0 +1,58 @@
+Round 1A 2013:
+Bullseye
+ManageYourEnergy
+
+Qualification Round 2013:
+Tic-Tac-Toe-Tomek
+Lawnmower
+Fair and Square
+
+Veterans 2013:
+Hedgemony
+BabyHeight
+OceanView
+
+Qualification Round 2012:
+SpeakingInTongues
+DancingWiththeGooglers
+RecycledNumbers
+
+EuroPython 2011:
+CentauriPrime
+MusicCollection
+IrregularExpressions
+Twibet
+
+Qualification Round 2011:
+BotTrust
+Magicka
+CandySplitting
+
+Round 1A 2010:
+Rotate
+
+Round 1C 2010:
+Rope Intranet
+
+Qualification Round Africa 2010:
+StoreCredit
+ReverseWords
+T9Spelling
+
+Online Competition Africa 2010:
+OddManOut
+GettoWork
+Milkshakes
+
+Round 1C 2009:
+AllYourBase
+
+Qualification Round 2009:
+AlienLanguage
+
+Round 1A 2008:
+MinimumScalarProduct
+
+Practice Problems:
+AlienNumbers
+AlwaysTurnLeft
diff --git a/RopeIntranet/Solution.cpp b/RopeIntranet/Solution.cpp
new file mode 100644
index 0000000..e70d051
--- /dev/null
+++ b/RopeIntranet/Solution.cpp
@@ -0,0 +1,81 @@
+#include <vector>
+#include <list>
+#include <map>
+#include <set>
+#include <queue>
+#include <deque>
+#include <stack>
+#include <bitset>
+#include <algorithm>
+#include <functional>
+#include <numeric>
+#include <utility>
+#include <sstream>
+#include <iostream>
+#include <iomanip>
+#include <cstdio>
+#include <cmath>
+#include <cstdlib>
+#include <ctime>
+#include <fstream>
+
+using namespace std;
+
+template< typename T>
+T next(istream & is) {
+    T t;
+    is >> t;
+    return t;
+}
+
+template< typename T>
+void print(ostream & os, int i, T t) {
+    os << "Case #" << i << ": " << t << endl;  
+}
+
+class Solution {
+public:
+    Solution() {
+        input.open("data.in", ios::in);
+        output.open("data.out", ios::out);
+    }
+
+    ~Solution() {
+        input.close();
+        output.close();
+    }
+
+    void solve() {
+        int T = next<int>(input);
+        for (int i = 1; i <= T; i++) {
+            print(output, i, solveCase());
+            //print(cout, i, solveCase());
+        } 
+    }
+
+private:
+    int solveCase() {
+        int N = next<int>(input);
+        vector<int> a;
+        vector<int> b;
+        for (int i = 0; i < N; i++) {
+            a.push_back(next<int>(input));
+            b.push_back(next<int>(input));
+        }
+        int res = 0;
+        for (int i = 1; i < N; i++)
+            for (int j = i-1; j >= 0; j--)
+                if ((a[i] > a[j] && b[i] < b[j]) || (a[i] < a[j] && b[i] > b[j]))
+                   res++;
+        return res;
+    }
+
+    ifstream input;
+    ofstream output;
+};
+
+
+int main() {
+    Solution sol;
+    sol.solve();
+}
diff --git a/Rotate/Solution.cpp b/Rotate/Solution.cpp
new file mode 100644
index 0000000..824ee11
--- /dev/null
+++ b/Rotate/Solution.cpp
@@ -0,0 +1,158 @@
+#include <vector>
+#include <list>
+#include <map>
+#include <set>
+#include <queue>
+#include <deque>
+#include <stack>
+#include <bitset>
+#include <algorithm>
+#include <functional>
+#include <numeric>
+#include <utility>
+#include <sstream>
+#include <iostream>
+#include <iomanip>
+#include <cstdio>
+#include <cmath>
+#include <cstdlib>
+#include <ctime>
+#include <fstream>
+
+using namespace std;
+
+class Solution {
+public:
+    Solution() {
+        input = freopen("data.in" , "r" , stdin);
+        output = freopen("data.out" , "w" , stdout);
+    }
+
+    void solve() {
+        int T;
+        cin >> T;
+        for(int i = 1; i <= T; i++)  {
+            cout << "Case #" << i << ": " << solveCase(i) << endl;
+        }
+    }
+
+private:
+    string solveCase(int id) {
+        int N, K;
+        cin >> N >> K;
+        vector<string> board;
+        board.reserve(N);
+        for (int i = 0; i < N; i++){
+            string row;
+            cin >> row;
+            board.push_back(row);
+        }
+
+        rotate(board);
+
+        drop(board);
+
+        bool red = check(board, 'R', K, id);
+        bool blue = check(board, 'B', K, id);
+
+        if (red && blue)
+            return "Both";
+        if (red)
+            return "Red";
+        if (blue)
+            return "Blue";
+        return "Neither";
+    }
+
+    void rotate(vector<string> & board) {
+        int N = board.size();
+        for (int j = 0; j < N/2; j++) {
+            int first = j;
+            int last = N - j - 1;
+            for (int i = first; i < last; i++) {
+                int offset = i - first;
+                int top = board[first][i];
+                board[first][i] = board[last-offset][first];
+                board[last-offset][first] = board[last][last-offset];
+                board[last][last-offset] = board[i][last];
+                board[i][last] = top;
+            }
+        }
+    }
+
+    void drop(vector<string> & board) {
+        int N = board.size();
+        for (int j = 0; j < N; j++){
+            int i1 = N-1;
+            while (true) {
+                while (i1 >= 0 && board[i1][j] != '.') i1--;
+                if (i1 < 0) break;
+                int i2 = i1-1;
+                while (i2 >= 0 && board[i2][j] == '.') i2--;
+                if (i2 < 0) break;
+                board[i1][j] = board[i2][j];
+                board[i2][j] = '.';
+            }
+        }
+    }
+
+    bool check(vector<string> & board, char ch, int K, int caseID) {
+        int N = board.size();
+
+        for (int i = N-1; i >= 0; --i) {
+            int c = 0;
+            for (int j = 0; j <= N-1; ++j) {
+                if (board[i][j] == ch) {
+                    if(++c == K) return true;
+                }
+                else c = 0;
+            }
+        }
+
+        for (int j = 0; j <= N-1; ++j) {
+            int c = 0;
+            for (int i = N-1; i >= 0; --i) {
+                if (board[i][j] == ch) {
+                    if(++c == K) return true;
+                }
+                else c = 0;
+            }
+        }
+
+        for (int i = 0; i < N*2-1; ++i) {
+            int k = i < N ? 0 : i-N+1;
+            int c = 0;
+            for (int j = k; j <= i-k; ++j) {
+                int row = j;
+                int col = (N-1)-(i-j);
+                if (board[row][col] == ch) {
+                    if(++c == K) return true;
+                }
+                else c = 0;
+            }
+        }
+
+        for (int i = 0; i < N*2-1; ++i) {
+            int k = i < N ? 0 : i-N+1;
+            int c = 0;
+            for (int j = k; j <= i-k; ++j) {
+                int row = j;
+                int col = (i-j);
+                if (board[row][col] == ch) {
+                    if(++c == K) return true;
+                }
+                else c = 0;
+            }
+        }
+
+        return false;
+    }
+
+    FILE * input;
+    FILE * output;
+};
+
+int main() {
+    Solution sol;
+    sol.solve();
+}
\ No newline at end of file
diff --git a/TicTacToeTomek/Solution.cpp b/TicTacToeTomek/Solution.cpp
new file mode 100644
index 0000000..97568ef
--- /dev/null
+++ b/TicTacToeTomek/Solution.cpp
@@ -0,0 +1,123 @@
+#include <vector>
+#include <list>
+#include <map>
+#include <set>
+#include <queue>
+#include <deque>
+#include <stack>
+#include <bitset>
+#include <algorithm>
+#include <functional>
+#include <numeric>
+#include <utility>
+#include <sstream>
+#include <iostream>
+#include <iomanip>
+#include <cstdio>
+#include <cmath>
+#include <cstdlib>
+#include <ctime>
+#include <fstream>
+
+using namespace std;
+
+class Solution {
+public:
+    Solution() {
+        input = freopen("data.in" , "r" , stdin);
+        output = freopen("data.out" , "w" , stdout);
+    }
+
+    void solve() {
+        int T;
+        cin >> T;
+        for(int i = 1; i <= T; i++)  {
+            cout << "Case #" << i << ": " << solveCase() << endl;
+        }
+    }
+
+private:
+    string solveCase() {
+        vector<string> board;
+        for (int i = 0; i < 4; i++) {
+            string row;
+            cin >> row;
+            board.push_back(row);
+        }
+        
+        bool over = true;
+        for (int i = 0; i < 4; i++) {
+            for (int j = 0; j < 4; j++) {
+                if (board[i][j] == '.') {
+                    over = false;
+                    break;
+                }
+            }
+        }
+
+        bool oWin = win(board, 'O');
+        bool xWin = win(board, 'X');
+
+        if (oWin)
+            return "O won";
+        if (xWin)
+            return "X won";
+        if (over)
+            return "Draw";
+        return "Game has not completed";
+    }
+
+    bool win(vector<string> & board, char ch) {
+        int c;
+        for (int i = 0; i < 4; i++) {
+            c = 0;
+            for (int j = 0; j < 4; j++) {
+                if (board[i][j] == ch || board[i][j] == 'T')
+                    c++;
+                else
+                    c = 0;
+            }
+            if (c == 4) return true;
+        } 
+        
+        for (int j = 0; j < 4; j++) {
+            c = 0;
+            for (int i = 0; i < 4; i++) {
+                if (board[i][j] == ch || board[i][j] == 'T')
+                    c++;
+                else
+                    c = 0;
+            }
+            if (c == 4) return true;
+        }
+    
+        c = 0;
+        for (int i = 3; i >= 0; i--) {
+            int j = 3-i;
+            if (board[i][j] == ch || board[i][j] == 'T')
+                    c++;
+                else
+                    c = 0;
+        }
+        if (c == 4) return true;
+
+        c = 0;
+        for (int i = 3; i >= 0; i--) {
+            int j = i;
+            if (board[i][j] == ch || board[i][j] == 'T')
+                    c++;
+                else
+                    c = 0;
+        }
+        if (c == 4) return true;
+        return false;
+    }
+
+    FILE * input;
+    FILE * output;
+};
+
+int main() {
+    Solution sol;
+    sol.solve();
+}