diff --git a/EADS/MidTerm/task1.cpp b/EADS/MidTerm/task1.cpp new file mode 100644 index 00000000..4d66a08f --- /dev/null +++ b/EADS/MidTerm/task1.cpp @@ -0,0 +1,57 @@ +// KRZYSZTOF RUDNICKI, 307585, task 1 + +class List +{ + private: + struct Node{ + double key; + Node* next; + }; + Node* head; + public: + int insert(double newVal, double firstVal, double secondVal); +}; + +int List::insert(double newVal, double firstVal, double secondVal) +{ + Node* curr = head; + + if(head == nullptr) return 0; // we can't insert anything inside empty list + if(curr->next == nullptr) return 0; // we can't insert a node between two nodes if there is only one node + if(curr->next->next == nullptr) // If there is exactly two nodes + { + if(head -> key == firstVal && head -> next -> key == secondVal) + { + Node* newNode = new Node(); + newNode -> key = newVal; + newNode -> next = head -> next; + head -> next = newNode; + return 1; + }else return 0; + } + + int insertions = 0; + while(curr -> next != nullptr) // If there is three nodes or more + { + bool foundKeys = 0; + if(curr -> key == firstVal && curr -> next -> key == secondVal) + { + Node* newNode = new Node(); + newNode -> key = newVal; + newNode -> next = curr->next; + curr -> next = newNode; + insertions++; + foundKeys = 1; + curr = newNode -> next; // If newVal == firstVal, then without this line we will have + // infintie loop, to counteract this we skip newly added node. + } + if(!foundKeys) curr = curr -> next; + } + + return insertions; +} + +int main() +{ + return 0; +} \ No newline at end of file diff --git a/EADS/MidTerm/task2.cpp b/EADS/MidTerm/task2.cpp new file mode 100644 index 00000000..863514f0 --- /dev/null +++ b/EADS/MidTerm/task2.cpp @@ -0,0 +1,55 @@ +// Krzysztof Rudnicki, 307585 + +struct treeNode +{ + int key; + treeNode *left; + treeNode *right; +}; + +class Tree{ + + private: + treeNode *root; + public: + bool checkKeys(int givenKey); + bool findNode(treeNode*& nodeToFound, int givenKey); + int sumNodeSub(treeNode* start); +}; + +int Tree::sumNodeSub(const treeNode* start) +{ + return (sumNodeSub(start->right) + + sumNodeSub(start->left) + + start->key); +} + +bool Tree::findNode(treeNode*& nodeToFound, int givenKey); +{ + treeNode* curr = root; + treeNode* Cleft = curr->left; + treeNode* Cright = curr->right; + while(curr != nullptr) + { + if(curr -> key == givenKey) + { + nodeToFound = curr; + return 1; + }else + { + if(Cleft.findNode(nodeToFound, givenKey)) return 1; + if(Cright.findNode(nodeToFound, givenKey)) return 1; + } + } + return 0; +} + + + +bool Tree::checkKeys(int key) +{ + treeNode* start; + if (!findNode(start, key)) return 0; + // if we did not find the node we cannot compare the keys of it's left and right subtrees + return (sumNodeSub(start->left) > sumNodeSub(start->right)); +} \ No newline at end of file diff --git a/EADS/MidTerm/task3.cpp b/EADS/MidTerm/task3.cpp new file mode 100644 index 00000000..37fac500 --- /dev/null +++ b/EADS/MidTerm/task3.cpp @@ -0,0 +1,62 @@ +// Krzysztof Rudnicki, 307585, task 3 + +template +class Ring{ + private: + struct Node{ + Key key; + Node* prev; + Node* next; + }; + Node* any; +public: + bool removeNeighbours(const Key& givenKey); +}; + +template +bool Ring::removeNeighbours(const Key& givenKey) +{ + Node* curr = any; + if(any == nullptr || any -> next == nullptr) return 0; + // we can't remove 2 nodes if there is less than 2 nodes + bool foundKey = 0; + // we are interested in 5 nodes, lets call them, from left to right: + // A; B; C; D; E + // I will use this for comments + // if C has a key then at the end we want to get: + // A; C; E + do{ + if(curr -> key == givenKey) + { + Node* temp = curr; + curr -> prev -> prev -> next = curr; + // curr -> prev -> prev points to Node "A" + // it used to point "next" to Node "B" which we are going to remove so it must + // start to point to a new node in our case node "C" + curr -> next -> next -> prev = curr; + // curr -> next -> next points to Node "E" + // it used to point "prev" to Node "D" which we are going to remove so it must + // start to point to a new node in our case node "C" + curr -> next = curr -> next -> next; + // curr points to Node "C" + // it used to point "next" to Node "D" which we are going to remove so it must + // start to point to a new node in our case node "E" + curr -> prev = curr -> prev -> prev; + // curr points to Node "C" + // it used to point "prev" to Node "B" which we are going to remove so it must + // start to point to a new node in our case node "A" + if(curr->prev == any || curr -> next == any) any = curr; + // if any of the neighours that we are going to delete is "any", we must provide + // the ring with a new "any" node + delete temp->prev; + // this way we will delete what USED to be curr->prev + // temp->prev points to "B" node + delete temp->next; + // this way we will delete what USED to be curr->next + // temp->next points to "D" node + foundKey = 1; + } + curr = curr->next; + }while(curr != any); + return foundKey; +} \ No newline at end of file diff --git a/EADS/lab1.cpp b/EADS/lab1.cpp new file mode 100644 index 00000000..83f0fdc8 --- /dev/null +++ b/EADS/lab1.cpp @@ -0,0 +1,355 @@ +#include +#include + +template +class Sequence{ + + private: + struct Node{ + Key key; + Info info; + Node* next; + }; + Node* head; + + public: + Sequence(); + void destroySequence(); + ~Sequence(); + void copySequence(const Sequence& otherSequence); + Sequence(const Sequence& otherSequence); + const Sequence& operator=(const Sequence& otherSequence); + int length() const; + void print() const; + bool isEmpty() const; + bool getKeyandInfoAt(const int position, Key& keyToReturn, Info& infoToReturn) const; + void insertAtEnd(const Key& newKey, const Info& newInfo); + +}; + + +template +Sequence::Sequence() +{ + head = nullptr; +} + +template +void Sequence::destroySequence() +{ + Node* curr; + while(head != nullptr) + { + curr = head; + head = head->next; + delete curr; + } +} + +template +Sequence::~Sequence() +{ + destroySequence(); +} + +template +void Sequence::copySequence(const Sequence& otherSequence) +{ + if(head != nullptr) destroySequence(); + if(otherSequence.head == nullptr) head = nullptr; + else + { + Node* curr = otherSequence.head; + head = new Node(); + head -> key = curr -> key; + head -> info = curr -> info; + head -> next = nullptr; + curr = curr -> next; + Node* nextNode; + while(curr != nullptr) + { + nextNode = new Node(); + nextNode->key = curr->key; + nextNode->info = curr->info; + nextNode->next = nullptr; + curr = curr -> next; + } + } +} + +template +Sequence::Sequence(const Sequence& otherSequence) +{ + head = nullptr; + copySequence(otherSequence); +} + +template +const Sequence& Sequence::operator=(const Sequence& otherSequence) +{ + if(this != &otherSequence) + { + copySequence(otherSequence); + } + return *this; +} + + + +template +int Sequence::length() const +{ + Node* curr = head; + int length = 0; + while(curr != nullptr) + { + curr = curr->next; + length++; + } + return length; +} + +template +void Sequence::print() const +{ + Node* curr = head; + int position = 0; + if(head == nullptr) std::cout << "Sequence is empty" << std::endl; + while(curr != nullptr) + { + std::cout << "Inspecting element number: [" << position << "]" << std::endl; + std::cout << "Key value is: [" << curr -> key << "]" << std::endl; + std::cout << "Info value is: [" << curr -> info << "]" << std::endl; + curr = curr -> next; + position++; + } +} + +template +bool Sequence::isEmpty() const +{ + return length() == 0; +} + +template +bool Sequence::getKeyandInfoAt(const int position, Key& keyToReturn, Info& infoToReturn) const +{ + Node* curr = head; + int currentPosition = 0; + while(curr != nullptr) + { + if(currentPosition == position) + { + infoToReturn = curr -> info; + keyToReturn = curr -> key; + return 1; + } + curr = curr -> next; + currentPosition++; + } + return 0; +} + +template +void Sequence::insertAtEnd(const Key& newKey, const Info& newInfo) +{ + Node* newNode = new Node(); + newNode -> key = newKey; + newNode -> info = newInfo; + newNode -> next = nullptr; + if(head == nullptr) head = newNode; + else + { + Node* curr = head; + while(curr->next != nullptr) curr = curr->next; + curr -> next = newNode; + } +} + +template +bool addSingleSequence(const Sequence & seq, int start, int dl, int limit, Sequence & outputSequence) +{ + int elementsFromFirstSequence = start + dl; + int lengthOfFirstSequence = seq.length(); + int outputSize = outputSequence.length(); + bool maxSize = 0; + for(int i = start; i <= elementsFromFirstSequence && i <= lengthOfFirstSequence; i++) + { + Key newKey; + Info newInfo; + if(seq.getKeyandInfoAt(i, newKey, newInfo)) + { + outputSequence.insertAtEnd(newKey, newInfo); + outputSize++; + if(outputSize >= limit) + { + maxSize = 1; + break; + } + } + + + } + return maxSize; +} + +template +Sequence produce( + const Sequence & seq1, int start1, int dl1, + const Sequence & seq2, int start2, int dl2, + int limit) +{ + Sequence newSequence; + bool maxSize = addSingleSequence(seq1, start1, dl1, limit, newSequence); + + if(maxSize) return newSequence; + else addSingleSequence(seq2, start2, dl2, limit, newSequence); + return newSequence; + + +} + +bool testingTwoEmpty() +{ + Sequence empty1; + Sequence empty2; + Sequence outputSequence = produce(empty1, 0, 1, empty2, 0, 1, 5); + if(!outputSequence.isEmpty()) + { + outputSequence.print(); + std::cerr << "testingTwoEmpty()" << std::endl; + return 0; + } + return 1; +} + +bool testingOneEmpty() +{ + Sequence empty1; + Sequence notEmpty; + notEmpty.insertAtEnd(1, 2); + notEmpty.insertAtEnd(3, 4); + notEmpty.insertAtEnd(5, 6); + Sequence outputSequence = produce(empty1, 0, 1, notEmpty, 0, 4, 5); + std::vector keys(3); + std::vector infos(3); + outputSequence.getKeyandInfoAt(0, keys.at(0), infos.at(0)); + outputSequence.getKeyandInfoAt(1, keys.at(1), infos.at(1)); + outputSequence.getKeyandInfoAt(2, keys.at(2), infos.at(2)); + if(keys.at(0) != 1 || keys.at(1) != 3 || keys.at(2) != 5 || + infos.at(0) != 2 || infos.at(1) != 4 || infos.at(2) != 6) + { + outputSequence.print(); + std::cerr << "testingOneEmpty()" << std::endl; + return 0; + } + return 1; +} + +bool testingFirstOverLimit() +{ + Sequence overLimit; + Sequence shouldntMatter; + overLimit.insertAtEnd(1, 2); + overLimit.insertAtEnd(3, 4); + overLimit.insertAtEnd(5, 6); + overLimit.insertAtEnd(7, 9); + overLimit.insertAtEnd(9, 10); + shouldntMatter.insertAtEnd(100, 200); + Sequence outputSequence = produce(overLimit, 0, 5, shouldntMatter, 0, 1, 4); + if(outputSequence.length() != 4) + { + outputSequence.print(); + std::cerr << "testingFirstOverLimit()" << std::endl; + return 0; + } + return 1; +} + +bool testingSecondOverLimit() +{ + Sequence empty; + Sequence overLimit; + overLimit.insertAtEnd(1, 2); + overLimit.insertAtEnd(3, 4); + overLimit.insertAtEnd(5, 6); + overLimit.insertAtEnd(7, 9); + overLimit.insertAtEnd(9, 10); + Sequence outputSequence = produce(empty, 0, 2, overLimit, 0, 5, 4); + if(outputSequence.length() != 4) + { + outputSequence.print(); + std::cerr << "testingSecondOverLimit()" << std::endl; + return 0; + } + return 1; +} + +bool testingTooBigStart() +{ + Sequence tooSmall; + Sequence shouldntMatter; + tooSmall.insertAtEnd(1, 2); + tooSmall.insertAtEnd(3, 4); + tooSmall.insertAtEnd(5, 6); + Sequence outputSequence = produce(tooSmall, 4, 5, shouldntMatter, 1, 0, 5); + if(!outputSequence.isEmpty()) + { + outputSequence.print(); + std::cerr << "testingTooBigStart()" << std::endl; + return 0; + } + return 1; +} + +bool testingTooBigLength() +{ + Sequence tooShort; + Sequence shouldntMatter; + tooShort.insertAtEnd(1, 2); + tooShort.insertAtEnd(3, 4); + tooShort.insertAtEnd(5, 6); + Sequence outputSequence = produce(tooShort, 0, 6, shouldntMatter, 1, 0, 7); + if(outputSequence.length() != 3) + { + outputSequence.print(); + std::cerr << "testingTooBigLength()" << std::endl; + return 0; + } + return 1; +} + +bool testingNormal() +{ + Sequence normal1; + Sequence normal2; + normal1.insertAtEnd(1, 2); + normal1.insertAtEnd(3, 4); + normal2.insertAtEnd(5, 6); + Sequence outputSequence = produce(normal1, 0, 2, normal2, 0, 1, 3); + std::vector keys(3); + std::vector infos(3); + outputSequence.getKeyandInfoAt(0, keys.at(0), infos.at(0)); + outputSequence.getKeyandInfoAt(1, keys.at(1), infos.at(1)); + outputSequence.getKeyandInfoAt(2, keys.at(2), infos.at(2)); + if(keys.at(0) != 1 || keys.at(1) != 3 || keys.at(2) != 5 || + infos.at(0) != 2 || infos.at(1) != 4 || infos.at(2) != 6) + { + outputSequence.print(); + std::cerr << "testingNormal()" << std::endl; + return 0; + } + return 1; +} + +bool tests() +{ + return testingTwoEmpty()&&testingOneEmpty()&&testingFirstOverLimit()&& + testingSecondOverLimit()&&testingTooBigStart()&&testingTooBigLength()&&testingNormal(); + +} +int main() +{ + std::cout << "Result of tests: " << tests() << std::endl; + return 0; +} \ No newline at end of file diff --git a/EADS/lab2.cpp b/EADS/lab2.cpp new file mode 100644 index 00000000..4c5a3455 --- /dev/null +++ b/EADS/lab2.cpp @@ -0,0 +1,359 @@ +// Krzysztof Rudnicki, 307585, EADS 2 +#include + +void print(const std::string s) +{ + std::cout << s << std::endl; +} + +template +class Ring{ +private: + struct Node{ + Key key; + Info info; + Node* next; + Node* prev; + }; + Node* any; +public: + + class Iterator + { + private: + Node* pNode; + public: + Iterator() { pNode = nullptr; } + ~Iterator() { pNode = nullptr; } + Iterator(Node* ptr) : pNode(ptr) {} + + bool operator!=(const Iterator& other) const + { + return pNode != other.pNode; + } + + Iterator& operator++() + { + pNode = pNode -> next; + return *this; + } + + Iterator operator++(int) + { + Iterator it = *this; + pNode = pNode -> next; + return it; + } + + Iterator& operator--() + { + pNode = pNode -> prev; + return *this; + } + + Iterator operator--(int) + { + Iterator it = *this; + pNode = pNode -> prev; + return it; + } + + Node& operator[](int index) + { + Node* indexedNode = pNode; + for(int i = 0; i < index; i++) + { + indexedNode = indexedNode -> next; + } + return *indexedNode; + } + + Node* operator->() + { + return pNode; + } + + Node& operator*() + { + return *pNode; + } + + bool operator==(const Iterator& other) const + { + return pNode == other.pNode; + } + }; + + Ring(); + ~Ring(); + void clearRing(); + void print() const; + void addAtEnd(Key newKey, Info newInfo); + int size() const; + Iterator begin() const // I will treat "any" Node as a "begining" of a ring + { + return Iterator(any); + } + + Iterator end() const // I will treat a Node just before "any" node as an "end" of a ring + { + if(any == nullptr) return nullptr; + return any -> prev; + } +}; + +template +Ring::Ring() +{ + any = nullptr; +} + +template +void Ring::clearRing() +{ + if(any == nullptr) return; + Node* curr = any; + Node* temp = any; + do{ + temp = curr; + curr = curr->next; + delete temp; + }while(curr != any); + + delete any; +} + +template +Ring::~Ring() +{ + this -> clearRing(); +} + +template +void Ring::print() const +{ + Node* curr = any; + do{ + std::cout << curr -> key << "; " << curr->info << std::endl; + curr = curr->next; + }while (curr != any); +} + +template +void Ring::addAtEnd(Key newKey, Info newInfo) +{ + Node* newNode = new Node(); + newNode -> key = newKey; + newNode -> info = newInfo; + if(any == nullptr) + { + any = newNode; + any -> next = any; + any -> prev = any; + return; + } + + if(any -> next == nullptr) + { + any -> next = newNode; + any -> prev = newNode; + newNode -> next = any; + newNode -> prev = any; + return; + } + + Node* curr = any; + while(curr -> next != any) curr = curr -> next; + any->prev = newNode; + curr->next = newNode; + newNode -> prev = curr; + newNode -> next = any; +} + +template +int Ring::size() const +{ + Node* curr = any; + int size = 0; + do{ + size++; + curr = curr -> next; + }while (curr != any); + return size; +} + +template +void printPair(const Key key, const Info info) +{ + std::cout << "Key: " << key << "; Info: " << info << std::endl; +} + +bool testForEmpty() +{ + Ring marcel; + Ring::Iterator it = marcel.begin(); + if(it != nullptr) + { + print("testForEmpty"); + return false; + } + return true; +} + +bool testOneElement() +{ + Ring marcel; + marcel.addAtEnd(1, 1); + Ring::Iterator it = marcel.begin(); + if(it -> key != 1 || it -> info != 1) + { + print("testForwardIncrementingOneElement"); + return false; + } + return true; +} + +bool testForwardIncrementing() +{ + Ring marcel; + marcel.addAtEnd(1, 1); + marcel.addAtEnd(2, 2); + marcel.addAtEnd(3, 3); + marcel.addAtEnd(4, 4); + marcel.addAtEnd(5, 5); + int i = 0; + for( Ring::Iterator it = marcel.begin(); + it != marcel.end(); it++, i++) + { + if(it -> key != i + 1 || it -> info != i + 1) + { + print("testForwardIncrementingNormal"); + return false; + } + } + if(marcel.end() -> key != 5 || marcel.end() -> info != 5) + { + print("testForwardIncrementingNormal"); + return false; + } + + return true; +} + +bool testBackwardDecrementing() +{ + Ring marcel; + marcel.addAtEnd(1, 1); + marcel.addAtEnd(2, 2); + marcel.addAtEnd(3, 3); + marcel.addAtEnd(4, 4); + marcel.addAtEnd(5, 5); + int i = 0; + for( Ring::Iterator it = marcel.end(); + it != marcel.begin(); it++, i++) + { + if(it -> key != 5 - i || it -> info != 5 - i) + { + print("testBackwardDecrementing"); + return false; + } + } + if(marcel.begin() -> key != 1 || marcel.begin() -> info != 1) + { + print("testBackwardDecrementing"); + return false; + } + + return true; +} + +bool testForwardSquareBracket() +{ + Ring marcel; + marcel.addAtEnd(1, 1); + marcel.addAtEnd(2, 2); + marcel.addAtEnd(3, 3); + marcel.addAtEnd(4, 4); + marcel.addAtEnd(5, 5); + Ring::Iterator it = marcel.begin(); + for(int i = 0; i < marcel.size(); i++) + { + if(it[i].key != i + 1 || it[i].info != i + 1) + { + print("testForwardSquareBracket"); + return false; + } + } + return true; +} + + +bool testBackwardSquareBracket() +{ + Ring marcel; + marcel.addAtEnd(1, 1); + marcel.addAtEnd(2, 2); + marcel.addAtEnd(3, 3); + marcel.addAtEnd(4, 4); + marcel.addAtEnd(5, 5); + Ring::Iterator it = marcel.end(); + for(int i = marcel.size(); i > 0; i--) + { + if(it[i].key != i || it[i].info != i) + { + print("testBackwardSquareBracket"); + return false; + } + } + return true; +} + +bool testSquareBracketRandomOverflow() +{ + Ring marcel; + marcel.addAtEnd(1, 1); + marcel.addAtEnd(2, 2); + marcel.addAtEnd(3, 3); + marcel.addAtEnd(4, 4); + marcel.addAtEnd(5, 5); + Ring::Iterator it = marcel.begin(); + //Checking for some random places in ring: + if(it[2].key != 3) + { + print("testSquareBracketRandomOverflow"); + return false; + } + + if(it[4].key != 5) + { + print("testSquareBracketRandomOverflow"); + return false; + } + + if(it[0].key != 1) + { + print("testSquareBracketRandomOverflow"); + return false; + } + //Checking for overflow: + if(it[10].key != 1) + { + print("testSquareBracketRandomOverflow"); + return false; + } + return true; +} + +bool tests() +{ + return testForEmpty()&&testOneElement()&&testForwardIncrementing() + &&testBackwardDecrementing()&&testForwardSquareBracket()&&testBackwardSquareBracket() + &&testSquareBracketRandomOverflow(); +} + +int main() +{ + std::cout << "Result of tests is: " << tests() << std::endl; + return 1; + +} \ No newline at end of file diff --git a/EADS/lab3.cpp b/EADS/lab3.cpp new file mode 100644 index 00000000..9f607752 --- /dev/null +++ b/EADS/lab3.cpp @@ -0,0 +1,540 @@ +// Krzysztof Rudnicki, 307585, lab3 EADS + +#include +#include + + + +template +struct Node{ + Key key; + Info info; + int balanceFactor; + Node* left; + Node* right; +}; + +template +class Dictionary{ +private: + + Node* root; +public: + Dictionary(); + Node* getRoot() const; + void destroy(Node* &someNode); + ~Dictionary(); + void copyDictionary(Dictionary *&copiedDictRoot, Dictionary *otherTreeRoot); + Dictionary(const Dictionary &other); + void insert(const Key &newKey, const Info &newInfo); + void remove(const Key &keyToRemove); + Info& search(const Key &keyToFind) const; + void print() const; + void insertAndPrint(const Key &newKey, const Info &newInfo); + Dictionary& operator=(const Dictionary& otherDictionary); +}; + +void print(std::string s) +{ + std::cout << s << std::endl; +} + +template +Dictionary::Dictionary() +{ + root = nullptr; +} + +template +Node* Dictionary::getRoot() const +{ + return root; +} + +template +void Dictionary::destroy(Node* &someNode) +{ + if( someNode != nullptr) + { + destroy(someNode -> left); + destroy(someNode -> right); + delete someNode; + someNode = nullptr; + } +} + +template +Dictionary::~Dictionary() { destroy(root); } + +template +void Dictionary::copyDictionary(Dictionary* &copiedDictRoot, Dictionary* otherDictRoot) +{ + if(otherDictRoot == nullptr) copiedDictRoot = nullptr; + else + { + copiedDictRoot = new Dictionary; + copiedDictRoot->info = otherDictRoot -> info; + copyDictionary(copiedDictRoot -> left, otherDictRoot -> left); + copyDictionary(copiedDictRoot -> right, otherDictRoot -> right); + } +} + +template +Dictionary::Dictionary(const Dictionary &other) +{ + if(other.root == nullptr) root = nullptr; + else copyTree(root, other.root); +} + +template +Dictionary& Dictionary::operator=(const Dictionary& otherDictionary) +{ + if(this != &otherDictionary) + { + if(root != nullptr) destroy(root); + if(otherDictionary.root == nullptr) root = nullptr; + else copyDictionary(root, otherDictionary.root); + } + return *this; +} + +template +void rotateToLeft(Node* &root) +{ + Node* p; + if (root == nullptr) std::cerr << "Error in the tree" << std::endl; + else if (root->right == nullptr) + std::cerr << "Error in the tree:" + <<" No right subtree to rotate." << std::endl; + else + { + p = root->right; + root->right = p->left; + p->left = root; + root = p; + } +} + +template +void rotateToRight(Node* &root) +{ + Node *p; + if (root == NULL) std::cerr << "Error in the tree" << std::endl; + else if (root-> left == NULL) + std::cerr << "Error in the tree:" + << " No left subtree to rotate." << std::endl; + else + { + p = root->left; + root->left = p->right; + p->right = root; + root = p; + } +} + +template +void balanceFromLeft(Node* &root) +{ + Node *p; + Node *w; + p = root->left; + switch (p->balanceFactor) + { + case -1: + root->balanceFactor = 0; + p->balanceFactor = 0; + rotateToRight(root); + break; + case 0: + std::cerr << "Error: Cannot balance from the left." << std::endl; + break; + case 1: + w = p->right; + switch (w->balanceFactor) + { + case -1: + root->balanceFactor = 1; + p->balanceFactor = 0; + break; + case 0: + root->balanceFactor = 0; + p->balanceFactor = 0; + break; + case 1: + root->balanceFactor = 0; + p->balanceFactor = -1; + } + w->balanceFactor = 0; + rotateToLeft(p); + root->left = p; + rotateToRight(root); + }; +} + +template +void balanceFromRight(Node* &root) +{ + Node *p; + Node *w; + p = root->right; + switch (p->balanceFactor) + { + case -1: + w = p->left; + switch (w->balanceFactor) + { + case -1: + root->balanceFactor = 0; + p->balanceFactor = 1; + break; + case 0: + root->balanceFactor = 0; + p->balanceFactor = 0; + break; + case 1: + root->balanceFactor = -1; + p->balanceFactor = 0; + } + w->balanceFactor = 0; + rotateToRight(p); + root->right = p; + rotateToLeft(root); + break; + case 0: + std::cerr << "Error: Cannot balance from the left." << std::endl; + break; + case 1: + root->balanceFactor = 0; + p->balanceFactor = 0; + rotateToLeft(root); + } +} + +template +void insertIntoDict(Node* &root, Node *newNode, bool& isTaller) +{ + if (root == NULL) + { + root = newNode; + isTaller = true; + } + else if (root->key == newNode->key) // if two nodes have the same key we replace one with another + { + root = newNode; + isTaller = true; + } + else if (root->key > newNode->key) + { + insertIntoDict(root->left, newNode, isTaller); + if (isTaller) + switch (root->balanceFactor) + { + case -1: + balanceFromLeft(root); + isTaller = false; + break; + case 0: + root->balanceFactor = -1; + isTaller = true; + break; + case 1: + root->balanceFactor = 0; + isTaller = false; + } + } + else + { + insertIntoDict(root->right, newNode, isTaller); + if (isTaller) + switch (root->balanceFactor) + { + case -1: + root->balanceFactor = 0; + isTaller = false; + break; + case 0: + root->balanceFactor = 1; + isTaller = true; + break; + case 1: + balanceFromRight(root); + isTaller = false; + } + } +} + +template +Info& Dictionary::search(const Key& keyToFind) const +{ + Node *curr; + bool found = 0; + + if(root == nullptr) + { + std::cerr << "cannot search if tree is empty" << std::endl; + }else + { + curr = root; + while(curr != nullptr && !found) + { + if( curr -> key == keyToFind) found = true; + else if (curr -> key > keyToFind) curr = curr -> left; + else curr = curr -> right; + } + } + if(found) return curr -> info; + else throw "Key not found"; + +} + + +template +void printDict(const std::string& prefix, const Node* node, bool isLeft) +{ + if( node != nullptr ) + { + std::cout << prefix; + + std::cout << (isLeft ? "├──" : "└──" ); + + // print the value of the node + std::cout << "( " << node->info << ", " << node->key << ")" << std::endl; + + // enter the next tree level - left and right branch + printDict( prefix + (isLeft ? "│ " : " "), node->left, true); + printDict( prefix + (isLeft ? "│ " : " "), node->right, false); + } +} + +template +void Dictionary::print() const +{ + printDict("", root, false); + std::cout << std::endl; +} + + +template +void Dictionary::insert(const Key &newKey, const Info &newInfo) +{ + bool isTaller = false; + Node* newNode; + newNode = new Node; + newNode -> key = newKey; + newNode->info = newInfo; + newNode->balanceFactor = 0; + newNode->left = NULL; + newNode->right = NULL; + insertIntoDict(root, newNode, isTaller); +} + +template +void Dictionary::insertAndPrint(const Key &newKey, const Info &newInfo) +{ + insert(newKey, newInfo); + print(); +} + +template +Node* minKeyNode(Node* node) +{ + Node* curr = node; + while(curr -> left != nullptr) curr = curr -> left; + return curr; +} + +int max(int a, int b) { return ( a > b ? a : b ); } + +template +int height(Node* root) +{ + if(root == nullptr) return 0; + else return 1 + max(height(root -> left), height(root -> right)); +} + +template +int getBalance(Node* root) +{ + if(root == nullptr) return 0; + return height(root -> left) - height(root -> right); +} + + +template +Node* deleteNode(Node* root, const Key& keyToDelete) +{ + if (root == nullptr) return root; + if ( (root -> key) > keyToDelete) root->left = deleteNode(root->left, keyToDelete); + else if( (root -> key) < keyToDelete) root->right = deleteNode(root->right, keyToDelete); + else + { + if( (root->left == nullptr) || (root->right == nullptr) ) + { + Node *temp; + if(root -> left == nullptr) temp = root -> right; + else temp = root -> left; + if (temp == nullptr) + { + temp = root; + root = nullptr; + } + else + { + *root = *temp; + delete temp; + } + } + else + { + Node* temp = minKeyNode(root->right); + root->key = temp->key; + root->info = temp->info; + root->right = deleteNode(root->right, temp->key); + } + } + if (root == nullptr) return root; + int balance = getBalance(root); + if (balance > 1 && getBalance(root->left) >= 0) + { + rotateToRight(root); + return root; + } + + if (balance > 1 && getBalance(root->left) < 0) + { + rotateToLeft(root->left); + rotateToRight(root); + return root; + } + + if (balance < -1 && getBalance(root->right) <= 0) + { + rotateToLeft(root); + return root; + } + + if (balance < -1 && getBalance(root->right) > 0) + { + rotateToRight(root->right); + rotateToLeft(root); + return root; + } + + return root; +} + +template +void Dictionary::remove(const Key& keyToRemove) +{ + deleteNode(root, keyToRemove); +} + +bool testInsertEmpty() +{ + print("testInsertEmpty print:"); + Dictionary marcel; + marcel.print(); + return true; +} + +bool testInsertOneElement() +{ + print("testInsertOneElement print:"); + Dictionary marcel; + marcel.insert("perception", 1); + marcel.print(); + return true; +} + +bool testInsertMoreElements() +{ + print("testInsertMoreElements print:"); + Dictionary marcel; + marcel.insertAndPrint("thank", 20); + marcel.insertAndPrint("accept", 90); + marcel.insertAndPrint("public", 30); + marcel.insertAndPrint("rack", 8); + marcel.insertAndPrint("pest", 10); + return true; +} + + +bool testInsert() +{ + + return testInsertEmpty()&&testInsertOneElement()&&testInsertMoreElements(); +} + +bool testSearchEmpty() +{ + Dictionary marcel; + try{ + marcel.search("marcel"); + } + catch (char const* e) + { + return true; + }; + return false; +} + + +bool testSearchOneElement() +{ + Dictionary marcel; + marcel.insert("jungle", 20); + if(marcel.search("jungle") != 20) + { + print("Error in testSearchOneElement"); + return 0; + } + return 1; +} + +bool testSearchMoreElements() +{ + Dictionary marcel; + marcel.insert("thank", 20); + marcel.insert("accept", 90); + marcel.insert("public", 30); + marcel.insert("rack", 8); + marcel.insert("pest", 10); + if(marcel.search("public") != 30) + { + print("Error in testSearchMoreElements"); + return 0; + } + return 1; +} + +bool testSearch() +{ + return testSearchEmpty()&&testSearchOneElement()&&testSearchMoreElements(); +} + +bool testRemoveEmpty() +{ + Dictionary marcel; + marcel.remove("marcel"); + return true; +} + +bool testRemove() +{ + return testRemoveEmpty(); +} + +bool tests() +{ + return testInsert()&&testSearch()&&testRemove(); + +} + + +int main() +{ + bool resultOfTests = tests(); + std::cout << "Result of tests is: " << resultOfTests << std::endl; + + return 1; +} diff --git a/EDISP/EDISP_KRZYSZTOF_RUDNICKI_307585_LAB_1.pdf b/EDISP/EDISP_KRZYSZTOF_RUDNICKI_307585_LAB_1.pdf new file mode 100644 index 00000000..9175d0fa Binary files /dev/null and b/EDISP/EDISP_KRZYSZTOF_RUDNICKI_307585_LAB_1.pdf differ diff --git a/EDISP/EDISP_LAB_4.pdf b/EDISP/EDISP_LAB_4.pdf new file mode 100644 index 00000000..b332e159 Binary files /dev/null and b/EDISP/EDISP_LAB_4.pdf differ diff --git a/EDISP/EDISP_LAB_5_KRZYSZTOF_RUDNICKI_307585.pdf b/EDISP/EDISP_LAB_5_KRZYSZTOF_RUDNICKI_307585.pdf new file mode 100644 index 00000000..e4fb16c9 Binary files /dev/null and b/EDISP/EDISP_LAB_5_KRZYSZTOF_RUDNICKI_307585.pdf differ diff --git a/EDISP/KRZYSZTOF_RUDNICKI_307585_EDISP_LAB_2.pdf b/EDISP/KRZYSZTOF_RUDNICKI_307585_EDISP_LAB_2.pdf new file mode 100644 index 00000000..4d223a70 Binary files /dev/null and b/EDISP/KRZYSZTOF_RUDNICKI_307585_EDISP_LAB_2.pdf differ diff --git a/EOOP/Various/set/set.cpp b/EOOP/Various/set/set.cpp new file mode 100644 index 00000000..4124e798 --- /dev/null +++ b/EOOP/Various/set/set.cpp @@ -0,0 +1,100 @@ +#include "set.hpp" + +Set::Set() +{ + data_ = {}; +} + +Set::~Set() +{ + data_.erase(data_.begin(), data_.end()); +} + +Set::Set(const Set& s) +{ + data_ = s.data_; +} + +Set& Set::operator=(const Set& s) +{ + data_ = s.data_; + return *this; +} + +bool Set::isEmpty() const +{ + return data_.size() == 0; +} + +SetData::size_type Set::size() const +{ + return data_.size(); +} + +void Set::add(int value) +{ + if(!contains(value)) data_.push_back(value); +} + +Set Set::operator+(const Set& s) const +{ + Set newSet(s); + for (unsigned int i = 0; i < data_.size(); ++i) + { + if(!newSet.contains(data_[i])) newSet.add(data_[i]); + } + return newSet; +} + +Set& Set::operator+=(const Set& s) +{ + for(unsigned int i = 0; i < s.size(); ++i) + { + if(!contains(s.data_[i])) add(s.data_[i]); + } + return *this; +} + +bool Set::contains(int value) const +{ + for(unsigned int i = 0; i < size(); ++i) + { + if(data_[i] == value) return 1; + } + return 0; +} + +Set Set::operator-(const Set& s) const +{ + Set newSet; + for(unsigned int i = 0; i < size(); ++i) + { + if(!s.contains(data_[i])) newSet.add(data_[i]); + } + return newSet; +} + +void Set::remove(int value) +{ + if(contains(value)) + { + for(unsigned int i = 0; i < size(); ++i) + { + if(data_[i] == value) data_.erase(data_.begin() + i); + } + } +} + +Set& Set::operator-=(const Set& s) +{ + for(int i = size(); i >= 0; i--) + { + if(s.contains(data_[i])) remove(data_[i]); + } + return *this; +} + +const int& Set::operator[](int index) const +{ + return data_[index]; +} diff --git a/EOOP/Warehouse/EOOP, Final Project, Krzysztof Rudnicki, 307585.pdf b/EOOP/Warehouse/EOOP, Final Project, Krzysztof Rudnicki, 307585.pdf new file mode 100644 index 00000000..c1ffcf24 Binary files /dev/null and b/EOOP/Warehouse/EOOP, Final Project, Krzysztof Rudnicki, 307585.pdf differ diff --git a/EPFU/labs/krudnic3_lab1.c b/EPFU/labs/krudnic3_lab1.c new file mode 100644 index 00000000..d9c611f3 --- /dev/null +++ b/EPFU/labs/krudnic3_lab1.c @@ -0,0 +1,18 @@ +#include +#include + +int main() +{ + int i_one, i_two; + float f_one, f_two; + char c_one, c_two; + printf("Chris\n"); + printf("Write two integers then two float numbers then two characters:"); + scanf("%d %d %f %f %c %c", &i_one, &i_two, &f_one, &f_two, &c_one, &c_two); + printf("%d %d %d %f %c %d", i_one, i_two, f_one, f_two, c_one, c_two); + printf("\n%d", i_one + i_two); + printf("\n%f", i_one / i_two); + printf("\n%f", f_one / f_two); + printf("\n%c%d", c_one, i_one); + return 0; +} diff --git a/EPFU/LICENSE b/EPFU/penguins/LICENSE similarity index 100% rename from EPFU/LICENSE rename to EPFU/penguins/LICENSE diff --git a/EPFU/README b/EPFU/penguins/README similarity index 100% rename from EPFU/README rename to EPFU/penguins/README diff --git a/EPFU/doc/.gitkeep b/EPFU/penguins/doc/.gitkeep similarity index 100% rename from EPFU/doc/.gitkeep rename to EPFU/penguins/doc/.gitkeep diff --git a/EPFU/doc/05.12/.gitkeep b/EPFU/penguins/doc/05.12/.gitkeep similarity index 100% rename from EPFU/doc/05.12/.gitkeep rename to EPFU/penguins/doc/05.12/.gitkeep diff --git a/EPFU/doc/05.12/report.pdf b/EPFU/penguins/doc/05.12/report.pdf similarity index 100% rename from EPFU/doc/05.12/report.pdf rename to EPFU/penguins/doc/05.12/report.pdf diff --git a/EPFU/doc/07.11/.gitkeep b/EPFU/penguins/doc/07.11/.gitkeep similarity index 100% rename from EPFU/doc/07.11/.gitkeep rename to EPFU/penguins/doc/07.11/.gitkeep diff --git a/EPFU/doc/07.11/Report b/EPFU/penguins/doc/07.11/Report similarity index 100% rename from EPFU/doc/07.11/Report rename to EPFU/penguins/doc/07.11/Report diff --git a/EPFU/doc/19.12/.gitkeep b/EPFU/penguins/doc/19.12/.gitkeep similarity index 100% rename from EPFU/doc/19.12/.gitkeep rename to EPFU/penguins/doc/19.12/.gitkeep diff --git a/EPFU/doc/19.12/report.pdf b/EPFU/penguins/doc/19.12/report.pdf similarity index 100% rename from EPFU/doc/19.12/report.pdf rename to EPFU/penguins/doc/19.12/report.pdf diff --git a/EPFU/doc/21.11/.gitkeep b/EPFU/penguins/doc/21.11/.gitkeep similarity index 100% rename from EPFU/doc/21.11/.gitkeep rename to EPFU/penguins/doc/21.11/.gitkeep diff --git a/EPFU/doc/21.11/boardgeneration.jpg b/EPFU/penguins/doc/21.11/boardgeneration.jpg similarity index 100% rename from EPFU/doc/21.11/boardgeneration.jpg rename to EPFU/penguins/doc/21.11/boardgeneration.jpg diff --git a/EPFU/doc/21.11/checkcoordinates.jpg b/EPFU/penguins/doc/21.11/checkcoordinates.jpg similarity index 100% rename from EPFU/doc/21.11/checkcoordinates.jpg rename to EPFU/penguins/doc/21.11/checkcoordinates.jpg diff --git a/EPFU/doc/21.11/main.png b/EPFU/penguins/doc/21.11/main.png similarity index 100% rename from EPFU/doc/21.11/main.png rename to EPFU/penguins/doc/21.11/main.png diff --git a/EPFU/doc/21.11/movement.jpg b/EPFU/penguins/doc/21.11/movement.jpg similarity index 100% rename from EPFU/doc/21.11/movement.jpg rename to EPFU/penguins/doc/21.11/movement.jpg diff --git a/EPFU/doc/21.11/placement.jpg b/EPFU/penguins/doc/21.11/placement.jpg similarity index 100% rename from EPFU/doc/21.11/placement.jpg rename to EPFU/penguins/doc/21.11/placement.jpg diff --git a/EPFU/doc/21.11/report.jpg b/EPFU/penguins/doc/21.11/report.jpg similarity index 100% rename from EPFU/doc/21.11/report.jpg rename to EPFU/penguins/doc/21.11/report.jpg diff --git a/EPFU/doc/21.11/userinteraction.jpg b/EPFU/penguins/doc/21.11/userinteraction.jpg similarity index 100% rename from EPFU/doc/21.11/userinteraction.jpg rename to EPFU/penguins/doc/21.11/userinteraction.jpg diff --git a/EPFU/doc/23.10/.gitkeep b/EPFU/penguins/doc/23.10/.gitkeep similarity index 100% rename from EPFU/doc/23.10/.gitkeep rename to EPFU/penguins/doc/23.10/.gitkeep diff --git a/EPFU/doc/AIflowchart.pdf b/EPFU/penguins/doc/AIflowchart.pdf similarity index 100% rename from EPFU/doc/AIflowchart.pdf rename to EPFU/penguins/doc/AIflowchart.pdf diff --git a/EPFU/doc/longerinteractiveversionFlowchart.pdf b/EPFU/penguins/doc/longerinteractiveversionFlowchart.pdf similarity index 100% rename from EPFU/doc/longerinteractiveversionFlowchart.pdf rename to EPFU/penguins/doc/longerinteractiveversionFlowchart.pdf diff --git a/EPFU/doc/report.txt b/EPFU/penguins/doc/report.txt similarity index 100% rename from EPFU/doc/report.txt rename to EPFU/penguins/doc/report.txt diff --git a/EPFU/doc/shorterinteractiveversionFlowchart.pdf b/EPFU/penguins/doc/shorterinteractiveversionFlowchart.pdf similarity index 100% rename from EPFU/doc/shorterinteractiveversionFlowchart.pdf rename to EPFU/penguins/doc/shorterinteractiveversionFlowchart.pdf diff --git a/EPFU/src/.gitkeep b/EPFU/penguins/src/.gitkeep similarity index 100% rename from EPFU/src/.gitkeep rename to EPFU/penguins/src/.gitkeep diff --git a/EPFU/src/Old stuff/.gitkeep b/EPFU/penguins/src/Old stuff/.gitkeep similarity index 100% rename from EPFU/src/Old stuff/.gitkeep rename to EPFU/penguins/src/Old stuff/.gitkeep diff --git a/EPFU/src/Old stuff/board.c b/EPFU/penguins/src/Old stuff/board.c similarity index 100% rename from EPFU/src/Old stuff/board.c rename to EPFU/penguins/src/Old stuff/board.c diff --git a/EPFU/src/Old stuff/src_main.c b/EPFU/penguins/src/Old stuff/src_main.c similarity index 100% rename from EPFU/src/Old stuff/src_main.c rename to EPFU/penguins/src/Old stuff/src_main.c diff --git a/EPFU/src/a.out b/EPFU/penguins/src/a.out similarity index 100% rename from EPFU/src/a.out rename to EPFU/penguins/src/a.out diff --git a/EPFU/src/boards/0.txt b/EPFU/penguins/src/boards/0.txt similarity index 100% rename from EPFU/src/boards/0.txt rename to EPFU/penguins/src/boards/0.txt diff --git a/EPFU/src/boards/1.txt b/EPFU/penguins/src/boards/1.txt similarity index 100% rename from EPFU/src/boards/1.txt rename to EPFU/penguins/src/boards/1.txt diff --git a/EPFU/src/boards/10.txt b/EPFU/penguins/src/boards/10.txt similarity index 100% rename from EPFU/src/boards/10.txt rename to EPFU/penguins/src/boards/10.txt diff --git a/EPFU/src/boards/100.txt b/EPFU/penguins/src/boards/100.txt similarity index 100% rename from EPFU/src/boards/100.txt rename to EPFU/penguins/src/boards/100.txt diff --git a/EPFU/src/boards/101.txt b/EPFU/penguins/src/boards/101.txt similarity index 100% rename from EPFU/src/boards/101.txt rename to EPFU/penguins/src/boards/101.txt diff --git a/EPFU/src/boards/102.txt b/EPFU/penguins/src/boards/102.txt similarity index 100% rename from EPFU/src/boards/102.txt rename to EPFU/penguins/src/boards/102.txt diff --git a/EPFU/src/boards/103.txt b/EPFU/penguins/src/boards/103.txt similarity index 100% rename from EPFU/src/boards/103.txt rename to EPFU/penguins/src/boards/103.txt diff --git a/EPFU/src/boards/104.txt b/EPFU/penguins/src/boards/104.txt similarity index 100% rename from EPFU/src/boards/104.txt rename to EPFU/penguins/src/boards/104.txt diff --git a/EPFU/src/boards/105.txt b/EPFU/penguins/src/boards/105.txt similarity index 100% rename from EPFU/src/boards/105.txt rename to EPFU/penguins/src/boards/105.txt diff --git a/EPFU/src/boards/106.txt b/EPFU/penguins/src/boards/106.txt similarity index 100% rename from EPFU/src/boards/106.txt rename to EPFU/penguins/src/boards/106.txt diff --git a/EPFU/src/boards/107.txt b/EPFU/penguins/src/boards/107.txt similarity index 100% rename from EPFU/src/boards/107.txt rename to EPFU/penguins/src/boards/107.txt diff --git a/EPFU/src/boards/108.txt b/EPFU/penguins/src/boards/108.txt similarity index 100% rename from EPFU/src/boards/108.txt rename to EPFU/penguins/src/boards/108.txt diff --git a/EPFU/src/boards/109.txt b/EPFU/penguins/src/boards/109.txt similarity index 100% rename from EPFU/src/boards/109.txt rename to EPFU/penguins/src/boards/109.txt diff --git a/EPFU/src/boards/11.txt b/EPFU/penguins/src/boards/11.txt similarity index 100% rename from EPFU/src/boards/11.txt rename to EPFU/penguins/src/boards/11.txt diff --git a/EPFU/src/boards/110.txt b/EPFU/penguins/src/boards/110.txt similarity index 100% rename from EPFU/src/boards/110.txt rename to EPFU/penguins/src/boards/110.txt diff --git a/EPFU/src/boards/111.txt b/EPFU/penguins/src/boards/111.txt similarity index 100% rename from EPFU/src/boards/111.txt rename to EPFU/penguins/src/boards/111.txt diff --git a/EPFU/src/boards/112.txt b/EPFU/penguins/src/boards/112.txt similarity index 100% rename from EPFU/src/boards/112.txt rename to EPFU/penguins/src/boards/112.txt diff --git a/EPFU/src/boards/113.txt b/EPFU/penguins/src/boards/113.txt similarity index 100% rename from EPFU/src/boards/113.txt rename to EPFU/penguins/src/boards/113.txt diff --git a/EPFU/src/boards/114.txt b/EPFU/penguins/src/boards/114.txt similarity index 100% rename from EPFU/src/boards/114.txt rename to EPFU/penguins/src/boards/114.txt diff --git a/EPFU/src/boards/115.txt b/EPFU/penguins/src/boards/115.txt similarity index 100% rename from EPFU/src/boards/115.txt rename to EPFU/penguins/src/boards/115.txt diff --git a/EPFU/src/boards/116.txt b/EPFU/penguins/src/boards/116.txt similarity index 100% rename from EPFU/src/boards/116.txt rename to EPFU/penguins/src/boards/116.txt diff --git a/EPFU/src/boards/117.txt b/EPFU/penguins/src/boards/117.txt similarity index 100% rename from EPFU/src/boards/117.txt rename to EPFU/penguins/src/boards/117.txt diff --git a/EPFU/src/boards/118.txt b/EPFU/penguins/src/boards/118.txt similarity index 100% rename from EPFU/src/boards/118.txt rename to EPFU/penguins/src/boards/118.txt diff --git a/EPFU/src/boards/119.txt b/EPFU/penguins/src/boards/119.txt similarity index 100% rename from EPFU/src/boards/119.txt rename to EPFU/penguins/src/boards/119.txt diff --git a/EPFU/src/boards/12.txt b/EPFU/penguins/src/boards/12.txt similarity index 100% rename from EPFU/src/boards/12.txt rename to EPFU/penguins/src/boards/12.txt diff --git a/EPFU/src/boards/120.txt b/EPFU/penguins/src/boards/120.txt similarity index 100% rename from EPFU/src/boards/120.txt rename to EPFU/penguins/src/boards/120.txt diff --git a/EPFU/src/boards/121.txt b/EPFU/penguins/src/boards/121.txt similarity index 100% rename from EPFU/src/boards/121.txt rename to EPFU/penguins/src/boards/121.txt diff --git a/EPFU/src/boards/122.txt b/EPFU/penguins/src/boards/122.txt similarity index 100% rename from EPFU/src/boards/122.txt rename to EPFU/penguins/src/boards/122.txt diff --git a/EPFU/src/boards/123.txt b/EPFU/penguins/src/boards/123.txt similarity index 100% rename from EPFU/src/boards/123.txt rename to EPFU/penguins/src/boards/123.txt diff --git a/EPFU/src/boards/124.txt b/EPFU/penguins/src/boards/124.txt similarity index 100% rename from EPFU/src/boards/124.txt rename to EPFU/penguins/src/boards/124.txt diff --git a/EPFU/src/boards/125.txt b/EPFU/penguins/src/boards/125.txt similarity index 100% rename from EPFU/src/boards/125.txt rename to EPFU/penguins/src/boards/125.txt diff --git a/EPFU/src/boards/126.txt b/EPFU/penguins/src/boards/126.txt similarity index 100% rename from EPFU/src/boards/126.txt rename to EPFU/penguins/src/boards/126.txt diff --git a/EPFU/src/boards/127.txt b/EPFU/penguins/src/boards/127.txt similarity index 100% rename from EPFU/src/boards/127.txt rename to EPFU/penguins/src/boards/127.txt diff --git a/EPFU/src/boards/128.txt b/EPFU/penguins/src/boards/128.txt similarity index 100% rename from EPFU/src/boards/128.txt rename to EPFU/penguins/src/boards/128.txt diff --git a/EPFU/src/boards/129.txt b/EPFU/penguins/src/boards/129.txt similarity index 100% rename from EPFU/src/boards/129.txt rename to EPFU/penguins/src/boards/129.txt diff --git a/EPFU/src/boards/13.txt b/EPFU/penguins/src/boards/13.txt similarity index 100% rename from EPFU/src/boards/13.txt rename to EPFU/penguins/src/boards/13.txt diff --git a/EPFU/src/boards/130.txt b/EPFU/penguins/src/boards/130.txt similarity index 100% rename from EPFU/src/boards/130.txt rename to EPFU/penguins/src/boards/130.txt diff --git a/EPFU/src/boards/131.txt b/EPFU/penguins/src/boards/131.txt similarity index 100% rename from EPFU/src/boards/131.txt rename to EPFU/penguins/src/boards/131.txt diff --git a/EPFU/src/boards/132.txt b/EPFU/penguins/src/boards/132.txt similarity index 100% rename from EPFU/src/boards/132.txt rename to EPFU/penguins/src/boards/132.txt diff --git a/EPFU/src/boards/133.txt b/EPFU/penguins/src/boards/133.txt similarity index 100% rename from EPFU/src/boards/133.txt rename to EPFU/penguins/src/boards/133.txt diff --git a/EPFU/src/boards/134.txt b/EPFU/penguins/src/boards/134.txt similarity index 100% rename from EPFU/src/boards/134.txt rename to EPFU/penguins/src/boards/134.txt diff --git a/EPFU/src/boards/135.txt b/EPFU/penguins/src/boards/135.txt similarity index 100% rename from EPFU/src/boards/135.txt rename to EPFU/penguins/src/boards/135.txt diff --git a/EPFU/src/boards/136.txt b/EPFU/penguins/src/boards/136.txt similarity index 100% rename from EPFU/src/boards/136.txt rename to EPFU/penguins/src/boards/136.txt diff --git a/EPFU/src/boards/137.txt b/EPFU/penguins/src/boards/137.txt similarity index 100% rename from EPFU/src/boards/137.txt rename to EPFU/penguins/src/boards/137.txt diff --git a/EPFU/src/boards/138.txt b/EPFU/penguins/src/boards/138.txt similarity index 100% rename from EPFU/src/boards/138.txt rename to EPFU/penguins/src/boards/138.txt diff --git a/EPFU/src/boards/139.txt b/EPFU/penguins/src/boards/139.txt similarity index 100% rename from EPFU/src/boards/139.txt rename to EPFU/penguins/src/boards/139.txt diff --git a/EPFU/src/boards/14.txt b/EPFU/penguins/src/boards/14.txt similarity index 100% rename from EPFU/src/boards/14.txt rename to EPFU/penguins/src/boards/14.txt diff --git a/EPFU/src/boards/140.txt b/EPFU/penguins/src/boards/140.txt similarity index 100% rename from EPFU/src/boards/140.txt rename to EPFU/penguins/src/boards/140.txt diff --git a/EPFU/src/boards/141.txt b/EPFU/penguins/src/boards/141.txt similarity index 100% rename from EPFU/src/boards/141.txt rename to EPFU/penguins/src/boards/141.txt diff --git a/EPFU/src/boards/142.txt b/EPFU/penguins/src/boards/142.txt similarity index 100% rename from EPFU/src/boards/142.txt rename to EPFU/penguins/src/boards/142.txt diff --git a/EPFU/src/boards/143.txt b/EPFU/penguins/src/boards/143.txt similarity index 100% rename from EPFU/src/boards/143.txt rename to EPFU/penguins/src/boards/143.txt diff --git a/EPFU/src/boards/144.txt b/EPFU/penguins/src/boards/144.txt similarity index 100% rename from EPFU/src/boards/144.txt rename to EPFU/penguins/src/boards/144.txt diff --git a/EPFU/src/boards/145.txt b/EPFU/penguins/src/boards/145.txt similarity index 100% rename from EPFU/src/boards/145.txt rename to EPFU/penguins/src/boards/145.txt diff --git a/EPFU/src/boards/146.txt b/EPFU/penguins/src/boards/146.txt similarity index 100% rename from EPFU/src/boards/146.txt rename to EPFU/penguins/src/boards/146.txt diff --git a/EPFU/src/boards/147.txt b/EPFU/penguins/src/boards/147.txt similarity index 100% rename from EPFU/src/boards/147.txt rename to EPFU/penguins/src/boards/147.txt diff --git a/EPFU/src/boards/148.txt b/EPFU/penguins/src/boards/148.txt similarity index 100% rename from EPFU/src/boards/148.txt rename to EPFU/penguins/src/boards/148.txt diff --git a/EPFU/src/boards/149.txt b/EPFU/penguins/src/boards/149.txt similarity index 100% rename from EPFU/src/boards/149.txt rename to EPFU/penguins/src/boards/149.txt diff --git a/EPFU/src/boards/15.txt b/EPFU/penguins/src/boards/15.txt similarity index 100% rename from EPFU/src/boards/15.txt rename to EPFU/penguins/src/boards/15.txt diff --git a/EPFU/src/boards/150.txt b/EPFU/penguins/src/boards/150.txt similarity index 100% rename from EPFU/src/boards/150.txt rename to EPFU/penguins/src/boards/150.txt diff --git a/EPFU/src/boards/151.txt b/EPFU/penguins/src/boards/151.txt similarity index 100% rename from EPFU/src/boards/151.txt rename to EPFU/penguins/src/boards/151.txt diff --git a/EPFU/src/boards/152.txt b/EPFU/penguins/src/boards/152.txt similarity index 100% rename from EPFU/src/boards/152.txt rename to EPFU/penguins/src/boards/152.txt diff --git a/EPFU/src/boards/153.txt b/EPFU/penguins/src/boards/153.txt similarity index 100% rename from EPFU/src/boards/153.txt rename to EPFU/penguins/src/boards/153.txt diff --git a/EPFU/src/boards/154.txt b/EPFU/penguins/src/boards/154.txt similarity index 100% rename from EPFU/src/boards/154.txt rename to EPFU/penguins/src/boards/154.txt diff --git a/EPFU/src/boards/155.txt b/EPFU/penguins/src/boards/155.txt similarity index 100% rename from EPFU/src/boards/155.txt rename to EPFU/penguins/src/boards/155.txt diff --git a/EPFU/src/boards/156.txt b/EPFU/penguins/src/boards/156.txt similarity index 100% rename from EPFU/src/boards/156.txt rename to EPFU/penguins/src/boards/156.txt diff --git a/EPFU/src/boards/157.txt b/EPFU/penguins/src/boards/157.txt similarity index 100% rename from EPFU/src/boards/157.txt rename to EPFU/penguins/src/boards/157.txt diff --git a/EPFU/src/boards/158.txt b/EPFU/penguins/src/boards/158.txt similarity index 100% rename from EPFU/src/boards/158.txt rename to EPFU/penguins/src/boards/158.txt diff --git a/EPFU/src/boards/159.txt b/EPFU/penguins/src/boards/159.txt similarity index 100% rename from EPFU/src/boards/159.txt rename to EPFU/penguins/src/boards/159.txt diff --git a/EPFU/src/boards/16.txt b/EPFU/penguins/src/boards/16.txt similarity index 100% rename from EPFU/src/boards/16.txt rename to EPFU/penguins/src/boards/16.txt diff --git a/EPFU/src/boards/160.txt b/EPFU/penguins/src/boards/160.txt similarity index 100% rename from EPFU/src/boards/160.txt rename to EPFU/penguins/src/boards/160.txt diff --git a/EPFU/src/boards/161.txt b/EPFU/penguins/src/boards/161.txt similarity index 100% rename from EPFU/src/boards/161.txt rename to EPFU/penguins/src/boards/161.txt diff --git a/EPFU/src/boards/162.txt b/EPFU/penguins/src/boards/162.txt similarity index 100% rename from EPFU/src/boards/162.txt rename to EPFU/penguins/src/boards/162.txt diff --git a/EPFU/src/boards/163.txt b/EPFU/penguins/src/boards/163.txt similarity index 100% rename from EPFU/src/boards/163.txt rename to EPFU/penguins/src/boards/163.txt diff --git a/EPFU/src/boards/165.txt b/EPFU/penguins/src/boards/165.txt similarity index 100% rename from EPFU/src/boards/165.txt rename to EPFU/penguins/src/boards/165.txt diff --git a/EPFU/src/boards/166.txt b/EPFU/penguins/src/boards/166.txt similarity index 100% rename from EPFU/src/boards/166.txt rename to EPFU/penguins/src/boards/166.txt diff --git a/EPFU/src/boards/167.txt b/EPFU/penguins/src/boards/167.txt similarity index 100% rename from EPFU/src/boards/167.txt rename to EPFU/penguins/src/boards/167.txt diff --git a/EPFU/src/boards/169.txt b/EPFU/penguins/src/boards/169.txt similarity index 100% rename from EPFU/src/boards/169.txt rename to EPFU/penguins/src/boards/169.txt diff --git a/EPFU/src/boards/17.txt b/EPFU/penguins/src/boards/17.txt similarity index 100% rename from EPFU/src/boards/17.txt rename to EPFU/penguins/src/boards/17.txt diff --git a/EPFU/src/boards/170.txt b/EPFU/penguins/src/boards/170.txt similarity index 100% rename from EPFU/src/boards/170.txt rename to EPFU/penguins/src/boards/170.txt diff --git a/EPFU/src/boards/171.txt b/EPFU/penguins/src/boards/171.txt similarity index 100% rename from EPFU/src/boards/171.txt rename to EPFU/penguins/src/boards/171.txt diff --git a/EPFU/src/boards/173.txt b/EPFU/penguins/src/boards/173.txt similarity index 100% rename from EPFU/src/boards/173.txt rename to EPFU/penguins/src/boards/173.txt diff --git a/EPFU/src/boards/174.txt b/EPFU/penguins/src/boards/174.txt similarity index 100% rename from EPFU/src/boards/174.txt rename to EPFU/penguins/src/boards/174.txt diff --git a/EPFU/src/boards/175.txt b/EPFU/penguins/src/boards/175.txt similarity index 100% rename from EPFU/src/boards/175.txt rename to EPFU/penguins/src/boards/175.txt diff --git a/EPFU/src/boards/177.txt b/EPFU/penguins/src/boards/177.txt similarity index 100% rename from EPFU/src/boards/177.txt rename to EPFU/penguins/src/boards/177.txt diff --git a/EPFU/src/boards/178.txt b/EPFU/penguins/src/boards/178.txt similarity index 100% rename from EPFU/src/boards/178.txt rename to EPFU/penguins/src/boards/178.txt diff --git a/EPFU/src/boards/179.txt b/EPFU/penguins/src/boards/179.txt similarity index 100% rename from EPFU/src/boards/179.txt rename to EPFU/penguins/src/boards/179.txt diff --git a/EPFU/src/boards/18.txt b/EPFU/penguins/src/boards/18.txt similarity index 100% rename from EPFU/src/boards/18.txt rename to EPFU/penguins/src/boards/18.txt diff --git a/EPFU/src/boards/181.txt b/EPFU/penguins/src/boards/181.txt similarity index 100% rename from EPFU/src/boards/181.txt rename to EPFU/penguins/src/boards/181.txt diff --git a/EPFU/src/boards/182.txt b/EPFU/penguins/src/boards/182.txt similarity index 100% rename from EPFU/src/boards/182.txt rename to EPFU/penguins/src/boards/182.txt diff --git a/EPFU/src/boards/183.txt b/EPFU/penguins/src/boards/183.txt similarity index 100% rename from EPFU/src/boards/183.txt rename to EPFU/penguins/src/boards/183.txt diff --git a/EPFU/src/boards/185.txt b/EPFU/penguins/src/boards/185.txt similarity index 100% rename from EPFU/src/boards/185.txt rename to EPFU/penguins/src/boards/185.txt diff --git a/EPFU/src/boards/186.txt b/EPFU/penguins/src/boards/186.txt similarity index 100% rename from EPFU/src/boards/186.txt rename to EPFU/penguins/src/boards/186.txt diff --git a/EPFU/src/boards/187.txt b/EPFU/penguins/src/boards/187.txt similarity index 100% rename from EPFU/src/boards/187.txt rename to EPFU/penguins/src/boards/187.txt diff --git a/EPFU/src/boards/189.txt b/EPFU/penguins/src/boards/189.txt similarity index 100% rename from EPFU/src/boards/189.txt rename to EPFU/penguins/src/boards/189.txt diff --git a/EPFU/src/boards/19.txt b/EPFU/penguins/src/boards/19.txt similarity index 100% rename from EPFU/src/boards/19.txt rename to EPFU/penguins/src/boards/19.txt diff --git a/EPFU/src/boards/190.txt b/EPFU/penguins/src/boards/190.txt similarity index 100% rename from EPFU/src/boards/190.txt rename to EPFU/penguins/src/boards/190.txt diff --git a/EPFU/src/boards/191.txt b/EPFU/penguins/src/boards/191.txt similarity index 100% rename from EPFU/src/boards/191.txt rename to EPFU/penguins/src/boards/191.txt diff --git a/EPFU/src/boards/193.txt b/EPFU/penguins/src/boards/193.txt similarity index 100% rename from EPFU/src/boards/193.txt rename to EPFU/penguins/src/boards/193.txt diff --git a/EPFU/src/boards/194.txt b/EPFU/penguins/src/boards/194.txt similarity index 100% rename from EPFU/src/boards/194.txt rename to EPFU/penguins/src/boards/194.txt diff --git a/EPFU/src/boards/195.txt b/EPFU/penguins/src/boards/195.txt similarity index 100% rename from EPFU/src/boards/195.txt rename to EPFU/penguins/src/boards/195.txt diff --git a/EPFU/src/boards/197.txt b/EPFU/penguins/src/boards/197.txt similarity index 100% rename from EPFU/src/boards/197.txt rename to EPFU/penguins/src/boards/197.txt diff --git a/EPFU/src/boards/198.txt b/EPFU/penguins/src/boards/198.txt similarity index 100% rename from EPFU/src/boards/198.txt rename to EPFU/penguins/src/boards/198.txt diff --git a/EPFU/src/boards/199.txt b/EPFU/penguins/src/boards/199.txt similarity index 100% rename from EPFU/src/boards/199.txt rename to EPFU/penguins/src/boards/199.txt diff --git a/EPFU/src/boards/2.txt b/EPFU/penguins/src/boards/2.txt similarity index 100% rename from EPFU/src/boards/2.txt rename to EPFU/penguins/src/boards/2.txt diff --git a/EPFU/src/boards/20.txt b/EPFU/penguins/src/boards/20.txt similarity index 100% rename from EPFU/src/boards/20.txt rename to EPFU/penguins/src/boards/20.txt diff --git a/EPFU/src/boards/201.txt b/EPFU/penguins/src/boards/201.txt similarity index 100% rename from EPFU/src/boards/201.txt rename to EPFU/penguins/src/boards/201.txt diff --git a/EPFU/src/boards/202.txt b/EPFU/penguins/src/boards/202.txt similarity index 100% rename from EPFU/src/boards/202.txt rename to EPFU/penguins/src/boards/202.txt diff --git a/EPFU/src/boards/203.txt b/EPFU/penguins/src/boards/203.txt similarity index 100% rename from EPFU/src/boards/203.txt rename to EPFU/penguins/src/boards/203.txt diff --git a/EPFU/src/boards/205.txt b/EPFU/penguins/src/boards/205.txt similarity index 100% rename from EPFU/src/boards/205.txt rename to EPFU/penguins/src/boards/205.txt diff --git a/EPFU/src/boards/206.txt b/EPFU/penguins/src/boards/206.txt similarity index 100% rename from EPFU/src/boards/206.txt rename to EPFU/penguins/src/boards/206.txt diff --git a/EPFU/src/boards/207.txt b/EPFU/penguins/src/boards/207.txt similarity index 100% rename from EPFU/src/boards/207.txt rename to EPFU/penguins/src/boards/207.txt diff --git a/EPFU/src/boards/209.txt b/EPFU/penguins/src/boards/209.txt similarity index 100% rename from EPFU/src/boards/209.txt rename to EPFU/penguins/src/boards/209.txt diff --git a/EPFU/src/boards/21.txt b/EPFU/penguins/src/boards/21.txt similarity index 100% rename from EPFU/src/boards/21.txt rename to EPFU/penguins/src/boards/21.txt diff --git a/EPFU/src/boards/210.txt b/EPFU/penguins/src/boards/210.txt similarity index 100% rename from EPFU/src/boards/210.txt rename to EPFU/penguins/src/boards/210.txt diff --git a/EPFU/src/boards/211.txt b/EPFU/penguins/src/boards/211.txt similarity index 100% rename from EPFU/src/boards/211.txt rename to EPFU/penguins/src/boards/211.txt diff --git a/EPFU/src/boards/213.txt b/EPFU/penguins/src/boards/213.txt similarity index 100% rename from EPFU/src/boards/213.txt rename to EPFU/penguins/src/boards/213.txt diff --git a/EPFU/src/boards/214.txt b/EPFU/penguins/src/boards/214.txt similarity index 100% rename from EPFU/src/boards/214.txt rename to EPFU/penguins/src/boards/214.txt diff --git a/EPFU/src/boards/215.txt b/EPFU/penguins/src/boards/215.txt similarity index 100% rename from EPFU/src/boards/215.txt rename to EPFU/penguins/src/boards/215.txt diff --git a/EPFU/src/boards/217.txt b/EPFU/penguins/src/boards/217.txt similarity index 100% rename from EPFU/src/boards/217.txt rename to EPFU/penguins/src/boards/217.txt diff --git a/EPFU/src/boards/218.txt b/EPFU/penguins/src/boards/218.txt similarity index 100% rename from EPFU/src/boards/218.txt rename to EPFU/penguins/src/boards/218.txt diff --git a/EPFU/src/boards/219.txt b/EPFU/penguins/src/boards/219.txt similarity index 100% rename from EPFU/src/boards/219.txt rename to EPFU/penguins/src/boards/219.txt diff --git a/EPFU/src/boards/22.txt b/EPFU/penguins/src/boards/22.txt similarity index 100% rename from EPFU/src/boards/22.txt rename to EPFU/penguins/src/boards/22.txt diff --git a/EPFU/src/boards/221.txt b/EPFU/penguins/src/boards/221.txt similarity index 100% rename from EPFU/src/boards/221.txt rename to EPFU/penguins/src/boards/221.txt diff --git a/EPFU/src/boards/222.txt b/EPFU/penguins/src/boards/222.txt similarity index 100% rename from EPFU/src/boards/222.txt rename to EPFU/penguins/src/boards/222.txt diff --git a/EPFU/src/boards/223.txt b/EPFU/penguins/src/boards/223.txt similarity index 100% rename from EPFU/src/boards/223.txt rename to EPFU/penguins/src/boards/223.txt diff --git a/EPFU/src/boards/225.txt b/EPFU/penguins/src/boards/225.txt similarity index 100% rename from EPFU/src/boards/225.txt rename to EPFU/penguins/src/boards/225.txt diff --git a/EPFU/src/boards/226.txt b/EPFU/penguins/src/boards/226.txt similarity index 100% rename from EPFU/src/boards/226.txt rename to EPFU/penguins/src/boards/226.txt diff --git a/EPFU/src/boards/227.txt b/EPFU/penguins/src/boards/227.txt similarity index 100% rename from EPFU/src/boards/227.txt rename to EPFU/penguins/src/boards/227.txt diff --git a/EPFU/src/boards/229.txt b/EPFU/penguins/src/boards/229.txt similarity index 100% rename from EPFU/src/boards/229.txt rename to EPFU/penguins/src/boards/229.txt diff --git a/EPFU/src/boards/23.txt b/EPFU/penguins/src/boards/23.txt similarity index 100% rename from EPFU/src/boards/23.txt rename to EPFU/penguins/src/boards/23.txt diff --git a/EPFU/src/boards/230.txt b/EPFU/penguins/src/boards/230.txt similarity index 100% rename from EPFU/src/boards/230.txt rename to EPFU/penguins/src/boards/230.txt diff --git a/EPFU/src/boards/231.txt b/EPFU/penguins/src/boards/231.txt similarity index 100% rename from EPFU/src/boards/231.txt rename to EPFU/penguins/src/boards/231.txt diff --git a/EPFU/src/boards/233.txt b/EPFU/penguins/src/boards/233.txt similarity index 100% rename from EPFU/src/boards/233.txt rename to EPFU/penguins/src/boards/233.txt diff --git a/EPFU/src/boards/234.txt b/EPFU/penguins/src/boards/234.txt similarity index 100% rename from EPFU/src/boards/234.txt rename to EPFU/penguins/src/boards/234.txt diff --git a/EPFU/src/boards/235.txt b/EPFU/penguins/src/boards/235.txt similarity index 100% rename from EPFU/src/boards/235.txt rename to EPFU/penguins/src/boards/235.txt diff --git a/EPFU/src/boards/237.txt b/EPFU/penguins/src/boards/237.txt similarity index 100% rename from EPFU/src/boards/237.txt rename to EPFU/penguins/src/boards/237.txt diff --git a/EPFU/src/boards/238.txt b/EPFU/penguins/src/boards/238.txt similarity index 100% rename from EPFU/src/boards/238.txt rename to EPFU/penguins/src/boards/238.txt diff --git a/EPFU/src/boards/239.txt b/EPFU/penguins/src/boards/239.txt similarity index 100% rename from EPFU/src/boards/239.txt rename to EPFU/penguins/src/boards/239.txt diff --git a/EPFU/src/boards/24.txt b/EPFU/penguins/src/boards/24.txt similarity index 100% rename from EPFU/src/boards/24.txt rename to EPFU/penguins/src/boards/24.txt diff --git a/EPFU/src/boards/241.txt b/EPFU/penguins/src/boards/241.txt similarity index 100% rename from EPFU/src/boards/241.txt rename to EPFU/penguins/src/boards/241.txt diff --git a/EPFU/src/boards/242.txt b/EPFU/penguins/src/boards/242.txt similarity index 100% rename from EPFU/src/boards/242.txt rename to EPFU/penguins/src/boards/242.txt diff --git a/EPFU/src/boards/243.txt b/EPFU/penguins/src/boards/243.txt similarity index 100% rename from EPFU/src/boards/243.txt rename to EPFU/penguins/src/boards/243.txt diff --git a/EPFU/src/boards/245.txt b/EPFU/penguins/src/boards/245.txt similarity index 100% rename from EPFU/src/boards/245.txt rename to EPFU/penguins/src/boards/245.txt diff --git a/EPFU/src/boards/246.txt b/EPFU/penguins/src/boards/246.txt similarity index 100% rename from EPFU/src/boards/246.txt rename to EPFU/penguins/src/boards/246.txt diff --git a/EPFU/src/boards/247.txt b/EPFU/penguins/src/boards/247.txt similarity index 100% rename from EPFU/src/boards/247.txt rename to EPFU/penguins/src/boards/247.txt diff --git a/EPFU/src/boards/248.txt b/EPFU/penguins/src/boards/248.txt similarity index 100% rename from EPFU/src/boards/248.txt rename to EPFU/penguins/src/boards/248.txt diff --git a/EPFU/src/boards/249.txt b/EPFU/penguins/src/boards/249.txt similarity index 100% rename from EPFU/src/boards/249.txt rename to EPFU/penguins/src/boards/249.txt diff --git a/EPFU/src/boards/25.txt b/EPFU/penguins/src/boards/25.txt similarity index 100% rename from EPFU/src/boards/25.txt rename to EPFU/penguins/src/boards/25.txt diff --git a/EPFU/src/boards/250.txt b/EPFU/penguins/src/boards/250.txt similarity index 100% rename from EPFU/src/boards/250.txt rename to EPFU/penguins/src/boards/250.txt diff --git a/EPFU/src/boards/251.txt b/EPFU/penguins/src/boards/251.txt similarity index 100% rename from EPFU/src/boards/251.txt rename to EPFU/penguins/src/boards/251.txt diff --git a/EPFU/src/boards/252.txt b/EPFU/penguins/src/boards/252.txt similarity index 100% rename from EPFU/src/boards/252.txt rename to EPFU/penguins/src/boards/252.txt diff --git a/EPFU/src/boards/253.txt b/EPFU/penguins/src/boards/253.txt similarity index 100% rename from EPFU/src/boards/253.txt rename to EPFU/penguins/src/boards/253.txt diff --git a/EPFU/src/boards/254.txt b/EPFU/penguins/src/boards/254.txt similarity index 100% rename from EPFU/src/boards/254.txt rename to EPFU/penguins/src/boards/254.txt diff --git a/EPFU/src/boards/255.txt b/EPFU/penguins/src/boards/255.txt similarity index 100% rename from EPFU/src/boards/255.txt rename to EPFU/penguins/src/boards/255.txt diff --git a/EPFU/src/boards/256.txt b/EPFU/penguins/src/boards/256.txt similarity index 100% rename from EPFU/src/boards/256.txt rename to EPFU/penguins/src/boards/256.txt diff --git a/EPFU/src/boards/257.txt b/EPFU/penguins/src/boards/257.txt similarity index 100% rename from EPFU/src/boards/257.txt rename to EPFU/penguins/src/boards/257.txt diff --git a/EPFU/src/boards/258.txt b/EPFU/penguins/src/boards/258.txt similarity index 100% rename from EPFU/src/boards/258.txt rename to EPFU/penguins/src/boards/258.txt diff --git a/EPFU/src/boards/259.txt b/EPFU/penguins/src/boards/259.txt similarity index 100% rename from EPFU/src/boards/259.txt rename to EPFU/penguins/src/boards/259.txt diff --git a/EPFU/src/boards/26.txt b/EPFU/penguins/src/boards/26.txt similarity index 100% rename from EPFU/src/boards/26.txt rename to EPFU/penguins/src/boards/26.txt diff --git a/EPFU/src/boards/260.txt b/EPFU/penguins/src/boards/260.txt similarity index 100% rename from EPFU/src/boards/260.txt rename to EPFU/penguins/src/boards/260.txt diff --git a/EPFU/src/boards/261.txt b/EPFU/penguins/src/boards/261.txt similarity index 100% rename from EPFU/src/boards/261.txt rename to EPFU/penguins/src/boards/261.txt diff --git a/EPFU/src/boards/262.txt b/EPFU/penguins/src/boards/262.txt similarity index 100% rename from EPFU/src/boards/262.txt rename to EPFU/penguins/src/boards/262.txt diff --git a/EPFU/src/boards/263.txt b/EPFU/penguins/src/boards/263.txt similarity index 100% rename from EPFU/src/boards/263.txt rename to EPFU/penguins/src/boards/263.txt diff --git a/EPFU/src/boards/265.txt b/EPFU/penguins/src/boards/265.txt similarity index 100% rename from EPFU/src/boards/265.txt rename to EPFU/penguins/src/boards/265.txt diff --git a/EPFU/src/boards/266.txt b/EPFU/penguins/src/boards/266.txt similarity index 100% rename from EPFU/src/boards/266.txt rename to EPFU/penguins/src/boards/266.txt diff --git a/EPFU/src/boards/268.txt b/EPFU/penguins/src/boards/268.txt similarity index 100% rename from EPFU/src/boards/268.txt rename to EPFU/penguins/src/boards/268.txt diff --git a/EPFU/src/boards/27.txt b/EPFU/penguins/src/boards/27.txt similarity index 100% rename from EPFU/src/boards/27.txt rename to EPFU/penguins/src/boards/27.txt diff --git a/EPFU/src/boards/270.txt b/EPFU/penguins/src/boards/270.txt similarity index 100% rename from EPFU/src/boards/270.txt rename to EPFU/penguins/src/boards/270.txt diff --git a/EPFU/src/boards/271.txt b/EPFU/penguins/src/boards/271.txt similarity index 100% rename from EPFU/src/boards/271.txt rename to EPFU/penguins/src/boards/271.txt diff --git a/EPFU/src/boards/273.txt b/EPFU/penguins/src/boards/273.txt similarity index 100% rename from EPFU/src/boards/273.txt rename to EPFU/penguins/src/boards/273.txt diff --git a/EPFU/src/boards/275.txt b/EPFU/penguins/src/boards/275.txt similarity index 100% rename from EPFU/src/boards/275.txt rename to EPFU/penguins/src/boards/275.txt diff --git a/EPFU/src/boards/276.txt b/EPFU/penguins/src/boards/276.txt similarity index 100% rename from EPFU/src/boards/276.txt rename to EPFU/penguins/src/boards/276.txt diff --git a/EPFU/src/boards/278.txt b/EPFU/penguins/src/boards/278.txt similarity index 100% rename from EPFU/src/boards/278.txt rename to EPFU/penguins/src/boards/278.txt diff --git a/EPFU/src/boards/28.txt b/EPFU/penguins/src/boards/28.txt similarity index 100% rename from EPFU/src/boards/28.txt rename to EPFU/penguins/src/boards/28.txt diff --git a/EPFU/src/boards/280.txt b/EPFU/penguins/src/boards/280.txt similarity index 100% rename from EPFU/src/boards/280.txt rename to EPFU/penguins/src/boards/280.txt diff --git a/EPFU/src/boards/281.txt b/EPFU/penguins/src/boards/281.txt similarity index 100% rename from EPFU/src/boards/281.txt rename to EPFU/penguins/src/boards/281.txt diff --git a/EPFU/src/boards/283.txt b/EPFU/penguins/src/boards/283.txt similarity index 100% rename from EPFU/src/boards/283.txt rename to EPFU/penguins/src/boards/283.txt diff --git a/EPFU/src/boards/285.txt b/EPFU/penguins/src/boards/285.txt similarity index 100% rename from EPFU/src/boards/285.txt rename to EPFU/penguins/src/boards/285.txt diff --git a/EPFU/src/boards/286.txt b/EPFU/penguins/src/boards/286.txt similarity index 100% rename from EPFU/src/boards/286.txt rename to EPFU/penguins/src/boards/286.txt diff --git a/EPFU/src/boards/288.txt b/EPFU/penguins/src/boards/288.txt similarity index 100% rename from EPFU/src/boards/288.txt rename to EPFU/penguins/src/boards/288.txt diff --git a/EPFU/src/boards/29.txt b/EPFU/penguins/src/boards/29.txt similarity index 100% rename from EPFU/src/boards/29.txt rename to EPFU/penguins/src/boards/29.txt diff --git a/EPFU/src/boards/290.txt b/EPFU/penguins/src/boards/290.txt similarity index 100% rename from EPFU/src/boards/290.txt rename to EPFU/penguins/src/boards/290.txt diff --git a/EPFU/src/boards/291.txt b/EPFU/penguins/src/boards/291.txt similarity index 100% rename from EPFU/src/boards/291.txt rename to EPFU/penguins/src/boards/291.txt diff --git a/EPFU/src/boards/293.txt b/EPFU/penguins/src/boards/293.txt similarity index 100% rename from EPFU/src/boards/293.txt rename to EPFU/penguins/src/boards/293.txt diff --git a/EPFU/src/boards/295.txt b/EPFU/penguins/src/boards/295.txt similarity index 100% rename from EPFU/src/boards/295.txt rename to EPFU/penguins/src/boards/295.txt diff --git a/EPFU/src/boards/296.txt b/EPFU/penguins/src/boards/296.txt similarity index 100% rename from EPFU/src/boards/296.txt rename to EPFU/penguins/src/boards/296.txt diff --git a/EPFU/src/boards/298.txt b/EPFU/penguins/src/boards/298.txt similarity index 100% rename from EPFU/src/boards/298.txt rename to EPFU/penguins/src/boards/298.txt diff --git a/EPFU/src/boards/3.txt b/EPFU/penguins/src/boards/3.txt similarity index 100% rename from EPFU/src/boards/3.txt rename to EPFU/penguins/src/boards/3.txt diff --git a/EPFU/src/boards/30.txt b/EPFU/penguins/src/boards/30.txt similarity index 100% rename from EPFU/src/boards/30.txt rename to EPFU/penguins/src/boards/30.txt diff --git a/EPFU/src/boards/300.txt b/EPFU/penguins/src/boards/300.txt similarity index 100% rename from EPFU/src/boards/300.txt rename to EPFU/penguins/src/boards/300.txt diff --git a/EPFU/src/boards/301.txt b/EPFU/penguins/src/boards/301.txt similarity index 100% rename from EPFU/src/boards/301.txt rename to EPFU/penguins/src/boards/301.txt diff --git a/EPFU/src/boards/303.txt b/EPFU/penguins/src/boards/303.txt similarity index 100% rename from EPFU/src/boards/303.txt rename to EPFU/penguins/src/boards/303.txt diff --git a/EPFU/src/boards/304.txt b/EPFU/penguins/src/boards/304.txt similarity index 100% rename from EPFU/src/boards/304.txt rename to EPFU/penguins/src/boards/304.txt diff --git a/EPFU/src/boards/306.txt b/EPFU/penguins/src/boards/306.txt similarity index 100% rename from EPFU/src/boards/306.txt rename to EPFU/penguins/src/boards/306.txt diff --git a/EPFU/src/boards/307.txt b/EPFU/penguins/src/boards/307.txt similarity index 100% rename from EPFU/src/boards/307.txt rename to EPFU/penguins/src/boards/307.txt diff --git a/EPFU/src/boards/309.txt b/EPFU/penguins/src/boards/309.txt similarity index 100% rename from EPFU/src/boards/309.txt rename to EPFU/penguins/src/boards/309.txt diff --git a/EPFU/src/boards/31.txt b/EPFU/penguins/src/boards/31.txt similarity index 100% rename from EPFU/src/boards/31.txt rename to EPFU/penguins/src/boards/31.txt diff --git a/EPFU/src/boards/310.txt b/EPFU/penguins/src/boards/310.txt similarity index 100% rename from EPFU/src/boards/310.txt rename to EPFU/penguins/src/boards/310.txt diff --git a/EPFU/src/boards/312.txt b/EPFU/penguins/src/boards/312.txt similarity index 100% rename from EPFU/src/boards/312.txt rename to EPFU/penguins/src/boards/312.txt diff --git a/EPFU/src/boards/313.txt b/EPFU/penguins/src/boards/313.txt similarity index 100% rename from EPFU/src/boards/313.txt rename to EPFU/penguins/src/boards/313.txt diff --git a/EPFU/src/boards/315.txt b/EPFU/penguins/src/boards/315.txt similarity index 100% rename from EPFU/src/boards/315.txt rename to EPFU/penguins/src/boards/315.txt diff --git a/EPFU/src/boards/316.txt b/EPFU/penguins/src/boards/316.txt similarity index 100% rename from EPFU/src/boards/316.txt rename to EPFU/penguins/src/boards/316.txt diff --git a/EPFU/src/boards/318.txt b/EPFU/penguins/src/boards/318.txt similarity index 100% rename from EPFU/src/boards/318.txt rename to EPFU/penguins/src/boards/318.txt diff --git a/EPFU/src/boards/319.txt b/EPFU/penguins/src/boards/319.txt similarity index 100% rename from EPFU/src/boards/319.txt rename to EPFU/penguins/src/boards/319.txt diff --git a/EPFU/src/boards/32.txt b/EPFU/penguins/src/boards/32.txt similarity index 100% rename from EPFU/src/boards/32.txt rename to EPFU/penguins/src/boards/32.txt diff --git a/EPFU/src/boards/321.txt b/EPFU/penguins/src/boards/321.txt similarity index 100% rename from EPFU/src/boards/321.txt rename to EPFU/penguins/src/boards/321.txt diff --git a/EPFU/src/boards/322.txt b/EPFU/penguins/src/boards/322.txt similarity index 100% rename from EPFU/src/boards/322.txt rename to EPFU/penguins/src/boards/322.txt diff --git a/EPFU/src/boards/324.txt b/EPFU/penguins/src/boards/324.txt similarity index 100% rename from EPFU/src/boards/324.txt rename to EPFU/penguins/src/boards/324.txt diff --git a/EPFU/src/boards/325.txt b/EPFU/penguins/src/boards/325.txt similarity index 100% rename from EPFU/src/boards/325.txt rename to EPFU/penguins/src/boards/325.txt diff --git a/EPFU/src/boards/327.txt b/EPFU/penguins/src/boards/327.txt similarity index 100% rename from EPFU/src/boards/327.txt rename to EPFU/penguins/src/boards/327.txt diff --git a/EPFU/src/boards/328.txt b/EPFU/penguins/src/boards/328.txt similarity index 100% rename from EPFU/src/boards/328.txt rename to EPFU/penguins/src/boards/328.txt diff --git a/EPFU/src/boards/33.txt b/EPFU/penguins/src/boards/33.txt similarity index 100% rename from EPFU/src/boards/33.txt rename to EPFU/penguins/src/boards/33.txt diff --git a/EPFU/src/boards/330.txt b/EPFU/penguins/src/boards/330.txt similarity index 100% rename from EPFU/src/boards/330.txt rename to EPFU/penguins/src/boards/330.txt diff --git a/EPFU/src/boards/331.txt b/EPFU/penguins/src/boards/331.txt similarity index 100% rename from EPFU/src/boards/331.txt rename to EPFU/penguins/src/boards/331.txt diff --git a/EPFU/src/boards/333.txt b/EPFU/penguins/src/boards/333.txt similarity index 100% rename from EPFU/src/boards/333.txt rename to EPFU/penguins/src/boards/333.txt diff --git a/EPFU/src/boards/334.txt b/EPFU/penguins/src/boards/334.txt similarity index 100% rename from EPFU/src/boards/334.txt rename to EPFU/penguins/src/boards/334.txt diff --git a/EPFU/src/boards/336.txt b/EPFU/penguins/src/boards/336.txt similarity index 100% rename from EPFU/src/boards/336.txt rename to EPFU/penguins/src/boards/336.txt diff --git a/EPFU/src/boards/337.txt b/EPFU/penguins/src/boards/337.txt similarity index 100% rename from EPFU/src/boards/337.txt rename to EPFU/penguins/src/boards/337.txt diff --git a/EPFU/src/boards/339.txt b/EPFU/penguins/src/boards/339.txt similarity index 100% rename from EPFU/src/boards/339.txt rename to EPFU/penguins/src/boards/339.txt diff --git a/EPFU/src/boards/34.txt b/EPFU/penguins/src/boards/34.txt similarity index 100% rename from EPFU/src/boards/34.txt rename to EPFU/penguins/src/boards/34.txt diff --git a/EPFU/src/boards/340.txt b/EPFU/penguins/src/boards/340.txt similarity index 100% rename from EPFU/src/boards/340.txt rename to EPFU/penguins/src/boards/340.txt diff --git a/EPFU/src/boards/342.txt b/EPFU/penguins/src/boards/342.txt similarity index 100% rename from EPFU/src/boards/342.txt rename to EPFU/penguins/src/boards/342.txt diff --git a/EPFU/src/boards/343.txt b/EPFU/penguins/src/boards/343.txt similarity index 100% rename from EPFU/src/boards/343.txt rename to EPFU/penguins/src/boards/343.txt diff --git a/EPFU/src/boards/345.txt b/EPFU/penguins/src/boards/345.txt similarity index 100% rename from EPFU/src/boards/345.txt rename to EPFU/penguins/src/boards/345.txt diff --git a/EPFU/src/boards/346.txt b/EPFU/penguins/src/boards/346.txt similarity index 100% rename from EPFU/src/boards/346.txt rename to EPFU/penguins/src/boards/346.txt diff --git a/EPFU/src/boards/348.txt b/EPFU/penguins/src/boards/348.txt similarity index 100% rename from EPFU/src/boards/348.txt rename to EPFU/penguins/src/boards/348.txt diff --git a/EPFU/src/boards/349.txt b/EPFU/penguins/src/boards/349.txt similarity index 100% rename from EPFU/src/boards/349.txt rename to EPFU/penguins/src/boards/349.txt diff --git a/EPFU/src/boards/35.txt b/EPFU/penguins/src/boards/35.txt similarity index 100% rename from EPFU/src/boards/35.txt rename to EPFU/penguins/src/boards/35.txt diff --git a/EPFU/src/boards/351.txt b/EPFU/penguins/src/boards/351.txt similarity index 100% rename from EPFU/src/boards/351.txt rename to EPFU/penguins/src/boards/351.txt diff --git a/EPFU/src/boards/352.txt b/EPFU/penguins/src/boards/352.txt similarity index 100% rename from EPFU/src/boards/352.txt rename to EPFU/penguins/src/boards/352.txt diff --git a/EPFU/src/boards/354.txt b/EPFU/penguins/src/boards/354.txt similarity index 100% rename from EPFU/src/boards/354.txt rename to EPFU/penguins/src/boards/354.txt diff --git a/EPFU/src/boards/355.txt b/EPFU/penguins/src/boards/355.txt similarity index 100% rename from EPFU/src/boards/355.txt rename to EPFU/penguins/src/boards/355.txt diff --git a/EPFU/src/boards/357.txt b/EPFU/penguins/src/boards/357.txt similarity index 100% rename from EPFU/src/boards/357.txt rename to EPFU/penguins/src/boards/357.txt diff --git a/EPFU/src/boards/358.txt b/EPFU/penguins/src/boards/358.txt similarity index 100% rename from EPFU/src/boards/358.txt rename to EPFU/penguins/src/boards/358.txt diff --git a/EPFU/src/boards/36.txt b/EPFU/penguins/src/boards/36.txt similarity index 100% rename from EPFU/src/boards/36.txt rename to EPFU/penguins/src/boards/36.txt diff --git a/EPFU/src/boards/360.txt b/EPFU/penguins/src/boards/360.txt similarity index 100% rename from EPFU/src/boards/360.txt rename to EPFU/penguins/src/boards/360.txt diff --git a/EPFU/src/boards/361.txt b/EPFU/penguins/src/boards/361.txt similarity index 100% rename from EPFU/src/boards/361.txt rename to EPFU/penguins/src/boards/361.txt diff --git a/EPFU/src/boards/363.txt b/EPFU/penguins/src/boards/363.txt similarity index 100% rename from EPFU/src/boards/363.txt rename to EPFU/penguins/src/boards/363.txt diff --git a/EPFU/src/boards/364.txt b/EPFU/penguins/src/boards/364.txt similarity index 100% rename from EPFU/src/boards/364.txt rename to EPFU/penguins/src/boards/364.txt diff --git a/EPFU/src/boards/366.txt b/EPFU/penguins/src/boards/366.txt similarity index 100% rename from EPFU/src/boards/366.txt rename to EPFU/penguins/src/boards/366.txt diff --git a/EPFU/src/boards/367.txt b/EPFU/penguins/src/boards/367.txt similarity index 100% rename from EPFU/src/boards/367.txt rename to EPFU/penguins/src/boards/367.txt diff --git a/EPFU/src/boards/369.txt b/EPFU/penguins/src/boards/369.txt similarity index 100% rename from EPFU/src/boards/369.txt rename to EPFU/penguins/src/boards/369.txt diff --git a/EPFU/src/boards/37.txt b/EPFU/penguins/src/boards/37.txt similarity index 100% rename from EPFU/src/boards/37.txt rename to EPFU/penguins/src/boards/37.txt diff --git a/EPFU/src/boards/370.txt b/EPFU/penguins/src/boards/370.txt similarity index 100% rename from EPFU/src/boards/370.txt rename to EPFU/penguins/src/boards/370.txt diff --git a/EPFU/src/boards/372.txt b/EPFU/penguins/src/boards/372.txt similarity index 100% rename from EPFU/src/boards/372.txt rename to EPFU/penguins/src/boards/372.txt diff --git a/EPFU/src/boards/373.txt b/EPFU/penguins/src/boards/373.txt similarity index 100% rename from EPFU/src/boards/373.txt rename to EPFU/penguins/src/boards/373.txt diff --git a/EPFU/src/boards/375.txt b/EPFU/penguins/src/boards/375.txt similarity index 100% rename from EPFU/src/boards/375.txt rename to EPFU/penguins/src/boards/375.txt diff --git a/EPFU/src/boards/376.txt b/EPFU/penguins/src/boards/376.txt similarity index 100% rename from EPFU/src/boards/376.txt rename to EPFU/penguins/src/boards/376.txt diff --git a/EPFU/src/boards/378.txt b/EPFU/penguins/src/boards/378.txt similarity index 100% rename from EPFU/src/boards/378.txt rename to EPFU/penguins/src/boards/378.txt diff --git a/EPFU/src/boards/379.txt b/EPFU/penguins/src/boards/379.txt similarity index 100% rename from EPFU/src/boards/379.txt rename to EPFU/penguins/src/boards/379.txt diff --git a/EPFU/src/boards/38.txt b/EPFU/penguins/src/boards/38.txt similarity index 100% rename from EPFU/src/boards/38.txt rename to EPFU/penguins/src/boards/38.txt diff --git a/EPFU/src/boards/381.txt b/EPFU/penguins/src/boards/381.txt similarity index 100% rename from EPFU/src/boards/381.txt rename to EPFU/penguins/src/boards/381.txt diff --git a/EPFU/src/boards/382.txt b/EPFU/penguins/src/boards/382.txt similarity index 100% rename from EPFU/src/boards/382.txt rename to EPFU/penguins/src/boards/382.txt diff --git a/EPFU/src/boards/384.txt b/EPFU/penguins/src/boards/384.txt similarity index 100% rename from EPFU/src/boards/384.txt rename to EPFU/penguins/src/boards/384.txt diff --git a/EPFU/src/boards/385.txt b/EPFU/penguins/src/boards/385.txt similarity index 100% rename from EPFU/src/boards/385.txt rename to EPFU/penguins/src/boards/385.txt diff --git a/EPFU/src/boards/387.txt b/EPFU/penguins/src/boards/387.txt similarity index 100% rename from EPFU/src/boards/387.txt rename to EPFU/penguins/src/boards/387.txt diff --git a/EPFU/src/boards/388.txt b/EPFU/penguins/src/boards/388.txt similarity index 100% rename from EPFU/src/boards/388.txt rename to EPFU/penguins/src/boards/388.txt diff --git a/EPFU/src/boards/39.txt b/EPFU/penguins/src/boards/39.txt similarity index 100% rename from EPFU/src/boards/39.txt rename to EPFU/penguins/src/boards/39.txt diff --git a/EPFU/src/boards/390.txt b/EPFU/penguins/src/boards/390.txt similarity index 100% rename from EPFU/src/boards/390.txt rename to EPFU/penguins/src/boards/390.txt diff --git a/EPFU/src/boards/391.txt b/EPFU/penguins/src/boards/391.txt similarity index 100% rename from EPFU/src/boards/391.txt rename to EPFU/penguins/src/boards/391.txt diff --git a/EPFU/src/boards/393.txt b/EPFU/penguins/src/boards/393.txt similarity index 100% rename from EPFU/src/boards/393.txt rename to EPFU/penguins/src/boards/393.txt diff --git a/EPFU/src/boards/394.txt b/EPFU/penguins/src/boards/394.txt similarity index 100% rename from EPFU/src/boards/394.txt rename to EPFU/penguins/src/boards/394.txt diff --git a/EPFU/src/boards/396.txt b/EPFU/penguins/src/boards/396.txt similarity index 100% rename from EPFU/src/boards/396.txt rename to EPFU/penguins/src/boards/396.txt diff --git a/EPFU/src/boards/397.txt b/EPFU/penguins/src/boards/397.txt similarity index 100% rename from EPFU/src/boards/397.txt rename to EPFU/penguins/src/boards/397.txt diff --git a/EPFU/src/boards/399.txt b/EPFU/penguins/src/boards/399.txt similarity index 100% rename from EPFU/src/boards/399.txt rename to EPFU/penguins/src/boards/399.txt diff --git a/EPFU/src/boards/4.txt b/EPFU/penguins/src/boards/4.txt similarity index 100% rename from EPFU/src/boards/4.txt rename to EPFU/penguins/src/boards/4.txt diff --git a/EPFU/src/boards/40.txt b/EPFU/penguins/src/boards/40.txt similarity index 100% rename from EPFU/src/boards/40.txt rename to EPFU/penguins/src/boards/40.txt diff --git a/EPFU/src/boards/400.txt b/EPFU/penguins/src/boards/400.txt similarity index 100% rename from EPFU/src/boards/400.txt rename to EPFU/penguins/src/boards/400.txt diff --git a/EPFU/src/boards/402.txt b/EPFU/penguins/src/boards/402.txt similarity index 100% rename from EPFU/src/boards/402.txt rename to EPFU/penguins/src/boards/402.txt diff --git a/EPFU/src/boards/403.txt b/EPFU/penguins/src/boards/403.txt similarity index 100% rename from EPFU/src/boards/403.txt rename to EPFU/penguins/src/boards/403.txt diff --git a/EPFU/src/boards/405.txt b/EPFU/penguins/src/boards/405.txt similarity index 100% rename from EPFU/src/boards/405.txt rename to EPFU/penguins/src/boards/405.txt diff --git a/EPFU/src/boards/406.txt b/EPFU/penguins/src/boards/406.txt similarity index 100% rename from EPFU/src/boards/406.txt rename to EPFU/penguins/src/boards/406.txt diff --git a/EPFU/src/boards/408.txt b/EPFU/penguins/src/boards/408.txt similarity index 100% rename from EPFU/src/boards/408.txt rename to EPFU/penguins/src/boards/408.txt diff --git a/EPFU/src/boards/409.txt b/EPFU/penguins/src/boards/409.txt similarity index 100% rename from EPFU/src/boards/409.txt rename to EPFU/penguins/src/boards/409.txt diff --git a/EPFU/src/boards/41.txt b/EPFU/penguins/src/boards/41.txt similarity index 100% rename from EPFU/src/boards/41.txt rename to EPFU/penguins/src/boards/41.txt diff --git a/EPFU/src/boards/411.txt b/EPFU/penguins/src/boards/411.txt similarity index 100% rename from EPFU/src/boards/411.txt rename to EPFU/penguins/src/boards/411.txt diff --git a/EPFU/src/boards/412.txt b/EPFU/penguins/src/boards/412.txt similarity index 100% rename from EPFU/src/boards/412.txt rename to EPFU/penguins/src/boards/412.txt diff --git a/EPFU/src/boards/414.txt b/EPFU/penguins/src/boards/414.txt similarity index 100% rename from EPFU/src/boards/414.txt rename to EPFU/penguins/src/boards/414.txt diff --git a/EPFU/src/boards/415.txt b/EPFU/penguins/src/boards/415.txt similarity index 100% rename from EPFU/src/boards/415.txt rename to EPFU/penguins/src/boards/415.txt diff --git a/EPFU/src/boards/417.txt b/EPFU/penguins/src/boards/417.txt similarity index 100% rename from EPFU/src/boards/417.txt rename to EPFU/penguins/src/boards/417.txt diff --git a/EPFU/src/boards/418.txt b/EPFU/penguins/src/boards/418.txt similarity index 100% rename from EPFU/src/boards/418.txt rename to EPFU/penguins/src/boards/418.txt diff --git a/EPFU/src/boards/42.txt b/EPFU/penguins/src/boards/42.txt similarity index 100% rename from EPFU/src/boards/42.txt rename to EPFU/penguins/src/boards/42.txt diff --git a/EPFU/src/boards/420.txt b/EPFU/penguins/src/boards/420.txt similarity index 100% rename from EPFU/src/boards/420.txt rename to EPFU/penguins/src/boards/420.txt diff --git a/EPFU/src/boards/421.txt b/EPFU/penguins/src/boards/421.txt similarity index 100% rename from EPFU/src/boards/421.txt rename to EPFU/penguins/src/boards/421.txt diff --git a/EPFU/src/boards/423.txt b/EPFU/penguins/src/boards/423.txt similarity index 100% rename from EPFU/src/boards/423.txt rename to EPFU/penguins/src/boards/423.txt diff --git a/EPFU/src/boards/424.txt b/EPFU/penguins/src/boards/424.txt similarity index 100% rename from EPFU/src/boards/424.txt rename to EPFU/penguins/src/boards/424.txt diff --git a/EPFU/src/boards/426.txt b/EPFU/penguins/src/boards/426.txt similarity index 100% rename from EPFU/src/boards/426.txt rename to EPFU/penguins/src/boards/426.txt diff --git a/EPFU/src/boards/427.txt b/EPFU/penguins/src/boards/427.txt similarity index 100% rename from EPFU/src/boards/427.txt rename to EPFU/penguins/src/boards/427.txt diff --git a/EPFU/src/boards/429.txt b/EPFU/penguins/src/boards/429.txt similarity index 100% rename from EPFU/src/boards/429.txt rename to EPFU/penguins/src/boards/429.txt diff --git a/EPFU/src/boards/43.txt b/EPFU/penguins/src/boards/43.txt similarity index 100% rename from EPFU/src/boards/43.txt rename to EPFU/penguins/src/boards/43.txt diff --git a/EPFU/src/boards/430.txt b/EPFU/penguins/src/boards/430.txt similarity index 100% rename from EPFU/src/boards/430.txt rename to EPFU/penguins/src/boards/430.txt diff --git a/EPFU/src/boards/432.txt b/EPFU/penguins/src/boards/432.txt similarity index 100% rename from EPFU/src/boards/432.txt rename to EPFU/penguins/src/boards/432.txt diff --git a/EPFU/src/boards/433.txt b/EPFU/penguins/src/boards/433.txt similarity index 100% rename from EPFU/src/boards/433.txt rename to EPFU/penguins/src/boards/433.txt diff --git a/EPFU/src/boards/435.txt b/EPFU/penguins/src/boards/435.txt similarity index 100% rename from EPFU/src/boards/435.txt rename to EPFU/penguins/src/boards/435.txt diff --git a/EPFU/src/boards/436.txt b/EPFU/penguins/src/boards/436.txt similarity index 100% rename from EPFU/src/boards/436.txt rename to EPFU/penguins/src/boards/436.txt diff --git a/EPFU/src/boards/438.txt b/EPFU/penguins/src/boards/438.txt similarity index 100% rename from EPFU/src/boards/438.txt rename to EPFU/penguins/src/boards/438.txt diff --git a/EPFU/src/boards/439.txt b/EPFU/penguins/src/boards/439.txt similarity index 100% rename from EPFU/src/boards/439.txt rename to EPFU/penguins/src/boards/439.txt diff --git a/EPFU/src/boards/44.txt b/EPFU/penguins/src/boards/44.txt similarity index 100% rename from EPFU/src/boards/44.txt rename to EPFU/penguins/src/boards/44.txt diff --git a/EPFU/src/boards/441.txt b/EPFU/penguins/src/boards/441.txt similarity index 100% rename from EPFU/src/boards/441.txt rename to EPFU/penguins/src/boards/441.txt diff --git a/EPFU/src/boards/442.txt b/EPFU/penguins/src/boards/442.txt similarity index 100% rename from EPFU/src/boards/442.txt rename to EPFU/penguins/src/boards/442.txt diff --git a/EPFU/src/boards/444.txt b/EPFU/penguins/src/boards/444.txt similarity index 100% rename from EPFU/src/boards/444.txt rename to EPFU/penguins/src/boards/444.txt diff --git a/EPFU/src/boards/445.txt b/EPFU/penguins/src/boards/445.txt similarity index 100% rename from EPFU/src/boards/445.txt rename to EPFU/penguins/src/boards/445.txt diff --git a/EPFU/src/boards/447.txt b/EPFU/penguins/src/boards/447.txt similarity index 100% rename from EPFU/src/boards/447.txt rename to EPFU/penguins/src/boards/447.txt diff --git a/EPFU/src/boards/448.txt b/EPFU/penguins/src/boards/448.txt similarity index 100% rename from EPFU/src/boards/448.txt rename to EPFU/penguins/src/boards/448.txt diff --git a/EPFU/src/boards/45.txt b/EPFU/penguins/src/boards/45.txt similarity index 100% rename from EPFU/src/boards/45.txt rename to EPFU/penguins/src/boards/45.txt diff --git a/EPFU/src/boards/450.txt b/EPFU/penguins/src/boards/450.txt similarity index 100% rename from EPFU/src/boards/450.txt rename to EPFU/penguins/src/boards/450.txt diff --git a/EPFU/src/boards/451.txt b/EPFU/penguins/src/boards/451.txt similarity index 100% rename from EPFU/src/boards/451.txt rename to EPFU/penguins/src/boards/451.txt diff --git a/EPFU/src/boards/453.txt b/EPFU/penguins/src/boards/453.txt similarity index 100% rename from EPFU/src/boards/453.txt rename to EPFU/penguins/src/boards/453.txt diff --git a/EPFU/src/boards/454.txt b/EPFU/penguins/src/boards/454.txt similarity index 100% rename from EPFU/src/boards/454.txt rename to EPFU/penguins/src/boards/454.txt diff --git a/EPFU/src/boards/456.txt b/EPFU/penguins/src/boards/456.txt similarity index 100% rename from EPFU/src/boards/456.txt rename to EPFU/penguins/src/boards/456.txt diff --git a/EPFU/src/boards/457.txt b/EPFU/penguins/src/boards/457.txt similarity index 100% rename from EPFU/src/boards/457.txt rename to EPFU/penguins/src/boards/457.txt diff --git a/EPFU/src/boards/459.txt b/EPFU/penguins/src/boards/459.txt similarity index 100% rename from EPFU/src/boards/459.txt rename to EPFU/penguins/src/boards/459.txt diff --git a/EPFU/src/boards/46.txt b/EPFU/penguins/src/boards/46.txt similarity index 100% rename from EPFU/src/boards/46.txt rename to EPFU/penguins/src/boards/46.txt diff --git a/EPFU/src/boards/460.txt b/EPFU/penguins/src/boards/460.txt similarity index 100% rename from EPFU/src/boards/460.txt rename to EPFU/penguins/src/boards/460.txt diff --git a/EPFU/src/boards/462.txt b/EPFU/penguins/src/boards/462.txt similarity index 100% rename from EPFU/src/boards/462.txt rename to EPFU/penguins/src/boards/462.txt diff --git a/EPFU/src/boards/463.txt b/EPFU/penguins/src/boards/463.txt similarity index 100% rename from EPFU/src/boards/463.txt rename to EPFU/penguins/src/boards/463.txt diff --git a/EPFU/src/boards/465.txt b/EPFU/penguins/src/boards/465.txt similarity index 100% rename from EPFU/src/boards/465.txt rename to EPFU/penguins/src/boards/465.txt diff --git a/EPFU/src/boards/466.txt b/EPFU/penguins/src/boards/466.txt similarity index 100% rename from EPFU/src/boards/466.txt rename to EPFU/penguins/src/boards/466.txt diff --git a/EPFU/src/boards/468.txt b/EPFU/penguins/src/boards/468.txt similarity index 100% rename from EPFU/src/boards/468.txt rename to EPFU/penguins/src/boards/468.txt diff --git a/EPFU/src/boards/469.txt b/EPFU/penguins/src/boards/469.txt similarity index 100% rename from EPFU/src/boards/469.txt rename to EPFU/penguins/src/boards/469.txt diff --git a/EPFU/src/boards/47.txt b/EPFU/penguins/src/boards/47.txt similarity index 100% rename from EPFU/src/boards/47.txt rename to EPFU/penguins/src/boards/47.txt diff --git a/EPFU/src/boards/471.txt b/EPFU/penguins/src/boards/471.txt similarity index 100% rename from EPFU/src/boards/471.txt rename to EPFU/penguins/src/boards/471.txt diff --git a/EPFU/src/boards/472.txt b/EPFU/penguins/src/boards/472.txt similarity index 100% rename from EPFU/src/boards/472.txt rename to EPFU/penguins/src/boards/472.txt diff --git a/EPFU/src/boards/474.txt b/EPFU/penguins/src/boards/474.txt similarity index 100% rename from EPFU/src/boards/474.txt rename to EPFU/penguins/src/boards/474.txt diff --git a/EPFU/src/boards/475.txt b/EPFU/penguins/src/boards/475.txt similarity index 100% rename from EPFU/src/boards/475.txt rename to EPFU/penguins/src/boards/475.txt diff --git a/EPFU/src/boards/477.txt b/EPFU/penguins/src/boards/477.txt similarity index 100% rename from EPFU/src/boards/477.txt rename to EPFU/penguins/src/boards/477.txt diff --git a/EPFU/src/boards/478.txt b/EPFU/penguins/src/boards/478.txt similarity index 100% rename from EPFU/src/boards/478.txt rename to EPFU/penguins/src/boards/478.txt diff --git a/EPFU/src/boards/48.txt b/EPFU/penguins/src/boards/48.txt similarity index 100% rename from EPFU/src/boards/48.txt rename to EPFU/penguins/src/boards/48.txt diff --git a/EPFU/src/boards/480.txt b/EPFU/penguins/src/boards/480.txt similarity index 100% rename from EPFU/src/boards/480.txt rename to EPFU/penguins/src/boards/480.txt diff --git a/EPFU/src/boards/481.txt b/EPFU/penguins/src/boards/481.txt similarity index 100% rename from EPFU/src/boards/481.txt rename to EPFU/penguins/src/boards/481.txt diff --git a/EPFU/src/boards/483.txt b/EPFU/penguins/src/boards/483.txt similarity index 100% rename from EPFU/src/boards/483.txt rename to EPFU/penguins/src/boards/483.txt diff --git a/EPFU/src/boards/484.txt b/EPFU/penguins/src/boards/484.txt similarity index 100% rename from EPFU/src/boards/484.txt rename to EPFU/penguins/src/boards/484.txt diff --git a/EPFU/src/boards/486.txt b/EPFU/penguins/src/boards/486.txt similarity index 100% rename from EPFU/src/boards/486.txt rename to EPFU/penguins/src/boards/486.txt diff --git a/EPFU/src/boards/487.txt b/EPFU/penguins/src/boards/487.txt similarity index 100% rename from EPFU/src/boards/487.txt rename to EPFU/penguins/src/boards/487.txt diff --git a/EPFU/src/boards/489.txt b/EPFU/penguins/src/boards/489.txt similarity index 100% rename from EPFU/src/boards/489.txt rename to EPFU/penguins/src/boards/489.txt diff --git a/EPFU/src/boards/49.txt b/EPFU/penguins/src/boards/49.txt similarity index 100% rename from EPFU/src/boards/49.txt rename to EPFU/penguins/src/boards/49.txt diff --git a/EPFU/src/boards/490.txt b/EPFU/penguins/src/boards/490.txt similarity index 100% rename from EPFU/src/boards/490.txt rename to EPFU/penguins/src/boards/490.txt diff --git a/EPFU/src/boards/492.txt b/EPFU/penguins/src/boards/492.txt similarity index 100% rename from EPFU/src/boards/492.txt rename to EPFU/penguins/src/boards/492.txt diff --git a/EPFU/src/boards/493.txt b/EPFU/penguins/src/boards/493.txt similarity index 100% rename from EPFU/src/boards/493.txt rename to EPFU/penguins/src/boards/493.txt diff --git a/EPFU/src/boards/495.txt b/EPFU/penguins/src/boards/495.txt similarity index 100% rename from EPFU/src/boards/495.txt rename to EPFU/penguins/src/boards/495.txt diff --git a/EPFU/src/boards/496.txt b/EPFU/penguins/src/boards/496.txt similarity index 100% rename from EPFU/src/boards/496.txt rename to EPFU/penguins/src/boards/496.txt diff --git a/EPFU/src/boards/498.txt b/EPFU/penguins/src/boards/498.txt similarity index 100% rename from EPFU/src/boards/498.txt rename to EPFU/penguins/src/boards/498.txt diff --git a/EPFU/src/boards/499.txt b/EPFU/penguins/src/boards/499.txt similarity index 100% rename from EPFU/src/boards/499.txt rename to EPFU/penguins/src/boards/499.txt diff --git a/EPFU/src/boards/5.txt b/EPFU/penguins/src/boards/5.txt similarity index 100% rename from EPFU/src/boards/5.txt rename to EPFU/penguins/src/boards/5.txt diff --git a/EPFU/src/boards/50.txt b/EPFU/penguins/src/boards/50.txt similarity index 100% rename from EPFU/src/boards/50.txt rename to EPFU/penguins/src/boards/50.txt diff --git a/EPFU/src/boards/501.txt b/EPFU/penguins/src/boards/501.txt similarity index 100% rename from EPFU/src/boards/501.txt rename to EPFU/penguins/src/boards/501.txt diff --git a/EPFU/src/boards/51.txt b/EPFU/penguins/src/boards/51.txt similarity index 100% rename from EPFU/src/boards/51.txt rename to EPFU/penguins/src/boards/51.txt diff --git a/EPFU/src/boards/52.txt b/EPFU/penguins/src/boards/52.txt similarity index 100% rename from EPFU/src/boards/52.txt rename to EPFU/penguins/src/boards/52.txt diff --git a/EPFU/src/boards/53.txt b/EPFU/penguins/src/boards/53.txt similarity index 100% rename from EPFU/src/boards/53.txt rename to EPFU/penguins/src/boards/53.txt diff --git a/EPFU/src/boards/54.txt b/EPFU/penguins/src/boards/54.txt similarity index 100% rename from EPFU/src/boards/54.txt rename to EPFU/penguins/src/boards/54.txt diff --git a/EPFU/src/boards/55.txt b/EPFU/penguins/src/boards/55.txt similarity index 100% rename from EPFU/src/boards/55.txt rename to EPFU/penguins/src/boards/55.txt diff --git a/EPFU/src/boards/56.txt b/EPFU/penguins/src/boards/56.txt similarity index 100% rename from EPFU/src/boards/56.txt rename to EPFU/penguins/src/boards/56.txt diff --git a/EPFU/src/boards/57.txt b/EPFU/penguins/src/boards/57.txt similarity index 100% rename from EPFU/src/boards/57.txt rename to EPFU/penguins/src/boards/57.txt diff --git a/EPFU/src/boards/58.txt b/EPFU/penguins/src/boards/58.txt similarity index 100% rename from EPFU/src/boards/58.txt rename to EPFU/penguins/src/boards/58.txt diff --git a/EPFU/src/boards/59.txt b/EPFU/penguins/src/boards/59.txt similarity index 100% rename from EPFU/src/boards/59.txt rename to EPFU/penguins/src/boards/59.txt diff --git a/EPFU/src/boards/6.txt b/EPFU/penguins/src/boards/6.txt similarity index 100% rename from EPFU/src/boards/6.txt rename to EPFU/penguins/src/boards/6.txt diff --git a/EPFU/src/boards/60.txt b/EPFU/penguins/src/boards/60.txt similarity index 100% rename from EPFU/src/boards/60.txt rename to EPFU/penguins/src/boards/60.txt diff --git a/EPFU/src/boards/61.txt b/EPFU/penguins/src/boards/61.txt similarity index 100% rename from EPFU/src/boards/61.txt rename to EPFU/penguins/src/boards/61.txt diff --git a/EPFU/src/boards/62.txt b/EPFU/penguins/src/boards/62.txt similarity index 100% rename from EPFU/src/boards/62.txt rename to EPFU/penguins/src/boards/62.txt diff --git a/EPFU/src/boards/63.txt b/EPFU/penguins/src/boards/63.txt similarity index 100% rename from EPFU/src/boards/63.txt rename to EPFU/penguins/src/boards/63.txt diff --git a/EPFU/src/boards/64.txt b/EPFU/penguins/src/boards/64.txt similarity index 100% rename from EPFU/src/boards/64.txt rename to EPFU/penguins/src/boards/64.txt diff --git a/EPFU/src/boards/65.txt b/EPFU/penguins/src/boards/65.txt similarity index 100% rename from EPFU/src/boards/65.txt rename to EPFU/penguins/src/boards/65.txt diff --git a/EPFU/src/boards/66.txt b/EPFU/penguins/src/boards/66.txt similarity index 100% rename from EPFU/src/boards/66.txt rename to EPFU/penguins/src/boards/66.txt diff --git a/EPFU/src/boards/67.txt b/EPFU/penguins/src/boards/67.txt similarity index 100% rename from EPFU/src/boards/67.txt rename to EPFU/penguins/src/boards/67.txt diff --git a/EPFU/src/boards/68.txt b/EPFU/penguins/src/boards/68.txt similarity index 100% rename from EPFU/src/boards/68.txt rename to EPFU/penguins/src/boards/68.txt diff --git a/EPFU/src/boards/69.txt b/EPFU/penguins/src/boards/69.txt similarity index 100% rename from EPFU/src/boards/69.txt rename to EPFU/penguins/src/boards/69.txt diff --git a/EPFU/src/boards/7.txt b/EPFU/penguins/src/boards/7.txt similarity index 100% rename from EPFU/src/boards/7.txt rename to EPFU/penguins/src/boards/7.txt diff --git a/EPFU/src/boards/70.txt b/EPFU/penguins/src/boards/70.txt similarity index 100% rename from EPFU/src/boards/70.txt rename to EPFU/penguins/src/boards/70.txt diff --git a/EPFU/src/boards/71.txt b/EPFU/penguins/src/boards/71.txt similarity index 100% rename from EPFU/src/boards/71.txt rename to EPFU/penguins/src/boards/71.txt diff --git a/EPFU/src/boards/72.txt b/EPFU/penguins/src/boards/72.txt similarity index 100% rename from EPFU/src/boards/72.txt rename to EPFU/penguins/src/boards/72.txt diff --git a/EPFU/src/boards/73.txt b/EPFU/penguins/src/boards/73.txt similarity index 100% rename from EPFU/src/boards/73.txt rename to EPFU/penguins/src/boards/73.txt diff --git a/EPFU/src/boards/74.txt b/EPFU/penguins/src/boards/74.txt similarity index 100% rename from EPFU/src/boards/74.txt rename to EPFU/penguins/src/boards/74.txt diff --git a/EPFU/src/boards/75.txt b/EPFU/penguins/src/boards/75.txt similarity index 100% rename from EPFU/src/boards/75.txt rename to EPFU/penguins/src/boards/75.txt diff --git a/EPFU/src/boards/76.txt b/EPFU/penguins/src/boards/76.txt similarity index 100% rename from EPFU/src/boards/76.txt rename to EPFU/penguins/src/boards/76.txt diff --git a/EPFU/src/boards/77.txt b/EPFU/penguins/src/boards/77.txt similarity index 100% rename from EPFU/src/boards/77.txt rename to EPFU/penguins/src/boards/77.txt diff --git a/EPFU/src/boards/78.txt b/EPFU/penguins/src/boards/78.txt similarity index 100% rename from EPFU/src/boards/78.txt rename to EPFU/penguins/src/boards/78.txt diff --git a/EPFU/src/boards/79.txt b/EPFU/penguins/src/boards/79.txt similarity index 100% rename from EPFU/src/boards/79.txt rename to EPFU/penguins/src/boards/79.txt diff --git a/EPFU/src/boards/8.txt b/EPFU/penguins/src/boards/8.txt similarity index 100% rename from EPFU/src/boards/8.txt rename to EPFU/penguins/src/boards/8.txt diff --git a/EPFU/src/boards/80.txt b/EPFU/penguins/src/boards/80.txt similarity index 100% rename from EPFU/src/boards/80.txt rename to EPFU/penguins/src/boards/80.txt diff --git a/EPFU/src/boards/81.txt b/EPFU/penguins/src/boards/81.txt similarity index 100% rename from EPFU/src/boards/81.txt rename to EPFU/penguins/src/boards/81.txt diff --git a/EPFU/src/boards/82.txt b/EPFU/penguins/src/boards/82.txt similarity index 100% rename from EPFU/src/boards/82.txt rename to EPFU/penguins/src/boards/82.txt diff --git a/EPFU/src/boards/83.txt b/EPFU/penguins/src/boards/83.txt similarity index 100% rename from EPFU/src/boards/83.txt rename to EPFU/penguins/src/boards/83.txt diff --git a/EPFU/src/boards/84.txt b/EPFU/penguins/src/boards/84.txt similarity index 100% rename from EPFU/src/boards/84.txt rename to EPFU/penguins/src/boards/84.txt diff --git a/EPFU/src/boards/85.txt b/EPFU/penguins/src/boards/85.txt similarity index 100% rename from EPFU/src/boards/85.txt rename to EPFU/penguins/src/boards/85.txt diff --git a/EPFU/src/boards/86.txt b/EPFU/penguins/src/boards/86.txt similarity index 100% rename from EPFU/src/boards/86.txt rename to EPFU/penguins/src/boards/86.txt diff --git a/EPFU/src/boards/87.txt b/EPFU/penguins/src/boards/87.txt similarity index 100% rename from EPFU/src/boards/87.txt rename to EPFU/penguins/src/boards/87.txt diff --git a/EPFU/src/boards/88.txt b/EPFU/penguins/src/boards/88.txt similarity index 100% rename from EPFU/src/boards/88.txt rename to EPFU/penguins/src/boards/88.txt diff --git a/EPFU/src/boards/89.txt b/EPFU/penguins/src/boards/89.txt similarity index 100% rename from EPFU/src/boards/89.txt rename to EPFU/penguins/src/boards/89.txt diff --git a/EPFU/src/boards/9.txt b/EPFU/penguins/src/boards/9.txt similarity index 100% rename from EPFU/src/boards/9.txt rename to EPFU/penguins/src/boards/9.txt diff --git a/EPFU/src/boards/90.txt b/EPFU/penguins/src/boards/90.txt similarity index 100% rename from EPFU/src/boards/90.txt rename to EPFU/penguins/src/boards/90.txt diff --git a/EPFU/src/boards/91.txt b/EPFU/penguins/src/boards/91.txt similarity index 100% rename from EPFU/src/boards/91.txt rename to EPFU/penguins/src/boards/91.txt diff --git a/EPFU/src/boards/92.txt b/EPFU/penguins/src/boards/92.txt similarity index 100% rename from EPFU/src/boards/92.txt rename to EPFU/penguins/src/boards/92.txt diff --git a/EPFU/src/boards/93.txt b/EPFU/penguins/src/boards/93.txt similarity index 100% rename from EPFU/src/boards/93.txt rename to EPFU/penguins/src/boards/93.txt diff --git a/EPFU/src/boards/94.txt b/EPFU/penguins/src/boards/94.txt similarity index 100% rename from EPFU/src/boards/94.txt rename to EPFU/penguins/src/boards/94.txt diff --git a/EPFU/src/boards/95.txt b/EPFU/penguins/src/boards/95.txt similarity index 100% rename from EPFU/src/boards/95.txt rename to EPFU/penguins/src/boards/95.txt diff --git a/EPFU/src/boards/96.txt b/EPFU/penguins/src/boards/96.txt similarity index 100% rename from EPFU/src/boards/96.txt rename to EPFU/penguins/src/boards/96.txt diff --git a/EPFU/src/boards/97.txt b/EPFU/penguins/src/boards/97.txt similarity index 100% rename from EPFU/src/boards/97.txt rename to EPFU/penguins/src/boards/97.txt diff --git a/EPFU/src/boards/98.txt b/EPFU/penguins/src/boards/98.txt similarity index 100% rename from EPFU/src/boards/98.txt rename to EPFU/penguins/src/boards/98.txt diff --git a/EPFU/src/boards/99.txt b/EPFU/penguins/src/boards/99.txt similarity index 100% rename from EPFU/src/boards/99.txt rename to EPFU/penguins/src/boards/99.txt diff --git a/EPFU/src/checkmove.c b/EPFU/penguins/src/checkmove.c similarity index 100% rename from EPFU/src/checkmove.c rename to EPFU/penguins/src/checkmove.c diff --git a/EPFU/src/command_line_parameters.c b/EPFU/penguins/src/command_line_parameters.c similarity index 100% rename from EPFU/src/command_line_parameters.c rename to EPFU/penguins/src/command_line_parameters.c diff --git a/EPFU/src/game_struct.h b/EPFU/penguins/src/game_struct.h similarity index 100% rename from EPFU/src/game_struct.h rename to EPFU/penguins/src/game_struct.h diff --git a/EPFU/src/generate.c b/EPFU/penguins/src/generate.c similarity index 100% rename from EPFU/src/generate.c rename to EPFU/penguins/src/generate.c diff --git a/EPFU/src/handling_files.c b/EPFU/penguins/src/handling_files.c similarity index 100% rename from EPFU/src/handling_files.c rename to EPFU/penguins/src/handling_files.c diff --git a/EPFU/src/main.c b/EPFU/penguins/src/main.c similarity index 100% rename from EPFU/src/main.c rename to EPFU/penguins/src/main.c diff --git a/EPFU/src/makefile b/EPFU/penguins/src/makefile similarity index 100% rename from EPFU/src/makefile rename to EPFU/penguins/src/makefile diff --git a/EPFU/src/movement.c b/EPFU/penguins/src/movement.c similarity index 100% rename from EPFU/src/movement.c rename to EPFU/penguins/src/movement.c diff --git a/EPFU/src/new/.gitkeep b/EPFU/penguins/src/new/.gitkeep similarity index 100% rename from EPFU/src/new/.gitkeep rename to EPFU/penguins/src/new/.gitkeep diff --git a/EPFU/src/new/printing.c b/EPFU/penguins/src/new/printing.c similarity index 100% rename from EPFU/src/new/printing.c rename to EPFU/penguins/src/new/printing.c diff --git a/EPFU/src/placement.c b/EPFU/penguins/src/placement.c similarity index 100% rename from EPFU/src/placement.c rename to EPFU/penguins/src/placement.c diff --git a/EPFU/src/printing.c b/EPFU/penguins/src/printing.c similarity index 100% rename from EPFU/src/printing.c rename to EPFU/penguins/src/printing.c diff --git a/EPFU/src/test_board.c b/EPFU/penguins/src/test_board.c similarity index 100% rename from EPFU/src/test_board.c rename to EPFU/penguins/src/test_board.c diff --git a/EPFU/src/userinteraction.c b/EPFU/penguins/src/userinteraction.c similarity index 100% rename from EPFU/src/userinteraction.c rename to EPFU/penguins/src/userinteraction.c diff --git a/EPHY2/Reports/EPHY, lab5, Krzysztof Rudnicki, 307585, Report.pdf b/EPHY2/Reports/EPHY, lab5, Krzysztof Rudnicki, 307585, Report.pdf new file mode 100644 index 00000000..d0e59271 Binary files /dev/null and b/EPHY2/Reports/EPHY, lab5, Krzysztof Rudnicki, 307585, Report.pdf differ diff --git a/EPHY2/Reports/EPHY2, lab6, Krzysztof Rudnicki, 307585, report.pdf b/EPHY2/Reports/EPHY2, lab6, Krzysztof Rudnicki, 307585, report.pdf new file mode 100644 index 00000000..452f04c5 Binary files /dev/null and b/EPHY2/Reports/EPHY2, lab6, Krzysztof Rudnicki, 307585, report.pdf differ diff --git a/EPHY2/Reports/Krzysztof Rudnicki, 307585, lab1 report.pdf b/EPHY2/Reports/Krzysztof Rudnicki, 307585, lab1 report.pdf new file mode 100644 index 00000000..0e027832 Binary files /dev/null and b/EPHY2/Reports/Krzysztof Rudnicki, 307585, lab1 report.pdf differ diff --git a/EPHY2/Reports/Krzysztof Rudnicki, 307585, lab2.pdf b/EPHY2/Reports/Krzysztof Rudnicki, 307585, lab2.pdf new file mode 100644 index 00000000..cf4f858f Binary files /dev/null and b/EPHY2/Reports/Krzysztof Rudnicki, 307585, lab2.pdf differ diff --git a/EPHY2/Reports/Krzysztof Rudnicki, 307585, report lab 4.pdf b/EPHY2/Reports/Krzysztof Rudnicki, 307585, report lab 4.pdf new file mode 100644 index 00000000..84cefe5c Binary files /dev/null and b/EPHY2/Reports/Krzysztof Rudnicki, 307585, report lab 4.pdf differ diff --git a/EPHY2/Reports/Krzysztof Rudnicki, 307585, report.pdf b/EPHY2/Reports/Krzysztof Rudnicki, 307585, report.pdf new file mode 100644 index 00000000..73736603 Binary files /dev/null and b/EPHY2/Reports/Krzysztof Rudnicki, 307585, report.pdf differ