diff --git a/.gitignore b/.gitignore new file mode 100644 index 00000000..7c3bf697 --- /dev/null +++ b/.gitignore @@ -0,0 +1,2 @@ +*.exe +*.exe.stackdump diff --git a/Cracking Code/+Helper/BinaryTree.h b/Cracking Code/+Helper/BinaryTree.h new file mode 100644 index 00000000..62fc0111 --- /dev/null +++ b/Cracking Code/+Helper/BinaryTree.h @@ -0,0 +1,85 @@ +#include +#include +#include +using namespace std; +#include +#include +#include + +struct TreeNode { + int val; + TreeNode *left; + TreeNode *right; + TreeNode(int x) : val(x), left(NULL), right(NULL) {} +}; + +vector breathFirstTraversal(TreeNode *root){ + if(!root) return vector(); + vector v; + queue q; + q.push(root); + int num = 1; + while(num){ + int nextNum = 0; + while(num--){ + TreeNode *n = q.front(); q.pop(); + v.push_back(n->val); + if(n->left){ + nextNum++; + q.push(n->left); + } + if(n->right){ + nextNum++; + q.push(n->right); + } + } + num = nextNum; + } + return v; +} + +// Note: Invalid input is not considered yet. +TreeNode* deserialize(string str){ + char *s = (char*)str.c_str(), *p = NULL; + p = strsep(&s, ","); + if(!strcmp(p, "#")) return NULL; + TreeNode *root = new TreeNode(atoi(p)); + queue q; + q.push(root); + while(!q.empty()){ + TreeNode *pnode = q.front(); q.pop(); + TreeNode *n[2] = {NULL}; + for(int i = 0; s && i < 2; ++i){ + p = strsep(&s, ","); + if(strcmp(p, "#")){ + n[i] = new TreeNode(atoi(p)); + q.push(n[i]); + } + } + pnode->left = n[0]; + pnode->right = n[1]; + } + return root; +} + +string serialize(TreeNode* root){ + if(!root) return ""; + char buf[100000] = {0}, *p = buf; + queue q; + q.push(root); + while(!q.empty()){ + TreeNode *n = q.front(); q.pop(); + if(n){ + p += sprintf(p, "%d,", n->val); + }else{ + p += sprintf(p, "#,"); + } + if(n){ + q.push(n->left); + q.push(n->right); + } + } + while(*(p - 1) == ',' && *(p - 2) == '#') p -= 2; + *(p - 1) = '\0'; + return string(buf); +} \ No newline at end of file diff --git a/Cracking Code/+Helper/BinaryTreeTest.cpp b/Cracking Code/+Helper/BinaryTreeTest.cpp new file mode 100644 index 00000000..e68140e7 --- /dev/null +++ b/Cracking Code/+Helper/BinaryTreeTest.cpp @@ -0,0 +1,9 @@ +#include "BinaryTree.h" + +int main(){ + string s = "3,9,20,#,#,15,7"; + TreeNode *root = deserialize(s); + printVector(breathFirstTraversal(root)); + cout << serialize(root) << endl; + return 0; +} \ No newline at end of file diff --git a/Cracking Code/+Helper/Helper.h b/Cracking Code/+Helper/Helper.h new file mode 100644 index 00000000..f9e5c2ae --- /dev/null +++ b/Cracking Code/+Helper/Helper.h @@ -0,0 +1,67 @@ +#ifndef Helper_h +#define Helper_h + +#include +#include +#include +#include +#include +#include +using namespace std; +#define CASET int ___T, case_n = 1; scanf("%d ", &___T); while (___T-- > 0) +#define PRINTCASE printf("Case #%d: ",case_n++) +#define PRINTCASE_ printf("Case #%d:\n",case_n++) +#define RD(a) scanf("%d", &(a)) +#define RDD(a, b) scanf("%d%d", &(a), &(b)) + +#define CLK_INIT clock_t clk_start = 0, clk_end = 0 +#define CLK_START clk_start = clock() +#define CLK_END\ + do{ clk_end = clock();\ + cout << "Time[" << (double)(clk_end - clk_start) / CLOCKS_PER_SEC << "s]" << endl; }while(0) + +template +void printVector(vector v){ + typename vector::iterator i = v.begin(); + for(; i != v.end(); ++i){ + cout << "[" << *i << "] "; + } + cout << endl; +} + +template +void printVector(vector > v){ + for(int i = 0; i < v.size(); ++i){ + for(int j = 0; j < v[i].size(); ++j){ + cout << "[" << v[i][j] << "] "; + } + cout << endl; + } +} + +vector > scanVector(int m, int n){ + vector > v; + for(int i = 0; i < m; ++i){ + vector v1; + for(int j = 0; j < n; ++j){ + int d; + cin >> d; + v1.push_back(d); + } + v.push_back(v1); + } + return v; +} + +vector scanVector(){ + vector v; + string str; + cin >> str; + char *s = (char*) str.c_str(), *p = NULL; + while(p = strsep(&s, ",")){ + v.push_back(atoi(p)); + } + return v; +} + +#endif \ No newline at end of file diff --git a/Cracking Code/+Helper/SinglyLinkedList.h b/Cracking Code/+Helper/SinglyLinkedList.h new file mode 100644 index 00000000..38c79d8f --- /dev/null +++ b/Cracking Code/+Helper/SinglyLinkedList.h @@ -0,0 +1,34 @@ +#ifndef SinglyLinkedList_h +#define SinglyLinkedList_h +struct ListNode{ + int val; + ListNode *next; + ListNode(int x) : val(x), next(NULL) {} +}; + +void list_destroy(ListNode *head){ + if(!head) return; + ListNode *next; + while(head){ + next = head->next; + delete head; + head = next; + } +} + +void listnode_append(ListNode *head, int val){ + if(!head) return; + while(head->next){ + head = head->next; + } + head->next = new ListNode(val); +} + +void print_list(ListNode *head){ + while(head){ + printf("[%d] ", head->val); + head = head->next; + } + printf("\n"); +} +#endif \ No newline at end of file diff --git a/Cracking Code/+Helper/TreeLinkNode.cpp b/Cracking Code/+Helper/TreeLinkNode.cpp new file mode 100644 index 00000000..58990ea5 --- /dev/null +++ b/Cracking Code/+Helper/TreeLinkNode.cpp @@ -0,0 +1,56 @@ +#include +#include +#include +using namespace std; +#include +#include + +struct TreeLinkNode { + int val; + TreeLinkNode *left, *right, *next; + TreeLinkNode(int x) : val(x), left(NULL), right(NULL), next(NULL) {} +}; + +// Note: Invalid input is not considered yet. +TreeLinkNode* deserialize(string str){ + char *s = (char*)str.c_str(), *p = NULL; + p = strsep(&s, ","); + if(!strcmp(p, "#")) return NULL; + TreeLinkNode *root = new TreeLinkNode(atoi(p)); + queue q; + q.push(root); + while(!q.empty()){ + TreeLinkNode *pnode = q.front(); q.pop(); + TreeLinkNode *n[2] = {NULL}; + for(int i = 0; s && i < 2; ++i){ + p = strsep(&s, ","); + if(strcmp(p, "#")){ + n[i] = new TreeLinkNode(atoi(p)); + q.push(n[i]); + } + } + pnode->left = n[0]; + pnode->right = n[1]; + } + return root; +} + +string serialize(TreeLinkNode* root){ + if(!root) return ""; + char buf[100000] = {0}, *p = buf; + TreeLinkNode *nextLv = root; + while(nextLv){ + root = nextLv; + nextLv = NULL; + while(root){ + p += sprintf(p, "%d,", root->val); + if(!nextLv && (root->left || root->right)){ + nextLv = root->left ? root->left : root->right; + } + root = root->next; + } + *(p - 1) = '#'; + } + *(p - 1) = '\0'; + return string(buf); +} \ No newline at end of file diff --git a/Cracking Code/+Helper/Undirected Graph.cpp b/Cracking Code/+Helper/Undirected Graph.cpp new file mode 100644 index 00000000..f0f91e55 --- /dev/null +++ b/Cracking Code/+Helper/Undirected Graph.cpp @@ -0,0 +1,110 @@ +#include +#include +#include +#include +#include +using namespace std; +#include +#include +#include + +struct UndirectedGraphNode { + int label; + vector neighbors; + UndirectedGraphNode(int x) : label(x) {}; +}; + +// set中不应该存储"已经被访问的节点", 因为这可能导致队列中出现重复的待访问节点. +// set中应该存储"已经插入过队列的节点", 也就是紧随q.push(n)操作. +vector breathFirstTraversal(UndirectedGraphNode *n){ + if(!n) return vector(); + vector v; + set s; + queue q; + q.push(n); + s.insert(n->label); + while(!q.empty()){ + n = q.front(); q.pop(); + v.push_back(n->label); + vector::iterator i; + i = n->neighbors.begin(); + for(; i != n->neighbors.end(); ++i){ + if(s.find((*i)->label) == s.end()){ + q.push(*i); + s.insert((*i)->label); + } + } + } + return v; +} + +void printVector(vector v){ + vector:: iterator i = v.begin(); + for(; i != v.end(); ++i){ + cout << "[" << *i << "] "; + } + cout << endl; +} + +// Note: Invalid input is not considered yet. +UndirectedGraphNode* deserialize(string str){ + char *s = (char*)str.c_str(), *p = NULL; + map m; + UndirectedGraphNode *ret = NULL; + while(p = strsep(&s, "#")){ + char *q = NULL; + UndirectedGraphNode *n = NULL; + vector v; + while(q = strsep(&p, ",")){ + int label = atoi(q); + if(m.find(label) != m.end()){ + n = m[label]; + }else{ + n = new UndirectedGraphNode(label); + m[label] = n; + } + v.push_back(n); + } + n = v.front(); + v.erase(v.begin()); + n->neighbors = v; + if(!ret){ + ret = n; + } + } + return ret; +} + +string serialize(UndirectedGraphNode* n){ + if(!n) return ""; + char buf[1000] = {0}, *p = buf; + set s; + queue q; + q.push(n); + s.insert(n->label); + while(!q.empty()){ + n = q.front(); q.pop(); + p += sprintf(p, "%d,", n->label); + vector::iterator i; + i = n->neighbors.begin(); + for(; i != n->neighbors.end(); ++i){ + int label = (*i)->label; + p += sprintf(p, "%d,", label); + if(s.find(label) == s.end()){ + q.push(*i); + s.insert(label); + } + } + *(p - 1) = '#'; + } + *(p - 1) = '\0'; + return string(buf); +} + +int main(){ + string s = "0,1,2#1,2#2,2"; + UndirectedGraphNode *n = deserialize(s); + printVector(breathFirstTraversal(n)); + cout << serialize(n) << endl; + return 0; +} \ No newline at end of file diff --git a/Cracking Code/1. Arrays and Strings/3.c b/Cracking Code/1. Arrays and Strings/3.c new file mode 100644 index 00000000..044ba1d5 --- /dev/null +++ b/Cracking Code/1. Arrays and Strings/3.c @@ -0,0 +1,29 @@ +#include +#include + +void remove_duplicate_char(char *str){ + int i, j, len; + if(!str) return; + len = strlen(str); + i = 0; + while(i < len){ + for(j = i + 1; j < len; ++j){ + if(str[i] == str[j]) str[j] = 0; + } + while(!str[++i]); + } + for(i = j = 0; j < len; j++){ + if(str[j]) str[i++] = str[j]; + } + str[i] = 0; +} + +int main(){ + char str[100] = {0}; + while(1){ + gets(str); + remove_duplicate_char(str); + puts(str); + } + return 0; +} \ No newline at end of file diff --git a/Cracking Code/1. Arrays and Strings/3_1.c b/Cracking Code/1. Arrays and Strings/3_1.c new file mode 100644 index 00000000..154a8c5c --- /dev/null +++ b/Cracking Code/1. Arrays and Strings/3_1.c @@ -0,0 +1,29 @@ +#include +#include + +void remove_duplicate_char(char *str){ + int i, j, tail, len; + if(!str) return; + len = strlen(str); + tail = 1; + for(i = 1; i < len; ++i){ + for(j = 0; j < tail; ++j){ + if(str[i] == str[j]) + break; + } + if(j == tail){ + str[tail++] = str[i]; + } + } + str[tail] = 0; +} + +int main(){ + char str[100] = {0}; + while(1){ + gets(str); + remove_duplicate_char(str); + puts(str); + } + return 0; +} diff --git a/Cracking Code/1. Arrays and Strings/3_2.c b/Cracking Code/1. Arrays and Strings/3_2.c new file mode 100644 index 00000000..6e798540 --- /dev/null +++ b/Cracking Code/1. Arrays and Strings/3_2.c @@ -0,0 +1,25 @@ +#include +#include + +void remove_duplicate_char(char *str){ + char hit[256] = {0}; + int i, tail = 0; + if(!str) return; + for(i = 0; str[i]; ++i){ + if(!hit[str[i]]){ + hit[str[i]] = 1; + str[tail++] = str[i]; + } + } + str[tail] = 0; +} + +int main(){ + char str[100] = {0}; + while(1){ + gets(str); + remove_duplicate_char(str); + puts(str); + } + return 0; +} \ No newline at end of file diff --git a/Cracking Code/1. Arrays and Strings/4.c b/Cracking Code/1. Arrays and Strings/4.c new file mode 100644 index 00000000..583a4b34 --- /dev/null +++ b/Cracking Code/1. Arrays and Strings/4.c @@ -0,0 +1,30 @@ +#include +#include + +int test_anagram(char *s1, char *s2){ + int len1, len2, i, j; + if(!s1 || !s2) return 0; + len1 = strlen(s1); + len2 = strlen(s2); + if(len1 != len2) return 0; + for(i = 0; i < len1; ++i){ + for(j = 0; j < len2; ++j){ + if(s2[j] == s1[i]){ + s2[j] = 0; + break; + } + } + if(j == len2) return 0; + } + return 1; +} + +int main(){ + char s1[100] = {0}, s2[100] = {0}; + while(1){ + gets(s1); + gets(s2); + printf("%d\n", test_anagram(s1, s2)); + } + return 0; +} diff --git a/Cracking Code/1. Arrays and Strings/4_1.c b/Cracking Code/1. Arrays and Strings/4_1.c new file mode 100644 index 00000000..80ccf295 --- /dev/null +++ b/Cracking Code/1. Arrays and Strings/4_1.c @@ -0,0 +1,40 @@ +#include +#include + +void qsort(char *s, int low, int high){ + int i, j; + char c; + if(!s || low >= high) return; + c = s[low]; + i = low; j = high; + while(i < j){ + while(i < j && s[j] > c) --j; + if(i < j) s[i++] = s[j]; + while(i < j && s[i] < c) ++i; + if(i < j) s[j--] = s[i]; + } + s[i] = c; + qsort(s, low, i - 1); + qsort(s, i + 1, high); +} + +int test_anagram(char *s1, char *s2){ + int len1, len2; + if(!s1 || !s2) return 0; + len1 = strlen(s1); + len2 = strlen(s2); + if(len1 != len2) return 0; + qsort(s1, 0, len1 - 1); + qsort(s2, 0, len2 - 1); + return !strcmp(s1, s2); +} + +int main(){ + char s1[100] = {0}, s2[100] = {0}; + while(1){ + gets(s1); + gets(s2); + printf("%d\n", test_anagram(s1, s2)); + } + return 0; +} \ No newline at end of file diff --git a/Cracking Code/1. Arrays and Strings/4_2.c b/Cracking Code/1. Arrays and Strings/4_2.c new file mode 100644 index 00000000..de563b5a --- /dev/null +++ b/Cracking Code/1. Arrays and Strings/4_2.c @@ -0,0 +1,29 @@ +#include +#include + +static int test_anagram(char *s1, char *s2){ + int dic[256] = {0}; + int len1, len2, i; + if(!s1 || !s2) return 0; + len1 = strlen(s1); + len2 = strlen(s2); + if(len1 != len2) return 0; + for(i = 0; i < len1; ++i){ + dic[s1[i]]++; + } + for(i = 0; i < len2; ++i){ + dic[s2[i]]--; + if(dic[s2[i]] < 0) return 0; + } + return 1; +} + +int main(){ + char s1[100] = {0}, s2[100] = {0}; + while(1){ + gets(s1); + gets(s2); + printf("%d\n", test_anagram(s1, s2)); + } + return 0; +} \ No newline at end of file diff --git a/Cracking Code/1. Arrays and Strings/5.c b/Cracking Code/1. Arrays and Strings/5.c new file mode 100644 index 00000000..795c3c1c --- /dev/null +++ b/Cracking Code/1. Arrays and Strings/5.c @@ -0,0 +1,27 @@ +#include +#include + +static void replace_space(char *src, char *dst){ + if(!src || !dst) return; + while(*src){ + if(*src == ' '){ + *dst++ = '%'; + *dst++ = '2'; + *dst++ = '0'; + }else{ + *dst++ = *src; + } + src++; + } + *dst = 0; +} + +int main(){ + char src[100] = {0}, dst[100] = {0}; + while(1){ + gets(src); + replace_space(src, dst); + puts(dst); + } + return 0; +} \ No newline at end of file diff --git a/Cracking Code/1. Arrays and Strings/5_1.c b/Cracking Code/1. Arrays and Strings/5_1.c new file mode 100644 index 00000000..7bbce3d6 --- /dev/null +++ b/Cracking Code/1. Arrays and Strings/5_1.c @@ -0,0 +1,31 @@ +#include +#include + +static void replace_space(char *s){ + int sp_cnt = 0, i, j; + if(!s) return; + for(i = 0; s[i]; ++i){ + if(s[i] == ' ') sp_cnt++; + } + j = i + (sp_cnt << 1); + while(i >= 0){ + if(s[i] == ' '){ + s[j--] = '0'; + s[j--] = '2'; + s[j--] = '%'; + }else{ + s[j--] = s[i]; + } + i--; + } +} + +int main(){ + char s[100] = {0}; + while(1){ + gets(s); + replace_space(s); + puts(s); + } + return 0; +} \ No newline at end of file diff --git a/Cracking Code/1. Arrays and Strings/6.c b/Cracking Code/1. Arrays and Strings/6.c new file mode 100644 index 00000000..ec640d41 --- /dev/null +++ b/Cracking Code/1. Arrays and Strings/6.c @@ -0,0 +1,37 @@ +#include + +typedef int pixel; +#define AT(mtx, N, i, j) ((mtx)[(i) * (N) + (j)]) +void rotate_matrix(pixel *mtx, size_t N){ + int i, j; pixel tmp; + if(!mtx) return; + for(i = 0; i < (N >> 1); ++i){ + for(j = i; j < N - i - 1; ++j){ + tmp = AT(mtx, N, i, j); + AT(mtx, N, i, j) = AT(mtx, N, N - j - 1, i); + AT(mtx, N, N - j - 1, i) = AT(mtx, N, N - i - 1, N - j - 1); + AT(mtx, N, N - i - 1, N - j - 1) = AT(mtx, N, j, N - i - 1); + AT(mtx, N, j, N - i - 1) = tmp; + } + } +} + +#define MAX_NxN 100 +int main(){ + pixel mtx[MAX_NxN] = {0}; + size_t N = 0; + int i; + while(1){ + scanf("%u", &N); + for(i = 0; i < N * N; ++i){ + scanf("%d", &mtx[i]); + } + rotate_matrix(mtx, N); + for(i = 0; i < N * N; ++i){ + printf("%d ", mtx[i]); + if((i + 1) % N == 0) + printf("\n"); + } + } + return 0; +} \ No newline at end of file diff --git a/Cracking Code/1. Arrays and Strings/6_1.c b/Cracking Code/1. Arrays and Strings/6_1.c new file mode 100644 index 00000000..960ce9e9 --- /dev/null +++ b/Cracking Code/1. Arrays and Strings/6_1.c @@ -0,0 +1,39 @@ +#include + +typedef int pixel; +#define MAX_N 100 +void rotate_matrix(pixel mtx[][MAX_N], size_t N){ + int i, j; pixel tmp; + if(!mtx) return; + for(i = 0; i < (N >> 1); ++i){ + for(j = i; j < N - i - 1; ++j){ + tmp = mtx[i][j]; + mtx[i][j] = mtx[N - j - 1][i]; + mtx[N - j - 1][i] = mtx[N - i - 1][N - j - 1]; + mtx[N - i - 1][N - j - 1] = mtx[j][N - i - 1]; + mtx[j][N - i - 1] = tmp; + } + } +} + +int main(){ + pixel mtx[MAX_N][MAX_N] = {0}; + size_t N = 0; + int i, j; + while(1){ + scanf("%u", &N); + for(i = 0; i < N; ++i){ + for(j = 0; j < N; ++j){ + scanf("%d", &mtx[i][j]); + } + } + rotate_matrix(mtx, N); + for(i = 0; i < N; ++i){ + for(j = 0; j < N; ++j){ + printf("%d ", mtx[i][j]); + } + printf("\n"); + } + } + return 0; +} \ No newline at end of file diff --git a/Cracking Code/1. Arrays and Strings/7.c b/Cracking Code/1. Arrays and Strings/7.c new file mode 100644 index 00000000..c1ead9ef --- /dev/null +++ b/Cracking Code/1. Arrays and Strings/7.c @@ -0,0 +1,70 @@ +#include + +#define MAX_N 100 +#define MAX_M MAX_N +void clear_row_col(int mtx[][MAX_N], size_t M, size_t N){ + int i, j; int first_row = 1, first_col = 1; + if(!mtx) return; + if(!mtx[0][0]){ + first_row = first_col = 0; + } + // set tag + for(j = 1; j < N; ++j){ + if(!mtx[0][j]){ + first_row = 0; + break; + } + } + for(i = 1; i < M; ++i){ + if(!mtx[i][0]){ + first_col = 0; + break; + } + } + for(i = 1; i < M; ++i){ + for(j = 1; j < N; ++j){ + if(!mtx[i][j]){ + mtx[i][0] = mtx[0][j] = 0; + } + } + } + // clear row and column + for(j = 1; j < N; ++j){ + if(!mtx[0][j]){ + for(i = 1; i < M; ++i) mtx[i][j] = 0; + } + } + for(i = 1; i < M; ++i){ + if(!mtx[i][0]){ + for(j = 1; j < N; ++j) mtx[i][j] = 0; + } + } + if(!first_row){ + for(j = 0; j < N; ++j) mtx[0][j] = 0; + } + if(!first_col){ + for(i = 0; i < M; ++i) mtx[i][0] = 0; + } +} + +int main(){ + int mtx[MAX_M][MAX_N] = {0}; + size_t M = 0, N = 0; + int i, j; + while(1){ + scanf("%u%u", &M, &N); + for(i = 0; i < M; ++i){ + for(j = 0; j < N; ++j){ + scanf("%d", &mtx[i][j]); + } + } + clear_row_col(mtx, M, N); + for(i = 0; i < M; ++i){ + for(j = 0; j < N; ++j){ + printf("%d ", mtx[i][j]); + } + printf("\n"); + } + } + return 0; +} \ No newline at end of file diff --git a/Cracking Code/1. Arrays and Strings/7_1.c b/Cracking Code/1. Arrays and Strings/7_1.c new file mode 100644 index 00000000..cc923443 --- /dev/null +++ b/Cracking Code/1. Arrays and Strings/7_1.c @@ -0,0 +1,41 @@ +#include + +#define MAX_N 100 +#define MAX_M MAX_N +void clear_row_col(int mtx[][MAX_N], size_t M, size_t N){ + int i, j; + int row[MAX_M] = {0}, col[MAX_N] = {0}; + if(!mtx) return; + for(i = 0; i < M; ++i){ + for(j = 0; j < N; ++j){ + if(!mtx[i][j]) row[i] = col[j] = 1; + } + } + for(i = 0; i < M; ++i){ + for(j = 0; j < N; ++j){ + if(row[i] || col[j]) mtx[i][j] = 0; + } + } +} + +int main(){ + int mtx[MAX_M][MAX_N] = {0}; + size_t M = 0, N = 0; + int i, j; + while(1){ + scanf("%u%u", &M, &N); + for(i = 0; i < M; ++i){ + for(j = 0; j < N; ++j){ + scanf("%d", &mtx[i][j]); + } + } + clear_row_col(mtx, M, N); + for(i = 0; i < M; ++i){ + for(j = 0; j < N; ++j){ + printf("%d ", mtx[i][j]); + } + printf("\n"); + } + } + return 0; +} \ No newline at end of file diff --git a/Cracking Code/1. Arrays and Strings/8.c b/Cracking Code/1. Arrays and Strings/8.c new file mode 100644 index 00000000..f5e3bd51 --- /dev/null +++ b/Cracking Code/1. Arrays and Strings/8.c @@ -0,0 +1,30 @@ +#include +#include + +int test_rotation(char *s1, char *s2){ + int i, j, len1, len2; + if(!s1 || !s2) return 0; + i = j = 0; + while(s2[j] && s2[j] != s1[0]) j++; + while(s1[i] && s2[j] && s1[i] == s2[j]){ + i++; j++; + } + if(s2[j]) return 0; + len2 = j; + j = 0; + while(s1[i] && s2[j] && s1[i] == s2[j]){ + i++; j++; + } + if(s1[i]) return 0; + len1 = i; + return len1 == len2; +} + +int main(){ + char s1[100] = {0}, s2[100] = {0}; + while(1){ + gets(s1); gets(s2); + printf("%d\n", test_rotation(s1, s2)); + } + return 0; +} \ No newline at end of file diff --git a/Cracking Code/1. Arrays and Strings/8_1.c b/Cracking Code/1. Arrays and Strings/8_1.c new file mode 100644 index 00000000..3db95490 --- /dev/null +++ b/Cracking Code/1. Arrays and Strings/8_1.c @@ -0,0 +1,21 @@ +#include +#include + +int test_rotation(char *s1, char *s2){ + int i, j, len1, len2; + if(!s1 || !s2) return 0; + len1 = strlen(s1); + len2 = strlen(s2); + if(len1 != len2) return 0; + memcpy(s1 + len1, s1, sizeof(char) * len1); + return strstr(s1, s2) != NULL; +} + +int main(){ + char s1[100] = {0}, s2[100] = {0}; + while(1){ + gets(s1); gets(s2); + printf("%d\n", test_rotation(s1, s2)); + } + return 0; +} \ No newline at end of file diff --git a/Cracking Code/2. Linked Lists/1.c b/Cracking Code/2. Linked Lists/1.c new file mode 100644 index 00000000..99a27478 --- /dev/null +++ b/Cracking Code/2. Linked Lists/1.c @@ -0,0 +1,80 @@ +#include +#include + +typedef struct ListNode{ + int data; + struct ListNode *next; +} ListNode; + +ListNode* listnode_create(int data){ + ListNode *p = malloc(sizeof *p); + p->data = data; + p->next = NULL; + return p; +} + +void list_destroy(ListNode *head){ + ListNode *next; + if(!head) return; + while(head){ + next = head->next; + free(head); + head = next; + } +} + +void listnode_append(ListNode *head, int data){ + if(!head) return; + while(head->next){ + head = head->next; + } + head->next = listnode_create(data); +} + +void print_list(ListNode *head){ + while(head){ + printf("[%d] ", head->data); + head = head->next; + } + printf("\n"); +} + +void remove_duplicate(ListNode *head){ + ListNode *p, *q; + if(!head) return; + while(head){ + p = head; q = p->next; + while(q){ + if(q->data == head->data){ + p->next = q->next; + free(q); + }else{ + p = q; + } + q = p->next; + } + head = head->next; + } +} + +int main(){ + size_t N; + int data; + ListNode *head; + while(1){ + head = NULL; + scanf("%u", &N); + while(N--){ + scanf("%d", &data); + if(!head){ + head = listnode_create(data); + }else{ + listnode_append(head, data); + } + } + remove_duplicate(head); + print_list(head); + list_destroy(head); + } + return 0; +} \ No newline at end of file diff --git a/Cracking Code/2. Linked Lists/1_1.cpp b/Cracking Code/2. Linked Lists/1_1.cpp new file mode 100644 index 00000000..017cdc75 --- /dev/null +++ b/Cracking Code/2. Linked Lists/1_1.cpp @@ -0,0 +1,83 @@ +#include +#include +#include +using namespace std; + +typedef struct ListNode{ + int data; + struct ListNode *next; +} ListNode; + +ListNode* listnode_create(int data){ + ListNode *p = (ListNode*)malloc(sizeof *p); + p->data = data; + p->next = NULL; + return p; +} + +void list_destroy(ListNode *head){ + ListNode *next; + if(!head) return; + while(head){ + next = head->next; + free(head); + head = next; + } +} + +void listnode_append(ListNode *head, int data){ + if(!head) return; + while(head->next){ + head = head->next; + } + head->next = listnode_create(data); +} + +void print_list(ListNode *head){ + while(head){ + printf("[%d] ", head->data); + head = head->next; + } + printf("\n"); +} + +void remove_duplicate(ListNode *head){ + if(!head || !head->next) return; + set s; + s.insert(head->data); + ListNode *p, *q; + p = head; + q = p->next; + while(q){ + if(s.find(q->data) == s.end()){ + s.insert(q->data); + p = q; + }else{ + p->next = q->next; + free(q); + } + q = p->next; + } +} + +int main(){ + size_t N; + int data; + ListNode *head; + while(1){ + head = NULL; + scanf("%u", &N); + while(N--){ + scanf("%d", &data); + if(!head){ + head = listnode_create(data); + }else{ + listnode_append(head, data); + } + } + remove_duplicate(head); + print_list(head); + list_destroy(head); + } + return 0; +} \ No newline at end of file diff --git a/Cracking Code/2. Linked Lists/1_2.c b/Cracking Code/2. Linked Lists/1_2.c new file mode 100644 index 00000000..e950e0c7 --- /dev/null +++ b/Cracking Code/2. Linked Lists/1_2.c @@ -0,0 +1,80 @@ +#include +#include + +typedef struct ListNode{ + int data; + struct ListNode *next; +} ListNode; + +ListNode* listnode_create(int data){ + ListNode *p = (ListNode*)malloc(sizeof *p); + p->data = data; + p->next = NULL; + return p; +} + +void list_destroy(ListNode *head){ + ListNode *next; + if(!head) return; + while(head){ + next = head->next; + free(head); + head = next; + } +} + +void listnode_append(ListNode *head, int data){ + if(!head) return; + while(head->next){ + head = head->next; + } + head->next = listnode_create(data); +} + +void print_list(ListNode *head){ + while(head){ + printf("[%d] ", head->data); + head = head->next; + } + printf("\n"); +} + +void remove_duplicate(ListNode *head){ + ListNode *p, *q, *r; + if(!head || !head->next) return; + p = head; + q = p->next; + while(q){ + r = head; + while(r->data != q->data) r = r->next; + if(r != q){ + p->next = q->next; + free(q); + }else{ + p = q; + } + q = p->next; + } +} + +int main(){ + size_t N; + int data; + ListNode *head; + while(1){ + head = NULL; + scanf("%u", &N); + while(N--){ + scanf("%d", &data); + if(!head){ + head = listnode_create(data); + }else{ + listnode_append(head, data); + } + } + remove_duplicate(head); + print_list(head); + list_destroy(head); + } + return 0; +} \ No newline at end of file diff --git a/Cracking Code/2. Linked Lists/2.c b/Cracking Code/2. Linked Lists/2.c new file mode 100644 index 00000000..fb281e16 --- /dev/null +++ b/Cracking Code/2. Linked Lists/2.c @@ -0,0 +1,79 @@ +#include +#include + +typedef struct ListNode{ + int data; + struct ListNode *next; +} ListNode; + +ListNode* listnode_create(int data){ + ListNode *p = malloc(sizeof *p); + p->data = data; + p->next = NULL; + return p; +} + +void list_destroy(ListNode *head){ + ListNode *next; + if(!head) return; + while(head){ + next = head->next; + free(head); + head = next; + } +} + +void listnode_append(ListNode *head, int data){ + if(!head) return; + while(head->next){ + head = head->next; + } + head->next = listnode_create(data); +} + +void print_list(ListNode *head){ + while(head){ + printf("[%d] ", head->data); + head = head->next; + } + printf("\n"); +} + +ListNode* findNthFromEnd(ListNode *head, int n){ + if(!head || n <= 0) return NULL; + ListNode *last; + last = head; + while(last && n--) last = last->next; + if(n > 0) return NULL; + while(last){ + head = head->next; + last = last->next; + } + return head; +} + +#include +int main(){ + ListNode *head; + head = listnode_create(1); + listnode_append(head, 2); + listnode_append(head, 3); + listnode_append(head, 4); + listnode_append(head, 5); + listnode_append(head, 6); + listnode_append(head, 7); + print_list(head); + assert(!findNthFromEnd(head, -1)); + assert(!findNthFromEnd(head, 0)); + assert(!findNthFromEnd(head, 8)); + assert(!findNthFromEnd(head, 9)); + printf("[%d] ", findNthFromEnd(head, 1)->data); + printf("[%d] ", findNthFromEnd(head, 2)->data); + printf("[%d] ", findNthFromEnd(head, 3)->data); + printf("[%d] ", findNthFromEnd(head, 4)->data); + printf("[%d] ", findNthFromEnd(head, 5)->data); + printf("[%d] ", findNthFromEnd(head, 6)->data); + printf("[%d] ", findNthFromEnd(head, 7)->data); + printf("\n"); + return 0; +} \ No newline at end of file diff --git a/Cracking Code/2. Linked Lists/3.c b/Cracking Code/2. Linked Lists/3.c new file mode 100644 index 00000000..cf27e496 --- /dev/null +++ b/Cracking Code/2. Linked Lists/3.c @@ -0,0 +1,80 @@ +#include +#include + +typedef struct ListNode{ + int data; + struct ListNode *next; +} ListNode; + +ListNode* listnode_create(int data){ + ListNode *p = malloc(sizeof *p); + p->data = data; + p->next = NULL; + return p; +} + +void list_destroy(ListNode *head){ + ListNode *next; + if(!head) return; + while(head){ + next = head->next; + free(head); + head = next; + } +} + +void listnode_append(ListNode *head, int data){ + if(!head) return; + while(head->next){ + head = head->next; + } + head->next = listnode_create(data); +} + +void print_list(ListNode *head){ + while(head){ + printf("[%d] ", head->data); + head = head->next; + } + printf("\n"); +} + +void remove_middle_node(ListNode *n){ + ListNode *next; + if(!n || !n->next) return; + next = n->next; + n->data = next->data; + n->next = next->next; + free(next); +} + +int main(){ + size_t N, n; + int data; + ListNode *head, *p; + while(1){ + head = NULL; + scanf("%u", &N); + while(N--){ + scanf("%d", &data); + if(!head){ + head = listnode_create(data); + }else{ + listnode_append(head, data); + } + } + scanf("%u", &n); + p = head; + while(n-- && p) p = p->next; + remove_middle_node(p); + print_list(head); + list_destroy(head); + } + return 0; +} + +/* + * 要删除单链表上的一个节点n就必须知道n的前一个节点, + * 此题可以人为创造一个前导节点, 即通过: + * 拷贝n->next的数据到n中, 删掉n->next即可. + */ \ No newline at end of file diff --git a/Cracking Code/2. Linked Lists/4_1.c b/Cracking Code/2. Linked Lists/4_1.c new file mode 100644 index 00000000..139100f6 --- /dev/null +++ b/Cracking Code/2. Linked Lists/4_1.c @@ -0,0 +1,71 @@ +#include +#include +typedef struct ListNode{ + int data; + struct ListNode *next; +} ListNode; + +ListNode* listnode_create(int data){ + ListNode *p = (ListNode*)malloc(sizeof *p); + p->data = data; + p->next = NULL; + return p; +} + +void list_destroy(ListNode *head){ + ListNode *next; + if(!head) return; + while(head){ + next = head->next; + free(head); + head = next; + } +} + +void listnode_append(ListNode *head, int data){ + if(!head) return; + while(head->next){ + head = head->next; + } + head->next = listnode_create(data); +} + +void print_list(ListNode *head){ + while(head){ + printf("[%d] ", head->data); + head = head->next; + } + printf("\n"); +} + +ListNode* addList(ListNode *l1, ListNode *l2, int carry){ + if(!l1 && !l2) return NULL; + ListNode *result = listnode_create(carry); + if(l1) result->data += l1->data; + if(l2) result->data += l2->data; + carry = result->data / 10; + result->data %= 10; + result->next = addList( + l1 ? l1->next : NULL, + l2 ? l2->next : NULL, + carry); + return result; +} + +int main(){ + ListNode *l1, *l2, *l3; + l1 = listnode_create(3); + listnode_append(l1, 1); + listnode_append(l1, 5); + l2 = listnode_create(5); + listnode_append(l2, 9); + listnode_append(l2, 2); + print_list(l1); + print_list(l2); + l3 = addList(l1, l2, 0); + print_list(l3); + list_destroy(l1); + list_destroy(l2); + list_destroy(l3); + return 0; +} \ No newline at end of file diff --git "a/Cracking Code/2. Linked Lists/4\351\224\231\344\272\206, carry!.c" "b/Cracking Code/2. Linked Lists/4\351\224\231\344\272\206, carry!.c" new file mode 100644 index 00000000..806ef97b --- /dev/null +++ "b/Cracking Code/2. Linked Lists/4\351\224\231\344\272\206, carry!.c" @@ -0,0 +1,87 @@ +#include +#include +typedef struct ListNode{ + int data; + struct ListNode *next; +} ListNode; + +ListNode* listnode_create(int data){ + ListNode *p = (ListNode*)malloc(sizeof *p); + p->data = data; + p->next = NULL; + return p; +} + +void list_destroy(ListNode *head){ + ListNode *next; + if(!head) return; + while(head){ + next = head->next; + free(head); + head = next; + } +} + +void listnode_append(ListNode *head, int data){ + if(!head) return; + while(head->next){ + head = head->next; + } + head->next = listnode_create(data); +} + +void print_list(ListNode *head){ + while(head){ + printf("[%d] ", head->data); + head = head->next; + } + printf("\n"); +} + +ListNode* addList(ListNode *l1, ListNode *l2){ + if(!l1 || !l2) return l1 ? l1 : l2; + ListNode *head, *tail, *p; + int carry = 0; + head = tail = NULL; + while(l1 && l2){ + carry += l1->data + l2->data; + p = listnode_create(carry % 10); + carry /= 10; + if(!head){ + head = p; + }else{ + tail->next = p; + } + tail = p; + l1 = l1->next; l2 = l2->next; + } + if(!l1) l1 = l2; + while(l1){ + carry += l1->data; + p = listnode_create(carry % 10); + carry /= 10; + tail->next = p; + tail = p; + l1 = l1->next; + } + tail->next = 0; + return head; +} + +int main(){ + ListNode *l1, *l2, *l3; + l1 = listnode_create(3); + listnode_append(l1, 1); + listnode_append(l1, 5); + l2 = listnode_create(5); + listnode_append(l2, 9); + listnode_append(l2, 2); + print_list(l1); + print_list(l2); + l3 = addList(l1, l2); + print_list(l3); + list_destroy(l1); + list_destroy(l2); + list_destroy(l3); + return 0; +} \ No newline at end of file diff --git a/Cracking Code/2. Linked Lists/5.c b/Cracking Code/2. Linked Lists/5.c new file mode 100644 index 00000000..b6cf8181 --- /dev/null +++ b/Cracking Code/2. Linked Lists/5.c @@ -0,0 +1,99 @@ +#include +#include + +typedef struct ListNode{ + int data; + struct ListNode *next; +} ListNode; + +ListNode* listnode_create(int data){ + ListNode *p = malloc(sizeof *p); + p->data = data; + p->next = NULL; + return p; +} + +void list_destroy(ListNode *head){ + ListNode *next; + if(!head) return; + while(head){ + next = head->next; + free(head); + head = next; + } +} + +ListNode* listnode_append(ListNode *head, int data){ + if(!head) return; + while(head->next){ + head = head->next; + } + return head->next = listnode_create(data); +} + +void print_list(ListNode *head){ + while(head){ + printf("[%d] ", head->data); + head = head->next; + } + printf("\n"); +} + +ListNode *find_loop_entrance(ListNode *head){ + ListNode *p, *q; + if(!head) return NULL; + p = q = head; + do{ + p = p->next; + q = q->next->next; + }while(p != q); + p = head; + while(p != q){ + p = p->next; + q = q->next; + } + return p; +} + +int main(){ + size_t N, n; + int data; + ListNode *head, *tail, *p, *ent; + while(1){ + head = NULL; + scanf("%u %u", &N, &n); + while(N--){ + scanf("%d", &data); + if(!head){ + head = tail = listnode_create(data); + }else{ + tail = listnode_append(head, data); + } + } + p = head; + while(n-- && p) p = p->next; + tail->next = p; + + ent = find_loop_entrance(head); + printf("Loop Entrance: [%d]\n", ent->data); + tail->next = NULL; + print_list(head); + list_destroy(head); + } + return 0; +} + + +/* + * 如何判断一个单链表是否有环? 设置指针 p 和 q 从 head 出发, p 每次走一步, q 每次走两步, p 和 q 汇合则说明有环. + * 汇合点是否有规律? + * 假设入环前有 x 个点, 当 p 到达入环点时, q 超过入环点 x%n 个点. + * 假设 p 再走 k 步即可和q汇合, 那么在环上, p 一共走了 k 个点, q 一共走了 x%n + 2k 个点. + * 第一次汇合则说明 (x%n + 2k) - k = n, 即 x%n = n - k, 其中 n 为环上点的个数. + * 从上式还可以看出 0 <= n - k < n, 即 0 < k <= n. + * 考虑 n - k 的含义, 它是 p 从汇合点走到入环点所需的步数. + * 记 x = x%n + a*n, 其中 a 为 x 除以 n 的商. + * 由 x%n = n - k 可得, x = (n - k) + a*n. + * 等号左侧含义为, 令指针 q 从 head 出发一步一点走 x 步到达入环点. + * 等号右侧含义为, 令指针 p 从汇合点出发一步一点走 n - k 步并多走 a 圈到达入环点. + */ \ No newline at end of file diff --git a/Cracking Code/3. Stacks and Queues/1.c b/Cracking Code/3. Stacks and Queues/1.c new file mode 100644 index 00000000..a3a3b416 --- /dev/null +++ b/Cracking Code/3. Stacks and Queues/1.c @@ -0,0 +1,68 @@ +#include +#include +#include +// Implementation of a simple 3-in-1 stack. +// Assume the total size of stack is n, +// then the first stack (indexed by 0) corresponds to [0, n/3), +// the second stack (indexed by 1) corresponds to [n/3, 2n/3), +// the third stack (indexed by 2) corresponds to [2n/3, n). +typedef struct Stack{ + int *buf; + int stackSize; // the size of a single stack + int top[3]; +}Stack; + +Stack* initStack(int stackSize){ + Stack *s = NULL; + assert(stackSize > 0); + s = malloc(sizeof *s); + assert(s); + s->buf = malloc(sizeof(int) * stackSize * 3); + assert(s->buf); + s->stackSize = stackSize; + s->top[0] = s->top[1] = s->top[2] = -1; + return s; +} + +void push(Stack *s, int stackNum, int data){ + assert(s && stackNum >= 0 && stackNum < 3); + assert(s->top[stackNum] + 1 < s->stackSize); // prevent overflow + s->top[stackNum]++; + s->buf[s->stackSize * stackNum + s->top[stackNum]] = data; +} + +void pop(Stack *s, int stackNum){ + assert(s && stackNum >= 0 && stackNum < 3); + assert(s->top[stackNum] >= 0); // prevent underflow + s->top[stackNum]--; +} + +int top(Stack *s, int stackNum){ + assert(s && stackNum >= 0 && stackNum < 3); + return s->buf[s->stackSize * stackNum + s->top[stackNum]]; +} + +int isEmpty(Stack *s, int stackNum){ + assert(s && stackNum >= 0 && stackNum < 3); + return s->top[stackNum] == -1; +} + +int main(){ + Stack *s = initStack(100); + int i = 0; + printf("Stack #0 is %sempty.\n", isEmpty(s, 0) ? "" : "not "); + while(i < 300){ + push(s, 0, i++); + push(s, 1, i++); + push(s, 2, i++); + } + printf("Top of Stack #1: %d\n", top(s, 1)); + printf("Stack #2 is %sempty.\n", isEmpty(s, 2) ? "" : "not "); + printf("%d\n", s->) + i = 0; + while(i < 100){ + pop(s, 1); + } + printf("Stack #1 is %sempty.\n", isEmpty(s, 1) ? "" : "not "); + return 0; +} \ No newline at end of file diff --git a/Cracking Code/4. Trees and Graphs/1.cpp b/Cracking Code/4. Trees and Graphs/1.cpp new file mode 100644 index 00000000..95ceac2b --- /dev/null +++ b/Cracking Code/4. Trees and Graphs/1.cpp @@ -0,0 +1,48 @@ +#include +#include +#include +using namespace std; +#define INT_MAX (((unsigned)~0) >> 1) +struct TreeNode{ + int val; + TreeNode *left; + TreeNode *right; + TreeNode(int x) : val(x), left(NULL), right(NULL) {} +}; + +class Solution { +public: + bool checkBalanced(TreeNode *root){ + if(!root) return true; + stack > s; + int max_dep = 0, min_dep = INT_MAX; + s.push(make_pair(root, 1)); + while(!s.empty()){ + pair p = s.top(); s.pop(); + root = p.first; + if(!root->left && !root->right){ + if(p.second > max_dep) max_dep = p.second; + if(p.second < min_dep) min_dep = p.second; + if(max_dep - min_dep > 1) return false; + }else{ + if(root->left) s.push(make_pair(root->left, p.second + 1)); + if(root->right) s.push(make_pair(root->right, p.second + 1)); + } + } + return true; + } +}; + +int main(){ + TreeNode *root; + root = new TreeNode(1); + root->left = new TreeNode(2); + root->left->left = new TreeNode(3); + root->left->right = new TreeNode(4); + root->left->left->left = new TreeNode(-1); + root->right = new TreeNode(5); + // root->right->left = new TreeNode(6); + // root->right->right = new TreeNode(7); + Solution s; + cout << boolalpha << s.checkBalanced(root) << endl; +} \ No newline at end of file diff --git a/Cracking Code/4. Trees and Graphs/1_1.cpp b/Cracking Code/4. Trees and Graphs/1_1.cpp new file mode 100644 index 00000000..61dcdb9f --- /dev/null +++ b/Cracking Code/4. Trees and Graphs/1_1.cpp @@ -0,0 +1,40 @@ +#include +#include +using namespace std; +#define INT_MAX (((unsigned)~0) >> 1) +struct TreeNode{ + int val; + TreeNode *left; + TreeNode *right; + TreeNode(int x) : val(x), left(NULL), right(NULL) {} +}; + +class Solution { +public: + int maxDepth(TreeNode *root){ + if(!root) return 0; + return max(maxDepth(root->left), maxDepth(root->right)) + 1; + } + int minDepth(TreeNode *root){ + if(!root) return 0; + return min(minDepth(root->left), minDepth(root->right)) + 1; + } + bool checkBalanced(TreeNode *root){ + if(!root) return true; + return maxDepth(root) - minDepth(root) <= 1; + } +}; + +int main(){ + TreeNode *root; + root = new TreeNode(1); + root->left = new TreeNode(2); + root->left->left = new TreeNode(3); + root->left->right = new TreeNode(4); + root->left->left->left = new TreeNode(-1); + root->right = new TreeNode(5); + // root->right->left = new TreeNode(6); + // root->right->right = new TreeNode(7); + Solution s; + cout << boolalpha << s.checkBalanced(root) << endl; +} \ No newline at end of file diff --git a/Cracking Code/4. Trees and Graphs/2.cpp b/Cracking Code/4. Trees and Graphs/2.cpp new file mode 100644 index 00000000..2ecaa236 --- /dev/null +++ b/Cracking Code/4. Trees and Graphs/2.cpp @@ -0,0 +1,23 @@ +#include +using namespace std; + +struct DirectedGraphNode { + int label; + vector in; + vector out; + DirectedGraphNode(int x) : label(x) {}; +}; + + +class Solution{ +public: + bool hasRootBetween(DirectedGraphNode* node, int i, int j){ + + return true; + } +}; + +int main(){ + + return 0; +} \ No newline at end of file diff --git a/Cracking Code/4. Trees and Graphs/3.cpp b/Cracking Code/4. Trees and Graphs/3.cpp new file mode 100644 index 00000000..e8c3ab4b --- /dev/null +++ b/Cracking Code/4. Trees and Graphs/3.cpp @@ -0,0 +1,39 @@ +#include "../+Helper/BinaryTree.h" +#include +using namespace std; + +class Solution{ +public: + TreeNode* buildBST(vector v){ + TreeNode *root = NULL; + vector::iterator i = v.begin(); + for(; i != v.end(); ++i){ + TreeNode *n = new TreeNode(*i); + if(!root){ + root = n; + }else{ + TreeNode *p = root; + while(true){ + if(n->val > p->val){ + if(p->right){ + p = p->right; + }else{ + p->right = n; + break; + } + }else if(n->val < p->val){ + if(p->left){ + p = p->left; + }else{ + p->left = n; + break; + } + }else{ + delete n; + } + } + } + } + return root; + } +}; \ No newline at end of file diff --git a/Cracking Code/4. Trees and Graphs/3in.txt b/Cracking Code/4. Trees and Graphs/3in.txt new file mode 100644 index 00000000..a1b0ba94 --- /dev/null +++ b/Cracking Code/4. Trees and Graphs/3in.txt @@ -0,0 +1,5 @@ +4 +1,2,3,4,5 +3,2,1,4,5 +2,3,4,5,1 +5,1,3,4,2 \ No newline at end of file diff --git a/Cracking Code/4. Trees and Graphs/4.cpp b/Cracking Code/4. Trees and Graphs/4.cpp new file mode 100644 index 00000000..7cfcb79b --- /dev/null +++ b/Cracking Code/4. Trees and Graphs/4.cpp @@ -0,0 +1,56 @@ +#include +using namespace std; +#include +#include +#include "../+Helper/Helper.h" +#include "../+Helper/BinaryTree.h" + +TreeNode* insertData(TreeNode *root, int data){ + TreeNode *node = new TreeNode(data); + while(root){ + if(data > root->val){ + if(root->right){ + root = root->right; + }else{ + root->right = node; + root = NULL; + } + }else{ + if(root->left){ + root = root->left; + }else{ + root->left = node; + root = NULL; + } + } + } + return node; +} + +TreeNode* balanceTree(TreeNode *root){ + + return root; +} + +TreeNode *sortedArrayToBST(vector &num) { + TreeNode *root = NULL; + for(int i = 0; i < num.size(); ++i){ + TreeNode* node = insertData(root, num[i]); + root = balanceTree(root); + } + return root; +} + +int main(){ + freopen("4_in.txt", "r", stdin); + CLK_INIT; + CASET{ + vector v = scanVector(); + PRINTCASE; + CLK_START; + cout << serialize(sortedArrayToBST(v)) << endl; + CLK_END; + } + + return 0; +} \ No newline at end of file diff --git a/Cracking Code/4. Trees and Graphs/4_in.txt b/Cracking Code/4. Trees and Graphs/4_in.txt new file mode 100644 index 00000000..c9fa1c12 --- /dev/null +++ b/Cracking Code/4. Trees and Graphs/4_in.txt @@ -0,0 +1,2 @@ +1 +1,2,3,4,5,6 \ No newline at end of file diff --git a/Cracking Code/4. Trees and Graphs/Breadth First Traversal.cpp b/Cracking Code/4. Trees and Graphs/Breadth First Traversal.cpp new file mode 100644 index 00000000..e17cf949 --- /dev/null +++ b/Cracking Code/4. Trees and Graphs/Breadth First Traversal.cpp @@ -0,0 +1,47 @@ +#include +#include +#include +using namespace std; + +struct TreeNode{ + int val; + TreeNode *left; + TreeNode *right; + TreeNode(int x) : val(x), left(NULL), right(NULL) {} +}; + +class Solution { +public: + vector breadthFirstTraversal(TreeNode *root) { + queue q; + vector v; + if(root){ + q.push(root); + while(!q.empty()){ + root = q.front(); q.pop(); + v.push_back(root->val); + if(root->left) q.push(root->left); + if(root->right) q.push(root->right); + } + } + return v; + } +}; + +int main(){ + TreeNode *root; + root = new TreeNode(1); + root->left = new TreeNode(2); + root->left->left = new TreeNode(3); + root->left->right = new TreeNode(4); + root->right = new TreeNode(5); + root->right->left = new TreeNode(6); + root->right->right = new TreeNode(7); + Solution s; + vector data = s.breadthFirstTraversal(root); + vector::iterator iter = data.begin(); + for(; iter != data.end(); iter++){ + cout << "[" << *iter << "] "; + } + cout << endl; +} \ No newline at end of file diff --git a/Cracking Code/4. Trees and Graphs/Main3.cpp b/Cracking Code/4. Trees and Graphs/Main3.cpp new file mode 100644 index 00000000..650d6fba --- /dev/null +++ b/Cracking Code/4. Trees and Graphs/Main3.cpp @@ -0,0 +1,36 @@ +#include +#include +#include +using namespace std; +#include +#include +#include "../+Helper/Helper.h" +#include "3.cpp" + +#include + +vector parseVector(string str){ + vector v; + char *s = (char*)str.c_str(), *p = NULL; + while(p = strsep(&s, ",")){ + v.push_back(atoi(p)); + } + return v; +} + +int main(){ + freopen("3in.txt", "r", stdin); + CLK_INIT; + Solution s; + CASET{ + string in; + cin >> in; + PRINTCASE; + CLK_START; + TreeNode *root = s.buildBST(parseVector(in)); + cout << serialize(root) << endl; + CLK_END; + } + + return 0; +} \ No newline at end of file diff --git a/Cracking Code/5. Bit Manipulation/1.c b/Cracking Code/5. Bit Manipulation/1.c new file mode 100644 index 00000000..7222708a --- /dev/null +++ b/Cracking Code/5. Bit Manipulation/1.c @@ -0,0 +1,51 @@ +#include +#include + +char* itoa(int value, char* result, int base) { + char* ptr = result, *ptr1 = result, tmp_char; + int tmp_value; + // check that the base if valid + if (base < 2 || base > 36) { *result = '\0'; return result; } + + do { + tmp_value = value; + value /= base; + *ptr++ = "zyxwvutsrqponmlkjihgfedcba9876543210123456789abcdefghijklmnopqrstuvwxyz" [35 + (tmp_value - value * base)]; + } while ( value ); + + // Apply negative sign + if (tmp_value < 0) *ptr++ = '-'; + + *ptr-- = '\0'; + + while(ptr1 < ptr) { + tmp_char = *ptr; + *ptr--= *ptr1; + *ptr1++ = tmp_char; + } + + return result; +} + +int interpose(int N, int M, int i, int j){ + int mask = 0, k; + for(k = j; k >= i; --k){ + mask <<= 1; + mask += 1; + } + for(; k >= 0; --k){ + mask <<=1; + M <<= 1; + } + return N & ~mask | M; +} + +int main(){ + int N, M, i, j; + char str[100] = {0}; + N = 0xffff; M = 10; i = 3; j = 7; + printf("i = %d, j = %d\n", i, j); + printf("N = %s\n", itoa(N, str, 2)); + printf("M = %s\n", itoa(M, str, 2)); + printf("Result = %s\n", itoa(interpose(N, M, i, j), str, 2)); +} \ No newline at end of file diff --git a/Cracking Code/5. Bit Manipulation/1_1.c b/Cracking Code/5. Bit Manipulation/1_1.c new file mode 100644 index 00000000..a8564056 --- /dev/null +++ b/Cracking Code/5. Bit Manipulation/1_1.c @@ -0,0 +1,42 @@ +#include +#include + +char* itoa(int value, char* result, int base) { + char* ptr = result, *ptr1 = result, tmp_char; + int tmp_value; + // check that the base if valid + if (base < 2 || base > 36) { *result = '\0'; return result; } + + do { + tmp_value = value; + value /= base; + *ptr++ = "zyxwvutsrqponmlkjihgfedcba9876543210123456789abcdefghijklmnopqrstuvwxyz" [35 + (tmp_value - value * base)]; + } while ( value ); + + // Apply negative sign + if (tmp_value < 0) *ptr++ = '-'; + + *ptr-- = '\0'; + + while(ptr1 < ptr) { + tmp_char = *ptr; + *ptr--= *ptr1; + *ptr1++ = tmp_char; + } + + return result; +} + +int interpose(int N, int M, int i, int j){ + return N & ~((1 << (j + 1)) - (1 << i)) | M << i; +} + +int main(){ + int N, M, i, j; + char str[100] = {0}; + N = 0xffff; M = 10; i = 3; j = 7; + printf("i = %d, j = %d\n", i, j); + printf("N = %s\n", itoa(N, str, 2)); + printf("M = %s\n", itoa(M, str, 2)); + printf("Result = %s\n", itoa(interpose(N, M, i, j), str, 2)); +} \ No newline at end of file diff --git a/Cracking Code/8. Recursion/1.cpp b/Cracking Code/8. Recursion/1.cpp new file mode 100644 index 00000000..22733ddc --- /dev/null +++ b/Cracking Code/8. Recursion/1.cpp @@ -0,0 +1,44 @@ +#include +using namespace std; +#include +#include "../+Helper/Helper.h" + +int fibonacci_recursive(int n){ + if(n <= 0) return 0; + if(n == 1 || n == 2) return 1; + return fibonacci_recursive(n - 1) + fibonacci_recursive(n - 2); +} + +int fibonacci_iterative(int n){ + if(n <= 0) return 0; + if(n == 1 || n == 2) return 1; + int a = 1, b = 1, ret; n -= 2; + while(n--){ + ret = a + b; + a = b; + b = ret; + } + return ret; +} + +int main(){ + CLK_INIT; + cout << "RECURSIVE" << endl; + for(int i = 1; i <= 20; ++i){ + CLK_START; + cout << i << ": " << fibonacci_recursive(i) << endl; + CLK_END; + } + CLK_START; + cout << "40: " << fibonacci_recursive(40) << endl; + CLK_END; + for(int i = 1; i <= 20; ++i){ + CLK_START; + cout << i << ": " << fibonacci_iterative(i) << endl; + CLK_END; + } + CLK_START; + cout << "40: " << fibonacci_iterative(40) << endl; + CLK_END; + return 0; +} \ No newline at end of file diff --git a/Leet Code/#Letter Combinations of a Phone Number/Letter Combinations of a Phone Number.cpp b/Leet Code/#Letter Combinations of a Phone Number/Letter Combinations of a Phone Number.cpp new file mode 100644 index 00000000..442df24b --- /dev/null +++ b/Leet Code/#Letter Combinations of a Phone Number/Letter Combinations of a Phone Number.cpp @@ -0,0 +1,34 @@ +#include +using namespace std; + +class Solution { +public: + static const char map[][5]; + char buf[10000]; + void DFS(const char *digits, char *output, vector &v){ + if(!*digits){ + *output = '\0'; + v.push_back(string(buf)); + return; + } + int n = *digits - '0'; + for(int i = 0; map[n][i]; ++i){ + *output++ = map[n][i]; + DFS(digits + 1, output, v); + output--; + } + } + + vector letterCombinations(string digits) { + vector v; + DFS(digits.c_str(), buf, v); + return v; + } +}; + +const char Solution::map[][5] = { + " ", + "", "abc", "def", + "ghi", "jkl", "mno", + "pqrs", "tuv", "wxyz", + }; \ No newline at end of file diff --git a/Leet Code/#Letter Combinations of a Phone Number/Main.cpp b/Leet Code/#Letter Combinations of a Phone Number/Main.cpp new file mode 100644 index 00000000..b28e3925 --- /dev/null +++ b/Leet Code/#Letter Combinations of a Phone Number/Main.cpp @@ -0,0 +1,22 @@ +#include +using namespace std; +#include +#include +#include "../+Helper/Helper.h" +#include "Letter Combinations of a Phone Number.cpp" + +int main(){ + freopen("in.txt", "r", stdin); + CLK_INIT; + Solution s; + CASET{ + string str; + cin >> str; + PRINTCASE_; + CLK_START; + printVector(s.letterCombinations(str)); + CLK_END; + } + + return 0; +} \ No newline at end of file diff --git a/Leet Code/#Letter Combinations of a Phone Number/in.txt b/Leet Code/#Letter Combinations of a Phone Number/in.txt new file mode 100644 index 00000000..4d2da69c --- /dev/null +++ b/Leet Code/#Letter Combinations of a Phone Number/in.txt @@ -0,0 +1,4 @@ +3 +23 +2 +23456789 \ No newline at end of file diff --git a/Leet Code/#Path Sum II/Path Sum II.cpp b/Leet Code/#Path Sum II/Path Sum II.cpp new file mode 100644 index 00000000..ffe7e82a --- /dev/null +++ b/Leet Code/#Path Sum II/Path Sum II.cpp @@ -0,0 +1,20 @@ +class Solution { +public: + void preorder(TreeNode *root, int sum, vector > &v, vector v1){ + if(!root) return; + v1.push_back(root->val); + sum -= root->val; + if(!root->left && !root->right && !sum){ + v.push_back(v1); + return; + } + preorder(root->left, sum, v, v1); + preorder(root->right, sum, v, v1); + } + + vector > pathSum(TreeNode *root, int sum) { + vector > v; + if(!root) return v; + preorder(root, sum, v, vector()); + } +}; \ No newline at end of file diff --git a/Leet Code/#Regular Expression Matching/Main.cpp b/Leet Code/#Regular Expression Matching/Main.cpp new file mode 100644 index 00000000..b238ebed --- /dev/null +++ b/Leet Code/#Regular Expression Matching/Main.cpp @@ -0,0 +1,22 @@ +#include +using namespace std; +#include +#include +#include "../+Helper/Helper.h" +#include "Regular Expression Matching.cpp" + +int main(){ + freopen("in.txt", "r", stdin); + CLK_INIT; + Solution s; + CASET{ + string str, reg; + cin >> str >> reg; + PRINTCASE; + CLK_START; + cout << boolalpha << s.isMatch(str.c_str(), reg.c_str()) << endl; + CLK_END; + } + + return 0; +} \ No newline at end of file diff --git a/Leet Code/#Regular Expression Matching/Regular Expression Matching.cpp b/Leet Code/#Regular Expression Matching/Regular Expression Matching.cpp new file mode 100644 index 00000000..6573a96b --- /dev/null +++ b/Leet Code/#Regular Expression Matching/Regular Expression Matching.cpp @@ -0,0 +1,28 @@ +#define MATCH_CHAR(s, p) ((p) == '.' ? s : (s) == (p)) +class Solution { +public: + // s is the input string, p is the regular expression. + bool isMatch(const char *s, const char *p) { + if(!s && !p) return true; + if(!s || !p) return false; + if(!*p) return !*s; + if(*(p + 1) == '*'){ + bool ret = false; + while(!(ret = isMatch(s, p + 2)) && MATCH_CHAR(*s, *p)) s++; + return ret; + }else{ + return MATCH_CHAR(*s, *p) && isMatch(s + 1, p + 1); + } + } +}; + +/* +Some examples: +isMatch("aa","a") → false +isMatch("aa","aa") → true +isMatch("aaa","aa") → false +isMatch("aa", "a*") → true +isMatch("aa", ".*") → true +isMatch("ab", ".*") → true +isMatch("aab", "c*a*b") → true +*/ \ No newline at end of file diff --git a/Leet Code/#Regular Expression Matching/TODO.txt b/Leet Code/#Regular Expression Matching/TODO.txt new file mode 100644 index 00000000..815b4d6c --- /dev/null +++ b/Leet Code/#Regular Expression Matching/TODO.txt @@ -0,0 +1 @@ +Implement this algorithm in iterative method \ No newline at end of file diff --git a/Leet Code/#Regular Expression Matching/in.txt b/Leet Code/#Regular Expression Matching/in.txt new file mode 100644 index 00000000..348556fd --- /dev/null +++ b/Leet Code/#Regular Expression Matching/in.txt @@ -0,0 +1,17 @@ +16 +a ab* +aa a +aa aa +aaa aa +aa a* +aa .* +ab .* +aab c*a*b +abcabc .*c +abcabc .*cabc +abcabc .*ab..* +abcabc .*c..* +abbabbb .*ab*b +abbabbb ab*b +abbabbb ab*ab* +acaabbaccbbacaabbbb a*.*b*.*a*aa*a* \ No newline at end of file diff --git a/Leet Code/#Search in Rotated Sorted Array II/Search in Rotated Sorted Array - binary.cpp b/Leet Code/#Search in Rotated Sorted Array II/Search in Rotated Sorted Array - binary.cpp new file mode 100644 index 00000000..40095a9e --- /dev/null +++ b/Leet Code/#Search in Rotated Sorted Array II/Search in Rotated Sorted Array - binary.cpp @@ -0,0 +1,23 @@ +class Solution { +public: + bool binarySearch(int A[], int low, int high, int target){ + int mid; + while(low <= high){ + mid = (low + high) / 2; + if(A[mid] == target) return true; + else if(target > A[mid]) low = mid + 1; + else high = mid - 1; + } + return false; + } + bool search(int A[], int n, int target) { + if(n <= 0) return -1; + int low = 0, high = n - 1, mid; + while(low <= high){ + mid = (low + high) / 2; + if(A[mid] == target) return true; + if() + } + return false; + } +}; \ No newline at end of file diff --git a/Leet Code/#Search in Rotated Sorted Array II/Search in Rotated Sorted Array II - seq.cpp b/Leet Code/#Search in Rotated Sorted Array II/Search in Rotated Sorted Array II - seq.cpp new file mode 100644 index 00000000..09fe046e --- /dev/null +++ b/Leet Code/#Search in Rotated Sorted Array II/Search in Rotated Sorted Array II - seq.cpp @@ -0,0 +1,14 @@ +class Solution { +public: + bool search(int A[], int n, int target) { + if(n <= 0) return -1; + int i; + if(target >= A[0]){ + for(i = 0; i < n && A[i] >= A[0] && A[i] < target; i++); + }else{ + for(i = n - 1; i >= 0 && A[i] <= A[n - 1] && A[i] > target; i--); + } + if(i >= 0 && i < n && A[i] == target) return true; + return false; + } +}; \ No newline at end of file diff --git a/Leet Code/#Sum Root to Leaf Numbers/Main.cpp b/Leet Code/#Sum Root to Leaf Numbers/Main.cpp new file mode 100644 index 00000000..6da5a065 --- /dev/null +++ b/Leet Code/#Sum Root to Leaf Numbers/Main.cpp @@ -0,0 +1,23 @@ +#include +using namespace std; +#include +#include +#include "../+Helper/Helper.h" +#include "Sum Root to Leaf Numbers.h" + +int main(){ + freopen("in.txt", "r", stdin); + CLK_INIT; + Solution s; + CASET{ + string str; + cin >> str; + TreeNode *root = deserialize(str); + PRINTCASE; + CLK_START; + cout << s.sumNumbers(root) << endl; + CLK_END; + } + + return 0; +} \ No newline at end of file diff --git a/Leet Code/#Sum Root to Leaf Numbers/Sum Root to Leaf Numbers.h b/Leet Code/#Sum Root to Leaf Numbers/Sum Root to Leaf Numbers.h new file mode 100644 index 00000000..dbe58176 --- /dev/null +++ b/Leet Code/#Sum Root to Leaf Numbers/Sum Root to Leaf Numbers.h @@ -0,0 +1,18 @@ +#include "../+Helper/BinaryTree.h" +class Solution { + void preorder(TreeNode *root, int &sum, int &num){ + if(!root) return; + num *= 10; + num += root->val; + if(!root->left && !root->right) sum += num; + preorder(root->left, sum, num); + preorder(root->right, sum, num); + num /= 10; + } +public: + int sumNumbers(TreeNode *root) { + int sum = 0, num = 0; + preorder(root, sum, num); + return sum; + } +}; \ No newline at end of file diff --git a/Leet Code/#Sum Root to Leaf Numbers/TODO.txt b/Leet Code/#Sum Root to Leaf Numbers/TODO.txt new file mode 100644 index 00000000..29428ea8 --- /dev/null +++ b/Leet Code/#Sum Root to Leaf Numbers/TODO.txt @@ -0,0 +1 @@ +implement this algorithm in iterative method. \ No newline at end of file diff --git a/Leet Code/#Sum Root to Leaf Numbers/in.txt b/Leet Code/#Sum Root to Leaf Numbers/in.txt new file mode 100644 index 00000000..ac5302cc --- /dev/null +++ b/Leet Code/#Sum Root to Leaf Numbers/in.txt @@ -0,0 +1,5 @@ +4 +1 +1,2,3 +1,2,3,4,# +1,2,3,4,5 \ No newline at end of file diff --git a/Leet Code/+Helper/BinaryTree.h b/Leet Code/+Helper/BinaryTree.h new file mode 100644 index 00000000..62fc0111 --- /dev/null +++ b/Leet Code/+Helper/BinaryTree.h @@ -0,0 +1,85 @@ +#include +#include +#include +using namespace std; +#include +#include +#include + +struct TreeNode { + int val; + TreeNode *left; + TreeNode *right; + TreeNode(int x) : val(x), left(NULL), right(NULL) {} +}; + +vector breathFirstTraversal(TreeNode *root){ + if(!root) return vector(); + vector v; + queue q; + q.push(root); + int num = 1; + while(num){ + int nextNum = 0; + while(num--){ + TreeNode *n = q.front(); q.pop(); + v.push_back(n->val); + if(n->left){ + nextNum++; + q.push(n->left); + } + if(n->right){ + nextNum++; + q.push(n->right); + } + } + num = nextNum; + } + return v; +} + +// Note: Invalid input is not considered yet. +TreeNode* deserialize(string str){ + char *s = (char*)str.c_str(), *p = NULL; + p = strsep(&s, ","); + if(!strcmp(p, "#")) return NULL; + TreeNode *root = new TreeNode(atoi(p)); + queue q; + q.push(root); + while(!q.empty()){ + TreeNode *pnode = q.front(); q.pop(); + TreeNode *n[2] = {NULL}; + for(int i = 0; s && i < 2; ++i){ + p = strsep(&s, ","); + if(strcmp(p, "#")){ + n[i] = new TreeNode(atoi(p)); + q.push(n[i]); + } + } + pnode->left = n[0]; + pnode->right = n[1]; + } + return root; +} + +string serialize(TreeNode* root){ + if(!root) return ""; + char buf[100000] = {0}, *p = buf; + queue q; + q.push(root); + while(!q.empty()){ + TreeNode *n = q.front(); q.pop(); + if(n){ + p += sprintf(p, "%d,", n->val); + }else{ + p += sprintf(p, "#,"); + } + if(n){ + q.push(n->left); + q.push(n->right); + } + } + while(*(p - 1) == ',' && *(p - 2) == '#') p -= 2; + *(p - 1) = '\0'; + return string(buf); +} \ No newline at end of file diff --git a/Leet Code/+Helper/BinaryTreeTest.cpp b/Leet Code/+Helper/BinaryTreeTest.cpp new file mode 100644 index 00000000..e68140e7 --- /dev/null +++ b/Leet Code/+Helper/BinaryTreeTest.cpp @@ -0,0 +1,9 @@ +#include "BinaryTree.h" + +int main(){ + string s = "3,9,20,#,#,15,7"; + TreeNode *root = deserialize(s); + printVector(breathFirstTraversal(root)); + cout << serialize(root) << endl; + return 0; +} \ No newline at end of file diff --git a/Leet Code/+Helper/Helper.h b/Leet Code/+Helper/Helper.h new file mode 100644 index 00000000..f9e5c2ae --- /dev/null +++ b/Leet Code/+Helper/Helper.h @@ -0,0 +1,67 @@ +#ifndef Helper_h +#define Helper_h + +#include +#include +#include +#include +#include +#include +using namespace std; +#define CASET int ___T, case_n = 1; scanf("%d ", &___T); while (___T-- > 0) +#define PRINTCASE printf("Case #%d: ",case_n++) +#define PRINTCASE_ printf("Case #%d:\n",case_n++) +#define RD(a) scanf("%d", &(a)) +#define RDD(a, b) scanf("%d%d", &(a), &(b)) + +#define CLK_INIT clock_t clk_start = 0, clk_end = 0 +#define CLK_START clk_start = clock() +#define CLK_END\ + do{ clk_end = clock();\ + cout << "Time[" << (double)(clk_end - clk_start) / CLOCKS_PER_SEC << "s]" << endl; }while(0) + +template +void printVector(vector v){ + typename vector::iterator i = v.begin(); + for(; i != v.end(); ++i){ + cout << "[" << *i << "] "; + } + cout << endl; +} + +template +void printVector(vector > v){ + for(int i = 0; i < v.size(); ++i){ + for(int j = 0; j < v[i].size(); ++j){ + cout << "[" << v[i][j] << "] "; + } + cout << endl; + } +} + +vector > scanVector(int m, int n){ + vector > v; + for(int i = 0; i < m; ++i){ + vector v1; + for(int j = 0; j < n; ++j){ + int d; + cin >> d; + v1.push_back(d); + } + v.push_back(v1); + } + return v; +} + +vector scanVector(){ + vector v; + string str; + cin >> str; + char *s = (char*) str.c_str(), *p = NULL; + while(p = strsep(&s, ",")){ + v.push_back(atoi(p)); + } + return v; +} + +#endif \ No newline at end of file diff --git a/Leet Code/+Helper/SinglyLinkedList.h b/Leet Code/+Helper/SinglyLinkedList.h new file mode 100644 index 00000000..a21e5aa5 --- /dev/null +++ b/Leet Code/+Helper/SinglyLinkedList.h @@ -0,0 +1,46 @@ +#ifndef SinglyLinkedList_h +#define SinglyLinkedList_h +struct ListNode{ + int val; + ListNode *next; + ListNode(int x) : val(x), next(NULL) {} +}; + +void list_destroy(ListNode *head){ + if(!head) return; + ListNode *next; + while(head){ + next = head->next; + delete head; + head = next; + } +} + +void listnode_append(ListNode *head, int val){ + if(!head) return; + while(head->next){ + head = head->next; + } + head->next = new ListNode(val); +} + +void print_list(ListNode *head){ + while(head){ + printf("[%d] ", head->val); + head = head->next; + } + printf("\n"); +} + +ListNode* vectorToList(vector &v){ + ListNode *head = NULL; + for(int i = 0; i < v.size(); ++i){ + if(!head){ + head = new ListNode(v[i]); + }else{ + listnode_append(head, v[i]); + } + } + return head; +} +#endif \ No newline at end of file diff --git a/Leet Code/+Helper/TreeLinkNode.cpp b/Leet Code/+Helper/TreeLinkNode.cpp new file mode 100644 index 00000000..58990ea5 --- /dev/null +++ b/Leet Code/+Helper/TreeLinkNode.cpp @@ -0,0 +1,56 @@ +#include +#include +#include +using namespace std; +#include +#include + +struct TreeLinkNode { + int val; + TreeLinkNode *left, *right, *next; + TreeLinkNode(int x) : val(x), left(NULL), right(NULL), next(NULL) {} +}; + +// Note: Invalid input is not considered yet. +TreeLinkNode* deserialize(string str){ + char *s = (char*)str.c_str(), *p = NULL; + p = strsep(&s, ","); + if(!strcmp(p, "#")) return NULL; + TreeLinkNode *root = new TreeLinkNode(atoi(p)); + queue q; + q.push(root); + while(!q.empty()){ + TreeLinkNode *pnode = q.front(); q.pop(); + TreeLinkNode *n[2] = {NULL}; + for(int i = 0; s && i < 2; ++i){ + p = strsep(&s, ","); + if(strcmp(p, "#")){ + n[i] = new TreeLinkNode(atoi(p)); + q.push(n[i]); + } + } + pnode->left = n[0]; + pnode->right = n[1]; + } + return root; +} + +string serialize(TreeLinkNode* root){ + if(!root) return ""; + char buf[100000] = {0}, *p = buf; + TreeLinkNode *nextLv = root; + while(nextLv){ + root = nextLv; + nextLv = NULL; + while(root){ + p += sprintf(p, "%d,", root->val); + if(!nextLv && (root->left || root->right)){ + nextLv = root->left ? root->left : root->right; + } + root = root->next; + } + *(p - 1) = '#'; + } + *(p - 1) = '\0'; + return string(buf); +} \ No newline at end of file diff --git a/Leet Code/+Helper/Undirected Graph.cpp b/Leet Code/+Helper/Undirected Graph.cpp new file mode 100644 index 00000000..f0f91e55 --- /dev/null +++ b/Leet Code/+Helper/Undirected Graph.cpp @@ -0,0 +1,110 @@ +#include +#include +#include +#include +#include +using namespace std; +#include +#include +#include + +struct UndirectedGraphNode { + int label; + vector neighbors; + UndirectedGraphNode(int x) : label(x) {}; +}; + +// set中不应该存储"已经被访问的节点", 因为这可能导致队列中出现重复的待访问节点. +// set中应该存储"已经插入过队列的节点", 也就是紧随q.push(n)操作. +vector breathFirstTraversal(UndirectedGraphNode *n){ + if(!n) return vector(); + vector v; + set s; + queue q; + q.push(n); + s.insert(n->label); + while(!q.empty()){ + n = q.front(); q.pop(); + v.push_back(n->label); + vector::iterator i; + i = n->neighbors.begin(); + for(; i != n->neighbors.end(); ++i){ + if(s.find((*i)->label) == s.end()){ + q.push(*i); + s.insert((*i)->label); + } + } + } + return v; +} + +void printVector(vector v){ + vector:: iterator i = v.begin(); + for(; i != v.end(); ++i){ + cout << "[" << *i << "] "; + } + cout << endl; +} + +// Note: Invalid input is not considered yet. +UndirectedGraphNode* deserialize(string str){ + char *s = (char*)str.c_str(), *p = NULL; + map m; + UndirectedGraphNode *ret = NULL; + while(p = strsep(&s, "#")){ + char *q = NULL; + UndirectedGraphNode *n = NULL; + vector v; + while(q = strsep(&p, ",")){ + int label = atoi(q); + if(m.find(label) != m.end()){ + n = m[label]; + }else{ + n = new UndirectedGraphNode(label); + m[label] = n; + } + v.push_back(n); + } + n = v.front(); + v.erase(v.begin()); + n->neighbors = v; + if(!ret){ + ret = n; + } + } + return ret; +} + +string serialize(UndirectedGraphNode* n){ + if(!n) return ""; + char buf[1000] = {0}, *p = buf; + set s; + queue q; + q.push(n); + s.insert(n->label); + while(!q.empty()){ + n = q.front(); q.pop(); + p += sprintf(p, "%d,", n->label); + vector::iterator i; + i = n->neighbors.begin(); + for(; i != n->neighbors.end(); ++i){ + int label = (*i)->label; + p += sprintf(p, "%d,", label); + if(s.find(label) == s.end()){ + q.push(*i); + s.insert(label); + } + } + *(p - 1) = '#'; + } + *(p - 1) = '\0'; + return string(buf); +} + +int main(){ + string s = "0,1,2#1,2#2,2"; + UndirectedGraphNode *n = deserialize(s); + printVector(breathFirstTraversal(n)); + cout << serialize(n) << endl; + return 0; +} \ No newline at end of file diff --git a/Leet Code/Add Binary/Add Binary.cpp b/Leet Code/Add Binary/Add Binary.cpp new file mode 100644 index 00000000..13505837 --- /dev/null +++ b/Leet Code/Add Binary/Add Binary.cpp @@ -0,0 +1,23 @@ +class Solution { +public: + string addBinary(string a, string b) { + string ret; + string::reverse_iterator i = a.rbegin(), j = b.rbegin(); + int carry = 0; + while(i != a.rend() || j != b.rend()){ + if(i != a.rend()){ + carry += *i++ - '0'; + } + if(j != b.rend()){ + carry += *j++ - '0'; + } + ret += carry % 2 + '0'; + carry /= 2; + } + if(carry){ + ret += '1'; + } + reverse(ret.begin(), ret.end()); + return ret; + } +}; \ No newline at end of file diff --git a/Leet Code/Balanced Binary Tree/BalancedBinaryTree.h b/Leet Code/Balanced Binary Tree/BalancedBinaryTree.h new file mode 100644 index 00000000..b7b4488f --- /dev/null +++ b/Leet Code/Balanced Binary Tree/BalancedBinaryTree.h @@ -0,0 +1,17 @@ +#include "../+Helper/BinaryTree.h" + +class Solution { +public: + int depth(TreeNode *root){ + if(!root) return 0; + int dl = depth(root->left), dr = depth(root->right); + return 1 + max(dl, dr); + } + + bool isBalanced(TreeNode *root) { + if(!root) return true; + int dl = depth(root->left), dr = depth(root->right); + if(dl - dr > 1 || dl - dr < -1) return false; + return isBalanced(root->left) && isBalanced(root->right); + } +}; \ No newline at end of file diff --git a/Leet Code/Balanced Binary Tree/BalancedBinaryTree_1.h b/Leet Code/Balanced Binary Tree/BalancedBinaryTree_1.h new file mode 100644 index 00000000..66dcad3a --- /dev/null +++ b/Leet Code/Balanced Binary Tree/BalancedBinaryTree_1.h @@ -0,0 +1,38 @@ +#include +#include +using namespace std; +#include "../+Helper/BinaryTree.h" + +class Solution { +public: + // 后序遍历, 将深度记录在map中 + // 此算法还不如递归快, 也更浪费空间! + // map需要占用额外空间(与树的总结点数成正比), 而且出入栈, map检索都要花费时间. + // 递归之所以可取, 因为空间复杂度只与树的深度成正比. + bool isBalanced(TreeNode *root) { + if(!root) return true; + stack s; + TreeNode *last = NULL; + map m; + m[NULL] = 0; + while(root || !s.empty()){ + if(root){ + s.push(root); + root = root->left; + }else{ + root = s.top(); + if(!root->right || root->right == last){ + s.pop(); + int dl = m[root->left], dr = m[root->right]; + if(dl - dr > 1 || dl - dr < -1) return false; + m[root] = 1 + max(dl, dr); + last = root; + root = NULL; + }else{ + root = root->right; + } + } + } + return true; + } +}; \ No newline at end of file diff --git a/Leet Code/Balanced Binary Tree/BalancedBinaryTree_2.h b/Leet Code/Balanced Binary Tree/BalancedBinaryTree_2.h new file mode 100644 index 00000000..ec0e36e8 --- /dev/null +++ b/Leet Code/Balanced Binary Tree/BalancedBinaryTree_2.h @@ -0,0 +1,21 @@ +#include "../+Helper/BinaryTree.h" + +class Solution { +private: + bool isBalanced(TreeNode *root, int &depth){ + if(!root){ + depth = 0; + return true; + } + int dl = 0, dr = 0; + if(!isBalanced(root->left, dl) || !isBalanced(root->right, dr)) + return false; + depth = 1 + max(dl, dr); + return dl - dr <= 1 && dl - dr >= -1; + } +public: + bool isBalanced(TreeNode *root) { + int depth = 0; + return isBalanced(root, depth); + } +}; \ No newline at end of file diff --git a/Leet Code/Balanced Binary Tree/Main.cpp b/Leet Code/Balanced Binary Tree/Main.cpp new file mode 100644 index 00000000..693f3df6 --- /dev/null +++ b/Leet Code/Balanced Binary Tree/Main.cpp @@ -0,0 +1,23 @@ +#include +using namespace std; +#include +#include +#include "../+Helper/Helper.h" +#include "BalancedBinaryTree.h" + +int main(){ + freopen("in.txt", "r", stdin); + CLK_INIT; + Solution s; + CASET{ + string str; + cin >> str; + TreeNode *root = deserialize(str); + PRINTCASE; + CLK_START; + cout << boolalpha << s.isBalanced(root) << endl; + CLK_END; + } + + return 0; +} \ No newline at end of file diff --git a/Leet Code/Balanced Binary Tree/gen_in.cpp b/Leet Code/Balanced Binary Tree/gen_in.cpp new file mode 100644 index 00000000..f815aa08 --- /dev/null +++ b/Leet Code/Balanced Binary Tree/gen_in.cpp @@ -0,0 +1,20 @@ +#include +#include +using namespace std; + +int main(){ + while(true){ + int limit = 0; + cin >> limit; + limit = (1 << limit) - 1; + char fname[20] = {0}; + sprintf(fname, "%d.txt", limit); + freopen(fname, "w", stdout); + cout << limit << ","; + for(int i = 2; i < limit; ++i){ + cout << 1 << ","; + } + cout << "1" << endl; + } + return 0; +} \ No newline at end of file diff --git a/Leet Code/Balanced Binary Tree/in.7z b/Leet Code/Balanced Binary Tree/in.7z new file mode 100644 index 00000000..82760843 Binary files /dev/null and b/Leet Code/Balanced Binary Tree/in.7z differ diff --git a/Leet Code/Binary Tree Inorder Traversal/Binary Tree Inorder Traversal - 1.cpp b/Leet Code/Binary Tree Inorder Traversal/Binary Tree Inorder Traversal - 1.cpp new file mode 100644 index 00000000..2409125e --- /dev/null +++ b/Leet Code/Binary Tree Inorder Traversal/Binary Tree Inorder Traversal - 1.cpp @@ -0,0 +1,54 @@ +#include +#include +#include +using namespace std; + +struct TreeNode{ + int val; + TreeNode *left; + TreeNode *right; + TreeNode(int x) : val(x), left(NULL), right(NULL) {} +}; + +// 期望合并原版中的向左下降的代码, 但是发现按照下面这种方式: +// 1. 逻辑更复杂. while(root || !s.empty()) 不如原版中的简单条件直观. +// 2. 实际上向左下降代码并没有省略, 还是有两个部分, 只不过第一个部分不需要while. +class Solution { +public: + vector inorderTraversal(TreeNode *root) { + stack s; + vector v; + if(root){ + s.push(root); + root = root->left; + while(root || !s.empty()){ + while(root){ + s.push(root); + root = root->left; + } + root = s.top(); s.pop(); + v.push_back(root->val); + root = root->right; + } + } + return v; + } +}; + +int main(){ + TreeNode *root; + root = new TreeNode(1); + root->left = new TreeNode(2); + root->left->left = new TreeNode(3); + root->left->right = new TreeNode(4); + root->right = new TreeNode(5); + root->right->left = new TreeNode(6); + root->right->right = new TreeNode(7); + Solution s; + vector data = s.inorderTraversal(root); + vector::iterator iter = data.begin(); + for(; iter != data.end(); iter++){ + cout << "[" << *iter << "] "; + } + cout << endl; +} \ No newline at end of file diff --git a/Leet Code/Binary Tree Inorder Traversal/Binary Tree Inorder Traversal.cpp b/Leet Code/Binary Tree Inorder Traversal/Binary Tree Inorder Traversal.cpp new file mode 100644 index 00000000..a3a74ae8 --- /dev/null +++ b/Leet Code/Binary Tree Inorder Traversal/Binary Tree Inorder Traversal.cpp @@ -0,0 +1,55 @@ +#include +#include +#include +using namespace std; + +struct TreeNode{ + int val; + TreeNode *left; + TreeNode *right; + TreeNode(int x) : val(x), left(NULL), right(NULL) {} +}; + +class Solution { +public: + // 思路: + // 堆栈中保存活节点. 活节点是左子树已经被访问的节点. + // 创造活节点: 当前节点入栈, 左移. + // 每次从栈中获取一个活节点, 访问, 右移, 创造活节点. + vector inorderTraversal(TreeNode *root) { + stack s; + vector v; + while(root){ + s.push(root); + root = root->left; + } + while(!s.empty()){ + root = s.top(); s.pop(); + v.push_back(root->val); + root = root->right; + while(root){ + s.push(root); + root = root->left; + } + } + return v; + } +}; + +int main(){ + TreeNode *root; + root = new TreeNode(1); + root->left = new TreeNode(2); + root->left->left = new TreeNode(3); + root->left->right = new TreeNode(4); + root->right = new TreeNode(5); + root->right->left = new TreeNode(6); + root->right->right = new TreeNode(7); + Solution s; + vector data = s.inorderTraversal(root); + vector::iterator iter = data.begin(); + for(; iter != data.end(); iter++){ + cout << "[" << *iter << "] "; + } + cout << endl; +} \ No newline at end of file diff --git a/Leet Code/Binary Tree Level Order Traversal II/Binary Tree Level Order Traversal II - 1.h b/Leet Code/Binary Tree Level Order Traversal II/Binary Tree Level Order Traversal II - 1.h new file mode 100644 index 00000000..4270dc4c --- /dev/null +++ b/Leet Code/Binary Tree Level Order Traversal II/Binary Tree Level Order Traversal II - 1.h @@ -0,0 +1,39 @@ +// Two stacks are used instead of function reverse. +// However, this method is slower and consume more space... +class Solution { +public: + vector > levelOrderBottom(TreeNode *root) { + vector > v; + if(!root) return v; + stack s, sn; + queue q; + q.push(root); + int n = 1; + while(n){ + sn.push(n); + int nextN = 0; + while(n--){ + root = q.front(); q.pop(); + s.push(root->val); + if(root->right){ + nextN++; + q.push(root->right); + } + if(root->left){ + nextN++; + q.push(root->left); + } + } + n = nextN; + } + while(!sn.empty()){ + vector v1; + n = sn.top(); sn.pop(); + while(n--){ + v1.push_back(s.top()); s.pop(); + } + v.push_back(v1); + } + return v; + } +}; \ No newline at end of file diff --git a/Leet Code/Binary Tree Level Order Traversal II/Binary Tree Level Order Traversal II.h b/Leet Code/Binary Tree Level Order Traversal II/Binary Tree Level Order Traversal II.h new file mode 100644 index 00000000..76a01a2a --- /dev/null +++ b/Leet Code/Binary Tree Level Order Traversal II/Binary Tree Level Order Traversal II.h @@ -0,0 +1,30 @@ +class Solution { +public: + vector > levelOrderBottom(TreeNode *root) { + vector > v; + if(!root) return v; + queue q; + q.push(root); + int n = 1; + while(n){ + int nextN = 0; + vector v1; + while(n--){ + root = q.front(); q.pop(); + v1.push_back(root->val); + if(root->left){ + nextN++; + q.push(root->left); + } + if(root->right){ + nextN++; + q.push(root->right); + } + } + v.push_back(v1); + n = nextN; + } + reverse(v.begin(), v.end()); + return v; + } +}; \ No newline at end of file diff --git a/Leet Code/Binary Tree Level Order Traversal/Binary Tree Level Order Traversal.h b/Leet Code/Binary Tree Level Order Traversal/Binary Tree Level Order Traversal.h new file mode 100644 index 00000000..ae303943 --- /dev/null +++ b/Leet Code/Binary Tree Level Order Traversal/Binary Tree Level Order Traversal.h @@ -0,0 +1,33 @@ +#include +#include +using namespace std; +#include "../+Helper/BinaryTree.h" +class Solution { +public: + vector > levelOrder(TreeNode *root) { + vector > v; + if(!root) return v; + queue q; + q.push(root); + int n = 1; + while(n){ + int nextN = 0; + vector v1; + while(n--){ + root = q.front(); q.pop(); + v1.push_back(root->val); + if(root->left){ + nextN++; + q.push(root->left); + } + if(root->right){ + nextN++; + q.push(root->right); + } + } + v.push_back(v1); + n = nextN; + } + return v; + } +}; \ No newline at end of file diff --git a/Leet Code/Binary Tree Level Order Traversal/Main.cpp b/Leet Code/Binary Tree Level Order Traversal/Main.cpp new file mode 100644 index 00000000..c350a5b2 --- /dev/null +++ b/Leet Code/Binary Tree Level Order Traversal/Main.cpp @@ -0,0 +1,23 @@ +#include +using namespace std; +#include +#include +#include "../+Helper/Helper.h" +#include "Binary Tree Level Order Traversal.h" + +int main(){ + freopen("in.txt", "r", stdin); + CLK_INIT; + Solution s; + CASET{ + string str; + cin >> str; + TreeNode *root = deserialize(str); + PRINTCASE_; + CLK_START; + printVector(s.levelOrder(root)); + CLK_END; + } + + return 0; +} \ No newline at end of file diff --git a/Leet Code/Binary Tree Level Order Traversal/in.txt b/Leet Code/Binary Tree Level Order Traversal/in.txt new file mode 100644 index 00000000..9f54175c --- /dev/null +++ b/Leet Code/Binary Tree Level Order Traversal/in.txt @@ -0,0 +1,3 @@ +2 +3,9,20,#,#,15,7 +1,2,3,#,#,4,#,#,5 \ No newline at end of file diff --git a/Leet Code/Binary Tree Postorder Traversal/Binary Tree Postorder Traversal - 1.cpp b/Leet Code/Binary Tree Postorder Traversal/Binary Tree Postorder Traversal - 1.cpp new file mode 100644 index 00000000..450db406 --- /dev/null +++ b/Leet Code/Binary Tree Postorder Traversal/Binary Tree Postorder Traversal - 1.cpp @@ -0,0 +1,55 @@ +#include +#include +#include +using namespace std; + +struct TreeNode{ + int val; + TreeNode *left; + TreeNode *right; + TreeNode(int x) : val(x), left(NULL), right(NULL) {} +}; + +class Solution { +public: + vector postorderTraversal(TreeNode *root) { + stack s; + vector v; + TreeNode *node = NULL; + while(root || !s.empty()){ + if(root){ // 若root(当前节点)存在, 入栈, 左移. + s.push(root); + root = root->left; + }else{ // 若root不存在, 取栈顶 + root = s.top(); + if(!root->right || root->right == node){ // 若root->right不存在或刚被访问过 + v.push_back(root->val); // 访问当前节点 + s.pop(); + node = root; // 将当前节点记录为node, 即刚访问过的节点 + root = NULL; // node置为null以便继续取栈顶 + }else{ + root = root->right; // 若root->right存在, 右移, 准备创造活节点. + } + } + } + return v; + } +}; + +int main(){ + TreeNode *root; + root = new TreeNode(1); + root->left = new TreeNode(2); + root->left->left = new TreeNode(3); + root->left->right = new TreeNode(4); + root->right = new TreeNode(5); + root->right->left = new TreeNode(6); + root->right->right = new TreeNode(7); + Solution s; + vector data = s.postorderTraversal(root); + vector::iterator iter = data.begin(); + for(; iter != data.end(); iter++){ + cout << "[" << *iter << "] "; + } + cout << endl; +} \ No newline at end of file diff --git a/Leet Code/Binary Tree Postorder Traversal/Binary Tree Postorder Traversal.cpp b/Leet Code/Binary Tree Postorder Traversal/Binary Tree Postorder Traversal.cpp new file mode 100644 index 00000000..cbf2bb05 --- /dev/null +++ b/Leet Code/Binary Tree Postorder Traversal/Binary Tree Postorder Traversal.cpp @@ -0,0 +1,63 @@ +#include +#include +#include +using namespace std; + +struct TreeNode{ + int val; + TreeNode *left; + TreeNode *right; + TreeNode(int x) : val(x), left(NULL), right(NULL) {} +}; + +class Solution { +public: + // 思路: + // 活节点: 左子树和右子树都已被访问的节点. + // 创造待选活节点: 栈中先存放右节点, 再存放当前节点, 左移. + // 每次退栈顶记为p: + // 1. 若栈顶为p->right, 则p还不能访问. 退栈顶记为root, 压p入栈, 利用root创造伪活节点. + // 2. 若栈顶不是p->right, 则访问p. + vector postorderTraversal(TreeNode *root) { + stack s; + vector v; + while(root){ + s.push(root->right); + s.push(root); + root = root->left; + } + while(!s.empty()){ + TreeNode *p = s.top(); s.pop(); + if(!s.empty() && p->right == s.top()){ + root = s.top(); s.pop(); + s.push(p); + while(root){ + s.push(root->right); + s.push(root); + root = root->left; + } + }else{ + v.push_back(p->val); + } + } + return v; + } +}; + +int main(){ + TreeNode *root; + root = new TreeNode(1); + root->left = new TreeNode(2); + root->left->left = new TreeNode(3); + root->left->right = new TreeNode(4); + root->right = new TreeNode(5); + root->right->left = new TreeNode(6); + root->right->right = new TreeNode(7); + Solution s; + vector data = s.postorderTraversal(root); + vector::iterator iter = data.begin(); + for(; iter != data.end(); iter++){ + cout << "[" << *iter << "] "; + } + cout << endl; +} \ No newline at end of file diff --git a/Leet Code/Binary Tree Preorder Traversal/Binary Tree Preorder Traversal - 1.cpp b/Leet Code/Binary Tree Preorder Traversal/Binary Tree Preorder Traversal - 1.cpp new file mode 100644 index 00000000..d3d764ce --- /dev/null +++ b/Leet Code/Binary Tree Preorder Traversal/Binary Tree Preorder Traversal - 1.cpp @@ -0,0 +1,50 @@ +#include +#include +#include +using namespace std; + +struct TreeNode{ + int val; + TreeNode *left; + TreeNode *right; + TreeNode(int x) : val(x), left(NULL), right(NULL) {} +}; + +class Solution { +public: + // 当前节点即为活节点. + // 每次退栈访问当前节点, 将当前节点的左右子节点作为活节点推入栈中. + // 以下代码的缺陷是 + vector preorderTraversal(TreeNode *root) { + stack s; + vector v; + if(root){ + s.push(root); + while(!s.empty()){ + root = s.top(); s.pop(); + v.push_back(root->val); + if(root->right) s.push(root->right); + if(root->left) s.push(root->left); + } + } + return v; + } +}; + +int main(){ + TreeNode *root; + root = new TreeNode(1); + root->left = new TreeNode(2); + root->left->left = new TreeNode(3); + root->left->right = new TreeNode(4); + root->right = new TreeNode(5); + root->right->left = new TreeNode(6); + root->right->right = new TreeNode(7); + Solution s; + vector data = s.preorderTraversal(root); + vector::iterator iter = data.begin(); + for(; iter != data.end(); iter++){ + cout << "[" << *iter << "] "; + } + cout << endl; +} \ No newline at end of file diff --git a/Leet Code/Binary Tree Preorder Traversal/Binary Tree Preorder Traversal - 2.cpp b/Leet Code/Binary Tree Preorder Traversal/Binary Tree Preorder Traversal - 2.cpp new file mode 100644 index 00000000..d9442893 --- /dev/null +++ b/Leet Code/Binary Tree Preorder Traversal/Binary Tree Preorder Traversal - 2.cpp @@ -0,0 +1,49 @@ +#include +#include +#include +using namespace std; + +struct TreeNode{ + int val; + TreeNode *left; + TreeNode *right; + TreeNode(int x) : val(x), left(NULL), right(NULL) {} +}; + +class Solution { +public: + vector preorderTraversal(TreeNode *root) { + stack s; + vector v; + while(root){ + v.push_back(root->val); + if(root->right) s.push(root->right); + if(root->left){ + root = root->left; + }else if(!s.empty()){ + root = s.top(); s.pop(); + }else{ + break; + } + } + return v; + } +}; + +int main(){ + TreeNode *root; + root = new TreeNode(1); + root->left = new TreeNode(2); + root->left->left = new TreeNode(3); + root->left->right = new TreeNode(4); + root->right = new TreeNode(5); + root->right->left = new TreeNode(6); + root->right->right = new TreeNode(7); + Solution s; + vector data = s.preorderTraversal(root); + vector::iterator iter = data.begin(); + for(; iter != data.end(); iter++){ + cout << "[" << *iter << "] "; + } + cout << endl; +} \ No newline at end of file diff --git a/Leet Code/Binary Tree Zigzag Level Order Traversal/Binary Tree Zigzag Level Order Traversal.cpp b/Leet Code/Binary Tree Zigzag Level Order Traversal/Binary Tree Zigzag Level Order Traversal.cpp new file mode 100644 index 00000000..d3cd1498 --- /dev/null +++ b/Leet Code/Binary Tree Zigzag Level Order Traversal/Binary Tree Zigzag Level Order Traversal.cpp @@ -0,0 +1,66 @@ +#include +#include "../+Serialization/BinaryTree.h" +#include + +class Solution { +public: + vector > zigzagLevelOrder(TreeNode *root) { + vector > v; + if(!root) return v; + int n = 1; + bool l2r = true; + queue q; + q.push(root); + while(n){ + vector v1; + int nextN = 0; + stack s; + while(n--){ + TreeNode *n = q.front(); q.pop(); + v1.push_back(n->val); + if(l2r){ + if(n->left){ + nextN++; + s.push(n->left); + } + if(n->right){ + nextN++; + s.push(n->right); + } + }else{ + if(n->right){ + nextN++; + s.push(n->right); + } + if(n->left){ + nextN++; + s.push(n->left); + } + } + } + while(!s.empty()){ + q.push(s.top()); s.pop(); + } + l2r = !l2r; + n = nextN; + v.push_back(v1); + } + return v; + } +}; + +int main(){ + string str = "3,9,20,#,#,15,7"; + TreeNode *root = deserialize(str); + Solution s; + vector > v = s.zigzagLevelOrder(root); + vector >::iterator i = v.begin(); + for(; i != v.end(); ++i){ + vector::iterator j = i->begin(); + for(; j != i->end(); ++j){ + cout << "[" << *j << "] "; + } + cout << endl; + } + return 0; +} \ No newline at end of file diff --git a/Leet Code/Binary Tree Zigzag Level Order Traversal/BinaryTree.h.gch b/Leet Code/Binary Tree Zigzag Level Order Traversal/BinaryTree.h.gch new file mode 100644 index 00000000..562e8a0d Binary files /dev/null and b/Leet Code/Binary Tree Zigzag Level Order Traversal/BinaryTree.h.gch differ diff --git a/Leet Code/Clone Graph/Clone Graph.cpp b/Leet Code/Clone Graph/Clone Graph.cpp new file mode 100644 index 00000000..b9a8264a --- /dev/null +++ b/Leet Code/Clone Graph/Clone Graph.cpp @@ -0,0 +1,59 @@ +#include +#include +#include +#include +using namespace std; + +struct UndirectedGraphNode { + int label; + vector neighbors; + UndirectedGraphNode(int x) : label(x) {}; +}; + +class Solution { +public: + UndirectedGraphNode *cloneGraph(UndirectedGraphNode *node) { + if(!node) return NULL; + queue q; + q.push(node); + map m; + UndirectedGraphNode *n1 = NULL, *n2 = NULL; + while(!q.empty()){ + n1 = q.front(); q.pop(); + n2 = new UndirectedGraphNode(n1->label); + m[n1] = n2; + vector::iterator iter; + iter = n1->neighbors.begin(); + for(; iter != n1->neighbors.end(); ++iter){ + if(m.find(*iter) == m.end()){ + q.push(*iter); + } + } + } + map::iterator iter1; + for(iter1 = m.begin(); iter1 != m.end(); ++iter1){ + n1 = iter1->first; + n2 = iter1->second; + vector::iterator iter2; + iter2 = n1->neighbors.begin(); + for(; iter2 != n1->neighbors.end(); ++iter2){ + n2->neighbors.push_back(m[*iter2]); + } + } + return m[node]; + } +}; + +int main(){ + UndirectedGraphNode n0(0), n1(1), n2(2); + n0.neighbors.push_back(&n1); + n0.neighbors.push_back(&n2); + n1.neighbors.push_back(&n0); + n1.neighbors.push_back(&n2); + n2.neighbors.push_back(&n0); + n2.neighbors.push_back(&n1); + n2.neighbors.push_back(&n2); + Solution s; + UndirectedGraphNode *n = s.cloneGraph(&n0); + return 0; +} \ No newline at end of file diff --git a/Leet Code/Construct Binary Tree from Inorder and Postorder Traversal/Construct Binary Tree from Inorder and Postorder Traversal - TLE - 1.h b/Leet Code/Construct Binary Tree from Inorder and Postorder Traversal/Construct Binary Tree from Inorder and Postorder Traversal - TLE - 1.h new file mode 100644 index 00000000..f952c2a4 --- /dev/null +++ b/Leet Code/Construct Binary Tree from Inorder and Postorder Traversal/Construct Binary Tree from Inorder and Postorder Traversal - TLE - 1.h @@ -0,0 +1,42 @@ +#include "../+Helper/BinaryTree.h" +#include +#include +#include +using namespace std; + +class Solution { +public: + TreeNode *buildTree(vector &inorder, vector &postorder) { + TreeNode *root = NULL; + map::iterator> m; + vector::reverse_iterator post = postorder.rbegin(); + for(; post != postorder.rend(); ++post){ + TreeNode *n = new TreeNode(*post); + vector::iterator i = find(inorder.begin(), inorder.end(), n->val); + m[n] = i; + if(!root){ + root = n; + }else{ + TreeNode *pnode = root; + while(true){ + if(i > m[pnode]){ + if(pnode->right){ + pnode = pnode->right; + }else{ + pnode->right = n; + break; + } + }else{ + if(pnode->left){ + pnode = pnode->left; + }else{ + pnode->left = n; + break; + } + } + } + } + } + return root; + } +}; \ No newline at end of file diff --git a/Leet Code/Construct Binary Tree from Inorder and Postorder Traversal/Construct Binary Tree from Inorder and Postorder Traversal - TLE.h b/Leet Code/Construct Binary Tree from Inorder and Postorder Traversal/Construct Binary Tree from Inorder and Postorder Traversal - TLE.h new file mode 100644 index 00000000..65d98f97 --- /dev/null +++ b/Leet Code/Construct Binary Tree from Inorder and Postorder Traversal/Construct Binary Tree from Inorder and Postorder Traversal - TLE.h @@ -0,0 +1,44 @@ +#include "../+Helper/BinaryTree.h" +#include +#include +using namespace std; + +class Solution { +public: + TreeNode *buildTree(vector &inorder, vector &postorder) { + TreeNode *root = NULL; + vector::reverse_iterator post = postorder.rbegin(); + for(; post != postorder.rend(); ++post){ + TreeNode *n = new TreeNode(*post); + if(!root){ + root = n; + }else{ + vector::iterator i = find(inorder.begin(), inorder.end(), + n->val); + vector::iterator start = inorder.begin(), end = inorder.end(); + TreeNode *pnode = root; + while(true){ + vector::iterator p = find(start, end, pnode->val); + if(i > p){ + if(pnode->right){ + pnode = pnode->right; + start = p + 1; + }else{ + pnode->right = n; + break; + } + }else{ + if(pnode->left){ + pnode = pnode->left; + end = p - 1; + }else{ + pnode->left = n; + break; + } + } + } + } + } + return root; + } +}; \ No newline at end of file diff --git a/Leet Code/Construct Binary Tree from Inorder and Postorder Traversal/Main.cpp b/Leet Code/Construct Binary Tree from Inorder and Postorder Traversal/Main.cpp new file mode 100644 index 00000000..8b4ea3ea --- /dev/null +++ b/Leet Code/Construct Binary Tree from Inorder and Postorder Traversal/Main.cpp @@ -0,0 +1,35 @@ +#include +using namespace std; +#include +#include +#include "../+Helper/Helper.h" +#include "Construct Binary Tree from Inorder and Postorder Traversal - TLE.h" + +#include +#include +vector parseVector(string str){ + vector v; + char *s = (char*)str.c_str(), *p = NULL; + while(p = strsep(&s, ",")){ + v.push_back(atoi(p)); + } + return v; +} + +int main(){ + freopen("in.txt", "r", stdin); + CLK_INIT; + Solution s; + CASET{ + string in, post; + cin >> in >> post; + vector inv = parseVector(in), postv = parseVector(post); + PRINTCASE; + CLK_START; + TreeNode *root = s.buildTree(inv, postv); + cout << serialize(root) << endl; + CLK_END; + } + + return 0; +} \ No newline at end of file diff --git a/Leet Code/Construct Binary Tree from Inorder and Postorder Traversal/in.txt b/Leet Code/Construct Binary Tree from Inorder and Postorder Traversal/in.txt new file mode 100644 index 00000000..008719e8 --- /dev/null +++ b/Leet Code/Construct Binary Tree from Inorder and Postorder Traversal/in.txt @@ -0,0 +1,9 @@ +4 +9,3,15,20,7 +9,15,7,20,3 +2,1,4,5,3 +2,5,4,3,1 +1 +1 +-999,-998,-997,-996,-995,-994,-993,-992,-991,-990,-989,-988,-987,-986,-985,-984,-983,-982,-981,-980,-979,-978,-977,-976,-975,-974,-973,-972,-971,-970,-969,-968,-967,-966,-965,-964,-963,-962,-961,-960,-959,-958,-957,-956,-955,-954,-953,-952,-951,-950,-949,-948,-947,-946,-945,-944,-943,-942,-941,-940,-939,-938,-937,-936,-935,-934,-933,-932,-931,-930,-929,-928,-927,-926,-925,-924,-923,-922,-921,-920,-919,-918,-917,-916,-915,-914,-913,-912,-911,-910,-909,-908,-907,-906,-905,-904,-903,-902,-901,-900,-899,-898,-897,-896,-895,-894,-893,-892,-891,-890,-889,-888,-887,-886,-885,-884,-883,-882,-881,-880,-879,-878,-877,-876,-875,-874,-873,-872,-871,-870,-869,-868,-867,-866,-865,-864,-863,-862,-861,-860,-859,-858,-857,-856,-855,-854,-853,-852,-851,-850,-849,-848,-847,-846,-845,-844,-843,-842,-841,-840,-839,-838,-837,-836,-835,-834,-833,-832,-831,-830,-829,-828,-827,-826,-825,-824,-823,-822,-821,-820,-819,-818,-817,-816,-815,-814,-813,-812,-811,-810,-809,-808,-807,-806,-805,-804,-803,-802,-801,-800,-799,-798,-797,-796,-795,-794,-793,-792,-791,-790,-789,-788,-787,-786,-785,-784,-783,-782,-781,-780,-779,-778,-777,-776,-775,-774,-773,-772,-771,-770,-769,-768,-767,-766,-765,-764,-763,-762,-761,-760,-759,-758,-757,-756,-755,-754,-753,-752,-751,-750,-749,-748,-747,-746,-745,-744,-743,-742,-741,-740,-739,-738,-737,-736,-735,-734,-733,-732,-731,-730,-729,-728,-727,-726,-725,-724,-723,-722,-721,-720,-719,-718,-717,-716,-715,-714,-713,-712,-711,-710,-709,-708,-707,-706,-705,-704,-703,-702,-701,-700,-699,-698,-697,-696,-695,-694,-693,-692,-691,-690,-689,-688,-687,-686,-685,-684,-683,-682,-681,-680,-679,-678,-677,-676,-675,-674,-673,-672,-671,-670,-669,-668,-667,-666,-665,-664,-663,-662,-661,-660,-659,-658,-657,-656,-655,-654,-653,-652,-651,-650,-649,-648,-647,-646,-645,-644,-643,-642,-641,-640,-639,-638,-637,-636,-635,-634,-633,-632,-631,-630,-629,-628,-627,-626,-625,-624,-623,-622,-621,-620,-619,-618,-617,-616,-615,-614,-613,-612,-611,-610,-609,-608,-607,-606,-605,-604,-603,-602,-601,-600,-599,-598,-597,-596,-595,-594,-593,-592,-591,-590,-589,-588,-587,-586,-585,-584,-583,-582,-581,-580,-579,-578,-577,-576,-575,-574,-573,-572,-571,-570,-569,-568,-567,-566,-565,-564,-563,-562,-561,-560,-559,-558,-557,-556,-555,-554,-553,-552,-551,-550,-549,-548,-547,-546,-545,-544,-543,-542,-541,-540,-539,-538,-537,-536,-535,-534,-533,-532,-531,-530,-529,-528,-527,-526,-525,-524,-523,-522,-521,-520,-519,-518,-517,-516,-515,-514,-513,-512,-511,-510,-509,-508,-507,-506,-505,-504,-503,-502,-501,-500,-499,-498,-497,-496,-495,-494,-493,-492,-491,-490,-489,-488,-487,-486,-485,-484,-483,-482,-481,-480,-479,-478,-477,-476,-475,-474,-473,-472,-471,-470,-469,-468,-467,-466,-465,-464,-463,-462,-461,-460,-459,-458,-457,-456,-455,-454,-453,-452,-451,-450,-449,-448,-447,-446,-445,-444,-443,-442,-441,-440,-439,-438,-437,-436,-435,-434,-433,-432,-431,-430,-429,-428,-427,-426,-425,-424,-423,-422,-421,-420,-419,-418,-417,-416,-415,-414,-413,-412,-411,-410,-409,-408,-407,-406,-405,-404,-403,-402,-401,-400,-399,-398,-397,-396,-395,-394,-393,-392,-391,-390,-389,-388,-387,-386,-385,-384,-383,-382,-381,-380,-379,-378,-377,-376,-375,-374,-373,-372,-371,-370,-369,-368,-367,-366,-365,-364,-363,-362,-361,-360,-359,-358,-357,-356,-355,-354,-353,-352,-351,-350,-349,-348,-347,-346,-345,-344,-343,-342,-341,-340,-339,-338,-337,-336,-335,-334,-333,-332,-331,-330,-329,-328,-327,-326,-325,-324,-323,-322,-321,-320,-319,-318,-317,-316,-315,-314,-313,-312,-311,-310,-309,-308,-307,-306,-305,-304,-303,-302,-301,-300,-299,-298,-297,-296,-295,-294,-293,-292,-291,-290,-289,-288,-287,-286,-285,-284,-283,-282,-281,-280,-279,-278,-277,-276,-275,-274,-273,-272,-271,-270,-269,-268,-267,-266,-265,-264,-263,-262,-261,-260,-259,-258,-257,-256,-255,-254,-253,-252,-251,-250,-249,-248,-247,-246,-245,-244,-243,-242,-241,-240,-239,-238,-237,-236,-235,-234,-233,-232,-231,-230,-229,-228,-227,-226,-225,-224,-223,-222,-221,-220,-219,-218,-217,-216,-215,-214,-213,-212,-211,-210,-209,-208,-207,-206,-205,-204,-203,-202,-201,-200,-199,-198,-197,-196,-195,-194,-193,-192,-191,-190,-189,-188,-187,-186,-185,-184,-183,-182,-181,-180,-179,-178,-177,-176,-175,-174,-173,-172,-171,-170,-169,-168,-167,-166,-165,-164,-163,-162,-161,-160,-159,-158,-157,-156,-155,-154,-153,-152,-151,-150,-149,-148,-147,-146,-145,-144,-143,-142,-141,-140,-139,-138,-137,-136,-135,-134,-133,-132,-131,-130,-129,-128,-127,-126,-125,-124,-123,-122,-121,-120,-119,-118,-117,-116,-115,-114,-113,-112,-111,-110,-109,-108,-107,-106,-105,-104,-103,-102,-101,-100,-99,-98,-97,-96,-95,-94,-93,-92,-91,-90,-89,-88,-87,-86,-85,-84,-83,-82,-81,-80,-79,-78,-77,-76,-75,-74,-73,-72,-71,-70,-69,-68,-67,-66,-65,-64,-63,-62,-61,-60,-59,-58,-57,-56,-55,-54,-53,-52,-51,-50,-49,-48,-47,-46,-45,-44,-43,-42,-41,-40,-39,-38,-37,-36,-35,-34,-33,-32,-31,-30,-29,-28,-27,-26,-25,-24,-23,-22,-21,-20,-19,-18,-17,-16,-15,-14,-13,-12,-11,-10,-9,-8,-7,-6,-5,-4,-3,-2,-1,0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,64,65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,80,81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,96,97,98,99,100,101,102,103,104,105,106,107,108,109,110,111,112,113,114,115,116,117,118,119,120,121,122,123,124,125,126,127,128,129,130,131,132,133,134,135,136,137,138,139,140,141,142,143,144,145,146,147,148,149,150,151,152,153,154,155,156,157,158,159,160,161,162,163,164,165,166,167,168,169,170,171,172,173,174,175,176,177,178,179,180,181,182,183,184,185,186,187,188,189,190,191,192,193,194,195,196,197,198,199,200,201,202,203,204,205,206,207,208,209,210,211,212,213,214,215,216,217,218,219,220,221,222,223,224,225,226,227,228,229,230,231,232,233,234,235,236,237,238,239,240,241,242,243,244,245,246,247,248,249,250,251,252,253,254,255,256,257,258,259,260,261,262,263,264,265,266,267,268,269,270,271,272,273,274,275,276,277,278,279,280,281,282,283,284,285,286,287,288,289,290,291,292,293,294,295,296,297,298,299,300,301,302,303,304,305,306,307,308,309,310,311,312,313,314,315,316,317,318,319,320,321,322,323,324,325,326,327,328,329,330,331,332,333,334,335,336,337,338,339,340,341,342,343,344,345,346,347,348,349,350,351,352,353,354,355,356,357,358,359,360,361,362,363,364,365,366,367,368,369,370,371,372,373,374,375,376,377,378,379,380,381,382,383,384,385,386,387,388,389,390,391,392,393,394,395,396,397,398,399,400,401,402,403,404,405,406,407,408,409,410,411,412,413,414,415,416,417,418,419,420,421,422,423,424,425,426,427,428,429,430,431,432,433,434,435,436,437,438,439,440,441,442,443,444,445,446,447,448,449,450,451,452,453,454,455,456,457,458,459,460,461,462,463,464,465,466,467,468,469,470,471,472,473,474,475,476,477,478,479,480,481,482,483,484,485,486,487,488,489,490,491,492,493,494,495,496,497,498,499,500,501,502,503,504,505,506,507,508,509,510,511,512,513,514,515,516,517,518,519,520,521,522,523,524,525,526,527,528,529,530,531,532,533,534,535,536,537,538,539,540,541,542,543,544,545,546,547,548,549,550,551,552,553,554,555,556,557,558,559,560,561,562,563,564,565,566,567,568,569,570,571,572,573,574,575,576,577,578,579,580,581,582,583,584,585,586,587,588,589,590,591,592,593,594,595,596,597,598,599,600,601,602,603,604,605,606,607,608,609,610,611,612,613,614,615,616,617,618,619,620,621,622,623,624,625,626,627,628,629,630,631,632,633,634,635,636,637,638,639,640,641,642,643,644,645,646,647,648,649,650,651,652,653,654,655,656,657,658,659,660,661,662,663,664,665,666,667,668,669,670,671,672,673,674,675,676,677,678,679,680,681,682,683,684,685,686,687,688,689,690,691,692,693,694,695,696,697,698,699,700,701,702,703,704,705,706,707,708,709,710,711,712,713,714,715,716,717,718,719,720,721,722,723,724,725,726,727,728,729,730,731,732,733,734,735,736,737,738,739,740,741,742,743,744,745,746,747,748,749,750,751,752,753,754,755,756,757,758,759,760,761,762,763,764,765,766,767,768,769,770,771,772,773,774,775,776,777,778,779,780,781,782,783,784,785,786,787,788,789,790,791,792,793,794,795,796,797,798,799,800,801,802,803,804,805,806,807,808,809,810,811,812,813,814,815,816,817,818,819,820,821,822,823,824,825,826,827,828,829,830,831,832,833,834,835,836,837,838,839,840,841,842,843,844,845,846,847,848,849,850,851,852,853,854,855,856,857,858,859,860,861,862,863,864,865,866,867,868,869,870,871,872,873,874,875,876,877,878,879,880,881,882,883,884,885,886,887,888,889,890,891,892,893,894,895,896,897,898,899,900,901,902,903,904,905,906,907,908,909,910,911,912,913,914,915,916,917,918,919,920,921,922,923,924,925,926,927,928,929,930,931,932,933,934,935,936,937,938,939,940,941,942,943,944,945,946,947,948,949,950,951,952,953,954,955,956,957,958,959,960,961,962,963,964,965,966,967,968,969,970,971,972,973,974,975,976,977,978,979,980,981,982,983,984,985,986,987,988,989,990,991,992,993,994,995,996,997,998,999,1000,1001,1002,1003,1004,1005,1006,1007,1008,1009,1010,1011,1012,1013,1014,1015,1016,1017,1018,1019,1020,1021,1022,1023,1024,1025,1026,1027,1028,1029,1030,1031,1032,1033,1034,1035,1036,1037,1038,1039,1040,1041,1042,1043,1044,1045,1046,1047,1048,1049,1050,1051,1052,1053,1054,1055,1056,1057,1058,1059,1060,1061,1062,1063,1064,1065,1066,1067,1068,1069,1070,1071,1072,1073,1074,1075,1076,1077,1078,1079,1080,1081,1082,1083,1084,1085,1086,1087,1088,1089,1090,1091,1092,1093,1094,1095,1096,1097,1098,1099,1100,1101,1102,1103,1104,1105,1106,1107,1108,1109,1110,1111,1112,1113,1114,1115,1116,1117,1118,1119,1120,1121,1122,1123,1124,1125,1126,1127,1128,1129,1130,1131,1132,1133,1134,1135,1136,1137,1138,1139,1140,1141,1142,1143,1144,1145,1146,1147,1148,1149,1150,1151,1152,1153,1154,1155,1156,1157,1158,1159,1160,1161,1162,1163,1164,1165,1166,1167,1168,1169,1170,1171,1172,1173,1174,1175,1176,1177,1178,1179,1180,1181,1182,1183,1184,1185,1186,1187,1188,1189,1190,1191,1192,1193,1194,1195,1196,1197,1198,1199,1200,1201,1202,1203,1204,1205,1206,1207,1208,1209,1210,1211,1212,1213,1214,1215,1216,1217,1218,1219,1220,1221,1222,1223,1224,1225,1226,1227,1228,1229,1230,1231,1232,1233,1234,1235,1236,1237,1238,1239,1240,1241,1242,1243,1244,1245,1246,1247,1248,1249,1250,1251,1252,1253,1254,1255,1256,1257,1258,1259,1260,1261,1262,1263,1264,1265,1266,1267,1268,1269,1270,1271,1272,1273,1274,1275,1276,1277,1278,1279,1280,1281,1282,1283,1284,1285,1286,1287,1288,1289,1290,1291,1292,1293,1294,1295,1296,1297,1298,1299,1300,1301,1302,1303,1304,1305,1306,1307,1308,1309,1310,1311,1312,1313,1314,1315,1316,1317,1318,1319,1320,1321,1322,1323,1324,1325,1326,1327,1328,1329,1330,1331,1332,1333,1334,1335,1336,1337,1338,1339,1340,1341,1342,1343,1344,1345,1346,1347,1348,1349,1350,1351,1352,1353,1354,1355,1356,1357,1358,1359,1360,1361,1362,1363,1364,1365,1366,1367,1368,1369,1370,1371,1372,1373,1374,1375,1376,1377,1378,1379,1380,1381,1382,1383,1384,1385,1386,1387,1388,1389,1390,1391,1392,1393,1394,1395,1396,1397,1398,1399,1400,1401,1402,1403,1404,1405,1406,1407,1408,1409,1410,1411,1412,1413,1414,1415,1416,1417,1418,1419,1420,1421,1422,1423,1424,1425,1426,1427,1428,1429,1430,1431,1432,1433,1434,1435,1436,1437,1438,1439,1440,1441,1442,1443,1444,1445,1446,1447,1448,1449,1450,1451,1452,1453,1454,1455,1456,1457,1458,1459,1460,1461,1462,1463,1464,1465,1466,1467,1468,1469,1470,1471,1472,1473,1474,1475,1476,1477,1478,1479,1480,1481,1482,1483,1484,1485,1486,1487,1488,1489,1490,1491,1492,1493,1494,1495,1496,1497,1498,1499,1500,1501,1502,1503,1504,1505,1506,1507,1508,1509,1510,1511,1512,1513,1514,1515,1516,1517,1518,1519,1520,1521,1522,1523,1524,1525,1526,1527,1528,1529,1530,1531,1532,1533,1534,1535,1536,1537,1538,1539,1540,1541,1542,1543,1544,1545,1546,1547,1548,1549,1550,1551,1552,1553,1554,1555,1556,1557,1558,1559,1560,1561,1562,1563,1564,1565,1566,1567,1568,1569,1570,1571,1572,1573,1574,1575,1576,1577,1578,1579,1580,1581,1582,1583,1584,1585,1586,1587,1588,1589,1590,1591,1592,1593,1594,1595,1596,1597,1598,1599,1600,1601,1602,1603,1604,1605,1606,1607,1608,1609,1610,1611,1612,1613,1614,1615,1616,1617,1618,1619,1620,1621,1622,1623,1624,1625,1626,1627,1628,1629,1630,1631,1632,1633,1634,1635,1636,1637,1638,1639,1640,1641,1642,1643,1644,1645,1646,1647,1648,1649,1650,1651,1652,1653,1654,1655,1656,1657,1658,1659,1660,1661,1662,1663,1664,1665,1666,1667,1668,1669,1670,1671,1672,1673,1674,1675,1676,1677,1678,1679,1680,1681,1682,1683,1684,1685,1686,1687,1688,1689,1690,1691,1692,1693,1694,1695,1696,1697,1698,1699,1700,1701,1702,1703,1704,1705,1706,1707,1708,1709,1710,1711,1712,1713,1714,1715,1716,1717,1718,1719,1720,1721,1722,1723,1724,1725,1726,1727,1728,1729,1730,1731,1732,1733,1734,1735,1736,1737,1738,1739,1740,1741,1742,1743,1744,1745,1746,1747,1748,1749,1750,1751,1752,1753,1754,1755,1756,1757,1758,1759,1760,1761,1762,1763,1764,1765,1766,1767,1768,1769,1770,1771,1772,1773,1774,1775,1776,1777,1778,1779,1780,1781,1782,1783,1784,1785,1786,1787,1788,1789,1790,1791,1792,1793,1794,1795,1796,1797,1798,1799,1800,1801,1802,1803,1804,1805,1806,1807,1808,1809,1810,1811,1812,1813,1814,1815,1816,1817,1818,1819,1820,1821,1822,1823,1824,1825,1826,1827,1828,1829,1830,1831,1832,1833,1834,1835,1836,1837,1838,1839,1840,1841,1842,1843,1844,1845,1846,1847,1848,1849,1850,1851,1852,1853,1854,1855,1856,1857,1858,1859,1860,1861,1862,1863,1864,1865,1866,1867,1868,1869,1870,1871,1872,1873,1874,1875,1876,1877,1878,1879,1880,1881,1882,1883,1884,1885,1886,1887,1888,1889,1890,1891,1892,1893,1894,1895,1896,1897,1898,1899,1900,1901,1902,1903,1904,1905,1906,1907,1908,1909,1910,1911,1912,1913,1914,1915,1916,1917,1918,1919,1920,1921,1922,1923,1924,1925,1926,1927,1928,1929,1930,1931,1932,1933,1934,1935,1936,1937,1938,1939,1940,1941,1942,1943,1944,1945,1946,1947,1948,1949,1950,1951,1952,1953,1954,1955,1956,1957,1958,1959,1960,1961,1962,1963,1964,1965,1966,1967,1968,1969,1970,1971,1972,1973,1974,1975,1976,1977,1978,1979,1980,1981,1982,1983,1984,1985,1986,1987,1988,1989,1990,1991,1992,1993,1994,1995,1996,1997,1998,1999,2000 +-999,-998,-997,-996,-995,-994,-993,-992,-991,-990,-989,-988,-987,-986,-985,-984,-983,-982,-981,-980,-979,-978,-977,-976,-975,-974,-973,-972,-971,-970,-969,-968,-967,-966,-965,-964,-963,-962,-961,-960,-959,-958,-957,-956,-955,-954,-953,-952,-951,-950,-949,-948,-947,-946,-945,-944,-943,-942,-941,-940,-939,-938,-937,-936,-935,-934,-933,-932,-931,-930,-929,-928,-927,-926,-925,-924,-923,-922,-921,-920,-919,-918,-917,-916,-915,-914,-913,-912,-911,-910,-909,-908,-907,-906,-905,-904,-903,-902,-901,-900,-899,-898,-897,-896,-895,-894,-893,-892,-891,-890,-889,-888,-887,-886,-885,-884,-883,-882,-881,-880,-879,-878,-877,-876,-875,-874,-873,-872,-871,-870,-869,-868,-867,-866,-865,-864,-863,-862,-861,-860,-859,-858,-857,-856,-855,-854,-853,-852,-851,-850,-849,-848,-847,-846,-845,-844,-843,-842,-841,-840,-839,-838,-837,-836,-835,-834,-833,-832,-831,-830,-829,-828,-827,-826,-825,-824,-823,-822,-821,-820,-819,-818,-817,-816,-815,-814,-813,-812,-811,-810,-809,-808,-807,-806,-805,-804,-803,-802,-801,-800,-799,-798,-797,-796,-795,-794,-793,-792,-791,-790,-789,-788,-787,-786,-785,-784,-783,-782,-781,-780,-779,-778,-777,-776,-775,-774,-773,-772,-771,-770,-769,-768,-767,-766,-765,-764,-763,-762,-761,-760,-759,-758,-757,-756,-755,-754,-753,-752,-751,-750,-749,-748,-747,-746,-745,-744,-743,-742,-741,-740,-739,-738,-737,-736,-735,-734,-733,-732,-731,-730,-729,-728,-727,-726,-725,-724,-723,-722,-721,-720,-719,-718,-717,-716,-715,-714,-713,-712,-711,-710,-709,-708,-707,-706,-705,-704,-703,-702,-701,-700,-699,-698,-697,-696,-695,-694,-693,-692,-691,-690,-689,-688,-687,-686,-685,-684,-683,-682,-681,-680,-679,-678,-677,-676,-675,-674,-673,-672,-671,-670,-669,-668,-667,-666,-665,-664,-663,-662,-661,-660,-659,-658,-657,-656,-655,-654,-653,-652,-651,-650,-649,-648,-647,-646,-645,-644,-643,-642,-641,-640,-639,-638,-637,-636,-635,-634,-633,-632,-631,-630,-629,-628,-627,-626,-625,-624,-623,-622,-621,-620,-619,-618,-617,-616,-615,-614,-613,-612,-611,-610,-609,-608,-607,-606,-605,-604,-603,-602,-601,-600,-599,-598,-597,-596,-595,-594,-593,-592,-591,-590,-589,-588,-587,-586,-585,-584,-583,-582,-581,-580,-579,-578,-577,-576,-575,-574,-573,-572,-571,-570,-569,-568,-567,-566,-565,-564,-563,-562,-561,-560,-559,-558,-557,-556,-555,-554,-553,-552,-551,-550,-549,-548,-547,-546,-545,-544,-543,-542,-541,-540,-539,-538,-537,-536,-535,-534,-533,-532,-531,-530,-529,-528,-527,-526,-525,-524,-523,-522,-521,-520,-519,-518,-517,-516,-515,-514,-513,-512,-511,-510,-509,-508,-507,-506,-505,-504,-503,-502,-501,-500,-499,-498,-497,-496,-495,-494,-493,-492,-491,-490,-489,-488,-487,-486,-485,-484,-483,-482,-481,-480,-479,-478,-477,-476,-475,-474,-473,-472,-471,-470,-469,-468,-467,-466,-465,-464,-463,-462,-461,-460,-459,-458,-457,-456,-455,-454,-453,-452,-451,-450,-449,-448,-447,-446,-445,-444,-443,-442,-441,-440,-439,-438,-437,-436,-435,-434,-433,-432,-431,-430,-429,-428,-427,-426,-425,-424,-423,-422,-421,-420,-419,-418,-417,-416,-415,-414,-413,-412,-411,-410,-409,-408,-407,-406,-405,-404,-403,-402,-401,-400,-399,-398,-397,-396,-395,-394,-393,-392,-391,-390,-389,-388,-387,-386,-385,-384,-383,-382,-381,-380,-379,-378,-377,-376,-375,-374,-373,-372,-371,-370,-369,-368,-367,-366,-365,-364,-363,-362,-361,-360,-359,-358,-357,-356,-355,-354,-353,-352,-351,-350,-349,-348,-347,-346,-345,-344,-343,-342,-341,-340,-339,-338,-337,-336,-335,-334,-333,-332,-331,-330,-329,-328,-327,-326,-325,-324,-323,-322,-321,-320,-319,-318,-317,-316,-315,-314,-313,-312,-311,-310,-309,-308,-307,-306,-305,-304,-303,-302,-301,-300,-299,-298,-297,-296,-295,-294,-293,-292,-291,-290,-289,-288,-287,-286,-285,-284,-283,-282,-281,-280,-279,-278,-277,-276,-275,-274,-273,-272,-271,-270,-269,-268,-267,-266,-265,-264,-263,-262,-261,-260,-259,-258,-257,-256,-255,-254,-253,-252,-251,-250,-249,-248,-247,-246,-245,-244,-243,-242,-241,-240,-239,-238,-237,-236,-235,-234,-233,-232,-231,-230,-229,-228,-227,-226,-225,-224,-223,-222,-221,-220,-219,-218,-217,-216,-215,-214,-213,-212,-211,-210,-209,-208,-207,-206,-205,-204,-203,-202,-201,-200,-199,-198,-197,-196,-195,-194,-193,-192,-191,-190,-189,-188,-187,-186,-185,-184,-183,-182,-181,-180,-179,-178,-177,-176,-175,-174,-173,-172,-171,-170,-169,-168,-167,-166,-165,-164,-163,-162,-161,-160,-159,-158,-157,-156,-155,-154,-153,-152,-151,-150,-149,-148,-147,-146,-145,-144,-143,-142,-141,-140,-139,-138,-137,-136,-135,-134,-133,-132,-131,-130,-129,-128,-127,-126,-125,-124,-123,-122,-121,-120,-119,-118,-117,-116,-115,-114,-113,-112,-111,-110,-109,-108,-107,-106,-105,-104,-103,-102,-101,-100,-99,-98,-97,-96,-95,-94,-93,-92,-91,-90,-89,-88,-87,-86,-85,-84,-83,-82,-81,-80,-79,-78,-77,-76,-75,-74,-73,-72,-71,-70,-69,-68,-67,-66,-65,-64,-63,-62,-61,-60,-59,-58,-57,-56,-55,-54,-53,-52,-51,-50,-49,-48,-47,-46,-45,-44,-43,-42,-41,-40,-39,-38,-37,-36,-35,-34,-33,-32,-31,-30,-29,-28,-27,-26,-25,-24,-23,-22,-21,-20,-19,-18,-17,-16,-15,-14,-13,-12,-11,-10,-9,-8,-7,-6,-5,-4,-3,-2,-1,0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,64,65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,80,81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,96,97,98,99,100,101,102,103,104,105,106,107,108,109,110,111,112,113,114,115,116,117,118,119,120,121,122,123,124,125,126,127,128,129,130,131,132,133,134,135,136,137,138,139,140,141,142,143,144,145,146,147,148,149,150,151,152,153,154,155,156,157,158,159,160,161,162,163,164,165,166,167,168,169,170,171,172,173,174,175,176,177,178,179,180,181,182,183,184,185,186,187,188,189,190,191,192,193,194,195,196,197,198,199,200,201,202,203,204,205,206,207,208,209,210,211,212,213,214,215,216,217,218,219,220,221,222,223,224,225,226,227,228,229,230,231,232,233,234,235,236,237,238,239,240,241,242,243,244,245,246,247,248,249,250,251,252,253,254,255,256,257,258,259,260,261,262,263,264,265,266,267,268,269,270,271,272,273,274,275,276,277,278,279,280,281,282,283,284,285,286,287,288,289,290,291,292,293,294,295,296,297,298,299,300,301,302,303,304,305,306,307,308,309,310,311,312,313,314,315,316,317,318,319,320,321,322,323,324,325,326,327,328,329,330,331,332,333,334,335,336,337,338,339,340,341,342,343,344,345,346,347,348,349,350,351,352,353,354,355,356,357,358,359,360,361,362,363,364,365,366,367,368,369,370,371,372,373,374,375,376,377,378,379,380,381,382,383,384,385,386,387,388,389,390,391,392,393,394,395,396,397,398,399,400,401,402,403,404,405,406,407,408,409,410,411,412,413,414,415,416,417,418,419,420,421,422,423,424,425,426,427,428,429,430,431,432,433,434,435,436,437,438,439,440,441,442,443,444,445,446,447,448,449,450,451,452,453,454,455,456,457,458,459,460,461,462,463,464,465,466,467,468,469,470,471,472,473,474,475,476,477,478,479,480,481,482,483,484,485,486,487,488,489,490,491,492,493,494,495,496,497,498,499,500,501,502,503,504,505,506,507,508,509,510,511,512,513,514,515,516,517,518,519,520,521,522,523,524,525,526,527,528,529,530,531,532,533,534,535,536,537,538,539,540,541,542,543,544,545,546,547,548,549,550,551,552,553,554,555,556,557,558,559,560,561,562,563,564,565,566,567,568,569,570,571,572,573,574,575,576,577,578,579,580,581,582,583,584,585,586,587,588,589,590,591,592,593,594,595,596,597,598,599,600,601,602,603,604,605,606,607,608,609,610,611,612,613,614,615,616,617,618,619,620,621,622,623,624,625,626,627,628,629,630,631,632,633,634,635,636,637,638,639,640,641,642,643,644,645,646,647,648,649,650,651,652,653,654,655,656,657,658,659,660,661,662,663,664,665,666,667,668,669,670,671,672,673,674,675,676,677,678,679,680,681,682,683,684,685,686,687,688,689,690,691,692,693,694,695,696,697,698,699,700,701,702,703,704,705,706,707,708,709,710,711,712,713,714,715,716,717,718,719,720,721,722,723,724,725,726,727,728,729,730,731,732,733,734,735,736,737,738,739,740,741,742,743,744,745,746,747,748,749,750,751,752,753,754,755,756,757,758,759,760,761,762,763,764,765,766,767,768,769,770,771,772,773,774,775,776,777,778,779,780,781,782,783,784,785,786,787,788,789,790,791,792,793,794,795,796,797,798,799,800,801,802,803,804,805,806,807,808,809,810,811,812,813,814,815,816,817,818,819,820,821,822,823,824,825,826,827,828,829,830,831,832,833,834,835,836,837,838,839,840,841,842,843,844,845,846,847,848,849,850,851,852,853,854,855,856,857,858,859,860,861,862,863,864,865,866,867,868,869,870,871,872,873,874,875,876,877,878,879,880,881,882,883,884,885,886,887,888,889,890,891,892,893,894,895,896,897,898,899,900,901,902,903,904,905,906,907,908,909,910,911,912,913,914,915,916,917,918,919,920,921,922,923,924,925,926,927,928,929,930,931,932,933,934,935,936,937,938,939,940,941,942,943,944,945,946,947,948,949,950,951,952,953,954,955,956,957,958,959,960,961,962,963,964,965,966,967,968,969,970,971,972,973,974,975,976,977,978,979,980,981,982,983,984,985,986,987,988,989,990,991,992,993,994,995,996,997,998,999,1000,1001,1002,1003,1004,1005,1006,1007,1008,1009,1010,1011,1012,1013,1014,1015,1016,1017,1018,1019,1020,1021,1022,1023,1024,1025,1026,1027,1028,1029,1030,1031,1032,1033,1034,1035,1036,1037,1038,1039,1040,1041,1042,1043,1044,1045,1046,1047,1048,1049,1050,1051,1052,1053,1054,1055,1056,1057,1058,1059,1060,1061,1062,1063,1064,1065,1066,1067,1068,1069,1070,1071,1072,1073,1074,1075,1076,1077,1078,1079,1080,1081,1082,1083,1084,1085,1086,1087,1088,1089,1090,1091,1092,1093,1094,1095,1096,1097,1098,1099,1100,1101,1102,1103,1104,1105,1106,1107,1108,1109,1110,1111,1112,1113,1114,1115,1116,1117,1118,1119,1120,1121,1122,1123,1124,1125,1126,1127,1128,1129,1130,1131,1132,1133,1134,1135,1136,1137,1138,1139,1140,1141,1142,1143,1144,1145,1146,1147,1148,1149,1150,1151,1152,1153,1154,1155,1156,1157,1158,1159,1160,1161,1162,1163,1164,1165,1166,1167,1168,1169,1170,1171,1172,1173,1174,1175,1176,1177,1178,1179,1180,1181,1182,1183,1184,1185,1186,1187,1188,1189,1190,1191,1192,1193,1194,1195,1196,1197,1198,1199,1200,1201,1202,1203,1204,1205,1206,1207,1208,1209,1210,1211,1212,1213,1214,1215,1216,1217,1218,1219,1220,1221,1222,1223,1224,1225,1226,1227,1228,1229,1230,1231,1232,1233,1234,1235,1236,1237,1238,1239,1240,1241,1242,1243,1244,1245,1246,1247,1248,1249,1250,1251,1252,1253,1254,1255,1256,1257,1258,1259,1260,1261,1262,1263,1264,1265,1266,1267,1268,1269,1270,1271,1272,1273,1274,1275,1276,1277,1278,1279,1280,1281,1282,1283,1284,1285,1286,1287,1288,1289,1290,1291,1292,1293,1294,1295,1296,1297,1298,1299,1300,1301,1302,1303,1304,1305,1306,1307,1308,1309,1310,1311,1312,1313,1314,1315,1316,1317,1318,1319,1320,1321,1322,1323,1324,1325,1326,1327,1328,1329,1330,1331,1332,1333,1334,1335,1336,1337,1338,1339,1340,1341,1342,1343,1344,1345,1346,1347,1348,1349,1350,1351,1352,1353,1354,1355,1356,1357,1358,1359,1360,1361,1362,1363,1364,1365,1366,1367,1368,1369,1370,1371,1372,1373,1374,1375,1376,1377,1378,1379,1380,1381,1382,1383,1384,1385,1386,1387,1388,1389,1390,1391,1392,1393,1394,1395,1396,1397,1398,1399,1400,1401,1402,1403,1404,1405,1406,1407,1408,1409,1410,1411,1412,1413,1414,1415,1416,1417,1418,1419,1420,1421,1422,1423,1424,1425,1426,1427,1428,1429,1430,1431,1432,1433,1434,1435,1436,1437,1438,1439,1440,1441,1442,1443,1444,1445,1446,1447,1448,1449,1450,1451,1452,1453,1454,1455,1456,1457,1458,1459,1460,1461,1462,1463,1464,1465,1466,1467,1468,1469,1470,1471,1472,1473,1474,1475,1476,1477,1478,1479,1480,1481,1482,1483,1484,1485,1486,1487,1488,1489,1490,1491,1492,1493,1494,1495,1496,1497,1498,1499,1500,1501,1502,1503,1504,1505,1506,1507,1508,1509,1510,1511,1512,1513,1514,1515,1516,1517,1518,1519,1520,1521,1522,1523,1524,1525,1526,1527,1528,1529,1530,1531,1532,1533,1534,1535,1536,1537,1538,1539,1540,1541,1542,1543,1544,1545,1546,1547,1548,1549,1550,1551,1552,1553,1554,1555,1556,1557,1558,1559,1560,1561,1562,1563,1564,1565,1566,1567,1568,1569,1570,1571,1572,1573,1574,1575,1576,1577,1578,1579,1580,1581,1582,1583,1584,1585,1586,1587,1588,1589,1590,1591,1592,1593,1594,1595,1596,1597,1598,1599,1600,1601,1602,1603,1604,1605,1606,1607,1608,1609,1610,1611,1612,1613,1614,1615,1616,1617,1618,1619,1620,1621,1622,1623,1624,1625,1626,1627,1628,1629,1630,1631,1632,1633,1634,1635,1636,1637,1638,1639,1640,1641,1642,1643,1644,1645,1646,1647,1648,1649,1650,1651,1652,1653,1654,1655,1656,1657,1658,1659,1660,1661,1662,1663,1664,1665,1666,1667,1668,1669,1670,1671,1672,1673,1674,1675,1676,1677,1678,1679,1680,1681,1682,1683,1684,1685,1686,1687,1688,1689,1690,1691,1692,1693,1694,1695,1696,1697,1698,1699,1700,1701,1702,1703,1704,1705,1706,1707,1708,1709,1710,1711,1712,1713,1714,1715,1716,1717,1718,1719,1720,1721,1722,1723,1724,1725,1726,1727,1728,1729,1730,1731,1732,1733,1734,1735,1736,1737,1738,1739,1740,1741,1742,1743,1744,1745,1746,1747,1748,1749,1750,1751,1752,1753,1754,1755,1756,1757,1758,1759,1760,1761,1762,1763,1764,1765,1766,1767,1768,1769,1770,1771,1772,1773,1774,1775,1776,1777,1778,1779,1780,1781,1782,1783,1784,1785,1786,1787,1788,1789,1790,1791,1792,1793,1794,1795,1796,1797,1798,1799,1800,1801,1802,1803,1804,1805,1806,1807,1808,1809,1810,1811,1812,1813,1814,1815,1816,1817,1818,1819,1820,1821,1822,1823,1824,1825,1826,1827,1828,1829,1830,1831,1832,1833,1834,1835,1836,1837,1838,1839,1840,1841,1842,1843,1844,1845,1846,1847,1848,1849,1850,1851,1852,1853,1854,1855,1856,1857,1858,1859,1860,1861,1862,1863,1864,1865,1866,1867,1868,1869,1870,1871,1872,1873,1874,1875,1876,1877,1878,1879,1880,1881,1882,1883,1884,1885,1886,1887,1888,1889,1890,1891,1892,1893,1894,1895,1896,1897,1898,1899,1900,1901,1902,1903,1904,1905,1906,1907,1908,1909,1910,1911,1912,1913,1914,1915,1916,1917,1918,1919,1920,1921,1922,1923,1924,1925,1926,1927,1928,1929,1930,1931,1932,1933,1934,1935,1936,1937,1938,1939,1940,1941,1942,1943,1944,1945,1946,1947,1948,1949,1950,1951,1952,1953,1954,1955,1956,1957,1958,1959,1960,1961,1962,1963,1964,1965,1966,1967,1968,1969,1970,1971,1972,1973,1974,1975,1976,1977,1978,1979,1980,1981,1982,1983,1984,1985,1986,1987,1988,1989,1990,1991,1992,1993,1994,1995,1996,1997,1998,1999,2000 \ No newline at end of file diff --git a/Leet Code/Container With Most Water/Container With Most Water.cpp b/Leet Code/Container With Most Water/Container With Most Water.cpp new file mode 100644 index 00000000..060b5b50 --- /dev/null +++ b/Leet Code/Container With Most Water/Container With Most Water.cpp @@ -0,0 +1,22 @@ +#include +using namespace std; + +#define VOLUME(h, i, j) (((j) - (i)) * min((h)[i], (h)[j])) +class Solution { +public: + int maxArea(vector &height) { + int len = height.size(); + int maxVal = VOLUME(height, 0, len - 1); + cout << maxVal << endl; + for(int i = 0; i < len; ++i){ + if(!height[i]) continue; + int d = maxVal / height[i] + 1; + for(int j = i + d; j < len; ++j){ + if(height[j] >= height[i]){ + maxVal = VOLUME(height, i, j); + } + } + } + return maxVal; + } +}; \ No newline at end of file diff --git a/Leet Code/Container With Most Water/Main.cpp b/Leet Code/Container With Most Water/Main.cpp new file mode 100644 index 00000000..c285b21e --- /dev/null +++ b/Leet Code/Container With Most Water/Main.cpp @@ -0,0 +1,21 @@ +#include +using namespace std; +#include +#include +#include "../+Helper/Helper.h" +#include "Container With Most Water.cpp" + +int main(){ + freopen("in.txt", "r", stdin); + CLK_INIT; + Solution s; + CASET{ + vector v = scanVector(); + PRINTCASE; + CLK_START; + cout << s.maxArea(v) << endl; + CLK_END; + } + + return 0; +} \ No newline at end of file diff --git a/Leet Code/Container With Most Water/in.txt b/Leet Code/Container With Most Water/in.txt new file mode 100644 index 00000000..0929d466 --- /dev/null +++ b/Leet Code/Container With Most Water/in.txt @@ -0,0 +1,5 @@ +4 +1,2,3,1 +1,3,4,5,3,5,1,3,5,7,2,1,3,5 +488,8584,8144,7414,6649,3463,3453,8665,8006,1313,3815,7404,6969,7759,3643,8530,9792,1815,2480,6996,1151,2849,3432,1198,6125,1666,978,930,1678,3348,5223,2167,1932,3367,5933,4933,6830,9386,9951,1188,7051,118,8593,373,7877,2236,5255,7669,4051,7735,1018,1554,584,4450,9105,3061,2468,83,3992,498,9784,5567,2665,8068,8935,4951,3002,5765,4337,9305,3306,7741,9423,1899,8114,7301,487,3369,4970,890,7456,2340,8797,4392,6790,7902,3805,5610,7985,4149,6109,4121,9717,5126,2190,8652,77,1544,769,767,849,4075,8508,272,2326,2974,7573,9165,2695,8896,56,6503,1236,8853,7247,4379,6755,1052,9989,1092,5202,6098,5214,4919,7577,3756,9923,7654,5300,7044,8421,6149,1120,3281,6421,9798,2607,347,8964,5302,9243,5372,1805,479,4225,9052,1210,7332,6457,1200,8424,8011,3650,9990,9282,1227,3746,9205,5234,9046,6249,7,1547,3721,3289,4321,9872,5896,4668,8836,1199,3911,560,9356,742,4785,4761,1953,8469,1218,9505,3245,5581,9507,3236,4863,7087,3334,4068,2321,8733,6669,2328,280,391,1969,4601,6615,7866,9269,1803,5417,9532,2363,1125,6627,7148,5886,4932,1969,3456,4437,5214,9037,296,4802,252,7383,8137,4320,9704,6870,7342,8385,3502,4085,354,8104,700,4572,3725,2503,9989,9610,4866,7467,6237,8366,9705,1169,335,9514,1958,1901,4903,2254,6704,5156,9638,1193,9476,5694,8063,3170,4079,7917,7255,4434,2373,7955,9006,6099,458,5348,2061,1676,2815,8298,42,2520,5819,6729,2034,7777,8631,6938,31,5335,8446,6021,6528,7922,1716,943,1093,5795,8860,4700,6581,7586,2656,1940,3685,3114,3640,5746,4791,2807,396,1185,1679,6215,7915,3714,3992,6546,7004,375,8233,5450,6397,1113,9724,8113,8408,7169,260,3620,1870,3194,1206,4526,5134,4891,3992,5126,6989,5135,7933,3737,2673,9612,9952,588,9678,296,3486,3034,672,8071,4836,3421,9184,4561,1534,7592,8082,8146,7564,9952,1340,8771,830,2826,14,1175,7952,3356,2662,2237,7093,5335,1850,3398,2275,7880,3694,2113,915,718,184,5751,491,5720,6664,2025,3312,4747,6524,877,1051,7864,6000,8234,7043,6014,5761,1347,9370,8423,3585,6464,111,1787,6214,8738,9667,6260,852,6934,6979,1036,2686,3822,3109,5702,5848,6421,449,8724,3650,7853,6588,6002,2439,9983,2017,8200,1331,7739,2975,4916,555,9438,3055,6769,8177,9074,3030,5381,6009,6361,6417,5047,183,5878,749,2383,2300,7551,1107,2302,5404,4048,4657,7843,4031,6674,2395,1714,4413,5370,6630,4969,4809,6037,1738,9338,5112,1120,4719,1121,7481,7488,6168,4017,3367,6917,6400,2019,4468,7508,673,6224,7908,5330,419,8291,2004,2814,6,2770,8185,2988,4091,9346,9026,2181,8684,4138,3302,3403,1611,7135,891,7779,1152,4258,1048,7553,6277,1869,1413,6951,4445,5673,2281,4865,3964,638,7679,3970,3408,5864,6959,3851,5210,5985,6032,3894,6475,5686,3649,8086,2822,4541,5865,326,8799,3265,4231,5077,5134,5644,8380,9580,7669,661,797,1634,7651,8476,5604,7411,693,8915,1262,5903,4900,3647,6150,7727,9333,9799,5813,2155,692,8030,8834,9492,1296,3065,921,2782,5062,5653,8714,2731,2666,9511,4365,318,4340,6322,7729,5033,5237,8992,7288,6490,8991,9790,4217,8324,9590,31,6832,6634,4413,5666,6126,5709,8731,3399,4844,3793,9052,9910,6525,1719,9422,7242,8389,114,3564,6118,5147,8802,1462,2435,1644,453,2226,5861,8778,8168,2244,1962,4802,6658,7628,7281,8719,6359,7032,9915,153,6085,9826,3030,4156,5600,272,2545,5714,3837,5015,861,8991,6478,9648,6987,3283,8226,2848,8413,6394,1445,375,7549,4455,8003,1182,3174,715,8214,3090,7220,651,9268,250,1159,4868,6874,3704,582,7063,5072,7795,6054,1550,7443,3041,1185,5670,2242,9599,8416,39,6326,2317,4494,4330,3499,4020,1397,8066,3462,8617,5069,2730,5219,6229,7598,2093,6285,8180,9157,1357,5975,1563,9259,9771,957,445,5441,3199,6396,209,3238,2722,2527,4084,3404,2378,8104,4801,6796,1567,3418,1866,4297,4989,8095,8248,7083,732,6428,2592,2090,8756,4155,1349,8527,1464,1794,3968,4663,8190,529,4253,7265,9408,4689,669,8139,2794,5471,4935,713,5241,3153,1362,6583,7600,9610,3666,8333,6039,2610,423,1147,3117,1772,9674,4582,9919,9994,5597,4461,523,6203,1726,9932,892,8748,4423,38,571,9358,7103,2164,8864,8466,8747,6464,8076,8765,1149,467,1375,1572,1614,4493,9697,7640,5427,9616,7634,1024,429,4510,7227,8508,794,4472,7256,5217,4510,4179,927,1614,6343,9791,80,1443,2608,4508,208,3757,1328,1584,5330,9294,2429,1379,6935,7856,7347,921,8880,7776,5431,2460,2636,6225,6932,6244,7794,7794,423,8722,9408,3119,4865,5840,4562,7473,6701,4770,1231,4381,2706,2913,3675,5135,4292,6962,9343,1639,7884,8224,5767,9667,7036,8404,2245,3968,4648,39,1762,1424,5113,7523,4543,9979,9715,9105,7452,6416,227,8683,797,2934,1596,825,8069,2240,7787,3765,3879,2023,1989,9647,8043,5377,4403,288,5697,9051,327,3811,475,1793,1334,1370,1772,1050,475,9224,3818,703,4260,4616,9989,2208,5441,8058,4449,9580,8175,4680,7956,164,679,5999,1893,5082,6287,7590,486,2966,1402,7313,4759,2736,8684,6531,138,9159,2108,3957,6214,2720,4925,6203,4928,6718,614,5729,6298,8789,6762,4254,5306,7441,6605,3551,8876,2892,1142,9362,2211,2544,6675,6970,1632,5359,9854,8123,871,8314,2080,3437,1034,3357,5993,2314,75,2959,4396,2725,1748,1158,3332,3406,4951,9937,6958,3827,2830,4452,3189,5041,6996,6217,8363,4980,7928,4569,3103,8799,2883,1535,8589,269,4892,4582,8936,4967,7541,3332,7693,5641,842,1025,5400,5793,962,2358,9621,144,6810,9162,1537,158,5379,6253,1490,9660,822,4594,8459,58,6129,7048,327,7374,7982,5615,2341,5523,5299,6386,7517,6141,3763,2917,8287,1078,1627,4260,7574,4789,3422,9112,4947,5154,5365,2789,4814,2539,7383,9625,2597,9865,3026,9277,7239,1008,4892,5932,2884,192,8671,6753,2685,2434,9670,972,3512,7649,5232,1087,2438,5007,6551,3737,6513,8268,6526,1327,807,3910,7304,9757,127,330,9034,3718,7691,278,9650,6927,6822,8321,32,5860,7108,9702,6832,6972,7351,8417,8059,6141,3424,962,9878,9937,9230,6404,7616,6390,6666,1272,6147,3145,7955,1533,6863,1998,8163,2866,5277,4986,1187,5309,846,4647,1363,4030,1620,5066,2447,6031,1207,2223,6994,1085,8512,2576,3841,2480,8966,6860,3753,1465,5,1708,2998,6869,3706,7514,9735,8983,2500,7274,4292,9698,1922,2007,80,3542,7073,2528,9573,8280,1103,2919,5717,9616,5496,9558,2096,814,6418,2201,2280,6424,3909,1630,9645,3967,9144,9380,9302,7996,6654,9946,4046,4928,1953,4127,8470,9026,3007,4396,7306,462,7315,9375,6430,9163,8934,8527,9978,1704,7080,8610,4480,7342,240,4125,1309,5737,3505,612,85,6512,6910,4132,1440,8864,4611,6263,7890,3970,659,1549,4432,4326,7276,863,3490,6210,5742,9820,4267,2822,8430,5099,164,5022,9225,7826,759,9082,4790,7197,1946,1700,7681,3387,6916,2292,6002,1159,2614,6661,9060,7046,7339,6336,4261,829,8899,6355,7001,3166,5530,5431,4617,2046,454,3842,9872,7565,9277,1014,4762,7575,2715,2443,7314,5983,1087,3316,7142,3701,9977,6202,7100,3669,2539,1361,850,1438,4069,7852,956,9599,3283,5573,1645,3737,5768,1518,1303,1397,2532,2417,8972,1599,4861,6287,3935,5948,9603,1077,9650,5933,7280,6750,9602,6171,4463,452,3961,8532,8304,4917,4483,7940,6842,6129,8029,2610,3999,5684,4007,2883,8102,9332,4483,2963,5619,4770,5263,1574,5847,4913,7507,9479,8015,3461,5650,8831,266,9611,7363,4922,880,1847,2862,7723,4328,7244,6685,8327,2928,7045,1210,1030,6377,2045,345,8348,6815,5609,9922,2663,6874,3782,8494,4890,3595,4145,3721,3861,108,7436,8784,7341,5635,7998,1416,9963,5242,8101,4642,4523,5146,5853,1905,7875,4250,2251,2575,1066,4212,8850,81,1086,2632,8575,2328,2579,9072,6049,6441,5533,9838,1577,2874,1825,5927,4290,8141,1170,8743,2783,2045,242,4988,3950,4469,9239,6201,7045,305,6765,5895,6738,7852,4879,5313,180,7458,738,2582,251,6271,8772,8180,5497,597,4108,6139,5090,1630,4882,4226,3675,1476,9214,7625,5946,8453,179,2991,5110,6944,5238,1848,4796,6469,3514,1329,279,4252,263,6883,6875,9035,5063,2372,5984,9171,4863,1075,801,9745,5301,828,1222,867,8454,3520,5673,8633,2863,783,1929,8101,8984,6726,922,8850,4407,1201,9454,4670,8084,6329,3705,3148,5053,6041,8671,9916,7116,5825,6013,8769,6653,7235,9637,5107,7107,1662,92,9970,8797,2022,4423,7781,5100,5345,2983,9507,2899,2437,529,7335,8766,4234,483,171,275,5507,87,3744,1332,6101,8865,4337,9688,4854,9445,6796,6516,5889,6766,5314,4263,1190,9447,9363,2887,2431,5222,5786,4868,5751,3122,9987,6337,9957,158,2965,1816,6598,6709,3148,2699,1926,7486,8739,6781,3283,5535,9649,5524,8654,4963,9788,6196,4411,5503,9083,3194,726,1222,4414,2829,4344,753,9167,653,7264,2132,2470,3862,5193,1970,2913,7119,5808,1652,252,9091,3540,9902,968,2194,1217,7108,4742,1980,2611,3825,5174,9689,5047,5941,8871,5743,6694,8038,2749,3958,6522,5219,7820,8067,7189,7085,1538,9350,5090,1791,8441,8630,8045,5761,7176,9262,2869,1918,1243,5481,2095,2769,1522,3495,8710,393,9238,5405,4783,8339,9363,7657,3558,3536,5724,7100,6973,7263,6450,2063,5406,1243,7045,3451,7005,4221,9065,6226,2491,308,8059,4587,3078,9582,8082,8140,6327,3672,3545,1111,2012,9261,5120,1922,9149,845,9022,6122,4460,1824,4538,9866,3068,1583,9669,6425,5805,8734,9003,4648,5395,7063,9235,8473,2997,3669,2965,9324,3694,6511,6787,5706,2124,1908,3980,1273,9105,3003,3747,3565,1179,8285,9783,599,9869,9452,3376,2026,4538,2380,6674,9933,9443,2262,4758,8792,5931,7724,8116,9625,587,1256,1683,2711,9516,5664,3984,8621,5019,4083,2186,6198,2369,8321,3150,8590,4125,6526,616,8663,5258,3642,4949,4701,5904,6059,9845,8188,3783,7962,4165,722,5570,2201,3433,5086,7865,3769,3707,9236,7853,2245,1786,222,566,4936,8812,4691,7815,5780,9706,3073,5774,4655,4127,1679,7067,3972,6219,7202,8286,6736,7925,3856,8937,1358,8942,3154,1480,9001,2390,9333,1246,4177,5907,8164,5465,1071,2855,3280,6851,8914,2706,2625,9921,6833,656,6988,805,3227,4191,9092,9964,2116,9300,5253,9826,8243,8408,1306,3596,798,6991,4843,1327,9250,3007,3145,321,2215,2777,3524,7481,5483,2502,7402,2316,9510,4391,9474,2738,4934,4918,9054,7050,4218,4307,3228,8813,9067,887,2410,6218,7878,3605,7545,7129,2964,7042,3802,1531,9820,7327,9012,1655,9829,6415,324,9339,7158,9798,8429,2092,1068,3835,5494,5286,8143,5074,452,7210,5961,9214,3428,192,9171,7326,3673,2135,720,7475,19,540,1154,9031,2196,7335,1798,2520,6675,5308,8670,1456,7400,9738,5292,9246,1376,9787,4321,8180,3349,6634,7394,3130,6826,2917,456,499,1405,1176,4327,1424,8069,5481,6807,6617,2817,4958,9137,5844,266,4159,7300,4019,249,8944,3265,1625,8731,3938,6158,2081,573,9904,5211,7399,2822,2019,4251,4227,9547,8578,2003,7616,4059,8810,4233,3228,3768,9722,9072,387,233,2725,4406,482,1669,4023,8460,6753,4314,4618,8834,4887,4522,397,8638,3696,2416,2889,4275,8315,7819,6278,2284,1879,5089,2869,1459,5209,2592,532,1948,9177,3257,6354,9660,4926,6730,4472,1679,1044,9090,6865,5931,9964,3614,921,3661,2382,163,7936,698,7982,567,2982,6213,2008,5851,7673,3569,4795,8205,5518,3973,7814,8224,9985,9092,4954,4457,7124,5998,9899,3989,8281,6215,7604,5555,6228,6338,5718,517,7036,3700,1084,18,6266,3092,2222,3939,6661,7017,8496,2179,7342,6310,404,3679,5402,1710,4488,2526,4061,4387,2868,2342,6955,6824,4249,3183,3162,9967,3700,199,20,4784,6569,6286,4228,5143,225,890,8513,8721,9421,5855,5031,6177,5887,6785,4240,375,5664,8301,1115,8532,6995,8070,1708,1245,1253,4870,1212,1306,1421,1232,6090,4343,7518,6671,9486,4095,3913,7999,2816,9686,207,4199,5864,6094,7337,104,2821,3001,4757,3936,7885,1752,8358,9593,2997,5964,815,562,7270,2237,1794,9712,6580,5665,6383,2418,6112,296,418,5281,9983,625,5832,2199,3071,3169,8655,2244,2522,3412,2533,407,5164,891,0,4514,6855,7168,5076,477,9405,3222,190,2337,5239,2925,1107,1352,3222,1525,6633,9557,8502,2465,1756,7925,1987,6763,170,4509,175,2703,1269,1691,3594,7621,2557,6802,4789,7633,3631,546,7208,173,2883,8799,3099,343,151,2673,1868,3136,2230,6723,1954,338,4648,3941,7101,1170,4802,3628,3873,6071,1671,3820,3693,4229,6974,8482,8214,605,5381,5422,7131,4616,4222,230,4959,725,2903,3180,214,5133,9903,2168,1823,903,2461,8924,2074,7263,8904,2299,9687,575,2471,9732,4804,9445,4566,9371,6403,9947,1145,3534,4564,1719,116,9523,2445,3019,2703,2659,4504,8958,1179,2679,6214,3640,1603,4640,7255,507,6939,3294,7434,9411,3026,8591,5208,7593,7962,7963,7540,9107,1497,8456,827,7965,7980,9624,984,7035,2283,1840,5994,9814,4519,2208,3454,2474,6848,7061,9333,139,356,6768,5902,3382,1711,1111,7327,9673,9074,1220,8780,6924,9676,9607,4889,4008,9231,2226,1044,7866,418,3390,7680,1290,1950,7486,116,5150,4548,9450,1641,1256,2570,7544,990,4281,8655,8318,306,4081,9538,9086,7357,5566,5046,8599,9575,629,825,6971,4848,7595,361,2528,8885,8663,6367,9002,3813,7267,4804,5454,8523,3726,2998,9513,4359,8005,4183,4665,8439,3721,103,5796,5640,5149,4395,5215,5779,1572,2186,627,9168,8899,9507,4405,7562,5874,9759,1375,9493,915,3181,8016,993,2532,3882,5352,537,8065,6369,5328,8139,6473,1125,3779,1622,1872,5346,3753,3445,7532,4380,8965,2783,240,3370,345,2466,9482,8072,1960,397,1253,6328,1391,137,6562,3095,675,4628,9465,2355,9119,5938,9832,9250,3912,1705,4596,7666,1502,8480,8398,467,1263,8638,189,7960,7457,9671,6032,9417,6421,3637,2097,4164,3775,8660,7259,802,9640,3076,3157,8759,9014,2990,8009,9279,1047,8957,6945,2549,7437,5343,9368,5052,334,9557,3012,7791,5581,5396,3560,8354,9033,5657,2518,9160,669,6129,9962,309,9206,9472,9068,4572,8814,3429,3851,9861,8738,7148,8762,6175,2492,8130,7579,9178,7687,6943,3321,9620,2339,6881,7974,7725,8890,492,3237,9560,2974,9552,9869,8532,9024,5290,3104,4190,5071,3308,4051,3810,456,9165,6337,9300,7295,3917,4830,4982,860,8151,955,9552,5032,8929,3629,275,5774,6866,9835,8748,6418,9704,7280,1794,1346,6736,5984,6418,44,6387,228,6853,5552,6565,2505,9199,6834,7336,534,7695,5487,1489,3599,6872,418,3580,7147,6192,446,6982,4940,3217,3038,8572,1363,737,5309,3700,7155,1705,87,3735,4910,1992,300,7416,1191,7135,4752,1725,1182,6591,9566,1133,9815,9985,4713,6962,2529,1511,296,7470,1080,9687,2394,2444,424,4055,6144,3931,5761,2583,7666,671,927,4318,4439,8471,7805,5543,6548,5339,2135,6115,6472,8302,6100,7537,1617,8629,5401,1913,2451,6481,7952,1198,5277,4728,5253,7773,8659,1014,357,2677,8038,1284,6996,2477,6107,4801,8021,2656,141,6508,8771,2965,4810,1223,6855,6427,9852,2256,4693,8656,8737,8997,9854,367,3726,5107,8140,8737,2474,8497,1415,6864,6134,8411,5693,2241,9564,3714,1249,6057,6574,20,5375,7737,1243,2230,516,7448,4486,1561,2456,9575,559,2310,9942,4285,3769,4435,3022,2595,9284,789,9459,5418,9200,5153,4012,5117,5219,5261,1174,8146,1634,6549,5883,2877,5131,2751,6677,9617,4313,9133,5545,1224,7795,5487,5509,7917,9922,4883,512,9207,5673,6324,977,1225,7829,1341,6342,9400,2955,3869,7546,4589,6770,9781,3818,1902,8885,496,1519,3198,9629,7064,4422,7425,8904,6283,5342,5178,7518,2206,737,9543,4882,1715,769,2711,9408,3463,2112,2363,7332,6010,3304,455,2144,7123,2357,1029,7619,228,579,3600,3645,1353,7377,8901,3988,2719,4079,1506,1278,4817,1050,6160,2884,8171,8872,8644,1634,7336,7360,5319,9698,664,2126,8194,7787,4483,9223,1758,1063,6154,1711,1060,7507,9088,9961,7847,8160,393,5706,9438,1562,6756,5598,798,1279,822,9442,9265,4510,6802,936,4209,7467,3062,2403,1606,3897,7979,9717,1313,4133,1428,2373,7993,516,2335,2192,8676,9080,7898,4466,642,1006,65,1440,2285,7239,882,7903,1750,7685,8839,2311,1504,8254,1066,9462,2151,9045,9179,9816,9531,607,2190,3876,7476,877,6068,2504,9957,3967,6971,6951,4973,3388,8391,3611,627,9273,1514,8729,3310,353,1040,1166,4959,2107,629,3463,7504,6160,3279,7035,6768,1821,7263,596,2698,3332,3100,9007,3651,6423,5958,4976,9811,701,8587,439,6327,101,9168,5989,6807,6561,7156,1766,8668,4137,5229,2524,297,4861,5912,3417,6682,3175,365,5733,2859,3466,1092,2862,9889,3403,7839,6053,4104,6426,6492,431,2880,2012,6421,9687,4925,9929,7805,9945,418,3035,2470,7067,7896,8382,485,930,7909,7202,6663,7121,668,7756,9983,6910,1159,4174,2963,5263,601,5807,2047,9833,4171,4820,9520,9097,1101,7325,9042,1519,6712,7864,4938,960,2598,1775,1891,508,8978,4906,3981,9646,2662,3964,2908,173,4491,5871,1789,5092,8030,3836,4925,2202,5008,797,7651,6109,4474,3045,3980,7539,910,8918,8499,3508,7046,6742,368,6024,1649,701,5670,4311,1018,4931,837,5509,802,2626,601,5185,2814,1878,7387,7822,9027,1390,283,9853,4435,615,7392,5345,5885,5892,5206,2931,8986,1926,8955,635,2628,978,1299,3646,5909,2136,9155,3063,4762,6108,8248,3928,4338,1987,1750,9717,3377,8385,9570,7813,5352,6963,9510,1237,9207,1068,4169,8193,2995,9476,5181,1975,454,6480,1973,2715,8616,1128,5779,9730,3588,379,10,4278,2367,1760,3995,2096,6497,9917,6261,1849,6880,5772,3086,2439,3192,3607,6985,2539,9436,2166,4514,9890,8646,6487,8958,3614,3967,4737,9696,3907,1468,9706,8185,187,7818,8532,2284,667,8450,8545,2516,1682,669,1954,4122,3862,1914,7459,2753,1350,9625,7268,7592,4623,107,6550,4589,427,7639,4285,4334,5460,343,8872,5647,8161,3756,4283,5180,2206,9181,7696,241,9850,6002,715,64,7916,8174,2818,5618,4151,6438,3211,8774,2897,6113,3363,3324,3753,4000,4011,9213,4343,9235,1212,8856,2991,5496,4036,1550,4677,8084,1791,879,4086,2506,944,8355,7032,114,3973,1183,2904,7184,9957,5801,9650,9672,5478,3403,3672,9489,8968,4367,5076,6532,3223,8067,2028,3611,5969,6705,1695,7760,3937,2133,6618,1233,488,3650,1347,4462,1185,603,7998,7494,6404,7648,7166,1882,7403,838,7723,6371,1557,2799,9256,4780,867,1284,4743,3188,4342,6438,949,8279,8572,3919,9512,9060,3922,7211,9874,5107,4166,7873,2602,570,5521,6120,8805,2925,3311,6528,5648,4868,9328,4904,9649,6547,2541,4392,9735,3235,7183,7036,1514,2107,7308,7378,7519,1230,941,7394,2689,5107,1619,1643,2029,7140,7764,834,6417,1075,3715,8418,5943,9395,9674,1944,2294,2215,2689,8381,5450,9872,5418,3316,8331,2726,7046,5850,308,7987,9596,2997,9446,1215,4641,7828,4708,8757,5014,7477,9832,8729,2247,5775,4476,1922,4072,6770,489,6761,5152,5940,2985,6922,5608,1316,9648,2655,3518,6308,6994,9467,5657,2793,7034,6650,621,1742,5407,5635,5572,5239,4365,7819,7367,8841,9741,1439,1964,231,8200,7116,2523,7537,4038,8131,5205,38,7138,8723,2698,4133,4542,8355,6926,1577,5006,7547,9671,413,9534,5243,2005,251,9415,9372,5445,9156,7163,7409,5739,1715,4525,4614,9252,4915,9098,4457,1305,6236,9532,4003,369,4075,2358,3647,5652,3716,7546,5323,482,7081,6919,2487,7332,6334,1859,2777,1842,5374,6538,7582,7089,7415,8548,6341,2330,7646,7150,9987,3883,3034,3990,604,7109,2701,604,9113,6417,8150,789,6899,1583,7708,5738,5268,4042,3949,4397,5884,9323,936,9818,6412,8351,8367,9105,7034,2365,6255,7021,2600,5642,7364,9557,2751,6417,161,8217,2834,4663,9006,6086,6247,6714,1824,7867,7108,2126,2264,9344,1449,3200,9163,7862,7904,3882,3319,1290,2599,5927,4663,5200,1569,8379,4757,672,4796,1270,8889,3983,5933,7895,69,8532,961,8245,6399,4421,371,5016,3766,8173,4568,9281,6035,8824,9515,5706,114,2114,1633,4778,3666,3202,9509,8423,3875,4306,9693,9116,8289,1979,3364,4710,511,4325,9307,3263,5099,6031,8279,8865,4204,2847,4498,6591,1672,4013,2297,8138,2479,3931,9268,6146,3485,8778,4569,3712,3084,615,2829,7725,2594,6193,2435,9457,6870,1742,2720,1969,4125,7351,7186,8329,6551,8036,4920,4575,2049,3570,2713,881,3853,8334,7027,3690,7112,7948,7403,6548,4915,232,4273,3861,2777,3060,3319,5999,4802,2391,7969,8928,9743,1507,3609,2646,9544,4882,7221,7945,8452,6286,8826,8657,4620,2205,2347,1732,6506,9750,4632,1421,6334,8905,5283,9111,1965,4954,5111,3120,7345,9432,8400,3440,7291,8361,6086,6835,3243,9659,4781,8047,5946,9959,6704,566,8517,9052,8651,5023,8802,3283,2796,5137,8541,4431,600,6858,9385,2063,6330,3083,7847,1082,6523,5139,9444,8962,8326,2687,8621,9459,7087,4567,9419,3791,1486,4288,2843,137,9311,7998,9772,2107,3135,8313,6539,87,5172,2276,8503,7854,5359,6350,8937,8235,7841,4733,7197,6168,3772,2170,5627,859,3090,1398,4651,4576,5686,7494,4713,1349,1844,4485,3457,1331,9151,6348,1419,675,4976,6274,8529,6688,8976,3818,4923,6818,8551,8472,2986,2324,642,4965,3183,3732,6364,7834,8308,8402,1681,9373,9752,3525,211,9561,1209,9362,2261,2628,37,7237,5254,8566,3925,4230,2385,5200,1048,936,3672,386,3260,667,1704,2796,751,8068,6982,5412,2822,5015,4785,2574,4893,4996,2135,6102,4358,4396,5082,747,7986,336,9314,1911,4566,8051,7112,1967,5339,7136,2353,4952,7803,4057,7748,8555,8477,4730,3967,1300,6098,5104,3874,991,6453,2362,7093,7163,6758,2175,7911,4744,2511,3577,3008,3429,1628,6472,5396,3319,3608,7750,8271,7764,8159,2371,6319,2989,3454,6638,4289,9552,8094,4515,543,4547,6877,7636,8063,9988,6163,5974,1084,8674,5903,4092,2103,3883,6916,3852,7202,525,1602,1826,8289,6113,4197,960,9102,7651,3950,9743,7203,8396,611,4098,9296,7488,1734,7359,3828,4249,9685,4913,9275,5588,5357,7731,9471,2274,1583,3025,9151,9537,4851,3792,5650,9049,1104,1105,6700,1406,848,256,9802,1459,4354,9098,5300,2441,6457,5480,6690,6142,6745,5966,1730,2103,3697,7553,729,5280,579,6232,4817,5430,6376,6819,4479,7480,7924,7532,8886,5125,7788,8688,2936,8494,4139,4588,935,596,69,7626,3091,6814,9944,1173,5269,9993,8727,2350,1625,5658,4934,6442,1088,1310,9613,1920,5142,3890,5804,4028,9015,9944,9069,8303,8438,3208,2892,5726,156,9313,3352,3247,2479,9648,4421,7749,9641,9500,6451,1266,5158,1386,4060,2598,9048,3673,4518,4191,3915,6674,4571,2930,6618,3640,7586,1409,3200,6830,7135,3357,6143,6839,6604,8622,6487,7377,2723,2480,6877,9175,98,8387,6913,4158,986,2313,4183,1856,6504,8099,8531,1076,7381,1501,1068,4967,2910,4269,1797,45,7626,4292,3236,582,2915,9723,4312,1990,8555,7541,7517,8653,5929,782,9163,6915,3096,3347,5123,9600,7798,3654,7028,1531,1508,8097,6499,4418,8718,4648,816,2696,5293,4052,3278,4560,128,3942,6550,8683,1484,4068,3689,7413,4850,2852,680,4298,2551,5803,3899,349,5810,7279,1881,7318,5376,4732,8088,446,5732,5256,3142,1025,9309,2773,5585,5789,6715,8488,824,8199,8908,4513,5612,110,7366,2644,4409,9917,8448,4660,6619,610,1939,4852,7928,3668,5936,2368,4114,8020,7625,7257,9046,3286,30,983,9075,6745,5823,6251,1297,4731,765,6909,4842,4483,5906,9251,752,4354,3911,7371,4964,2202,8575,9244,5870,863,1612,9985,8884,5589,7242,4282,8875,3624,1617,4302,369,7441,554,8018,2172,7671,1280,3366,2154,7186,8969,2906,7892,9232,278,2856,1435,5205,8452,7305,6069,6416,7290,4953,2006,884,5587,7233,4508,7204,1536,1230,4645,8442,9248,3170,6113,528,6536,8267,7714,1858,1173,1958,1090,7803,4814,2525,9361,9618,9831,5430,6035,3473,6735,4393,4358,2322,1626,5218,9526,3162,2800,524,7956,8401,3694,4069,5281,6582,8688,2996,4792,6214,1306,5883,369,6121,4760,9730,2091,4591,1512,8126,4417,8247,8871,5127,6921,498,345,2800,3660,9498,3324,7969,7899,3370,2038,3180,6304,727,2528,1097,3293,3835,3332,3662,6308,8092,3393,8399,9036,4905,2878,3453,9505,1749,8580,2778,8599,5277,5578,2260,4775,8902,229,9026,8624,8619,8559,4929,5698,1087,2378,8991,1274,5710,2654,7582,3802,2399,2334,2838,3656,1564,6291,3161,9665,1223,5940,8265,6501,7870,6877,7628,3125,3458,3007,1749,8429,1566,3030,4128,9005,5408,9471,280,1118,8477,4214,1273,876,2900,4111,4533,816,6755,4046,482,7978,6338,5099,831,4209,8328,4812,7334,1786,7819,5435,215,5737,8466,695,4742,226,6519,5022,1345,4996,5589,8970,2225,8489,3081,6758,5658,6188,7156,6140,4167,3495,7591,1350,4056,5919,6162,1390,4057,333,6825,624,6070,1643,7672,813,1870,4191,2187,9567,9187,7776,8537,7764,2618,7970,874,8276,4159,8031,768,4678,7878,4711,6028,1934,630,8543,9676,4687,5228,2853,5311,1299,4497,2983,8464,6367,3526,7003,5934,9066,1132,823,6830,3750,8793,7705,8378,2952,2088,5498,3982,9966,209,6363,8252,839,4906,7928,1878,6486,781,3541,7785,5278,2877,2601,7997,6403,9605,283,5469,737,1106,8652,839,9900,6357,5569,9204,8445,1067,9539,4763,7628,5902,3015,4819,7160,943,6697,3646,8076,6590,7784,9707,9467,385,7704,2223,6342,7988,4044,7079,5446,9048,4270,1698,5405,9839,7255,202,7258,6794,1317,4886,2696,4332,9705,9856,1627,2754,3502,6056,9345,7638,5763,5164,8024,3467,3739,4366,7807,4136,7798,9606,3184,2068,1304,8590,8260,4911,5144,5518,1705,2814,405,753,7146,110,609,5126,2865,464,7534,8562,8102,3297,3726,2478,3116,3818,3197,7276,7954,995,6882,1138,9415,4538,6080,7675,9450,1225,3194,7507,391,3599,8261,7537,61,5222,9015,9278,5686,6549,7840,141,6198,1567,8971,9315,5385,2168,2943,9691,9515,9825,829,8931,715,6910,6606,6517,4487,6152,4025,4878,6103,2286,8767,6165,7508,4135,5443,9547,7036,3284,6040,3235,1203,5011,2550,2940,7180,5493,2631,6695,1670,9812,1978,8737,6722,8585,5255,1209,1089,9280,2439,7193,7918,1207,9710,1778,5342,1505,7677,2378,4789,3717,1965,2344,8729,867,1636,2261,2712,619,5308,4382,432,7287,9472,3506,2224,4727,1068,3313,359,3507,6858,4629,1066,6568,6407,6408,8074,437,5139,9215,4154,7104,7912,9235,4324,5900,7848,7036,6520,3157,7771,3304,444,7243,6810,2668,1970,7878,2333,8681,7738,9192,3310,8804,2112,6069,1565,6538,6506,6704,5754,7013,160,18,6248,836,5918,449,7873,2438,3606,5644,2094,402,2887,8905,9422,1209,3135,1755,9890,873,7299,3200,9678,9412,9269,1243,2302,2128,4299,8056,9141,811,4426,1741,1648,345,2190,9521,9135,2148,1517,1230,2550,756,6487,1972,1965,9622,80,8207,496,7379,7759,6526,3143,3380,4121,5446,5508,8420,9854,1001,5583,633,2743,7231,978,4933,3104,6465,3434,4621,4047,5984,5377,534,4309,3694,157,4389,8253,7005,8120,2364,9883,7616,5745,4004,9414,7605,2424,5620,8607,8007,6253,7702,1591,3583,8987,4695,6401,2421,5669,448,8406,7398,983,9067,7445,7492,9808,5698,849,7928,8063,732,1896,160,4736,7662,4117,3512,3283,2724,7871,5888,6778,9462,5824,5766,510,2225,8187,6179,2673,2945,9929,8,2012,7374,7500,1820,3073,4701,6101,7488,5433,4349,4000,169,2012,8117,33,1647,7194,7905,7535,3972,7367,9711,9738,4229,1936,4278,408,962,7223,338,970,9236,4064,4823,7408,7137,9524,9861,977,4958,4211,1329,1479,2575,5799,1513,4222,2993,5770,8109,3317,3137,7821,9408 +15000,14999,14998,14997,14996,14995,14994,14993,14992,14991,14990,14989,14988,14987,14986,14985,14984,14983,14982,14981,14980,14979,14978,14977,14976,14975,14974,14973,14972,14971,14970,14969,14968,14967,14966,14965,14964,14963,14962,14961,14960,14959,14958,14957,14956,14955,14954,14953,14952,14951,14950,14949,14948,14947,14946,14945,14944,14943,14942,14941,14940,14939,14938,14937,14936,14935,14934,14933,14932,14931,14930,14929,14928,14927,14926,14925,14924,14923,14922,14921,14920,14919,14918,14917,14916,14915,14914,14913,14912,14911,14910,14909,14908,14907,14906,14905,14904,14903,14902,14901,14900,14899,14898,14897,14896,14895,14894,14893,14892,14891,14890,14889,14888,14887,14886,14885,14884,14883,14882,14881,14880,14879,14878,14877,14876,14875,14874,14873,14872,14871,14870,14869,14868,14867,14866,14865,14864,14863,14862,14861,14860,14859,14858,14857,14856,14855,14854,14853,14852,14851,14850,14849,14848,14847,14846,14845,14844,14843,14842,14841,14840,14839,14838,14837,14836,14835,14834,14833,14832,14831,14830,14829,14828,14827,14826,14825,14824,14823,14822,14821,14820,14819,14818,14817,14816,14815,14814,14813,14812,14811,14810,14809,14808,14807,14806,14805,14804,14803,14802,14801,14800,14799,14798,14797,14796,14795,14794,14793,14792,14791,14790,14789,14788,14787,14786,14785,14784,14783,14782,14781,14780,14779,14778,14777,14776,14775,14774,14773,14772,14771,14770,14769,14768,14767,14766,14765,14764,14763,14762,14761,14760,14759,14758,14757,14756,14755,14754,14753,14752,14751,14750,14749,14748,14747,14746,14745,14744,14743,14742,14741,14740,14739,14738,14737,14736,14735,14734,14733,14732,14731,14730,14729,14728,14727,14726,14725,14724,14723,14722,14721,14720,14719,14718,14717,14716,14715,14714,14713,14712,14711,14710,14709,14708,14707,14706,14705,14704,14703,14702,14701,14700,14699,14698,14697,14696,14695,14694,14693,14692,14691,14690,14689,14688,14687,14686,14685,14684,14683,14682,14681,14680,14679,14678,14677,14676,14675,14674,14673,14672,14671,14670,14669,14668,14667,14666,14665,14664,14663,14662,14661,14660,14659,14658,14657,14656,14655,14654,14653,14652,14651,14650,14649,14648,14647,14646,14645,14644,14643,14642,14641,14640,14639,14638,14637,14636,14635,14634,14633,14632,14631,14630,14629,14628,14627,14626,14625,14624,14623,14622,14621,14620,14619,14618,14617,14616,14615,14614,14613,14612,14611,14610,14609,14608,14607,14606,14605,14604,14603,14602,14601,14600,14599,14598,14597,14596,14595,14594,14593,14592,14591,14590,14589,14588,14587,14586,14585,14584,14583,14582,14581,14580,14579,14578,14577,14576,14575,14574,14573,14572,14571,14570,14569,14568,14567,14566,14565,14564,14563,14562,14561,14560,14559,14558,14557,14556,14555,14554,14553,14552,14551,14550,14549,14548,14547,14546,14545,14544,14543,14542,14541,14540,14539,14538,14537,14536,14535,14534,14533,14532,14531,14530,14529,14528,14527,14526,14525,14524,14523,14522,14521,14520,14519,14518,14517,14516,14515,14514,14513,14512,14511,14510,14509,14508,14507,14506,14505,14504,14503,14502,14501,14500,14499,14498,14497,14496,14495,14494,14493,14492,14491,14490,14489,14488,14487,14486,14485,14484,14483,14482,14481,14480,14479,14478,14477,14476,14475,14474,14473,14472,14471,14470,14469,14468,14467,14466,14465,14464,14463,14462,14461,14460,14459,14458,14457,14456,14455,14454,14453,14452,14451,14450,14449,14448,14447,14446,14445,14444,14443,14442,14441,14440,14439,14438,14437,14436,14435,14434,14433,14432,14431,14430,14429,14428,14427,14426,14425,14424,14423,14422,14421,14420,14419,14418,14417,14416,14415,14414,14413,14412,14411,14410,14409,14408,14407,14406,14405,14404,14403,14402,14401,14400,14399,14398,14397,14396,14395,14394,14393,14392,14391,14390,14389,14388,14387,14386,14385,14384,14383,14382,14381,14380,14379,14378,14377,14376,14375,14374,14373,14372,14371,14370,14369,14368,14367,14366,14365,14364,14363,14362,14361,14360,14359,14358,14357,14356,14355,14354,14353,14352,14351,14350,14349,14348,14347,14346,14345,14344,14343,14342,14341,14340,14339,14338,14337,14336,14335,14334,14333,14332,14331,14330,14329,14328,14327,14326,14325,14324,14323,14322,14321,14320,14319,14318,14317,14316,14315,14314,14313,14312,14311,14310,14309,14308,14307,14306,14305,14304,14303,14302,14301,14300,14299,14298,14297,14296,14295,14294,14293,14292,14291,14290,14289,14288,14287,14286,14285,14284,14283,14282,14281,14280,14279,14278,14277,14276,14275,14274,14273,14272,14271,14270,14269,14268,14267,14266,14265,14264,14263,14262,14261,14260,14259,14258,14257,14256,14255,14254,14253,14252,14251,14250,14249,14248,14247,14246,14245,14244,14243,14242,14241,14240,14239,14238,14237,14236,14235,14234,14233,14232,14231,14230,14229,14228,14227,14226,14225,14224,14223,14222,14221,14220,14219,14218,14217,14216,14215,14214,14213,14212,14211,14210,14209,14208,14207,14206,14205,14204,14203,14202,14201,14200,14199,14198,14197,14196,14195,14194,14193,14192,14191,14190,14189,14188,14187,14186,14185,14184,14183,14182,14181,14180,14179,14178,14177,14176,14175,14174,14173,14172,14171,14170,14169,14168,14167,14166,14165,14164,14163,14162,14161,14160,14159,14158,14157,14156,14155,14154,14153,14152,14151,14150,14149,14148,14147,14146,14145,14144,14143,14142,14141,14140,14139,14138,14137,14136,14135,14134,14133,14132,14131,14130,14129,14128,14127,14126,14125,14124,14123,14122,14121,14120,14119,14118,14117,14116,14115,14114,14113,14112,14111,14110,14109,14108,14107,14106,14105,14104,14103,14102,14101,14100,14099,14098,14097,14096,14095,14094,14093,14092,14091,14090,14089,14088,14087,14086,14085,14084,14083,14082,14081,14080,14079,14078,14077,14076,14075,14074,14073,14072,14071,14070,14069,14068,14067,14066,14065,14064,14063,14062,14061,14060,14059,14058,14057,14056,14055,14054,14053,14052,14051,14050,14049,14048,14047,14046,14045,14044,14043,14042,14041,14040,14039,14038,14037,14036,14035,14034,14033,14032,14031,14030,14029,14028,14027,14026,14025,14024,14023,14022,14021,14020,14019,14018,14017,14016,14015,14014,14013,14012,14011,14010,14009,14008,14007,14006,14005,14004,14003,14002,14001,14000,13999,13998,13997,13996,13995,13994,13993,13992,13991,13990,13989,13988,13987,13986,13985,13984,13983,13982,13981,13980,13979,13978,13977,13976,13975,13974,13973,13972,13971,13970,13969,13968,13967,13966,13965,13964,13963,13962,13961,13960,13959,13958,13957,13956,13955,13954,13953,13952,13951,13950,13949,13948,13947,13946,13945,13944,13943,13942,13941,13940,13939,13938,13937,13936,13935,13934,13933,13932,13931,13930,13929,13928,13927,13926,13925,13924,13923,13922,13921,13920,13919,13918,13917,13916,13915,13914,13913,13912,13911,13910,13909,13908,13907,13906,13905,13904,13903,13902,13901,13900,13899,13898,13897,13896,13895,13894,13893,13892,13891,13890,13889,13888,13887,13886,13885,13884,13883,13882,13881,13880,13879,13878,13877,13876,13875,13874,13873,13872,13871,13870,13869,13868,13867,13866,13865,13864,13863,13862,13861,13860,13859,13858,13857,13856,13855,13854,13853,13852,13851,13850,13849,13848,13847,13846,13845,13844,13843,13842,13841,13840,13839,13838,13837,13836,13835,13834,13833,13832,13831,13830,13829,13828,13827,13826,13825,13824,13823,13822,13821,13820,13819,13818,13817,13816,13815,13814,13813,13812,13811,13810,13809,13808,13807,13806,13805,13804,13803,13802,13801,13800,13799,13798,13797,13796,13795,13794,13793,13792,13791,13790,13789,13788,13787,13786,13785,13784,13783,13782,13781,13780,13779,13778,13777,13776,13775,13774,13773,13772,13771,13770,13769,13768,13767,13766,13765,13764,13763,13762,13761,13760,13759,13758,13757,13756,13755,13754,13753,13752,13751,13750,13749,13748,13747,13746,13745,13744,13743,13742,13741,13740,13739,13738,13737,13736,13735,13734,13733,13732,13731,13730,13729,13728,13727,13726,13725,13724,13723,13722,13721,13720,13719,13718,13717,13716,13715,13714,13713,13712,13711,13710,13709,13708,13707,13706,13705,13704,13703,13702,13701,13700,13699,13698,13697,13696,13695,13694,13693,13692,13691,13690,13689,13688,13687,13686,13685,13684,13683,13682,13681,13680,13679,13678,13677,13676,13675,13674,13673,13672,13671,13670,13669,13668,13667,13666,13665,13664,13663,13662,13661,13660,13659,13658,13657,13656,13655,13654,13653,13652,13651,13650,13649,13648,13647,13646,13645,13644,13643,13642,13641,13640,13639,13638,13637,13636,13635,13634,13633,13632,13631,13630,13629,13628,13627,13626,13625,13624,13623,13622,13621,13620,13619,13618,13617,13616,13615,13614,13613,13612,13611,13610,13609,13608,13607,13606,13605,13604,13603,13602,13601,13600,13599,13598,13597,13596,13595,13594,13593,13592,13591,13590,13589,13588,13587,13586,13585,13584,13583,13582,13581,13580,13579,13578,13577,13576,13575,13574,13573,13572,13571,13570,13569,13568,13567,13566,13565,13564,13563,13562,13561,13560,13559,13558,13557,13556,13555,13554,13553,13552,13551,13550,13549,13548,13547,13546,13545,13544,13543,13542,13541,13540,13539,13538,13537,13536,13535,13534,13533,13532,13531,13530,13529,13528,13527,13526,13525,13524,13523,13522,13521,13520,13519,13518,13517,13516,13515,13514,13513,13512,13511,13510,13509,13508,13507,13506,13505,13504,13503,13502,13501,13500,13499,13498,13497,13496,13495,13494,13493,13492,13491,13490,13489,13488,13487,13486,13485,13484,13483,13482,13481,13480,13479,13478,13477,13476,13475,13474,13473,13472,13471,13470,13469,13468,13467,13466,13465,13464,13463,13462,13461,13460,13459,13458,13457,13456,13455,13454,13453,13452,13451,13450,13449,13448,13447,13446,13445,13444,13443,13442,13441,13440,13439,13438,13437,13436,13435,13434,13433,13432,13431,13430,13429,13428,13427,13426,13425,13424,13423,13422,13421,13420,13419,13418,13417,13416,13415,13414,13413,13412,13411,13410,13409,13408,13407,13406,13405,13404,13403,13402,13401,13400,13399,13398,13397,13396,13395,13394,13393,13392,13391,13390,13389,13388,13387,13386,13385,13384,13383,13382,13381,13380,13379,13378,13377,13376,13375,13374,13373,13372,13371,13370,13369,13368,13367,13366,13365,13364,13363,13362,13361,13360,13359,13358,13357,13356,13355,13354,13353,13352,13351,13350,13349,13348,13347,13346,13345,13344,13343,13342,13341,13340,13339,13338,13337,13336,13335,13334,13333,13332,13331,13330,13329,13328,13327,13326,13325,13324,13323,13322,13321,13320,13319,13318,13317,13316,13315,13314,13313,13312,13311,13310,13309,13308,13307,13306,13305,13304,13303,13302,13301,13300,13299,13298,13297,13296,13295,13294,13293,13292,13291,13290,13289,13288,13287,13286,13285,13284,13283,13282,13281,13280,13279,13278,13277,13276,13275,13274,13273,13272,13271,13270,13269,13268,13267,13266,13265,13264,13263,13262,13261,13260,13259,13258,13257,13256,13255,13254,13253,13252,13251,13250,13249,13248,13247,13246,13245,13244,13243,13242,13241,13240,13239,13238,13237,13236,13235,13234,13233,13232,13231,13230,13229,13228,13227,13226,13225,13224,13223,13222,13221,13220,13219,13218,13217,13216,13215,13214,13213,13212,13211,13210,13209,13208,13207,13206,13205,13204,13203,13202,13201,13200,13199,13198,13197,13196,13195,13194,13193,13192,13191,13190,13189,13188,13187,13186,13185,13184,13183,13182,13181,13180,13179,13178,13177,13176,13175,13174,13173,13172,13171,13170,13169,13168,13167,13166,13165,13164,13163,13162,13161,13160,13159,13158,13157,13156,13155,13154,13153,13152,13151,13150,13149,13148,13147,13146,13145,13144,13143,13142,13141,13140,13139,13138,13137,13136,13135,13134,13133,13132,13131,13130,13129,13128,13127,13126,13125,13124,13123,13122,13121,13120,13119,13118,13117,13116,13115,13114,13113,13112,13111,13110,13109,13108,13107,13106,13105,13104,13103,13102,13101,13100,13099,13098,13097,13096,13095,13094,13093,13092,13091,13090,13089,13088,13087,13086,13085,13084,13083,13082,13081,13080,13079,13078,13077,13076,13075,13074,13073,13072,13071,13070,13069,13068,13067,13066,13065,13064,13063,13062,13061,13060,13059,13058,13057,13056,13055,13054,13053,13052,13051,13050,13049,13048,13047,13046,13045,13044,13043,13042,13041,13040,13039,13038,13037,13036,13035,13034,13033,13032,13031,13030,13029,13028,13027,13026,13025,13024,13023,13022,13021,13020,13019,13018,13017,13016,13015,13014,13013,13012,13011,13010,13009,13008,13007,13006,13005,13004,13003,13002,13001,13000,12999,12998,12997,12996,12995,12994,12993,12992,12991,12990,12989,12988,12987,12986,12985,12984,12983,12982,12981,12980,12979,12978,12977,12976,12975,12974,12973,12972,12971,12970,12969,12968,12967,12966,12965,12964,12963,12962,12961,12960,12959,12958,12957,12956,12955,12954,12953,12952,12951,12950,12949,12948,12947,12946,12945,12944,12943,12942,12941,12940,12939,12938,12937,12936,12935,12934,12933,12932,12931,12930,12929,12928,12927,12926,12925,12924,12923,12922,12921,12920,12919,12918,12917,12916,12915,12914,12913,12912,12911,12910,12909,12908,12907,12906,12905,12904,12903,12902,12901,12900,12899,12898,12897,12896,12895,12894,12893,12892,12891,12890,12889,12888,12887,12886,12885,12884,12883,12882,12881,12880,12879,12878,12877,12876,12875,12874,12873,12872,12871,12870,12869,12868,12867,12866,12865,12864,12863,12862,12861,12860,12859,12858,12857,12856,12855,12854,12853,12852,12851,12850,12849,12848,12847,12846,12845,12844,12843,12842,12841,12840,12839,12838,12837,12836,12835,12834,12833,12832,12831,12830,12829,12828,12827,12826,12825,12824,12823,12822,12821,12820,12819,12818,12817,12816,12815,12814,12813,12812,12811,12810,12809,12808,12807,12806,12805,12804,12803,12802,12801,12800,12799,12798,12797,12796,12795,12794,12793,12792,12791,12790,12789,12788,12787,12786,12785,12784,12783,12782,12781,12780,12779,12778,12777,12776,12775,12774,12773,12772,12771,12770,12769,12768,12767,12766,12765,12764,12763,12762,12761,12760,12759,12758,12757,12756,12755,12754,12753,12752,12751,12750,12749,12748,12747,12746,12745,12744,12743,12742,12741,12740,12739,12738,12737,12736,12735,12734,12733,12732,12731,12730,12729,12728,12727,12726,12725,12724,12723,12722,12721,12720,12719,12718,12717,12716,12715,12714,12713,12712,12711,12710,12709,12708,12707,12706,12705,12704,12703,12702,12701,12700,12699,12698,12697,12696,12695,12694,12693,12692,12691,12690,12689,12688,12687,12686,12685,12684,12683,12682,12681,12680,12679,12678,12677,12676,12675,12674,12673,12672,12671,12670,12669,12668,12667,12666,12665,12664,12663,12662,12661,12660,12659,12658,12657,12656,12655,12654,12653,12652,12651,12650,12649,12648,12647,12646,12645,12644,12643,12642,12641,12640,12639,12638,12637,12636,12635,12634,12633,12632,12631,12630,12629,12628,12627,12626,12625,12624,12623,12622,12621,12620,12619,12618,12617,12616,12615,12614,12613,12612,12611,12610,12609,12608,12607,12606,12605,12604,12603,12602,12601,12600,12599,12598,12597,12596,12595,12594,12593,12592,12591,12590,12589,12588,12587,12586,12585,12584,12583,12582,12581,12580,12579,12578,12577,12576,12575,12574,12573,12572,12571,12570,12569,12568,12567,12566,12565,12564,12563,12562,12561,12560,12559,12558,12557,12556,12555,12554,12553,12552,12551,12550,12549,12548,12547,12546,12545,12544,12543,12542,12541,12540,12539,12538,12537,12536,12535,12534,12533,12532,12531,12530,12529,12528,12527,12526,12525,12524,12523,12522,12521,12520,12519,12518,12517,12516,12515,12514,12513,12512,12511,12510,12509,12508,12507,12506,12505,12504,12503,12502,12501,12500,12499,12498,12497,12496,12495,12494,12493,12492,12491,12490,12489,12488,12487,12486,12485,12484,12483,12482,12481,12480,12479,12478,12477,12476,12475,12474,12473,12472,12471,12470,12469,12468,12467,12466,12465,12464,12463,12462,12461,12460,12459,12458,12457,12456,12455,12454,12453,12452,12451,12450,12449,12448,12447,12446,12445,12444,12443,12442,12441,12440,12439,12438,12437,12436,12435,12434,12433,12432,12431,12430,12429,12428,12427,12426,12425,12424,12423,12422,12421,12420,12419,12418,12417,12416,12415,12414,12413,12412,12411,12410,12409,12408,12407,12406,12405,12404,12403,12402,12401,12400,12399,12398,12397,12396,12395,12394,12393,12392,12391,12390,12389,12388,12387,12386,12385,12384,12383,12382,12381,12380,12379,12378,12377,12376,12375,12374,12373,12372,12371,12370,12369,12368,12367,12366,12365,12364,12363,12362,12361,12360,12359,12358,12357,12356,12355,12354,12353,12352,12351,12350,12349,12348,12347,12346,12345,12344,12343,12342,12341,12340,12339,12338,12337,12336,12335,12334,12333,12332,12331,12330,12329,12328,12327,12326,12325,12324,12323,12322,12321,12320,12319,12318,12317,12316,12315,12314,12313,12312,12311,12310,12309,12308,12307,12306,12305,12304,12303,12302,12301,12300,12299,12298,12297,12296,12295,12294,12293,12292,12291,12290,12289,12288,12287,12286,12285,12284,12283,12282,12281,12280,12279,12278,12277,12276,12275,12274,12273,12272,12271,12270,12269,12268,12267,12266,12265,12264,12263,12262,12261,12260,12259,12258,12257,12256,12255,12254,12253,12252,12251,12250,12249,12248,12247,12246,12245,12244,12243,12242,12241,12240,12239,12238,12237,12236,12235,12234,12233,12232,12231,12230,12229,12228,12227,12226,12225,12224,12223,12222,12221,12220,12219,12218,12217,12216,12215,12214,12213,12212,12211,12210,12209,12208,12207,12206,12205,12204,12203,12202,12201,12200,12199,12198,12197,12196,12195,12194,12193,12192,12191,12190,12189,12188,12187,12186,12185,12184,12183,12182,12181,12180,12179,12178,12177,12176,12175,12174,12173,12172,12171,12170,12169,12168,12167,12166,12165,12164,12163,12162,12161,12160,12159,12158,12157,12156,12155,12154,12153,12152,12151,12150,12149,12148,12147,12146,12145,12144,12143,12142,12141,12140,12139,12138,12137,12136,12135,12134,12133,12132,12131,12130,12129,12128,12127,12126,12125,12124,12123,12122,12121,12120,12119,12118,12117,12116,12115,12114,12113,12112,12111,12110,12109,12108,12107,12106,12105,12104,12103,12102,12101,12100,12099,12098,12097,12096,12095,12094,12093,12092,12091,12090,12089,12088,12087,12086,12085,12084,12083,12082,12081,12080,12079,12078,12077,12076,12075,12074,12073,12072,12071,12070,12069,12068,12067,12066,12065,12064,12063,12062,12061,12060,12059,12058,12057,12056,12055,12054,12053,12052,12051,12050,12049,12048,12047,12046,12045,12044,12043,12042,12041,12040,12039,12038,12037,12036,12035,12034,12033,12032,12031,12030,12029,12028,12027,12026,12025,12024,12023,12022,12021,12020,12019,12018,12017,12016,12015,12014,12013,12012,12011,12010,12009,12008,12007,12006,12005,12004,12003,12002,12001,12000,11999,11998,11997,11996,11995,11994,11993,11992,11991,11990,11989,11988,11987,11986,11985,11984,11983,11982,11981,11980,11979,11978,11977,11976,11975,11974,11973,11972,11971,11970,11969,11968,11967,11966,11965,11964,11963,11962,11961,11960,11959,11958,11957,11956,11955,11954,11953,11952,11951,11950,11949,11948,11947,11946,11945,11944,11943,11942,11941,11940,11939,11938,11937,11936,11935,11934,11933,11932,11931,11930,11929,11928,11927,11926,11925,11924,11923,11922,11921,11920,11919,11918,11917,11916,11915,11914,11913,11912,11911,11910,11909,11908,11907,11906,11905,11904,11903,11902,11901,11900,11899,11898,11897,11896,11895,11894,11893,11892,11891,11890,11889,11888,11887,11886,11885,11884,11883,11882,11881,11880,11879,11878,11877,11876,11875,11874,11873,11872,11871,11870,11869,11868,11867,11866,11865,11864,11863,11862,11861,11860,11859,11858,11857,11856,11855,11854,11853,11852,11851,11850,11849,11848,11847,11846,11845,11844,11843,11842,11841,11840,11839,11838,11837,11836,11835,11834,11833,11832,11831,11830,11829,11828,11827,11826,11825,11824,11823,11822,11821,11820,11819,11818,11817,11816,11815,11814,11813,11812,11811,11810,11809,11808,11807,11806,11805,11804,11803,11802,11801,11800,11799,11798,11797,11796,11795,11794,11793,11792,11791,11790,11789,11788,11787,11786,11785,11784,11783,11782,11781,11780,11779,11778,11777,11776,11775,11774,11773,11772,11771,11770,11769,11768,11767,11766,11765,11764,11763,11762,11761,11760,11759,11758,11757,11756,11755,11754,11753,11752,11751,11750,11749,11748,11747,11746,11745,11744,11743,11742,11741,11740,11739,11738,11737,11736,11735,11734,11733,11732,11731,11730,11729,11728,11727,11726,11725,11724,11723,11722,11721,11720,11719,11718,11717,11716,11715,11714,11713,11712,11711,11710,11709,11708,11707,11706,11705,11704,11703,11702,11701,11700,11699,11698,11697,11696,11695,11694,11693,11692,11691,11690,11689,11688,11687,11686,11685,11684,11683,11682,11681,11680,11679,11678,11677,11676,11675,11674,11673,11672,11671,11670,11669,11668,11667,11666,11665,11664,11663,11662,11661,11660,11659,11658,11657,11656,11655,11654,11653,11652,11651,11650,11649,11648,11647,11646,11645,11644,11643,11642,11641,11640,11639,11638,11637,11636,11635,11634,11633,11632,11631,11630,11629,11628,11627,11626,11625,11624,11623,11622,11621,11620,11619,11618,11617,11616,11615,11614,11613,11612,11611,11610,11609,11608,11607,11606,11605,11604,11603,11602,11601,11600,11599,11598,11597,11596,11595,11594,11593,11592,11591,11590,11589,11588,11587,11586,11585,11584,11583,11582,11581,11580,11579,11578,11577,11576,11575,11574,11573,11572,11571,11570,11569,11568,11567,11566,11565,11564,11563,11562,11561,11560,11559,11558,11557,11556,11555,11554,11553,11552,11551,11550,11549,11548,11547,11546,11545,11544,11543,11542,11541,11540,11539,11538,11537,11536,11535,11534,11533,11532,11531,11530,11529,11528,11527,11526,11525,11524,11523,11522,11521,11520,11519,11518,11517,11516,11515,11514,11513,11512,11511,11510,11509,11508,11507,11506,11505,11504,11503,11502,11501,11500,11499,11498,11497,11496,11495,11494,11493,11492,11491,11490,11489,11488,11487,11486,11485,11484,11483,11482,11481,11480,11479,11478,11477,11476,11475,11474,11473,11472,11471,11470,11469,11468,11467,11466,11465,11464,11463,11462,11461,11460,11459,11458,11457,11456,11455,11454,11453,11452,11451,11450,11449,11448,11447,11446,11445,11444,11443,11442,11441,11440,11439,11438,11437,11436,11435,11434,11433,11432,11431,11430,11429,11428,11427,11426,11425,11424,11423,11422,11421,11420,11419,11418,11417,11416,11415,11414,11413,11412,11411,11410,11409,11408,11407,11406,11405,11404,11403,11402,11401,11400,11399,11398,11397,11396,11395,11394,11393,11392,11391,11390,11389,11388,11387,11386,11385,11384,11383,11382,11381,11380,11379,11378,11377,11376,11375,11374,11373,11372,11371,11370,11369,11368,11367,11366,11365,11364,11363,11362,11361,11360,11359,11358,11357,11356,11355,11354,11353,11352,11351,11350,11349,11348,11347,11346,11345,11344,11343,11342,11341,11340,11339,11338,11337,11336,11335,11334,11333,11332,11331,11330,11329,11328,11327,11326,11325,11324,11323,11322,11321,11320,11319,11318,11317,11316,11315,11314,11313,11312,11311,11310,11309,11308,11307,11306,11305,11304,11303,11302,11301,11300,11299,11298,11297,11296,11295,11294,11293,11292,11291,11290,11289,11288,11287,11286,11285,11284,11283,11282,11281,11280,11279,11278,11277,11276,11275,11274,11273,11272,11271,11270,11269,11268,11267,11266,11265,11264,11263,11262,11261,11260,11259,11258,11257,11256,11255,11254,11253,11252,11251,11250,11249,11248,11247,11246,11245,11244,11243,11242,11241,11240,11239,11238,11237,11236,11235,11234,11233,11232,11231,11230,11229,11228,11227,11226,11225,11224,11223,11222,11221,11220,11219,11218,11217,11216,11215,11214,11213,11212,11211,11210,11209,11208,11207,11206,11205,11204,11203,11202,11201,11200,11199,11198,11197,11196,11195,11194,11193,11192,11191,11190,11189,11188,11187,11186,11185,11184,11183,11182,11181,11180,11179,11178,11177,11176,11175,11174,11173,11172,11171,11170,11169,11168,11167,11166,11165,11164,11163,11162,11161,11160,11159,11158,11157,11156,11155,11154,11153,11152,11151,11150,11149,11148,11147,11146,11145,11144,11143,11142,11141,11140,11139,11138,11137,11136,11135,11134,11133,11132,11131,11130,11129,11128,11127,11126,11125,11124,11123,11122,11121,11120,11119,11118,11117,11116,11115,11114,11113,11112,11111,11110,11109,11108,11107,11106,11105,11104,11103,11102,11101,11100,11099,11098,11097,11096,11095,11094,11093,11092,11091,11090,11089,11088,11087,11086,11085,11084,11083,11082,11081,11080,11079,11078,11077,11076,11075,11074,11073,11072,11071,11070,11069,11068,11067,11066,11065,11064,11063,11062,11061,11060,11059,11058,11057,11056,11055,11054,11053,11052,11051,11050,11049,11048,11047,11046,11045,11044,11043,11042,11041,11040,11039,11038,11037,11036,11035,11034,11033,11032,11031,11030,11029,11028,11027,11026,11025,11024,11023,11022,11021,11020,11019,11018,11017,11016,11015,11014,11013,11012,11011,11010,11009,11008,11007,11006,11005,11004,11003,11002,11001,11000,10999,10998,10997,10996,10995,10994,10993,10992,10991,10990,10989,10988,10987,10986,10985,10984,10983,10982,10981,10980,10979,10978,10977,10976,10975,10974,10973,10972,10971,10970,10969,10968,10967,10966,10965,10964,10963,10962,10961,10960,10959,10958,10957,10956,10955,10954,10953,10952,10951,10950,10949,10948,10947,10946,10945,10944,10943,10942,10941,10940,10939,10938,10937,10936,10935,10934,10933,10932,10931,10930,10929,10928,10927,10926,10925,10924,10923,10922,10921,10920,10919,10918,10917,10916,10915,10914,10913,10912,10911,10910,10909,10908,10907,10906,10905,10904,10903,10902,10901,10900,10899,10898,10897,10896,10895,10894,10893,10892,10891,10890,10889,10888,10887,10886,10885,10884,10883,10882,10881,10880,10879,10878,10877,10876,10875,10874,10873,10872,10871,10870,10869,10868,10867,10866,10865,10864,10863,10862,10861,10860,10859,10858,10857,10856,10855,10854,10853,10852,10851,10850,10849,10848,10847,10846,10845,10844,10843,10842,10841,10840,10839,10838,10837,10836,10835,10834,10833,10832,10831,10830,10829,10828,10827,10826,10825,10824,10823,10822,10821,10820,10819,10818,10817,10816,10815,10814,10813,10812,10811,10810,10809,10808,10807,10806,10805,10804,10803,10802,10801,10800,10799,10798,10797,10796,10795,10794,10793,10792,10791,10790,10789,10788,10787,10786,10785,10784,10783,10782,10781,10780,10779,10778,10777,10776,10775,10774,10773,10772,10771,10770,10769,10768,10767,10766,10765,10764,10763,10762,10761,10760,10759,10758,10757,10756,10755,10754,10753,10752,10751,10750,10749,10748,10747,10746,10745,10744,10743,10742,10741,10740,10739,10738,10737,10736,10735,10734,10733,10732,10731,10730,10729,10728,10727,10726,10725,10724,10723,10722,10721,10720,10719,10718,10717,10716,10715,10714,10713,10712,10711,10710,10709,10708,10707,10706,10705,10704,10703,10702,10701,10700,10699,10698,10697,10696,10695,10694,10693,10692,10691,10690,10689,10688,10687,10686,10685,10684,10683,10682,10681,10680,10679,10678,10677,10676,10675,10674,10673,10672,10671,10670,10669,10668,10667,10666,10665,10664,10663,10662,10661,10660,10659,10658,10657,10656,10655,10654,10653,10652,10651,10650,10649,10648,10647,10646,10645,10644,10643,10642,10641,10640,10639,10638,10637,10636,10635,10634,10633,10632,10631,10630,10629,10628,10627,10626,10625,10624,10623,10622,10621,10620,10619,10618,10617,10616,10615,10614,10613,10612,10611,10610,10609,10608,10607,10606,10605,10604,10603,10602,10601,10600,10599,10598,10597,10596,10595,10594,10593,10592,10591,10590,10589,10588,10587,10586,10585,10584,10583,10582,10581,10580,10579,10578,10577,10576,10575,10574,10573,10572,10571,10570,10569,10568,10567,10566,10565,10564,10563,10562,10561,10560,10559,10558,10557,10556,10555,10554,10553,10552,10551,10550,10549,10548,10547,10546,10545,10544,10543,10542,10541,10540,10539,10538,10537,10536,10535,10534,10533,10532,10531,10530,10529,10528,10527,10526,10525,10524,10523,10522,10521,10520,10519,10518,10517,10516,10515,10514,10513,10512,10511,10510,10509,10508,10507,10506,10505,10504,10503,10502,10501,10500,10499,10498,10497,10496,10495,10494,10493,10492,10491,10490,10489,10488,10487,10486,10485,10484,10483,10482,10481,10480,10479,10478,10477,10476,10475,10474,10473,10472,10471,10470,10469,10468,10467,10466,10465,10464,10463,10462,10461,10460,10459,10458,10457,10456,10455,10454,10453,10452,10451,10450,10449,10448,10447,10446,10445,10444,10443,10442,10441,10440,10439,10438,10437,10436,10435,10434,10433,10432,10431,10430,10429,10428,10427,10426,10425,10424,10423,10422,10421,10420,10419,10418,10417,10416,10415,10414,10413,10412,10411,10410,10409,10408,10407,10406,10405,10404,10403,10402,10401,10400,10399,10398,10397,10396,10395,10394,10393,10392,10391,10390,10389,10388,10387,10386,10385,10384,10383,10382,10381,10380,10379,10378,10377,10376,10375,10374,10373,10372,10371,10370,10369,10368,10367,10366,10365,10364,10363,10362,10361,10360,10359,10358,10357,10356,10355,10354,10353,10352,10351,10350,10349,10348,10347,10346,10345,10344,10343,10342,10341,10340,10339,10338,10337,10336,10335,10334,10333,10332,10331,10330,10329,10328,10327,10326,10325,10324,10323,10322,10321,10320,10319,10318,10317,10316,10315,10314,10313,10312,10311,10310,10309,10308,10307,10306,10305,10304,10303,10302,10301,10300,10299,10298,10297,10296,10295,10294,10293,10292,10291,10290,10289,10288,10287,10286,10285,10284,10283,10282,10281,10280,10279,10278,10277,10276,10275,10274,10273,10272,10271,10270,10269,10268,10267,10266,10265,10264,10263,10262,10261,10260,10259,10258,10257,10256,10255,10254,10253,10252,10251,10250,10249,10248,10247,10246,10245,10244,10243,10242,10241,10240,10239,10238,10237,10236,10235,10234,10233,10232,10231,10230,10229,10228,10227,10226,10225,10224,10223,10222,10221,10220,10219,10218,10217,10216,10215,10214,10213,10212,10211,10210,10209,10208,10207,10206,10205,10204,10203,10202,10201,10200,10199,10198,10197,10196,10195,10194,10193,10192,10191,10190,10189,10188,10187,10186,10185,10184,10183,10182,10181,10180,10179,10178,10177,10176,10175,10174,10173,10172,10171,10170,10169,10168,10167,10166,10165,10164,10163,10162,10161,10160,10159,10158,10157,10156,10155,10154,10153,10152,10151,10150,10149,10148,10147,10146,10145,10144,10143,10142,10141,10140,10139,10138,10137,10136,10135,10134,10133,10132,10131,10130,10129,10128,10127,10126,10125,10124,10123,10122,10121,10120,10119,10118,10117,10116,10115,10114,10113,10112,10111,10110,10109,10108,10107,10106,10105,10104,10103,10102,10101,10100,10099,10098,10097,10096,10095,10094,10093,10092,10091,10090,10089,10088,10087,10086,10085,10084,10083,10082,10081,10080,10079,10078,10077,10076,10075,10074,10073,10072,10071,10070,10069,10068,10067,10066,10065,10064,10063,10062,10061,10060,10059,10058,10057,10056,10055,10054,10053,10052,10051,10050,10049,10048,10047,10046,10045,10044,10043,10042,10041,10040,10039,10038,10037,10036,10035,10034,10033,10032,10031,10030,10029,10028,10027,10026,10025,10024,10023,10022,10021,10020,10019,10018,10017,10016,10015,10014,10013,10012,10011,10010,10009,10008,10007,10006,10005,10004,10003,10002,10001,10000,9999,9998,9997,9996,9995,9994,9993,9992,9991,9990,9989,9988,9987,9986,9985,9984,9983,9982,9981,9980,9979,9978,9977,9976,9975,9974,9973,9972,9971,9970,9969,9968,9967,9966,9965,9964,9963,9962,9961,9960,9959,9958,9957,9956,9955,9954,9953,9952,9951,9950,9949,9948,9947,9946,9945,9944,9943,9942,9941,9940,9939,9938,9937,9936,9935,9934,9933,9932,9931,9930,9929,9928,9927,9926,9925,9924,9923,9922,9921,9920,9919,9918,9917,9916,9915,9914,9913,9912,9911,9910,9909,9908,9907,9906,9905,9904,9903,9902,9901,9900,9899,9898,9897,9896,9895,9894,9893,9892,9891,9890,9889,9888,9887,9886,9885,9884,9883,9882,9881,9880,9879,9878,9877,9876,9875,9874,9873,9872,9871,9870,9869,9868,9867,9866,9865,9864,9863,9862,9861,9860,9859,9858,9857,9856,9855,9854,9853,9852,9851,9850,9849,9848,9847,9846,9845,9844,9843,9842,9841,9840,9839,9838,9837,9836,9835,9834,9833,9832,9831,9830,9829,9828,9827,9826,9825,9824,9823,9822,9821,9820,9819,9818,9817,9816,9815,9814,9813,9812,9811,9810,9809,9808,9807,9806,9805,9804,9803,9802,9801,9800,9799,9798,9797,9796,9795,9794,9793,9792,9791,9790,9789,9788,9787,9786,9785,9784,9783,9782,9781,9780,9779,9778,9777,9776,9775,9774,9773,9772,9771,9770,9769,9768,9767,9766,9765,9764,9763,9762,9761,9760,9759,9758,9757,9756,9755,9754,9753,9752,9751,9750,9749,9748,9747,9746,9745,9744,9743,9742,9741,9740,9739,9738,9737,9736,9735,9734,9733,9732,9731,9730,9729,9728,9727,9726,9725,9724,9723,9722,9721,9720,9719,9718,9717,9716,9715,9714,9713,9712,9711,9710,9709,9708,9707,9706,9705,9704,9703,9702,9701,9700,9699,9698,9697,9696,9695,9694,9693,9692,9691,9690,9689,9688,9687,9686,9685,9684,9683,9682,9681,9680,9679,9678,9677,9676,9675,9674,9673,9672,9671,9670,9669,9668,9667,9666,9665,9664,9663,9662,9661,9660,9659,9658,9657,9656,9655,9654,9653,9652,9651,9650,9649,9648,9647,9646,9645,9644,9643,9642,9641,9640,9639,9638,9637,9636,9635,9634,9633,9632,9631,9630,9629,9628,9627,9626,9625,9624,9623,9622,9621,9620,9619,9618,9617,9616,9615,9614,9613,9612,9611,9610,9609,9608,9607,9606,9605,9604,9603,9602,9601,9600,9599,9598,9597,9596,9595,9594,9593,9592,9591,9590,9589,9588,9587,9586,9585,9584,9583,9582,9581,9580,9579,9578,9577,9576,9575,9574,9573,9572,9571,9570,9569,9568,9567,9566,9565,9564,9563,9562,9561,9560,9559,9558,9557,9556,9555,9554,9553,9552,9551,9550,9549,9548,9547,9546,9545,9544,9543,9542,9541,9540,9539,9538,9537,9536,9535,9534,9533,9532,9531,9530,9529,9528,9527,9526,9525,9524,9523,9522,9521,9520,9519,9518,9517,9516,9515,9514,9513,9512,9511,9510,9509,9508,9507,9506,9505,9504,9503,9502,9501,9500,9499,9498,9497,9496,9495,9494,9493,9492,9491,9490,9489,9488,9487,9486,9485,9484,9483,9482,9481,9480,9479,9478,9477,9476,9475,9474,9473,9472,9471,9470,9469,9468,9467,9466,9465,9464,9463,9462,9461,9460,9459,9458,9457,9456,9455,9454,9453,9452,9451,9450,9449,9448,9447,9446,9445,9444,9443,9442,9441,9440,9439,9438,9437,9436,9435,9434,9433,9432,9431,9430,9429,9428,9427,9426,9425,9424,9423,9422,9421,9420,9419,9418,9417,9416,9415,9414,9413,9412,9411,9410,9409,9408,9407,9406,9405,9404,9403,9402,9401,9400,9399,9398,9397,9396,9395,9394,9393,9392,9391,9390,9389,9388,9387,9386,9385,9384,9383,9382,9381,9380,9379,9378,9377,9376,9375,9374,9373,9372,9371,9370,9369,9368,9367,9366,9365,9364,9363,9362,9361,9360,9359,9358,9357,9356,9355,9354,9353,9352,9351,9350,9349,9348,9347,9346,9345,9344,9343,9342,9341,9340,9339,9338,9337,9336,9335,9334,9333,9332,9331,9330,9329,9328,9327,9326,9325,9324,9323,9322,9321,9320,9319,9318,9317,9316,9315,9314,9313,9312,9311,9310,9309,9308,9307,9306,9305,9304,9303,9302,9301,9300,9299,9298,9297,9296,9295,9294,9293,9292,9291,9290,9289,9288,9287,9286,9285,9284,9283,9282,9281,9280,9279,9278,9277,9276,9275,9274,9273,9272,9271,9270,9269,9268,9267,9266,9265,9264,9263,9262,9261,9260,9259,9258,9257,9256,9255,9254,9253,9252,9251,9250,9249,9248,9247,9246,9245,9244,9243,9242,9241,9240,9239,9238,9237,9236,9235,9234,9233,9232,9231,9230,9229,9228,9227,9226,9225,9224,9223,9222,9221,9220,9219,9218,9217,9216,9215,9214,9213,9212,9211,9210,9209,9208,9207,9206,9205,9204,9203,9202,9201,9200,9199,9198,9197,9196,9195,9194,9193,9192,9191,9190,9189,9188,9187,9186,9185,9184,9183,9182,9181,9180,9179,9178,9177,9176,9175,9174,9173,9172,9171,9170,9169,9168,9167,9166,9165,9164,9163,9162,9161,9160,9159,9158,9157,9156,9155,9154,9153,9152,9151,9150,9149,9148,9147,9146,9145,9144,9143,9142,9141,9140,9139,9138,9137,9136,9135,9134,9133,9132,9131,9130,9129,9128,9127,9126,9125,9124,9123,9122,9121,9120,9119,9118,9117,9116,9115,9114,9113,9112,9111,9110,9109,9108,9107,9106,9105,9104,9103,9102,9101,9100,9099,9098,9097,9096,9095,9094,9093,9092,9091,9090,9089,9088,9087,9086,9085,9084,9083,9082,9081,9080,9079,9078,9077,9076,9075,9074,9073,9072,9071,9070,9069,9068,9067,9066,9065,9064,9063,9062,9061,9060,9059,9058,9057,9056,9055,9054,9053,9052,9051,9050,9049,9048,9047,9046,9045,9044,9043,9042,9041,9040,9039,9038,9037,9036,9035,9034,9033,9032,9031,9030,9029,9028,9027,9026,9025,9024,9023,9022,9021,9020,9019,9018,9017,9016,9015,9014,9013,9012,9011,9010,9009,9008,9007,9006,9005,9004,9003,9002,9001,9000,8999,8998,8997,8996,8995,8994,8993,8992,8991,8990,8989,8988,8987,8986,8985,8984,8983,8982,8981,8980,8979,8978,8977,8976,8975,8974,8973,8972,8971,8970,8969,8968,8967,8966,8965,8964,8963,8962,8961,8960,8959,8958,8957,8956,8955,8954,8953,8952,8951,8950,8949,8948,8947,8946,8945,8944,8943,8942,8941,8940,8939,8938,8937,8936,8935,8934,8933,8932,8931,8930,8929,8928,8927,8926,8925,8924,8923,8922,8921,8920,8919,8918,8917,8916,8915,8914,8913,8912,8911,8910,8909,8908,8907,8906,8905,8904,8903,8902,8901,8900,8899,8898,8897,8896,8895,8894,8893,8892,8891,8890,8889,8888,8887,8886,8885,8884,8883,8882,8881,8880,8879,8878,8877,8876,8875,8874,8873,8872,8871,8870,8869,8868,8867,8866,8865,8864,8863,8862,8861,8860,8859,8858,8857,8856,8855,8854,8853,8852,8851,8850,8849,8848,8847,8846,8845,8844,8843,8842,8841,8840,8839,8838,8837,8836,8835,8834,8833,8832,8831,8830,8829,8828,8827,8826,8825,8824,8823,8822,8821,8820,8819,8818,8817,8816,8815,8814,8813,8812,8811,8810,8809,8808,8807,8806,8805,8804,8803,8802,8801,8800,8799,8798,8797,8796,8795,8794,8793,8792,8791,8790,8789,8788,8787,8786,8785,8784,8783,8782,8781,8780,8779,8778,8777,8776,8775,8774,8773,8772,8771,8770,8769,8768,8767,8766,8765,8764,8763,8762,8761,8760,8759,8758,8757,8756,8755,8754,8753,8752,8751,8750,8749,8748,8747,8746,8745,8744,8743,8742,8741,8740,8739,8738,8737,8736,8735,8734,8733,8732,8731,8730,8729,8728,8727,8726,8725,8724,8723,8722,8721,8720,8719,8718,8717,8716,8715,8714,8713,8712,8711,8710,8709,8708,8707,8706,8705,8704,8703,8702,8701,8700,8699,8698,8697,8696,8695,8694,8693,8692,8691,8690,8689,8688,8687,8686,8685,8684,8683,8682,8681,8680,8679,8678,8677,8676,8675,8674,8673,8672,8671,8670,8669,8668,8667,8666,8665,8664,8663,8662,8661,8660,8659,8658,8657,8656,8655,8654,8653,8652,8651,8650,8649,8648,8647,8646,8645,8644,8643,8642,8641,8640,8639,8638,8637,8636,8635,8634,8633,8632,8631,8630,8629,8628,8627,8626,8625,8624,8623,8622,8621,8620,8619,8618,8617,8616,8615,8614,8613,8612,8611,8610,8609,8608,8607,8606,8605,8604,8603,8602,8601,8600,8599,8598,8597,8596,8595,8594,8593,8592,8591,8590,8589,8588,8587,8586,8585,8584,8583,8582,8581,8580,8579,8578,8577,8576,8575,8574,8573,8572,8571,8570,8569,8568,8567,8566,8565,8564,8563,8562,8561,8560,8559,8558,8557,8556,8555,8554,8553,8552,8551,8550,8549,8548,8547,8546,8545,8544,8543,8542,8541,8540,8539,8538,8537,8536,8535,8534,8533,8532,8531,8530,8529,8528,8527,8526,8525,8524,8523,8522,8521,8520,8519,8518,8517,8516,8515,8514,8513,8512,8511,8510,8509,8508,8507,8506,8505,8504,8503,8502,8501,8500,8499,8498,8497,8496,8495,8494,8493,8492,8491,8490,8489,8488,8487,8486,8485,8484,8483,8482,8481,8480,8479,8478,8477,8476,8475,8474,8473,8472,8471,8470,8469,8468,8467,8466,8465,8464,8463,8462,8461,8460,8459,8458,8457,8456,8455,8454,8453,8452,8451,8450,8449,8448,8447,8446,8445,8444,8443,8442,8441,8440,8439,8438,8437,8436,8435,8434,8433,8432,8431,8430,8429,8428,8427,8426,8425,8424,8423,8422,8421,8420,8419,8418,8417,8416,8415,8414,8413,8412,8411,8410,8409,8408,8407,8406,8405,8404,8403,8402,8401,8400,8399,8398,8397,8396,8395,8394,8393,8392,8391,8390,8389,8388,8387,8386,8385,8384,8383,8382,8381,8380,8379,8378,8377,8376,8375,8374,8373,8372,8371,8370,8369,8368,8367,8366,8365,8364,8363,8362,8361,8360,8359,8358,8357,8356,8355,8354,8353,8352,8351,8350,8349,8348,8347,8346,8345,8344,8343,8342,8341,8340,8339,8338,8337,8336,8335,8334,8333,8332,8331,8330,8329,8328,8327,8326,8325,8324,8323,8322,8321,8320,8319,8318,8317,8316,8315,8314,8313,8312,8311,8310,8309,8308,8307,8306,8305,8304,8303,8302,8301,8300,8299,8298,8297,8296,8295,8294,8293,8292,8291,8290,8289,8288,8287,8286,8285,8284,8283,8282,8281,8280,8279,8278,8277,8276,8275,8274,8273,8272,8271,8270,8269,8268,8267,8266,8265,8264,8263,8262,8261,8260,8259,8258,8257,8256,8255,8254,8253,8252,8251,8250,8249,8248,8247,8246,8245,8244,8243,8242,8241,8240,8239,8238,8237,8236,8235,8234,8233,8232,8231,8230,8229,8228,8227,8226,8225,8224,8223,8222,8221,8220,8219,8218,8217,8216,8215,8214,8213,8212,8211,8210,8209,8208,8207,8206,8205,8204,8203,8202,8201,8200,8199,8198,8197,8196,8195,8194,8193,8192,8191,8190,8189,8188,8187,8186,8185,8184,8183,8182,8181,8180,8179,8178,8177,8176,8175,8174,8173,8172,8171,8170,8169,8168,8167,8166,8165,8164,8163,8162,8161,8160,8159,8158,8157,8156,8155,8154,8153,8152,8151,8150,8149,8148,8147,8146,8145,8144,8143,8142,8141,8140,8139,8138,8137,8136,8135,8134,8133,8132,8131,8130,8129,8128,8127,8126,8125,8124,8123,8122,8121,8120,8119,8118,8117,8116,8115,8114,8113,8112,8111,8110,8109,8108,8107,8106,8105,8104,8103,8102,8101,8100,8099,8098,8097,8096,8095,8094,8093,8092,8091,8090,8089,8088,8087,8086,8085,8084,8083,8082,8081,8080,8079,8078,8077,8076,8075,8074,8073,8072,8071,8070,8069,8068,8067,8066,8065,8064,8063,8062,8061,8060,8059,8058,8057,8056,8055,8054,8053,8052,8051,8050,8049,8048,8047,8046,8045,8044,8043,8042,8041,8040,8039,8038,8037,8036,8035,8034,8033,8032,8031,8030,8029,8028,8027,8026,8025,8024,8023,8022,8021,8020,8019,8018,8017,8016,8015,8014,8013,8012,8011,8010,8009,8008,8007,8006,8005,8004,8003,8002,8001,8000,7999,7998,7997,7996,7995,7994,7993,7992,7991,7990,7989,7988,7987,7986,7985,7984,7983,7982,7981,7980,7979,7978,7977,7976,7975,7974,7973,7972,7971,7970,7969,7968,7967,7966,7965,7964,7963,7962,7961,7960,7959,7958,7957,7956,7955,7954,7953,7952,7951,7950,7949,7948,7947,7946,7945,7944,7943,7942,7941,7940,7939,7938,7937,7936,7935,7934,7933,7932,7931,7930,7929,7928,7927,7926,7925,7924,7923,7922,7921,7920,7919,7918,7917,7916,7915,7914,7913,7912,7911,7910,7909,7908,7907,7906,7905,7904,7903,7902,7901,7900,7899,7898,7897,7896,7895,7894,7893,7892,7891,7890,7889,7888,7887,7886,7885,7884,7883,7882,7881,7880,7879,7878,7877,7876,7875,7874,7873,7872,7871,7870,7869,7868,7867,7866,7865,7864,7863,7862,7861,7860,7859,7858,7857,7856,7855,7854,7853,7852,7851,7850,7849,7848,7847,7846,7845,7844,7843,7842,7841,7840,7839,7838,7837,7836,7835,7834,7833,7832,7831,7830,7829,7828,7827,7826,7825,7824,7823,7822,7821,7820,7819,7818,7817,7816,7815,7814,7813,7812,7811,7810,7809,7808,7807,7806,7805,7804,7803,7802,7801,7800,7799,7798,7797,7796,7795,7794,7793,7792,7791,7790,7789,7788,7787,7786,7785,7784,7783,7782,7781,7780,7779,7778,7777,7776,7775,7774,7773,7772,7771,7770,7769,7768,7767,7766,7765,7764,7763,7762,7761,7760,7759,7758,7757,7756,7755,7754,7753,7752,7751,7750,7749,7748,7747,7746,7745,7744,7743,7742,7741,7740,7739,7738,7737,7736,7735,7734,7733,7732,7731,7730,7729,7728,7727,7726,7725,7724,7723,7722,7721,7720,7719,7718,7717,7716,7715,7714,7713,7712,7711,7710,7709,7708,7707,7706,7705,7704,7703,7702,7701,7700,7699,7698,7697,7696,7695,7694,7693,7692,7691,7690,7689,7688,7687,7686,7685,7684,7683,7682,7681,7680,7679,7678,7677,7676,7675,7674,7673,7672,7671,7670,7669,7668,7667,7666,7665,7664,7663,7662,7661,7660,7659,7658,7657,7656,7655,7654,7653,7652,7651,7650,7649,7648,7647,7646,7645,7644,7643,7642,7641,7640,7639,7638,7637,7636,7635,7634,7633,7632,7631,7630,7629,7628,7627,7626,7625,7624,7623,7622,7621,7620,7619,7618,7617,7616,7615,7614,7613,7612,7611,7610,7609,7608,7607,7606,7605,7604,7603,7602,7601,7600,7599,7598,7597,7596,7595,7594,7593,7592,7591,7590,7589,7588,7587,7586,7585,7584,7583,7582,7581,7580,7579,7578,7577,7576,7575,7574,7573,7572,7571,7570,7569,7568,7567,7566,7565,7564,7563,7562,7561,7560,7559,7558,7557,7556,7555,7554,7553,7552,7551,7550,7549,7548,7547,7546,7545,7544,7543,7542,7541,7540,7539,7538,7537,7536,7535,7534,7533,7532,7531,7530,7529,7528,7527,7526,7525,7524,7523,7522,7521,7520,7519,7518,7517,7516,7515,7514,7513,7512,7511,7510,7509,7508,7507,7506,7505,7504,7503,7502,7501,7500,7499,7498,7497,7496,7495,7494,7493,7492,7491,7490,7489,7488,7487,7486,7485,7484,7483,7482,7481,7480,7479,7478,7477,7476,7475,7474,7473,7472,7471,7470,7469,7468,7467,7466,7465,7464,7463,7462,7461,7460,7459,7458,7457,7456,7455,7454,7453,7452,7451,7450,7449,7448,7447,7446,7445,7444,7443,7442,7441,7440,7439,7438,7437,7436,7435,7434,7433,7432,7431,7430,7429,7428,7427,7426,7425,7424,7423,7422,7421,7420,7419,7418,7417,7416,7415,7414,7413,7412,7411,7410,7409,7408,7407,7406,7405,7404,7403,7402,7401,7400,7399,7398,7397,7396,7395,7394,7393,7392,7391,7390,7389,7388,7387,7386,7385,7384,7383,7382,7381,7380,7379,7378,7377,7376,7375,7374,7373,7372,7371,7370,7369,7368,7367,7366,7365,7364,7363,7362,7361,7360,7359,7358,7357,7356,7355,7354,7353,7352,7351,7350,7349,7348,7347,7346,7345,7344,7343,7342,7341,7340,7339,7338,7337,7336,7335,7334,7333,7332,7331,7330,7329,7328,7327,7326,7325,7324,7323,7322,7321,7320,7319,7318,7317,7316,7315,7314,7313,7312,7311,7310,7309,7308,7307,7306,7305,7304,7303,7302,7301,7300,7299,7298,7297,7296,7295,7294,7293,7292,7291,7290,7289,7288,7287,7286,7285,7284,7283,7282,7281,7280,7279,7278,7277,7276,7275,7274,7273,7272,7271,7270,7269,7268,7267,7266,7265,7264,7263,7262,7261,7260,7259,7258,7257,7256,7255,7254,7253,7252,7251,7250,7249,7248,7247,7246,7245,7244,7243,7242,7241,7240,7239,7238,7237,7236,7235,7234,7233,7232,7231,7230,7229,7228,7227,7226,7225,7224,7223,7222,7221,7220,7219,7218,7217,7216,7215,7214,7213,7212,7211,7210,7209,7208,7207,7206,7205,7204,7203,7202,7201,7200,7199,7198,7197,7196,7195,7194,7193,7192,7191,7190,7189,7188,7187,7186,7185,7184,7183,7182,7181,7180,7179,7178,7177,7176,7175,7174,7173,7172,7171,7170,7169,7168,7167,7166,7165,7164,7163,7162,7161,7160,7159,7158,7157,7156,7155,7154,7153,7152,7151,7150,7149,7148,7147,7146,7145,7144,7143,7142,7141,7140,7139,7138,7137,7136,7135,7134,7133,7132,7131,7130,7129,7128,7127,7126,7125,7124,7123,7122,7121,7120,7119,7118,7117,7116,7115,7114,7113,7112,7111,7110,7109,7108,7107,7106,7105,7104,7103,7102,7101,7100,7099,7098,7097,7096,7095,7094,7093,7092,7091,7090,7089,7088,7087,7086,7085,7084,7083,7082,7081,7080,7079,7078,7077,7076,7075,7074,7073,7072,7071,7070,7069,7068,7067,7066,7065,7064,7063,7062,7061,7060,7059,7058,7057,7056,7055,7054,7053,7052,7051,7050,7049,7048,7047,7046,7045,7044,7043,7042,7041,7040,7039,7038,7037,7036,7035,7034,7033,7032,7031,7030,7029,7028,7027,7026,7025,7024,7023,7022,7021,7020,7019,7018,7017,7016,7015,7014,7013,7012,7011,7010,7009,7008,7007,7006,7005,7004,7003,7002,7001,7000,6999,6998,6997,6996,6995,6994,6993,6992,6991,6990,6989,6988,6987,6986,6985,6984,6983,6982,6981,6980,6979,6978,6977,6976,6975,6974,6973,6972,6971,6970,6969,6968,6967,6966,6965,6964,6963,6962,6961,6960,6959,6958,6957,6956,6955,6954,6953,6952,6951,6950,6949,6948,6947,6946,6945,6944,6943,6942,6941,6940,6939,6938,6937,6936,6935,6934,6933,6932,6931,6930,6929,6928,6927,6926,6925,6924,6923,6922,6921,6920,6919,6918,6917,6916,6915,6914,6913,6912,6911,6910,6909,6908,6907,6906,6905,6904,6903,6902,6901,6900,6899,6898,6897,6896,6895,6894,6893,6892,6891,6890,6889,6888,6887,6886,6885,6884,6883,6882,6881,6880,6879,6878,6877,6876,6875,6874,6873,6872,6871,6870,6869,6868,6867,6866,6865,6864,6863,6862,6861,6860,6859,6858,6857,6856,6855,6854,6853,6852,6851,6850,6849,6848,6847,6846,6845,6844,6843,6842,6841,6840,6839,6838,6837,6836,6835,6834,6833,6832,6831,6830,6829,6828,6827,6826,6825,6824,6823,6822,6821,6820,6819,6818,6817,6816,6815,6814,6813,6812,6811,6810,6809,6808,6807,6806,6805,6804,6803,6802,6801,6800,6799,6798,6797,6796,6795,6794,6793,6792,6791,6790,6789,6788,6787,6786,6785,6784,6783,6782,6781,6780,6779,6778,6777,6776,6775,6774,6773,6772,6771,6770,6769,6768,6767,6766,6765,6764,6763,6762,6761,6760,6759,6758,6757,6756,6755,6754,6753,6752,6751,6750,6749,6748,6747,6746,6745,6744,6743,6742,6741,6740,6739,6738,6737,6736,6735,6734,6733,6732,6731,6730,6729,6728,6727,6726,6725,6724,6723,6722,6721,6720,6719,6718,6717,6716,6715,6714,6713,6712,6711,6710,6709,6708,6707,6706,6705,6704,6703,6702,6701,6700,6699,6698,6697,6696,6695,6694,6693,6692,6691,6690,6689,6688,6687,6686,6685,6684,6683,6682,6681,6680,6679,6678,6677,6676,6675,6674,6673,6672,6671,6670,6669,6668,6667,6666,6665,6664,6663,6662,6661,6660,6659,6658,6657,6656,6655,6654,6653,6652,6651,6650,6649,6648,6647,6646,6645,6644,6643,6642,6641,6640,6639,6638,6637,6636,6635,6634,6633,6632,6631,6630,6629,6628,6627,6626,6625,6624,6623,6622,6621,6620,6619,6618,6617,6616,6615,6614,6613,6612,6611,6610,6609,6608,6607,6606,6605,6604,6603,6602,6601,6600,6599,6598,6597,6596,6595,6594,6593,6592,6591,6590,6589,6588,6587,6586,6585,6584,6583,6582,6581,6580,6579,6578,6577,6576,6575,6574,6573,6572,6571,6570,6569,6568,6567,6566,6565,6564,6563,6562,6561,6560,6559,6558,6557,6556,6555,6554,6553,6552,6551,6550,6549,6548,6547,6546,6545,6544,6543,6542,6541,6540,6539,6538,6537,6536,6535,6534,6533,6532,6531,6530,6529,6528,6527,6526,6525,6524,6523,6522,6521,6520,6519,6518,6517,6516,6515,6514,6513,6512,6511,6510,6509,6508,6507,6506,6505,6504,6503,6502,6501,6500,6499,6498,6497,6496,6495,6494,6493,6492,6491,6490,6489,6488,6487,6486,6485,6484,6483,6482,6481,6480,6479,6478,6477,6476,6475,6474,6473,6472,6471,6470,6469,6468,6467,6466,6465,6464,6463,6462,6461,6460,6459,6458,6457,6456,6455,6454,6453,6452,6451,6450,6449,6448,6447,6446,6445,6444,6443,6442,6441,6440,6439,6438,6437,6436,6435,6434,6433,6432,6431,6430,6429,6428,6427,6426,6425,6424,6423,6422,6421,6420,6419,6418,6417,6416,6415,6414,6413,6412,6411,6410,6409,6408,6407,6406,6405,6404,6403,6402,6401,6400,6399,6398,6397,6396,6395,6394,6393,6392,6391,6390,6389,6388,6387,6386,6385,6384,6383,6382,6381,6380,6379,6378,6377,6376,6375,6374,6373,6372,6371,6370,6369,6368,6367,6366,6365,6364,6363,6362,6361,6360,6359,6358,6357,6356,6355,6354,6353,6352,6351,6350,6349,6348,6347,6346,6345,6344,6343,6342,6341,6340,6339,6338,6337,6336,6335,6334,6333,6332,6331,6330,6329,6328,6327,6326,6325,6324,6323,6322,6321,6320,6319,6318,6317,6316,6315,6314,6313,6312,6311,6310,6309,6308,6307,6306,6305,6304,6303,6302,6301,6300,6299,6298,6297,6296,6295,6294,6293,6292,6291,6290,6289,6288,6287,6286,6285,6284,6283,6282,6281,6280,6279,6278,6277,6276,6275,6274,6273,6272,6271,6270,6269,6268,6267,6266,6265,6264,6263,6262,6261,6260,6259,6258,6257,6256,6255,6254,6253,6252,6251,6250,6249,6248,6247,6246,6245,6244,6243,6242,6241,6240,6239,6238,6237,6236,6235,6234,6233,6232,6231,6230,6229,6228,6227,6226,6225,6224,6223,6222,6221,6220,6219,6218,6217,6216,6215,6214,6213,6212,6211,6210,6209,6208,6207,6206,6205,6204,6203,6202,6201,6200,6199,6198,6197,6196,6195,6194,6193,6192,6191,6190,6189,6188,6187,6186,6185,6184,6183,6182,6181,6180,6179,6178,6177,6176,6175,6174,6173,6172,6171,6170,6169,6168,6167,6166,6165,6164,6163,6162,6161,6160,6159,6158,6157,6156,6155,6154,6153,6152,6151,6150,6149,6148,6147,6146,6145,6144,6143,6142,6141,6140,6139,6138,6137,6136,6135,6134,6133,6132,6131,6130,6129,6128,6127,6126,6125,6124,6123,6122,6121,6120,6119,6118,6117,6116,6115,6114,6113,6112,6111,6110,6109,6108,6107,6106,6105,6104,6103,6102,6101,6100,6099,6098,6097,6096,6095,6094,6093,6092,6091,6090,6089,6088,6087,6086,6085,6084,6083,6082,6081,6080,6079,6078,6077,6076,6075,6074,6073,6072,6071,6070,6069,6068,6067,6066,6065,6064,6063,6062,6061,6060,6059,6058,6057,6056,6055,6054,6053,6052,6051,6050,6049,6048,6047,6046,6045,6044,6043,6042,6041,6040,6039,6038,6037,6036,6035,6034,6033,6032,6031,6030,6029,6028,6027,6026,6025,6024,6023,6022,6021,6020,6019,6018,6017,6016,6015,6014,6013,6012,6011,6010,6009,6008,6007,6006,6005,6004,6003,6002,6001,6000,5999,5998,5997,5996,5995,5994,5993,5992,5991,5990,5989,5988,5987,5986,5985,5984,5983,5982,5981,5980,5979,5978,5977,5976,5975,5974,5973,5972,5971,5970,5969,5968,5967,5966,5965,5964,5963,5962,5961,5960,5959,5958,5957,5956,5955,5954,5953,5952,5951,5950,5949,5948,5947,5946,5945,5944,5943,5942,5941,5940,5939,5938,5937,5936,5935,5934,5933,5932,5931,5930,5929,5928,5927,5926,5925,5924,5923,5922,5921,5920,5919,5918,5917,5916,5915,5914,5913,5912,5911,5910,5909,5908,5907,5906,5905,5904,5903,5902,5901,5900,5899,5898,5897,5896,5895,5894,5893,5892,5891,5890,5889,5888,5887,5886,5885,5884,5883,5882,5881,5880,5879,5878,5877,5876,5875,5874,5873,5872,5871,5870,5869,5868,5867,5866,5865,5864,5863,5862,5861,5860,5859,5858,5857,5856,5855,5854,5853,5852,5851,5850,5849,5848,5847,5846,5845,5844,5843,5842,5841,5840,5839,5838,5837,5836,5835,5834,5833,5832,5831,5830,5829,5828,5827,5826,5825,5824,5823,5822,5821,5820,5819,5818,5817,5816,5815,5814,5813,5812,5811,5810,5809,5808,5807,5806,5805,5804,5803,5802,5801,5800,5799,5798,5797,5796,5795,5794,5793,5792,5791,5790,5789,5788,5787,5786,5785,5784,5783,5782,5781,5780,5779,5778,5777,5776,5775,5774,5773,5772,5771,5770,5769,5768,5767,5766,5765,5764,5763,5762,5761,5760,5759,5758,5757,5756,5755,5754,5753,5752,5751,5750,5749,5748,5747,5746,5745,5744,5743,5742,5741,5740,5739,5738,5737,5736,5735,5734,5733,5732,5731,5730,5729,5728,5727,5726,5725,5724,5723,5722,5721,5720,5719,5718,5717,5716,5715,5714,5713,5712,5711,5710,5709,5708,5707,5706,5705,5704,5703,5702,5701,5700,5699,5698,5697,5696,5695,5694,5693,5692,5691,5690,5689,5688,5687,5686,5685,5684,5683,5682,5681,5680,5679,5678,5677,5676,5675,5674,5673,5672,5671,5670,5669,5668,5667,5666,5665,5664,5663,5662,5661,5660,5659,5658,5657,5656,5655,5654,5653,5652,5651,5650,5649,5648,5647,5646,5645,5644,5643,5642,5641,5640,5639,5638,5637,5636,5635,5634,5633,5632,5631,5630,5629,5628,5627,5626,5625,5624,5623,5622,5621,5620,5619,5618,5617,5616,5615,5614,5613,5612,5611,5610,5609,5608,5607,5606,5605,5604,5603,5602,5601,5600,5599,5598,5597,5596,5595,5594,5593,5592,5591,5590,5589,5588,5587,5586,5585,5584,5583,5582,5581,5580,5579,5578,5577,5576,5575,5574,5573,5572,5571,5570,5569,5568,5567,5566,5565,5564,5563,5562,5561,5560,5559,5558,5557,5556,5555,5554,5553,5552,5551,5550,5549,5548,5547,5546,5545,5544,5543,5542,5541,5540,5539,5538,5537,5536,5535,5534,5533,5532,5531,5530,5529,5528,5527,5526,5525,5524,5523,5522,5521,5520,5519,5518,5517,5516,5515,5514,5513,5512,5511,5510,5509,5508,5507,5506,5505,5504,5503,5502,5501,5500,5499,5498,5497,5496,5495,5494,5493,5492,5491,5490,5489,5488,5487,5486,5485,5484,5483,5482,5481,5480,5479,5478,5477,5476,5475,5474,5473,5472,5471,5470,5469,5468,5467,5466,5465,5464,5463,5462,5461,5460,5459,5458,5457,5456,5455,5454,5453,5452,5451,5450,5449,5448,5447,5446,5445,5444,5443,5442,5441,5440,5439,5438,5437,5436,5435,5434,5433,5432,5431,5430,5429,5428,5427,5426,5425,5424,5423,5422,5421,5420,5419,5418,5417,5416,5415,5414,5413,5412,5411,5410,5409,5408,5407,5406,5405,5404,5403,5402,5401,5400,5399,5398,5397,5396,5395,5394,5393,5392,5391,5390,5389,5388,5387,5386,5385,5384,5383,5382,5381,5380,5379,5378,5377,5376,5375,5374,5373,5372,5371,5370,5369,5368,5367,5366,5365,5364,5363,5362,5361,5360,5359,5358,5357,5356,5355,5354,5353,5352,5351,5350,5349,5348,5347,5346,5345,5344,5343,5342,5341,5340,5339,5338,5337,5336,5335,5334,5333,5332,5331,5330,5329,5328,5327,5326,5325,5324,5323,5322,5321,5320,5319,5318,5317,5316,5315,5314,5313,5312,5311,5310,5309,5308,5307,5306,5305,5304,5303,5302,5301,5300,5299,5298,5297,5296,5295,5294,5293,5292,5291,5290,5289,5288,5287,5286,5285,5284,5283,5282,5281,5280,5279,5278,5277,5276,5275,5274,5273,5272,5271,5270,5269,5268,5267,5266,5265,5264,5263,5262,5261,5260,5259,5258,5257,5256,5255,5254,5253,5252,5251,5250,5249,5248,5247,5246,5245,5244,5243,5242,5241,5240,5239,5238,5237,5236,5235,5234,5233,5232,5231,5230,5229,5228,5227,5226,5225,5224,5223,5222,5221,5220,5219,5218,5217,5216,5215,5214,5213,5212,5211,5210,5209,5208,5207,5206,5205,5204,5203,5202,5201,5200,5199,5198,5197,5196,5195,5194,5193,5192,5191,5190,5189,5188,5187,5186,5185,5184,5183,5182,5181,5180,5179,5178,5177,5176,5175,5174,5173,5172,5171,5170,5169,5168,5167,5166,5165,5164,5163,5162,5161,5160,5159,5158,5157,5156,5155,5154,5153,5152,5151,5150,5149,5148,5147,5146,5145,5144,5143,5142,5141,5140,5139,5138,5137,5136,5135,5134,5133,5132,5131,5130,5129,5128,5127,5126,5125,5124,5123,5122,5121,5120,5119,5118,5117,5116,5115,5114,5113,5112,5111,5110,5109,5108,5107,5106,5105,5104,5103,5102,5101,5100,5099,5098,5097,5096,5095,5094,5093,5092,5091,5090,5089,5088,5087,5086,5085,5084,5083,5082,5081,5080,5079,5078,5077,5076,5075,5074,5073,5072,5071,5070,5069,5068,5067,5066,5065,5064,5063,5062,5061,5060,5059,5058,5057,5056,5055,5054,5053,5052,5051,5050,5049,5048,5047,5046,5045,5044,5043,5042,5041,5040,5039,5038,5037,5036,5035,5034,5033,5032,5031,5030,5029,5028,5027,5026,5025,5024,5023,5022,5021,5020,5019,5018,5017,5016,5015,5014,5013,5012,5011,5010,5009,5008,5007,5006,5005,5004,5003,5002,5001,5000,4999,4998,4997,4996,4995,4994,4993,4992,4991,4990,4989,4988,4987,4986,4985,4984,4983,4982,4981,4980,4979,4978,4977,4976,4975,4974,4973,4972,4971,4970,4969,4968,4967,4966,4965,4964,4963,4962,4961,4960,4959,4958,4957,4956,4955,4954,4953,4952,4951,4950,4949,4948,4947,4946,4945,4944,4943,4942,4941,4940,4939,4938,4937,4936,4935,4934,4933,4932,4931,4930,4929,4928,4927,4926,4925,4924,4923,4922,4921,4920,4919,4918,4917,4916,4915,4914,4913,4912,4911,4910,4909,4908,4907,4906,4905,4904,4903,4902,4901,4900,4899,4898,4897,4896,4895,4894,4893,4892,4891,4890,4889,4888,4887,4886,4885,4884,4883,4882,4881,4880,4879,4878,4877,4876,4875,4874,4873,4872,4871,4870,4869,4868,4867,4866,4865,4864,4863,4862,4861,4860,4859,4858,4857,4856,4855,4854,4853,4852,4851,4850,4849,4848,4847,4846,4845,4844,4843,4842,4841,4840,4839,4838,4837,4836,4835,4834,4833,4832,4831,4830,4829,4828,4827,4826,4825,4824,4823,4822,4821,4820,4819,4818,4817,4816,4815,4814,4813,4812,4811,4810,4809,4808,4807,4806,4805,4804,4803,4802,4801,4800,4799,4798,4797,4796,4795,4794,4793,4792,4791,4790,4789,4788,4787,4786,4785,4784,4783,4782,4781,4780,4779,4778,4777,4776,4775,4774,4773,4772,4771,4770,4769,4768,4767,4766,4765,4764,4763,4762,4761,4760,4759,4758,4757,4756,4755,4754,4753,4752,4751,4750,4749,4748,4747,4746,4745,4744,4743,4742,4741,4740,4739,4738,4737,4736,4735,4734,4733,4732,4731,4730,4729,4728,4727,4726,4725,4724,4723,4722,4721,4720,4719,4718,4717,4716,4715,4714,4713,4712,4711,4710,4709,4708,4707,4706,4705,4704,4703,4702,4701,4700,4699,4698,4697,4696,4695,4694,4693,4692,4691,4690,4689,4688,4687,4686,4685,4684,4683,4682,4681,4680,4679,4678,4677,4676,4675,4674,4673,4672,4671,4670,4669,4668,4667,4666,4665,4664,4663,4662,4661,4660,4659,4658,4657,4656,4655,4654,4653,4652,4651,4650,4649,4648,4647,4646,4645,4644,4643,4642,4641,4640,4639,4638,4637,4636,4635,4634,4633,4632,4631,4630,4629,4628,4627,4626,4625,4624,4623,4622,4621,4620,4619,4618,4617,4616,4615,4614,4613,4612,4611,4610,4609,4608,4607,4606,4605,4604,4603,4602,4601,4600,4599,4598,4597,4596,4595,4594,4593,4592,4591,4590,4589,4588,4587,4586,4585,4584,4583,4582,4581,4580,4579,4578,4577,4576,4575,4574,4573,4572,4571,4570,4569,4568,4567,4566,4565,4564,4563,4562,4561,4560,4559,4558,4557,4556,4555,4554,4553,4552,4551,4550,4549,4548,4547,4546,4545,4544,4543,4542,4541,4540,4539,4538,4537,4536,4535,4534,4533,4532,4531,4530,4529,4528,4527,4526,4525,4524,4523,4522,4521,4520,4519,4518,4517,4516,4515,4514,4513,4512,4511,4510,4509,4508,4507,4506,4505,4504,4503,4502,4501,4500,4499,4498,4497,4496,4495,4494,4493,4492,4491,4490,4489,4488,4487,4486,4485,4484,4483,4482,4481,4480,4479,4478,4477,4476,4475,4474,4473,4472,4471,4470,4469,4468,4467,4466,4465,4464,4463,4462,4461,4460,4459,4458,4457,4456,4455,4454,4453,4452,4451,4450,4449,4448,4447,4446,4445,4444,4443,4442,4441,4440,4439,4438,4437,4436,4435,4434,4433,4432,4431,4430,4429,4428,4427,4426,4425,4424,4423,4422,4421,4420,4419,4418,4417,4416,4415,4414,4413,4412,4411,4410,4409,4408,4407,4406,4405,4404,4403,4402,4401,4400,4399,4398,4397,4396,4395,4394,4393,4392,4391,4390,4389,4388,4387,4386,4385,4384,4383,4382,4381,4380,4379,4378,4377,4376,4375,4374,4373,4372,4371,4370,4369,4368,4367,4366,4365,4364,4363,4362,4361,4360,4359,4358,4357,4356,4355,4354,4353,4352,4351,4350,4349,4348,4347,4346,4345,4344,4343,4342,4341,4340,4339,4338,4337,4336,4335,4334,4333,4332,4331,4330,4329,4328,4327,4326,4325,4324,4323,4322,4321,4320,4319,4318,4317,4316,4315,4314,4313,4312,4311,4310,4309,4308,4307,4306,4305,4304,4303,4302,4301,4300,4299,4298,4297,4296,4295,4294,4293,4292,4291,4290,4289,4288,4287,4286,4285,4284,4283,4282,4281,4280,4279,4278,4277,4276,4275,4274,4273,4272,4271,4270,4269,4268,4267,4266,4265,4264,4263,4262,4261,4260,4259,4258,4257,4256,4255,4254,4253,4252,4251,4250,4249,4248,4247,4246,4245,4244,4243,4242,4241,4240,4239,4238,4237,4236,4235,4234,4233,4232,4231,4230,4229,4228,4227,4226,4225,4224,4223,4222,4221,4220,4219,4218,4217,4216,4215,4214,4213,4212,4211,4210,4209,4208,4207,4206,4205,4204,4203,4202,4201,4200,4199,4198,4197,4196,4195,4194,4193,4192,4191,4190,4189,4188,4187,4186,4185,4184,4183,4182,4181,4180,4179,4178,4177,4176,4175,4174,4173,4172,4171,4170,4169,4168,4167,4166,4165,4164,4163,4162,4161,4160,4159,4158,4157,4156,4155,4154,4153,4152,4151,4150,4149,4148,4147,4146,4145,4144,4143,4142,4141,4140,4139,4138,4137,4136,4135,4134,4133,4132,4131,4130,4129,4128,4127,4126,4125,4124,4123,4122,4121,4120,4119,4118,4117,4116,4115,4114,4113,4112,4111,4110,4109,4108,4107,4106,4105,4104,4103,4102,4101,4100,4099,4098,4097,4096,4095,4094,4093,4092,4091,4090,4089,4088,4087,4086,4085,4084,4083,4082,4081,4080,4079,4078,4077,4076,4075,4074,4073,4072,4071,4070,4069,4068,4067,4066,4065,4064,4063,4062,4061,4060,4059,4058,4057,4056,4055,4054,4053,4052,4051,4050,4049,4048,4047,4046,4045,4044,4043,4042,4041,4040,4039,4038,4037,4036,4035,4034,4033,4032,4031,4030,4029,4028,4027,4026,4025,4024,4023,4022,4021,4020,4019,4018,4017,4016,4015,4014,4013,4012,4011,4010,4009,4008,4007,4006,4005,4004,4003,4002,4001,4000,3999,3998,3997,3996,3995,3994,3993,3992,3991,3990,3989,3988,3987,3986,3985,3984,3983,3982,3981,3980,3979,3978,3977,3976,3975,3974,3973,3972,3971,3970,3969,3968,3967,3966,3965,3964,3963,3962,3961,3960,3959,3958,3957,3956,3955,3954,3953,3952,3951,3950,3949,3948,3947,3946,3945,3944,3943,3942,3941,3940,3939,3938,3937,3936,3935,3934,3933,3932,3931,3930,3929,3928,3927,3926,3925,3924,3923,3922,3921,3920,3919,3918,3917,3916,3915,3914,3913,3912,3911,3910,3909,3908,3907,3906,3905,3904,3903,3902,3901,3900,3899,3898,3897,3896,3895,3894,3893,3892,3891,3890,3889,3888,3887,3886,3885,3884,3883,3882,3881,3880,3879,3878,3877,3876,3875,3874,3873,3872,3871,3870,3869,3868,3867,3866,3865,3864,3863,3862,3861,3860,3859,3858,3857,3856,3855,3854,3853,3852,3851,3850,3849,3848,3847,3846,3845,3844,3843,3842,3841,3840,3839,3838,3837,3836,3835,3834,3833,3832,3831,3830,3829,3828,3827,3826,3825,3824,3823,3822,3821,3820,3819,3818,3817,3816,3815,3814,3813,3812,3811,3810,3809,3808,3807,3806,3805,3804,3803,3802,3801,3800,3799,3798,3797,3796,3795,3794,3793,3792,3791,3790,3789,3788,3787,3786,3785,3784,3783,3782,3781,3780,3779,3778,3777,3776,3775,3774,3773,3772,3771,3770,3769,3768,3767,3766,3765,3764,3763,3762,3761,3760,3759,3758,3757,3756,3755,3754,3753,3752,3751,3750,3749,3748,3747,3746,3745,3744,3743,3742,3741,3740,3739,3738,3737,3736,3735,3734,3733,3732,3731,3730,3729,3728,3727,3726,3725,3724,3723,3722,3721,3720,3719,3718,3717,3716,3715,3714,3713,3712,3711,3710,3709,3708,3707,3706,3705,3704,3703,3702,3701,3700,3699,3698,3697,3696,3695,3694,3693,3692,3691,3690,3689,3688,3687,3686,3685,3684,3683,3682,3681,3680,3679,3678,3677,3676,3675,3674,3673,3672,3671,3670,3669,3668,3667,3666,3665,3664,3663,3662,3661,3660,3659,3658,3657,3656,3655,3654,3653,3652,3651,3650,3649,3648,3647,3646,3645,3644,3643,3642,3641,3640,3639,3638,3637,3636,3635,3634,3633,3632,3631,3630,3629,3628,3627,3626,3625,3624,3623,3622,3621,3620,3619,3618,3617,3616,3615,3614,3613,3612,3611,3610,3609,3608,3607,3606,3605,3604,3603,3602,3601,3600,3599,3598,3597,3596,3595,3594,3593,3592,3591,3590,3589,3588,3587,3586,3585,3584,3583,3582,3581,3580,3579,3578,3577,3576,3575,3574,3573,3572,3571,3570,3569,3568,3567,3566,3565,3564,3563,3562,3561,3560,3559,3558,3557,3556,3555,3554,3553,3552,3551,3550,3549,3548,3547,3546,3545,3544,3543,3542,3541,3540,3539,3538,3537,3536,3535,3534,3533,3532,3531,3530,3529,3528,3527,3526,3525,3524,3523,3522,3521,3520,3519,3518,3517,3516,3515,3514,3513,3512,3511,3510,3509,3508,3507,3506,3505,3504,3503,3502,3501,3500,3499,3498,3497,3496,3495,3494,3493,3492,3491,3490,3489,3488,3487,3486,3485,3484,3483,3482,3481,3480,3479,3478,3477,3476,3475,3474,3473,3472,3471,3470,3469,3468,3467,3466,3465,3464,3463,3462,3461,3460,3459,3458,3457,3456,3455,3454,3453,3452,3451,3450,3449,3448,3447,3446,3445,3444,3443,3442,3441,3440,3439,3438,3437,3436,3435,3434,3433,3432,3431,3430,3429,3428,3427,3426,3425,3424,3423,3422,3421,3420,3419,3418,3417,3416,3415,3414,3413,3412,3411,3410,3409,3408,3407,3406,3405,3404,3403,3402,3401,3400,3399,3398,3397,3396,3395,3394,3393,3392,3391,3390,3389,3388,3387,3386,3385,3384,3383,3382,3381,3380,3379,3378,3377,3376,3375,3374,3373,3372,3371,3370,3369,3368,3367,3366,3365,3364,3363,3362,3361,3360,3359,3358,3357,3356,3355,3354,3353,3352,3351,3350,3349,3348,3347,3346,3345,3344,3343,3342,3341,3340,3339,3338,3337,3336,3335,3334,3333,3332,3331,3330,3329,3328,3327,3326,3325,3324,3323,3322,3321,3320,3319,3318,3317,3316,3315,3314,3313,3312,3311,3310,3309,3308,3307,3306,3305,3304,3303,3302,3301,3300,3299,3298,3297,3296,3295,3294,3293,3292,3291,3290,3289,3288,3287,3286,3285,3284,3283,3282,3281,3280,3279,3278,3277,3276,3275,3274,3273,3272,3271,3270,3269,3268,3267,3266,3265,3264,3263,3262,3261,3260,3259,3258,3257,3256,3255,3254,3253,3252,3251,3250,3249,3248,3247,3246,3245,3244,3243,3242,3241,3240,3239,3238,3237,3236,3235,3234,3233,3232,3231,3230,3229,3228,3227,3226,3225,3224,3223,3222,3221,3220,3219,3218,3217,3216,3215,3214,3213,3212,3211,3210,3209,3208,3207,3206,3205,3204,3203,3202,3201,3200,3199,3198,3197,3196,3195,3194,3193,3192,3191,3190,3189,3188,3187,3186,3185,3184,3183,3182,3181,3180,3179,3178,3177,3176,3175,3174,3173,3172,3171,3170,3169,3168,3167,3166,3165,3164,3163,3162,3161,3160,3159,3158,3157,3156,3155,3154,3153,3152,3151,3150,3149,3148,3147,3146,3145,3144,3143,3142,3141,3140,3139,3138,3137,3136,3135,3134,3133,3132,3131,3130,3129,3128,3127,3126,3125,3124,3123,3122,3121,3120,3119,3118,3117,3116,3115,3114,3113,3112,3111,3110,3109,3108,3107,3106,3105,3104,3103,3102,3101,3100,3099,3098,3097,3096,3095,3094,3093,3092,3091,3090,3089,3088,3087,3086,3085,3084,3083,3082,3081,3080,3079,3078,3077,3076,3075,3074,3073,3072,3071,3070,3069,3068,3067,3066,3065,3064,3063,3062,3061,3060,3059,3058,3057,3056,3055,3054,3053,3052,3051,3050,3049,3048,3047,3046,3045,3044,3043,3042,3041,3040,3039,3038,3037,3036,3035,3034,3033,3032,3031,3030,3029,3028,3027,3026,3025,3024,3023,3022,3021,3020,3019,3018,3017,3016,3015,3014,3013,3012,3011,3010,3009,3008,3007,3006,3005,3004,3003,3002,3001,3000,2999,2998,2997,2996,2995,2994,2993,2992,2991,2990,2989,2988,2987,2986,2985,2984,2983,2982,2981,2980,2979,2978,2977,2976,2975,2974,2973,2972,2971,2970,2969,2968,2967,2966,2965,2964,2963,2962,2961,2960,2959,2958,2957,2956,2955,2954,2953,2952,2951,2950,2949,2948,2947,2946,2945,2944,2943,2942,2941,2940,2939,2938,2937,2936,2935,2934,2933,2932,2931,2930,2929,2928,2927,2926,2925,2924,2923,2922,2921,2920,2919,2918,2917,2916,2915,2914,2913,2912,2911,2910,2909,2908,2907,2906,2905,2904,2903,2902,2901,2900,2899,2898,2897,2896,2895,2894,2893,2892,2891,2890,2889,2888,2887,2886,2885,2884,2883,2882,2881,2880,2879,2878,2877,2876,2875,2874,2873,2872,2871,2870,2869,2868,2867,2866,2865,2864,2863,2862,2861,2860,2859,2858,2857,2856,2855,2854,2853,2852,2851,2850,2849,2848,2847,2846,2845,2844,2843,2842,2841,2840,2839,2838,2837,2836,2835,2834,2833,2832,2831,2830,2829,2828,2827,2826,2825,2824,2823,2822,2821,2820,2819,2818,2817,2816,2815,2814,2813,2812,2811,2810,2809,2808,2807,2806,2805,2804,2803,2802,2801,2800,2799,2798,2797,2796,2795,2794,2793,2792,2791,2790,2789,2788,2787,2786,2785,2784,2783,2782,2781,2780,2779,2778,2777,2776,2775,2774,2773,2772,2771,2770,2769,2768,2767,2766,2765,2764,2763,2762,2761,2760,2759,2758,2757,2756,2755,2754,2753,2752,2751,2750,2749,2748,2747,2746,2745,2744,2743,2742,2741,2740,2739,2738,2737,2736,2735,2734,2733,2732,2731,2730,2729,2728,2727,2726,2725,2724,2723,2722,2721,2720,2719,2718,2717,2716,2715,2714,2713,2712,2711,2710,2709,2708,2707,2706,2705,2704,2703,2702,2701,2700,2699,2698,2697,2696,2695,2694,2693,2692,2691,2690,2689,2688,2687,2686,2685,2684,2683,2682,2681,2680,2679,2678,2677,2676,2675,2674,2673,2672,2671,2670,2669,2668,2667,2666,2665,2664,2663,2662,2661,2660,2659,2658,2657,2656,2655,2654,2653,2652,2651,2650,2649,2648,2647,2646,2645,2644,2643,2642,2641,2640,2639,2638,2637,2636,2635,2634,2633,2632,2631,2630,2629,2628,2627,2626,2625,2624,2623,2622,2621,2620,2619,2618,2617,2616,2615,2614,2613,2612,2611,2610,2609,2608,2607,2606,2605,2604,2603,2602,2601,2600,2599,2598,2597,2596,2595,2594,2593,2592,2591,2590,2589,2588,2587,2586,2585,2584,2583,2582,2581,2580,2579,2578,2577,2576,2575,2574,2573,2572,2571,2570,2569,2568,2567,2566,2565,2564,2563,2562,2561,2560,2559,2558,2557,2556,2555,2554,2553,2552,2551,2550,2549,2548,2547,2546,2545,2544,2543,2542,2541,2540,2539,2538,2537,2536,2535,2534,2533,2532,2531,2530,2529,2528,2527,2526,2525,2524,2523,2522,2521,2520,2519,2518,2517,2516,2515,2514,2513,2512,2511,2510,2509,2508,2507,2506,2505,2504,2503,2502,2501,2500,2499,2498,2497,2496,2495,2494,2493,2492,2491,2490,2489,2488,2487,2486,2485,2484,2483,2482,2481,2480,2479,2478,2477,2476,2475,2474,2473,2472,2471,2470,2469,2468,2467,2466,2465,2464,2463,2462,2461,2460,2459,2458,2457,2456,2455,2454,2453,2452,2451,2450,2449,2448,2447,2446,2445,2444,2443,2442,2441,2440,2439,2438,2437,2436,2435,2434,2433,2432,2431,2430,2429,2428,2427,2426,2425,2424,2423,2422,2421,2420,2419,2418,2417,2416,2415,2414,2413,2412,2411,2410,2409,2408,2407,2406,2405,2404,2403,2402,2401,2400,2399,2398,2397,2396,2395,2394,2393,2392,2391,2390,2389,2388,2387,2386,2385,2384,2383,2382,2381,2380,2379,2378,2377,2376,2375,2374,2373,2372,2371,2370,2369,2368,2367,2366,2365,2364,2363,2362,2361,2360,2359,2358,2357,2356,2355,2354,2353,2352,2351,2350,2349,2348,2347,2346,2345,2344,2343,2342,2341,2340,2339,2338,2337,2336,2335,2334,2333,2332,2331,2330,2329,2328,2327,2326,2325,2324,2323,2322,2321,2320,2319,2318,2317,2316,2315,2314,2313,2312,2311,2310,2309,2308,2307,2306,2305,2304,2303,2302,2301,2300,2299,2298,2297,2296,2295,2294,2293,2292,2291,2290,2289,2288,2287,2286,2285,2284,2283,2282,2281,2280,2279,2278,2277,2276,2275,2274,2273,2272,2271,2270,2269,2268,2267,2266,2265,2264,2263,2262,2261,2260,2259,2258,2257,2256,2255,2254,2253,2252,2251,2250,2249,2248,2247,2246,2245,2244,2243,2242,2241,2240,2239,2238,2237,2236,2235,2234,2233,2232,2231,2230,2229,2228,2227,2226,2225,2224,2223,2222,2221,2220,2219,2218,2217,2216,2215,2214,2213,2212,2211,2210,2209,2208,2207,2206,2205,2204,2203,2202,2201,2200,2199,2198,2197,2196,2195,2194,2193,2192,2191,2190,2189,2188,2187,2186,2185,2184,2183,2182,2181,2180,2179,2178,2177,2176,2175,2174,2173,2172,2171,2170,2169,2168,2167,2166,2165,2164,2163,2162,2161,2160,2159,2158,2157,2156,2155,2154,2153,2152,2151,2150,2149,2148,2147,2146,2145,2144,2143,2142,2141,2140,2139,2138,2137,2136,2135,2134,2133,2132,2131,2130,2129,2128,2127,2126,2125,2124,2123,2122,2121,2120,2119,2118,2117,2116,2115,2114,2113,2112,2111,2110,2109,2108,2107,2106,2105,2104,2103,2102,2101,2100,2099,2098,2097,2096,2095,2094,2093,2092,2091,2090,2089,2088,2087,2086,2085,2084,2083,2082,2081,2080,2079,2078,2077,2076,2075,2074,2073,2072,2071,2070,2069,2068,2067,2066,2065,2064,2063,2062,2061,2060,2059,2058,2057,2056,2055,2054,2053,2052,2051,2050,2049,2048,2047,2046,2045,2044,2043,2042,2041,2040,2039,2038,2037,2036,2035,2034,2033,2032,2031,2030,2029,2028,2027,2026,2025,2024,2023,2022,2021,2020,2019,2018,2017,2016,2015,2014,2013,2012,2011,2010,2009,2008,2007,2006,2005,2004,2003,2002,2001,2000,1999,1998,1997,1996,1995,1994,1993,1992,1991,1990,1989,1988,1987,1986,1985,1984,1983,1982,1981,1980,1979,1978,1977,1976,1975,1974,1973,1972,1971,1970,1969,1968,1967,1966,1965,1964,1963,1962,1961,1960,1959,1958,1957,1956,1955,1954,1953,1952,1951,1950,1949,1948,1947,1946,1945,1944,1943,1942,1941,1940,1939,1938,1937,1936,1935,1934,1933,1932,1931,1930,1929,1928,1927,1926,1925,1924,1923,1922,1921,1920,1919,1918,1917,1916,1915,1914,1913,1912,1911,1910,1909,1908,1907,1906,1905,1904,1903,1902,1901,1900,1899,1898,1897,1896,1895,1894,1893,1892,1891,1890,1889,1888,1887,1886,1885,1884,1883,1882,1881,1880,1879,1878,1877,1876,1875,1874,1873,1872,1871,1870,1869,1868,1867,1866,1865,1864,1863,1862,1861,1860,1859,1858,1857,1856,1855,1854,1853,1852,1851,1850,1849,1848,1847,1846,1845,1844,1843,1842,1841,1840,1839,1838,1837,1836,1835,1834,1833,1832,1831,1830,1829,1828,1827,1826,1825,1824,1823,1822,1821,1820,1819,1818,1817,1816,1815,1814,1813,1812,1811,1810,1809,1808,1807,1806,1805,1804,1803,1802,1801,1800,1799,1798,1797,1796,1795,1794,1793,1792,1791,1790,1789,1788,1787,1786,1785,1784,1783,1782,1781,1780,1779,1778,1777,1776,1775,1774,1773,1772,1771,1770,1769,1768,1767,1766,1765,1764,1763,1762,1761,1760,1759,1758,1757,1756,1755,1754,1753,1752,1751,1750,1749,1748,1747,1746,1745,1744,1743,1742,1741,1740,1739,1738,1737,1736,1735,1734,1733,1732,1731,1730,1729,1728,1727,1726,1725,1724,1723,1722,1721,1720,1719,1718,1717,1716,1715,1714,1713,1712,1711,1710,1709,1708,1707,1706,1705,1704,1703,1702,1701,1700,1699,1698,1697,1696,1695,1694,1693,1692,1691,1690,1689,1688,1687,1686,1685,1684,1683,1682,1681,1680,1679,1678,1677,1676,1675,1674,1673,1672,1671,1670,1669,1668,1667,1666,1665,1664,1663,1662,1661,1660,1659,1658,1657,1656,1655,1654,1653,1652,1651,1650,1649,1648,1647,1646,1645,1644,1643,1642,1641,1640,1639,1638,1637,1636,1635,1634,1633,1632,1631,1630,1629,1628,1627,1626,1625,1624,1623,1622,1621,1620,1619,1618,1617,1616,1615,1614,1613,1612,1611,1610,1609,1608,1607,1606,1605,1604,1603,1602,1601,1600,1599,1598,1597,1596,1595,1594,1593,1592,1591,1590,1589,1588,1587,1586,1585,1584,1583,1582,1581,1580,1579,1578,1577,1576,1575,1574,1573,1572,1571,1570,1569,1568,1567,1566,1565,1564,1563,1562,1561,1560,1559,1558,1557,1556,1555,1554,1553,1552,1551,1550,1549,1548,1547,1546,1545,1544,1543,1542,1541,1540,1539,1538,1537,1536,1535,1534,1533,1532,1531,1530,1529,1528,1527,1526,1525,1524,1523,1522,1521,1520,1519,1518,1517,1516,1515,1514,1513,1512,1511,1510,1509,1508,1507,1506,1505,1504,1503,1502,1501,1500,1499,1498,1497,1496,1495,1494,1493,1492,1491,1490,1489,1488,1487,1486,1485,1484,1483,1482,1481,1480,1479,1478,1477,1476,1475,1474,1473,1472,1471,1470,1469,1468,1467,1466,1465,1464,1463,1462,1461,1460,1459,1458,1457,1456,1455,1454,1453,1452,1451,1450,1449,1448,1447,1446,1445,1444,1443,1442,1441,1440,1439,1438,1437,1436,1435,1434,1433,1432,1431,1430,1429,1428,1427,1426,1425,1424,1423,1422,1421,1420,1419,1418,1417,1416,1415,1414,1413,1412,1411,1410,1409,1408,1407,1406,1405,1404,1403,1402,1401,1400,1399,1398,1397,1396,1395,1394,1393,1392,1391,1390,1389,1388,1387,1386,1385,1384,1383,1382,1381,1380,1379,1378,1377,1376,1375,1374,1373,1372,1371,1370,1369,1368,1367,1366,1365,1364,1363,1362,1361,1360,1359,1358,1357,1356,1355,1354,1353,1352,1351,1350,1349,1348,1347,1346,1345,1344,1343,1342,1341,1340,1339,1338,1337,1336,1335,1334,1333,1332,1331,1330,1329,1328,1327,1326,1325,1324,1323,1322,1321,1320,1319,1318,1317,1316,1315,1314,1313,1312,1311,1310,1309,1308,1307,1306,1305,1304,1303,1302,1301,1300,1299,1298,1297,1296,1295,1294,1293,1292,1291,1290,1289,1288,1287,1286,1285,1284,1283,1282,1281,1280,1279,1278,1277,1276,1275,1274,1273,1272,1271,1270,1269,1268,1267,1266,1265,1264,1263,1262,1261,1260,1259,1258,1257,1256,1255,1254,1253,1252,1251,1250,1249,1248,1247,1246,1245,1244,1243,1242,1241,1240,1239,1238,1237,1236,1235,1234,1233,1232,1231,1230,1229,1228,1227,1226,1225,1224,1223,1222,1221,1220,1219,1218,1217,1216,1215,1214,1213,1212,1211,1210,1209,1208,1207,1206,1205,1204,1203,1202,1201,1200,1199,1198,1197,1196,1195,1194,1193,1192,1191,1190,1189,1188,1187,1186,1185,1184,1183,1182,1181,1180,1179,1178,1177,1176,1175,1174,1173,1172,1171,1170,1169,1168,1167,1166,1165,1164,1163,1162,1161,1160,1159,1158,1157,1156,1155,1154,1153,1152,1151,1150,1149,1148,1147,1146,1145,1144,1143,1142,1141,1140,1139,1138,1137,1136,1135,1134,1133,1132,1131,1130,1129,1128,1127,1126,1125,1124,1123,1122,1121,1120,1119,1118,1117,1116,1115,1114,1113,1112,1111,1110,1109,1108,1107,1106,1105,1104,1103,1102,1101,1100,1099,1098,1097,1096,1095,1094,1093,1092,1091,1090,1089,1088,1087,1086,1085,1084,1083,1082,1081,1080,1079,1078,1077,1076,1075,1074,1073,1072,1071,1070,1069,1068,1067,1066,1065,1064,1063,1062,1061,1060,1059,1058,1057,1056,1055,1054,1053,1052,1051,1050,1049,1048,1047,1046,1045,1044,1043,1042,1041,1040,1039,1038,1037,1036,1035,1034,1033,1032,1031,1030,1029,1028,1027,1026,1025,1024,1023,1022,1021,1020,1019,1018,1017,1016,1015,1014,1013,1012,1011,1010,1009,1008,1007,1006,1005,1004,1003,1002,1001,1000,999,998,997,996,995,994,993,992,991,990,989,988,987,986,985,984,983,982,981,980,979,978,977,976,975,974,973,972,971,970,969,968,967,966,965,964,963,962,961,960,959,958,957,956,955,954,953,952,951,950,949,948,947,946,945,944,943,942,941,940,939,938,937,936,935,934,933,932,931,930,929,928,927,926,925,924,923,922,921,920,919,918,917,916,915,914,913,912,911,910,909,908,907,906,905,904,903,902,901,900,899,898,897,896,895,894,893,892,891,890,889,888,887,886,885,884,883,882,881,880,879,878,877,876,875,874,873,872,871,870,869,868,867,866,865,864,863,862,861,860,859,858,857,856,855,854,853,852,851,850,849,848,847,846,845,844,843,842,841,840,839,838,837,836,835,834,833,832,831,830,829,828,827,826,825,824,823,822,821,820,819,818,817,816,815,814,813,812,811,810,809,808,807,806,805,804,803,802,801,800,799,798,797,796,795,794,793,792,791,790,789,788,787,786,785,784,783,782,781,780,779,778,777,776,775,774,773,772,771,770,769,768,767,766,765,764,763,762,761,760,759,758,757,756,755,754,753,752,751,750,749,748,747,746,745,744,743,742,741,740,739,738,737,736,735,734,733,732,731,730,729,728,727,726,725,724,723,722,721,720,719,718,717,716,715,714,713,712,711,710,709,708,707,706,705,704,703,702,701,700,699,698,697,696,695,694,693,692,691,690,689,688,687,686,685,684,683,682,681,680,679,678,677,676,675,674,673,672,671,670,669,668,667,666,665,664,663,662,661,660,659,658,657,656,655,654,653,652,651,650,649,648,647,646,645,644,643,642,641,640,639,638,637,636,635,634,633,632,631,630,629,628,627,626,625,624,623,622,621,620,619,618,617,616,615,614,613,612,611,610,609,608,607,606,605,604,603,602,601,600,599,598,597,596,595,594,593,592,591,590,589,588,587,586,585,584,583,582,581,580,579,578,577,576,575,574,573,572,571,570,569,568,567,566,565,564,563,562,561,560,559,558,557,556,555,554,553,552,551,550,549,548,547,546,545,544,543,542,541,540,539,538,537,536,535,534,533,532,531,530,529,528,527,526,525,524,523,522,521,520,519,518,517,516,515,514,513,512,511,510,509,508,507,506,505,504,503,502,501,500,499,498,497,496,495,494,493,492,491,490,489,488,487,486,485,484,483,482,481,480,479,478,477,476,475,474,473,472,471,470,469,468,467,466,465,464,463,462,461,460,459,458,457,456,455,454,453,452,451,450,449,448,447,446,445,444,443,442,441,440,439,438,437,436,435,434,433,432,431,430,429,428,427,426,425,424,423,422,421,420,419,418,417,416,415,414,413,412,411,410,409,408,407,406,405,404,403,402,401,400,399,398,397,396,395,394,393,392,391,390,389,388,387,386,385,384,383,382,381,380,379,378,377,376,375,374,373,372,371,370,369,368,367,366,365,364,363,362,361,360,359,358,357,356,355,354,353,352,351,350,349,348,347,346,345,344,343,342,341,340,339,338,337,336,335,334,333,332,331,330,329,328,327,326,325,324,323,322,321,320,319,318,317,316,315,314,313,312,311,310,309,308,307,306,305,304,303,302,301,300,299,298,297,296,295,294,293,292,291,290,289,288,287,286,285,284,283,282,281,280,279,278,277,276,275,274,273,272,271,270,269,268,267,266,265,264,263,262,261,260,259,258,257,256,255,254,253,252,251,250,249,248,247,246,245,244,243,242,241,240,239,238,237,236,235,234,233,232,231,230,229,228,227,226,225,224,223,222,221,220,219,218,217,216,215,214,213,212,211,210,209,208,207,206,205,204,203,202,201,200,199,198,197,196,195,194,193,192,191,190,189,188,187,186,185,184,183,182,181,180,179,178,177,176,175,174,173,172,171,170,169,168,167,166,165,164,163,162,161,160,159,158,157,156,155,154,153,152,151,150,149,148,147,146,145,144,143,142,141,140,139,138,137,136,135,134,133,132,131,130,129,128,127,126,125,124,123,122,121,120,119,118,117,116,115,114,113,112,111,110,109,108,107,106,105,104,103,102,101,100,99,98,97,96,95,94,93,92,91,90,89,88,87,86,85,84,83,82,81,80,79,78,77,76,75,74,73,72,71,70,69,68,67,66,65,64,63,62,61,60,59,58,57,56,55,54,53,52,51,50,49,48,47,46,45,44,43,42,41,40,39,38,37,36,35,34,33,32,31,30,29,28,27,26,25,24,23,22,21,20,19,18,17,16,15,14,13,12,11,10,9,8,7,6,5,4,3,2,1 \ No newline at end of file diff --git a/Leet Code/Convert Sorted Array to Binary Search Tree/Convert Sorted Array to Binary Search Tree.cpp b/Leet Code/Convert Sorted Array to Binary Search Tree/Convert Sorted Array to Binary Search Tree.cpp new file mode 100644 index 00000000..505edd42 --- /dev/null +++ b/Leet Code/Convert Sorted Array to Binary Search Tree/Convert Sorted Array to Binary Search Tree.cpp @@ -0,0 +1,41 @@ +#include "../+Helper/BinaryTree.h" +#include +using namespace std; + +class Solution { +public: + TreeNode *insertData(TreeNode *root, int data){ + TreeNode *node = new TreeNode(data); + while(root){ + if(data > root->val){ + if(root->right){ + root = root->right; + }else{ + root->right = node; + root = NULL; + } + }else{ + if(root->left){ + root = root->left; + }else{ + root->left = node; + root = NULL; + } + } + } + return node; + } + + TreeNode *recursiveInsert(TreeNode *root, vector &num, int L, int R){ + if(L >= R) return NULL; + int mid = (L + R) / 2; + TreeNode *node = insertData(root, num[mid]); + recursiveInsert(node, num, L, mid); + recursiveInsert(node, num, mid + 1, R); + return node; + } + + TreeNode *sortedArrayToBST(vector &num) { + return recursiveInsert(NULL, num, 0, num.size()); + } +}; \ No newline at end of file diff --git a/Leet Code/Convert Sorted Array to Binary Search Tree/Main.cpp b/Leet Code/Convert Sorted Array to Binary Search Tree/Main.cpp new file mode 100644 index 00000000..c5f1093e --- /dev/null +++ b/Leet Code/Convert Sorted Array to Binary Search Tree/Main.cpp @@ -0,0 +1,21 @@ +#include +using namespace std; +#include +#include +#include "../+Helper/Helper.h" +#include "Convert Sorted Array to Binary Search Tree.cpp" + +int main(){ + freopen("in.txt", "r", stdin); + CLK_INIT; + Solution s; + CASET{ + vector v = scanVector(); + PRINTCASE; + CLK_START; + cout << serialize(s.sortedArrayToBST(v)) << endl; + CLK_END; + } + + return 0; +} \ No newline at end of file diff --git a/Leet Code/Convert Sorted Array to Binary Search Tree/in.txt b/Leet Code/Convert Sorted Array to Binary Search Tree/in.txt new file mode 100644 index 00000000..69bd9385 --- /dev/null +++ b/Leet Code/Convert Sorted Array to Binary Search Tree/in.txt @@ -0,0 +1,2 @@ +1 +0,1,2,3,4,5 \ No newline at end of file diff --git a/Leet Code/Convert Sorted List to Binary Search Tree/Convert Sorted List to Binary Search Tree.cpp b/Leet Code/Convert Sorted List to Binary Search Tree/Convert Sorted List to Binary Search Tree.cpp new file mode 100644 index 00000000..ba08c750 --- /dev/null +++ b/Leet Code/Convert Sorted List to Binary Search Tree/Convert Sorted List to Binary Search Tree.cpp @@ -0,0 +1,58 @@ +#include "../+Helper/SinglyLinkedList.h" +#include "../+Helper/BinaryTree.h" +#include +using namespace std; + +class Solution { +public: + ListNode* getListNodeByIndex(ListNode *head, int index){ + while(head && index-- > 0){ + head = head->next; + } + return head; + } + + int listLength(ListNode *head){ + int len = 0; + while(head){ + head = head->next; len++; + } + return len; + } + + TreeNode *insertData(TreeNode *root, int data){ + TreeNode *node = new TreeNode(data); + while(root){ + if(data > root->val){ + if(root->right){ + root = root->right; + }else{ + root->right = node; + root = NULL; + } + }else{ + if(root->left){ + root = root->left; + }else{ + root->left = node; + root = NULL; + } + } + } + return node; + } + + TreeNode *recursiveInsert(TreeNode *root, ListNode *head, int len){ + if(!head || !len) return NULL; + int mid = len / 2; + ListNode *dataNode = getListNodeByIndex(head, mid); + TreeNode *node = insertData(root, dataNode->val); + recursiveInsert(node, head, mid); + recursiveInsert(node, dataNode->next, len - mid - 1); + return node; + } + + TreeNode *sortedListToBST(ListNode *head) { + return recursiveInsert(NULL, head, listLength(head)); + } +}; \ No newline at end of file diff --git a/Leet Code/Convert Sorted List to Binary Search Tree/Main.cpp b/Leet Code/Convert Sorted List to Binary Search Tree/Main.cpp new file mode 100644 index 00000000..b34ffa91 --- /dev/null +++ b/Leet Code/Convert Sorted List to Binary Search Tree/Main.cpp @@ -0,0 +1,23 @@ +#include +using namespace std; +#include +#include +#include "../+Helper/Helper.h" +#include "../+Helper/SinglyLinkedList.h" +#include "Convert Sorted List to Binary Search Tree.cpp" + +int main(){ + freopen("in.txt", "r", stdin); + CLK_INIT; + Solution s; + CASET{ + vector v = scanVector(); + ListNode *head = vectorToList(v); + PRINTCASE; + CLK_START; + cout << serialize(s.sortedListToBST(head)) << endl; + CLK_END; + } + + return 0; +} \ No newline at end of file diff --git a/Leet Code/Convert Sorted List to Binary Search Tree/in.txt b/Leet Code/Convert Sorted List to Binary Search Tree/in.txt new file mode 100644 index 00000000..d9d5a4b6 --- /dev/null +++ b/Leet Code/Convert Sorted List to Binary Search Tree/in.txt @@ -0,0 +1,3 @@ +2 +0,1,2,3,4,5 +-1,0,1,2 \ No newline at end of file diff --git a/Leet Code/Copy List with Random Pointer/Copy List with Random Pointer - TLE.cpp b/Leet Code/Copy List with Random Pointer/Copy List with Random Pointer - TLE.cpp new file mode 100644 index 00000000..6ea0ee6a --- /dev/null +++ b/Leet Code/Copy List with Random Pointer/Copy List with Random Pointer - TLE.cpp @@ -0,0 +1,43 @@ +/** + * Definition for singly-linked list with a random pointer. + * struct RandomListNode { + * int label; + * RandomListNode *next, *random; + * RandomListNode(int x) : label(x), next(NULL), random(NULL) {} + * }; + */ +class Solution { +public: + RandomListNode *copyRandomList(RandomListNode *head) { + if(!head) return NULL; + RandomListNode *new_head, *p, *q, *prev, *r, *s; + p = head; + new_head = new RandomListNode(p->label); + prev = new_head; + p = p->next; + while(p){ + q = new RandomListNode(p->label); + prev->next = q; + p = p->next; + prev = q; + } + p = head; + q = new_head; + while(p){ + if(p->random){ + r = head; + s = new_head; + while(r != p->random){ + r = r->next; + s = s->next; + } + q->random = s; + }else{ + q->random = NULL; + } + p = p->next; + q = q->next; + } + return new_head; + } +}; \ No newline at end of file diff --git a/Leet Code/Copy List with Random Pointer/Copy List with Random Pointer.cpp b/Leet Code/Copy List with Random Pointer/Copy List with Random Pointer.cpp new file mode 100644 index 00000000..384a2f09 --- /dev/null +++ b/Leet Code/Copy List with Random Pointer/Copy List with Random Pointer.cpp @@ -0,0 +1,39 @@ +/** + * Definition for singly-linked list with a random pointer. + * struct RandomListNode { + * int label; + * RandomListNode *next, *random; + * RandomListNode(int x) : label(x), next(NULL), random(NULL) {} + * }; + */ + #include + using namespace std; + +class Solution { +public: + RandomListNode *copyRandomList(RandomListNode *head) { + if(!head) return NULL; + RandomListNode *new_head, *p, *q, *prev; + map m; + m[NULL] = NULL; + new_head = new RandomListNode(head->label); + m[head] = new_head; + p = head->next; + prev = new_head; + while(p){ + q = new RandomListNode(p->label); + m[p] = q; + prev->next = q; + prev = q; + p = p->next; + } + p = head; + q = new_head; + while(p){ + q->random = m[p->random]; + p = p->next; + q = q->next; + } + return new_head; + } +}; \ No newline at end of file diff --git a/Leet Code/Count and Say/Count and Say.cpp b/Leet Code/Count and Say/Count and Say.cpp new file mode 100644 index 00000000..a3241f97 --- /dev/null +++ b/Leet Code/Count and Say/Count and Say.cpp @@ -0,0 +1,26 @@ +#include +using namespace std; +#include + +class Solution { +public: + string countAndSay(int n) { + string in = "1"; + char buf[100000] = {0}, *p = NULL; + while(--n > 0){ + p = buf; + string::iterator i = in.begin(); + while(i != in.end()){ + int cnt = 1; + char c = *i++; + while(i != in.end() && *i == c){ + i++; + cnt++; + } + p += sprintf(p, "%d%c", cnt, c); + } + in = string(buf); + } + return in; + } +}; \ No newline at end of file diff --git a/Leet Code/Count and Say/Main.cpp b/Leet Code/Count and Say/Main.cpp new file mode 100644 index 00000000..5fafacea --- /dev/null +++ b/Leet Code/Count and Say/Main.cpp @@ -0,0 +1,22 @@ +#include +using namespace std; +#include +#include +#include "../+Helper/Helper.h" +#include "Count and Say.cpp" + +int main(){ + freopen("in.txt", "r", stdin); + CLK_INIT; + Solution s; + CASET{ + int n; + cin >> n; + PRINTCASE; + CLK_START; + cout << s.countAndSay(n) << endl; + CLK_END; + } + + return 0; +} \ No newline at end of file diff --git a/Leet Code/Count and Say/in.txt b/Leet Code/Count and Say/in.txt new file mode 100644 index 00000000..ddc1f024 --- /dev/null +++ b/Leet Code/Count and Say/in.txt @@ -0,0 +1,6 @@ +5 +1 +2 +3 +4 +5 \ No newline at end of file diff --git a/Leet Code/Divide Two Integers/Divide Two Integers.h b/Leet Code/Divide Two Integers/Divide Two Integers.h new file mode 100644 index 00000000..3663abbb --- /dev/null +++ b/Leet Code/Divide Two Integers/Divide Two Integers.h @@ -0,0 +1,27 @@ +#define INT_MAX ((int)((unsigned)~0 >> 1)) +#define INT_MIN ((int)~INT_MAX) + +class Solution { +public: + int divide(int dividend, int divisor) { + if(!divisor) return 0; // divide-by-zero error + bool pos1 = dividend > 0, pos2 = divisor > 0, pos = !(pos1^pos2); + if(pos1) dividend = -dividend; + if(pos2) divisor = -divisor; + int q = 0, d = divisor, t = 1; + while(t > 0){ + if(dividend - d <= 0){ + dividend -= d; + q += t; + if((INT_MIN >> 1) < d){ + t <<= 1; + d <<= 1; + } + }else{ + d >>= 1; + t >>= 1; + } + } + return pos? q : -q; + } +}; \ No newline at end of file diff --git a/Leet Code/Divide Two Integers/Main.cpp b/Leet Code/Divide Two Integers/Main.cpp new file mode 100644 index 00000000..bc233e9d --- /dev/null +++ b/Leet Code/Divide Two Integers/Main.cpp @@ -0,0 +1,18 @@ +#include +#include +using namespace std; +#include "../+Helper/Helper.h" +#include "Divide Two Integers.h" + +int main(){ + freopen("in.txt", "r", stdin); + Solution s; + cout << ((int)-2147483648) << endl; + CASET{ + int a, b; + cin >> a >> b; + PRINTCASE; + cout << s.divide(a, b) << endl; + } + return 0; +} \ No newline at end of file diff --git a/Leet Code/Divide Two Integers/in.txt b/Leet Code/Divide Two Integers/in.txt new file mode 100644 index 00000000..7ce08452 --- /dev/null +++ b/Leet Code/Divide Two Integers/in.txt @@ -0,0 +1,15 @@ +14 +0 0 +0 1 +1 0 +1 1 +-2147483648 1 +-2147483648 -2147483648 +8 3 +8 -3 +-8 3 +-8 -3 +2147483647 2 +2147483647 -2 +-2147483647 2 +-2147483647 -2 \ No newline at end of file diff --git a/Leet Code/Flatten Binary Tree to Linked List/Flatten Binary Tree to Linked List.h b/Leet Code/Flatten Binary Tree to Linked List/Flatten Binary Tree to Linked List.h new file mode 100644 index 00000000..c07f1419 --- /dev/null +++ b/Leet Code/Flatten Binary Tree to Linked List/Flatten Binary Tree to Linked List.h @@ -0,0 +1,23 @@ +#include "../+Helper/BinaryTree.h" +#include + +class Solution { +public: + void flatten(TreeNode *root) { + if(!root) return; + TreeNode *pnode = NULL; + stack s; + s.push(root); + while(!s.empty()){ + root = s.top(); s.pop(); + if(pnode){ + pnode->left = NULL; + pnode->right = root; + } + if(root->right) s.push(root->right); + if(root->left) s.push(root->left); + pnode = root; + } + pnode->left = pnode->right = NULL; + } +}; \ No newline at end of file diff --git a/Leet Code/Flatten Binary Tree to Linked List/Main.cpp b/Leet Code/Flatten Binary Tree to Linked List/Main.cpp new file mode 100644 index 00000000..1235e962 --- /dev/null +++ b/Leet Code/Flatten Binary Tree to Linked List/Main.cpp @@ -0,0 +1,24 @@ +#include +using namespace std; +#include +#include +#include "../+Helper/Helper.h" +#include "Flatten Binary Tree to Linked List.h" + +int main(){ + freopen("in.txt", "r", stdin); + CLK_INIT; + Solution s; + CASET{ + string str; + cin >> str; + TreeNode *root = deserialize(str); + PRINTCASE; + CLK_START; + s.flatten(root); + cout << serialize(root) << endl; + CLK_END; + } + + return 0; +} \ No newline at end of file diff --git a/Leet Code/Flatten Binary Tree to Linked List/in.txt b/Leet Code/Flatten Binary Tree to Linked List/in.txt new file mode 100644 index 00000000..9f54175c --- /dev/null +++ b/Leet Code/Flatten Binary Tree to Linked List/in.txt @@ -0,0 +1,3 @@ +2 +3,9,20,#,#,15,7 +1,2,3,#,#,4,#,#,5 \ No newline at end of file diff --git a/Leet Code/Gray Code/Gray Code - 1.cpp b/Leet Code/Gray Code/Gray Code - 1.cpp new file mode 100644 index 00000000..ce83eadf --- /dev/null +++ b/Leet Code/Gray Code/Gray Code - 1.cpp @@ -0,0 +1,36 @@ +#include +using namespace std; + +#define TOGGLE(val, n) ((val) ^ (1 << n)) +class Solution { +public: + vector grayCode(int n) { + vector v; + if(n < 0) return v; + int b = 0, val = 0; + v.push_back(val); + while(b < n){ + int cnt = 1 << b, p = 0; + val = TOGGLE(val, b); + v.push_back(val); + bool l2r = false; + while(-- cnt > 0){ + val = TOGGLE(val, p); + v.push_back(val); + if(l2r){ + if(p > 0) p--; + else{ + p++; l2r = false; + } + }else{ + if(p < b - 1) p++; + else{ + p--; l2r = true; + } + } + } + b++; + } + return v; + } +}; \ No newline at end of file diff --git a/Leet Code/Gray Code/Gray Code - 2.cpp b/Leet Code/Gray Code/Gray Code - 2.cpp new file mode 100644 index 00000000..aab018f2 --- /dev/null +++ b/Leet Code/Gray Code/Gray Code - 2.cpp @@ -0,0 +1,21 @@ +#include +using namespace std; + +#define TOGGLE(val, n) ((val) ^ (1 << n)) +class Solution { +public: + int grayCode(int n, int val, vector &v){ + if(n < 0) return val; + val = grayCode(n - 1, val, v); + val = TOGGLE(val, n); + v.push_back(val); + return grayCode(n - 1, val, v); + } + vector grayCode(int n) { + vector v; + if(n < 0) return v; + v.push_back(0); + grayCode(n - 1, 0, v); + return v; + } +}; \ No newline at end of file diff --git a/Leet Code/Gray Code/Gray Code - 3.cpp b/Leet Code/Gray Code/Gray Code - 3.cpp new file mode 100644 index 00000000..a4bbfe2c --- /dev/null +++ b/Leet Code/Gray Code/Gray Code - 3.cpp @@ -0,0 +1,22 @@ +#include +using namespace std; + +#define TOGGLE(val, n) ((val) ^ (1 << n)) +class Solution { +public: + void grayCode(int n, int &val, vector &v){ + if(n < 0) return; + grayCode(n - 1, val, v); + val = TOGGLE(val, n); + v.push_back(val); + grayCode(n - 1, val, v); + } + vector grayCode(int n) { + vector v; + if(n < 0) return v; + int val = 0; + v.push_back(val); + grayCode(n - 1, val, v); + return v; + } +}; \ No newline at end of file diff --git a/Leet Code/Gray Code/Gray Code.cpp b/Leet Code/Gray Code/Gray Code.cpp new file mode 100644 index 00000000..12cc7685 --- /dev/null +++ b/Leet Code/Gray Code/Gray Code.cpp @@ -0,0 +1,34 @@ +#include +using namespace std; + +#define TOGGLE(val, n) ((val) ^ (1 << n)) +class Solution { +public: + vector grayCode(int n) { + vector v; + if(n < 0) return v; + int b = 0, val = 0; + v.push_back(val); + while(b < n){ + int cnt = 1 << b, p = b; + bool l2r = true; + while(cnt -- > 0){ + val = TOGGLE(val, p); + v.push_back(val); + if(l2r){ + if(p > 0) p--; + else{ + p++; l2r = false; + } + }else{ + if(p < b - 1) p++; + else{ + p--; l2r = true; + } + } + } + b++; + } + return v; + } +}; \ No newline at end of file diff --git a/Leet Code/Gray Code/Main.cpp b/Leet Code/Gray Code/Main.cpp new file mode 100644 index 00000000..5305cfe7 --- /dev/null +++ b/Leet Code/Gray Code/Main.cpp @@ -0,0 +1,22 @@ +#include +using namespace std; +#include +#include +#include "../+Helper/Helper.h" +#include "Gray Code - 3.cpp" + +int main(){ + freopen("in.txt", "r", stdin); + CLK_INIT; + Solution s; + CASET{ + int n; + cin >> n; + PRINTCASE; + CLK_START; + printVector(s.grayCode(n)); + CLK_END; + } + + return 0; +} \ No newline at end of file diff --git a/Leet Code/Gray Code/in.txt b/Leet Code/Gray Code/in.txt new file mode 100644 index 00000000..af8e8c13 --- /dev/null +++ b/Leet Code/Gray Code/in.txt @@ -0,0 +1,6 @@ +5 +0 +1 +2 +3 +4 \ No newline at end of file diff --git a/Leet Code/Implement strStr()/Implement strStr().cpp b/Leet Code/Implement strStr()/Implement strStr().cpp new file mode 100644 index 00000000..531e39ac --- /dev/null +++ b/Leet Code/Implement strStr()/Implement strStr().cpp @@ -0,0 +1,18 @@ +class Solution { +public: + char *strStr(char *haystack, char *needle) { + while(true){ + char *p = haystack, *q = needle; + while(*p && *q && *p == *q){ + p++; q++; + } + if(!*q){ + return haystack; + }else if(*p){ + haystack++; + }else{ + return NULL; + } + } + } +}; \ No newline at end of file diff --git a/Leet Code/Implement strStr()/Main.cpp b/Leet Code/Implement strStr()/Main.cpp new file mode 100644 index 00000000..95ffc791 --- /dev/null +++ b/Leet Code/Implement strStr()/Main.cpp @@ -0,0 +1,24 @@ +#include +using namespace std; +#include +#include +#include "../+Helper/Helper.h" +#include "Implement strStr().cpp" + +int main(){ + freopen("in.txt", "r", stdin); + CLK_INIT; + Solution s; + char c = '\0'; + cout << "Case #0: " << boolalpha << (s.strStr(&c, &c) != NULL) << endl; + CASET{ + string a, b; + cin >> a >> b; + PRINTCASE; + CLK_START; + cout << boolalpha << (s.strStr((char*)a.c_str(), (char*)b.c_str()) != NULL) << endl; + CLK_END; + } + + return 0; +} \ No newline at end of file diff --git a/Leet Code/Implement strStr()/in.txt b/Leet Code/Implement strStr()/in.txt new file mode 100644 index 00000000..08c55b1b --- /dev/null +++ b/Leet Code/Implement strStr()/in.txt @@ -0,0 +1,4 @@ +2 +123 2 +aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaab diff --git a/Leet Code/Insertion Sort List/Insertion Sort List.cpp b/Leet Code/Insertion Sort List/Insertion Sort List.cpp new file mode 100644 index 00000000..f24dcc60 --- /dev/null +++ b/Leet Code/Insertion Sort List/Insertion Sort List.cpp @@ -0,0 +1,25 @@ +#include "../+Helper/SinglyLinkedList.h" + +class Solution { +public: + ListNode *insertionSortList(ListNode *head) { + if(!head) return NULL; + ListNode *ret = NULL, n = NULL, prev = NULL, p = NULL; + while(head){ + n = head; head = head->next; + prev = NULL; p = ret; + while(p && n->val > p->val){ + prev = p; p = p->next; + } + if(prev){ + prev->next = n; + }else{ + ret = prev; + } + if(p){ + n->next = p; + } + } + return ret; + } +}; \ No newline at end of file diff --git a/Leet Code/Integer to Roman/Integer to Roman - 1.h b/Leet Code/Integer to Roman/Integer to Roman - 1.h new file mode 100644 index 00000000..7576139b --- /dev/null +++ b/Leet Code/Integer to Roman/Integer to Roman - 1.h @@ -0,0 +1,33 @@ +#include +using namespace std; +// Input is guaranteed to be within the range from 1 to 3999. +class Solution { +public: + string intToRoman(int num) { + string ret; + char d[] = "--MDCLXVI"; + char *p = d, d1, d5, d10; + int a, b, base = 1000; + while(num){ + d10 = *p++; + d5 = *p++; + d1 = *p; + a = num / base; + b = a % 5; + if(b < 4){ + if(a >= 5) ret += d5; + for(int i = 0; i < b; ++i) ret += d1; + }else{ + ret += d1; + if(a == 9){ + ret += d10; + }else{ + ret += d5; + } + } + num -= a * base; + base /= 10; + } + return ret; + } +}; \ No newline at end of file diff --git a/Leet Code/Integer to Roman/Integer to Roman.h b/Leet Code/Integer to Roman/Integer to Roman.h new file mode 100644 index 00000000..bf93cf03 --- /dev/null +++ b/Leet Code/Integer to Roman/Integer to Roman.h @@ -0,0 +1,33 @@ +#include +using namespace std; +// Input is guaranteed to be within the range from 1 to 3999. +class Solution { +public: + string intToRoman(int num) { + string ret; + char d[] = "IVXLCDM"; + char *p = d, d1, d5, d10; + int a, b; + while(num){ + d1 = *p++; + d5 = *p++; + d10 = *p; + a = num % 10; + b = a % 5; + if(b < 4){ + for(int i = 0; i < b; ++i) ret += d1; + if(a >= 5) ret += d5; + }else{ + if(a == 9){ + ret += d10; + }else{ + ret += d5; + } + ret += d1; + } + num /= 10; + } + reverse(ret.begin(), ret.end()); + return ret; + } +}; \ No newline at end of file diff --git a/Leet Code/Integer to Roman/Main.cpp b/Leet Code/Integer to Roman/Main.cpp new file mode 100644 index 00000000..0b05504b --- /dev/null +++ b/Leet Code/Integer to Roman/Main.cpp @@ -0,0 +1,17 @@ +#include +#include +using namespace std; +#include "../+Helper/Helper.h" +#include "Integer to Roman - 1.h" + +int main(){ + freopen("in.txt", "r", stdin); + Solution s; + CASET{ + int n; + cin >> n; + PRINTCASE; + cout << s.intToRoman(n) << endl; + } + return 0; +} \ No newline at end of file diff --git a/Leet Code/Integer to Roman/in.txt b/Leet Code/Integer to Roman/in.txt new file mode 100644 index 00000000..c893c475 --- /dev/null +++ b/Leet Code/Integer to Roman/in.txt @@ -0,0 +1,15 @@ +14 +1000 +4 +5 +9 +19 +49 +99 +999 +8 +88 +888 +1888 +1990 +3999 \ No newline at end of file diff --git a/Leet Code/Interleaving String/Interleaving String.cpp b/Leet Code/Interleaving String/Interleaving String.cpp new file mode 100644 index 00000000..8bd576dd --- /dev/null +++ b/Leet Code/Interleaving String/Interleaving String.cpp @@ -0,0 +1,129 @@ +#include +#include +using namespace std; + +void print_vector(vector v){ + vector::iterator i = v.begin(); + for(; i != v.end(); ++i){ + cout << *i << " "; + } + cout< v; + string::iterator i1, i2, i3; + i1 = s1.begin(); + i2 = s2.begin(); + i3 = s3.begin(); + v.push_back(1); + while(!v.empty() && i3 != s3.end()){ + if(v.back() == 1){ + if(i1 != s1.end() && *i1 == *i3){ + i1++; i3++; + v.push_back(1); + }else{ + v.back() = 2; + } + }else{ + if(i2 != s2.end() && *i2 == *i3){ + i2++; i3++; + v.push_back(1); + }else{ + v.pop_back(); + while(!v.empty() && v.back() == 2){ + i2--; i3--; + v.pop_back(); + } + if(!v.empty()){ + i1--; i3--; + v.back() = 2; + } + } + } + } + return i1 == s1.end() && i2 == s2.end() && i3 == s3.end(); + } +}; + +int main(){ + string s1, s2, s3; + s1 = "aabcc"; + s2 = "dbbca"; + // s3 = "aadbbcbcac"; // true + // s3 = "aadbbbaccc"; // false + + s1 = "bbbbbabbbbabaababaaaabbababbaaabbabbaaabaaaaababbbababbbbbabbbbababbabaabababbbaabababababbbaaababaa"; + s2 = "babaaaabbababbbabbbbaabaabbaabbbbaabaaabaababaaaabaaabbaaabaaaabaabaabbbbbbbbbbbabaaabbababbabbabaab"; + s3 = "babbbabbbaaabbababbbbababaabbabaabaaabbbbabbbaaabbbaaaaabbbbaabbaaabababbaaaaaabababbababaababbababbbababbbbaaaabaabbabbaaaaabbabbaaaabbbaabaaabaababaababbaaabbbbbabbbbaabbabaabbbbabaaabbababbabbabbab"; + Solution s; + cout << boolalpha << s.isInterleave(s1, s2, s3) << endl; + return 0; +} + + +/* + +class Solution { +public: + bool isInterleave(string s1, string s2, string s3) { + int a, b, c, i, j; + a = b = c = 0; + while(s1[a] && s2[b] && s3[c]){ + i = a; j = b; + if(s1[i] != s3[c] && s2[j] != s3[c]){ + return false; + }else{ + while(s1[i] && s2[j] && s3[c] && + s1[i] == s3[c] && s2[j] == s3[c]){ + i++; j++; c++; + } + if(s1[i] && s3[c] && s1[i] == s3[c]){ + a = i + 1; c++; + }else if(s2[j] && s3[c] && s2[j] == s3[c]){ + b = j + 1; c++; + } + } + } + if(s1[a] == s3[c]){ + while(s1[a] && s3[c] && s1[a] == s3[c]){ + a++; c++; + } + }else{ + while(s2[b] && s3[c] && s2[b] == s3[c]){ + b++; c++; + } + } + return !s1[a] && !s2[b] && !s3[c]; + } +}; + +*/ + +/* + +class Solution { +public: + bool isInterleave(string s1, string s2, string s3) { + stack s; + string::iterator i1, i2, i3; + i1 = s1.begin(); + i2 = s2.begin(); + i3 = s3.begin(); + while(i1 != s1.end() && i2 != s2.end() && i3 != s3.end()){ + if(*i1 != *i3 && *i2 != *i3){ + return false; + }else if(*i1 == *i3 && *i2 == *i3){ + + }else if(*i1 == *i3){ + i1++; i3++; + }else{ + i2++; i3++; + } + } + return true; + } +}; + +*/ \ No newline at end of file diff --git a/Leet Code/Length of Last Word/Length of Last Word.cpp b/Leet Code/Length of Last Word/Length of Last Word.cpp new file mode 100644 index 00000000..2d6542d9 --- /dev/null +++ b/Leet Code/Length of Last Word/Length of Last Word.cpp @@ -0,0 +1,17 @@ +#define SKIP_SPACE(s) while(*s == ' ') s++; +#define SKIP_NON_SPACE(s) while(*s && *s != ' ') s++; +class Solution { +public: + int lengthOfLastWord(const char *s) { + if(!s) return 0; + char *begin = NULL, *end = NULL, *p = (char*)s; + SKIP_SPACE(p); + while(*p){ + end = begin = p; + SKIP_NON_SPACE(end); + p = end; + SKIP_SPACE(p); + } + return (end - begin) / sizeof(char); + } +}; \ No newline at end of file diff --git a/Leet Code/Linked List Cycle II/Linked List Cycle II.cpp b/Leet Code/Linked List Cycle II/Linked List Cycle II.cpp new file mode 100644 index 00000000..93d8874f --- /dev/null +++ b/Leet Code/Linked List Cycle II/Linked List Cycle II.cpp @@ -0,0 +1,28 @@ +/** + * Definition for singly-linked list. + * struct ListNode { + * int val; + * ListNode *next; + * ListNode(int x) : val(x), next(NULL) {} + * }; + */ +class Solution { +public: + ListNode *detectCycle(ListNode *head) { + if(!head) return NULL; + ListNode *p, *q; + p = q = head; + while(q && q->next){ + p = p->next; + q = q->next->next; + if(p == q) break; + } + if(!q || !q->next) return NULL; + q = head; + while(p != q){ + p = p->next; + q = q->next; + } + return p; + } +}; \ No newline at end of file diff --git a/Leet Code/Linked List Cycle/Linked List Cycle.cpp b/Leet Code/Linked List Cycle/Linked List Cycle.cpp new file mode 100644 index 00000000..402c6f54 --- /dev/null +++ b/Leet Code/Linked List Cycle/Linked List Cycle.cpp @@ -0,0 +1,22 @@ +/** + * Definition for singly-linked list. + * struct ListNode { + * int val; + * ListNode *next; + * ListNode(int x) : val(x), next(NULL) {} + * }; + */ +class Solution { +public: + bool hasCycle(ListNode *head) { + if(!head) return false; + ListNode *p, *q; + p = q = head; + while(q && q->next){ + p = p->next; + q = q->next->next; + if(p == q) return true; + } + return false; + } +}; \ No newline at end of file diff --git a/Leet Code/Longest Common Prefix/Longest Common Prefix.cpp b/Leet Code/Longest Common Prefix/Longest Common Prefix.cpp new file mode 100644 index 00000000..374426c2 --- /dev/null +++ b/Leet Code/Longest Common Prefix/Longest Common Prefix.cpp @@ -0,0 +1,21 @@ +#include +#include +using namespace std; + +class Solution { +public: + string longestCommonPrefix(vector &strs) { + int size = strs.size(); + if(size == 0) return ""; + if(size == 1) return strs[0]; + int cnt = 0; + while(true){ + for(int i = 1; i < size; ++i){ + if(!strs[i][cnt] || strs[i][cnt] != strs[0][cnt]){ + return string(strs[0], 0, cnt); + } + } + cnt++; + } + } +}; \ No newline at end of file diff --git a/Leet Code/Longest Common Prefix/M.cpp b/Leet Code/Longest Common Prefix/M.cpp new file mode 100644 index 00000000..945a7605 --- /dev/null +++ b/Leet Code/Longest Common Prefix/M.cpp @@ -0,0 +1,12 @@ +#include +#include +#include +using namespace std; + +int main(){ + string s = "123456"; + cout << string("123456", 3) << endl; + cout << string(s, 3) << endl; + cout << string(s.c_str(), 3) << endl; + return 0; +} \ No newline at end of file diff --git a/Leet Code/Longest Common Prefix/Main.cpp b/Leet Code/Longest Common Prefix/Main.cpp new file mode 100644 index 00000000..0881a6ea --- /dev/null +++ b/Leet Code/Longest Common Prefix/Main.cpp @@ -0,0 +1,30 @@ +#include +using namespace std; +#include +#include +#include "../+Helper/Helper.h" +#include "Longest Common Prefix.cpp" + +#include +#include +int main(){ + freopen("in.txt", "r", stdin); + CLK_INIT; + Solution s; + CASET{ + int n = 0; + RD(n); + vector v; + string str; + while(n--){ + cin >> str; + v.push_back(str); + } + PRINTCASE; + CLK_START; + cout << s.longestCommonPrefix(v) << endl; + CLK_END; + } + + return 0; +} \ No newline at end of file diff --git a/Leet Code/Longest Common Prefix/String.cpp b/Leet Code/Longest Common Prefix/String.cpp new file mode 100644 index 00000000..97579db1 --- /dev/null +++ b/Leet Code/Longest Common Prefix/String.cpp @@ -0,0 +1,26 @@ +#include +#include +using namespace std; + +void printString(const char *s){ + cout << "const char *s" << endl; +} + +// String.cpp:22:17: warning: deprecated conversion from string constant to ‘char*’ +// void printString(char *s){ +// cout << "char *s" << endl; +// } + +void printString(const string s){ + cout << "const string s" << endl; +} + +// String.cpp:18:6: error: redefinition of ‘void printString(std::string)’ +// void printString(string s){ +// cout << "string s" << endl; +// } + +int main(){ + printString("Hello"); + return 0; +} \ No newline at end of file diff --git a/Leet Code/Longest Common Prefix/in.txt b/Leet Code/Longest Common Prefix/in.txt new file mode 100644 index 00000000..c8f6718c --- /dev/null +++ b/Leet Code/Longest Common Prefix/in.txt @@ -0,0 +1,10 @@ +3 +3 +abcde +abdec +abced +3 +abc +abcd +abcde +2 \ No newline at end of file diff --git a/Leet Code/Longest Palindromic Substring/Longest Palindromic Substring.cpp b/Leet Code/Longest Palindromic Substring/Longest Palindromic Substring.cpp new file mode 100644 index 00000000..c0b8d792 --- /dev/null +++ b/Leet Code/Longest Palindromic Substring/Longest Palindromic Substring.cpp @@ -0,0 +1,26 @@ +#include +using namespace std; + +class Solution { +public: + bool isPalindrome(const char *s, int len){ + int i = 0, j = len - 1; + while(i < j && s[i] == s[j]){ + i++; j--; + } + return i >= j; + } + + string longestPalindrome(string s) { + const char *str = s.c_str(); + int len = s.size(), L = len; + while(L > 1){ + for(int i = 0; i <= len - L; ++i){ + if(isPalindrome(str + i, L)) + return string(s, i, L); + } + --L; + } + return string(s, 0, L); + } +}; \ No newline at end of file diff --git a/Leet Code/Longest Palindromic Substring/Main.cpp b/Leet Code/Longest Palindromic Substring/Main.cpp new file mode 100644 index 00000000..f49b47ce --- /dev/null +++ b/Leet Code/Longest Palindromic Substring/Main.cpp @@ -0,0 +1,22 @@ +#include +using namespace std; +#include +#include +#include "../+Helper/Helper.h" +#include "Longest Palindromic Substring.cpp" + +int main(){ + freopen("in.txt", "r", stdin); + CLK_INIT; + Solution s; + CASET{ + string str; + cin >> str; + PRINTCASE; + CLK_START; + cout << s.longestPalindrome(str) << endl; + CLK_END; + } + + return 0; +} \ No newline at end of file diff --git a/Leet Code/Longest Palindromic Substring/in.txt b/Leet Code/Longest Palindromic Substring/in.txt new file mode 100644 index 00000000..efddb0ea --- /dev/null +++ b/Leet Code/Longest Palindromic Substring/in.txt @@ -0,0 +1,6 @@ +5 +a +kabcbap +1234567890987654321 +123432101234320 +aaabbbaaaddd \ No newline at end of file diff --git a/Leet Code/Merge Sorted Array/Merge Sorted Array.cpp b/Leet Code/Merge Sorted Array/Merge Sorted Array.cpp new file mode 100644 index 00000000..ac9594fc --- /dev/null +++ b/Leet Code/Merge Sorted Array/Merge Sorted Array.cpp @@ -0,0 +1,12 @@ +class Solution { +public: + void merge(int A[], int m, int B[], int n) { + int i = m - 1, j = n - 1, k = m + n - 1; + while(i >= 0 && j >= 0){ + if(A[i] > B[j]) A[k--] = A[i--]; + else A[k--] = B[j--]; + } + while(i >= 0) A[k--] = A[i--]; + while(j >= 0) A[k--] = B[j--]; + } +}; \ No newline at end of file diff --git a/Leet Code/Merge Two Sorted Lists/Merge Two Sorted Lists.cpp b/Leet Code/Merge Two Sorted Lists/Merge Two Sorted Lists.cpp new file mode 100644 index 00000000..d459056f --- /dev/null +++ b/Leet Code/Merge Two Sorted Lists/Merge Two Sorted Lists.cpp @@ -0,0 +1,35 @@ +/** + * Definition for singly-linked list. + * struct ListNode { + * int val; + * ListNode *next; + * ListNode(int x) : val(x), next(NULL) {} + * }; + */ +class Solution { +public: + ListNode *mergeTwoLists(ListNode *l1, ListNode *l2) { + if(!l1 || !l2) return l1? l1 : l2; + ListNode *head, *tail; + if(l1->val < l2->val){ + head = tail = l1; + l1 = l1->next; + }else{ + head = tail = l2; + l2 = l2->next; + } + while(l1 && l2){ + if(l1->val < l2->val){ + tail->next = l1; + tail = l1; + l1 = l1->next; + }else{ + tail->next = l2; + tail = l2; + l2 = l2->next; + } + } + tail->next = l1 ? l1 : l2; + return head; + } +}; \ No newline at end of file diff --git a/Leet Code/Merge k Sorted Lists/Merge k Sorted Lists.cpp b/Leet Code/Merge k Sorted Lists/Merge k Sorted Lists.cpp new file mode 100644 index 00000000..e69de29b diff --git a/Leet Code/Minimum Depth of Binary Tree/Main.cpp b/Leet Code/Minimum Depth of Binary Tree/Main.cpp new file mode 100644 index 00000000..25d131b5 --- /dev/null +++ b/Leet Code/Minimum Depth of Binary Tree/Main.cpp @@ -0,0 +1,23 @@ +#include +using namespace std; +#include +#include +#include "../+Helper/Helper.h" +#include "Minimum Depth of Binary Tree.h" + +int main(){ + freopen("in.txt", "r", stdin); + CLK_INIT; + Solution s; + CASET{ + string str; + cin >> str; + TreeNode *root = deserialize(str); + PRINTCASE; + CLK_START; + cout << s.minDepth(root) << endl; + CLK_END; + } + + return 0; +} \ No newline at end of file diff --git a/Leet Code/Minimum Depth of Binary Tree/Minimum Depth of Binary Tree.h b/Leet Code/Minimum Depth of Binary Tree/Minimum Depth of Binary Tree.h new file mode 100644 index 00000000..43aa226e --- /dev/null +++ b/Leet Code/Minimum Depth of Binary Tree/Minimum Depth of Binary Tree.h @@ -0,0 +1,28 @@ +#include "../+Helper/BinaryTree.h" +#include +class Solution { +public: + int minDepth(TreeNode *root) { + if(!root) return 0; + queue q; + q.push(root); + int n = 1, depth = 1; + while(n){ + int nextN = 0; + while(n--){ + root = q.front(); q.pop(); + if(!root->left && !root->right) return depth; + if(root->left){ + nextN++; + q.push(root->left); + } + if(root->right){ + nextN++; + q.push(root->right); + } + } + n = nextN; + depth++; + } + } +}; \ No newline at end of file diff --git a/Leet Code/Minimum Depth of Binary Tree/in.txt b/Leet Code/Minimum Depth of Binary Tree/in.txt new file mode 100644 index 00000000..e5ae0cf2 --- /dev/null +++ b/Leet Code/Minimum Depth of Binary Tree/in.txt @@ -0,0 +1,5 @@ +4 +3,9,20,#,#,15,7 +1,2,3,#,#,4,#,#,5 +1 +1,2,3,4,5,6,7 \ No newline at end of file diff --git a/Leet Code/Multiply Strings/Main.cpp b/Leet Code/Multiply Strings/Main.cpp new file mode 100644 index 00000000..a26ce9c1 --- /dev/null +++ b/Leet Code/Multiply Strings/Main.cpp @@ -0,0 +1,17 @@ +#include +#include +using namespace std; +#include "../+Helper/Helper.h" +#include "Multiply Strings.h" + +int main(){ + freopen("in.txt", "r", stdin); + Solution s; + CASET{ + string a, b; + cin >> a >> b; + PRINTCASE; + cout << s.multiply(a, b) << endl; + } + return 0; +} \ No newline at end of file diff --git a/Leet Code/Multiply Strings/Multiply Strings.h b/Leet Code/Multiply Strings/Multiply Strings.h new file mode 100644 index 00000000..7fbd0c6a --- /dev/null +++ b/Leet Code/Multiply Strings/Multiply Strings.h @@ -0,0 +1,63 @@ +#include +#include // reverse +using namespace std; +class Solution { +public: + string multiply(string num, int digit){ + if(!digit || num == "0") return "0"; + string::reverse_iterator i = num.rbegin(); + string ret; + int carry = 0; + for(; i != num.rend(); ++i){ + carry += (*i - '0') * digit; + ret += carry % 10 + '0'; + carry /= 10; + } + if(carry){ + ret += carry + '0'; + } + reverse(ret.begin(), ret.end()); + return ret; + } + + string plus(string num1, string num2, int offset_of_num2){ + if(num2 == "0") return num1; + string ret; + string::reverse_iterator i = num1.rbegin(), j = num2.rbegin(); + while(offset_of_num2-- > 0){ + if(i != num1.rend()){ + ret += *i; + i++; + }else{ + ret += '0'; + } + } + int carry = 0; + while(i != num1.rend() || j != num2.rend()){ + if(i != num1.rend()){ + carry += (*i - '0'); + i++; + } + if(j != num2.rend()){ + carry += (*j - '0'); + j++; + } + ret += carry % 10 + '0'; + carry /= 10; + } + if(carry){ + ret += carry + '0'; + } + reverse(ret.begin(), ret.end()); + return ret; + } + + string multiply(string num1, string num2) { + string ret = "0"; + int len2 = num2.size(); + for(int i = 0; i < len2; ++i){ + ret = plus(ret, multiply(num1, num2[len2 - i - 1] - '0'), i); + } + return ret; + } +}; \ No newline at end of file diff --git a/Leet Code/Multiply Strings/in.txt b/Leet Code/Multiply Strings/in.txt new file mode 100644 index 00000000..a7e45479 --- /dev/null +++ b/Leet Code/Multiply Strings/in.txt @@ -0,0 +1,11 @@ +10 +0 0 +1024 1024 +1024 1048576 +1024 1073741824 +1024 4294967296 +1024 0 +0 1024 +2 12345678901234567890 +12345678901234567890 2 +12345678901234567890 12345678901234567890 \ No newline at end of file diff --git a/Leet Code/Next Permutation/Main.cpp b/Leet Code/Next Permutation/Main.cpp new file mode 100644 index 00000000..7337d42a --- /dev/null +++ b/Leet Code/Next Permutation/Main.cpp @@ -0,0 +1,22 @@ +#include +using namespace std; +#include +#include +#include "../+Helper/Helper.h" +#include "Next Permutation.cpp" + +int main(){ + freopen("in.txt", "r", stdin); + CLK_INIT; + Solution s; + CASET{ + vector v = scanVector(); + PRINTCASE_; + CLK_START; + s.nextPermutation(v) + printVector(v); + CLK_END; + } + + return 0; +} \ No newline at end of file diff --git a/Leet Code/Next Permutation/Next Permutation.cpp b/Leet Code/Next Permutation/Next Permutation.cpp new file mode 100644 index 00000000..87b3a22b --- /dev/null +++ b/Leet Code/Next Permutation/Next Permutation.cpp @@ -0,0 +1,11 @@ +#include +#include +using namespace std; + +#define SWAP(a, b) do{int tmp = a; a = b; b = tmp;}while(0) +class Solution { +public: + void nextPermutation(vector &num) { + + } +}; \ No newline at end of file diff --git a/Leet Code/Palindrome Number/Palindrome Number.cpp b/Leet Code/Palindrome Number/Palindrome Number.cpp new file mode 100644 index 00000000..79ba811b --- /dev/null +++ b/Leet Code/Palindrome Number/Palindrome Number.cpp @@ -0,0 +1,13 @@ +class Solution { +public + bool isPalindrome(int x) { + if(x 0) return false; + int a = x, b = 0; + while(a){ + b = 10; + b += a % 10; + a = 10; + } + return b == x; + } +}; \ No newline at end of file diff --git a/Leet Code/Partition List/Partition List.cpp b/Leet Code/Partition List/Partition List.cpp new file mode 100644 index 00000000..d5e6ff82 --- /dev/null +++ b/Leet Code/Partition List/Partition List.cpp @@ -0,0 +1,44 @@ +/** + * Definition for singly-linked list. + * struct ListNode { + * int val; + * ListNode *next; + * ListNode(int x) : val(x), next(NULL) {} + * }; + */ +class Solution { +public: + ListNode *partition(ListNode *head, int x) { + if(!head) return NULL; + ListNode *p, *lt_head, *lt_tail, *geq_head, *geq_tail; + lt_head = lt_tail = geq_head = geq_tail = NULL; + while(head){ + p = head; head = head->next; + if(p->val < x){ + if(!lt_head){ + lt_head = p; + }else{ + lt_tail->next = p; + } + lt_tail = p; + }else{ + if(!geq_head){ + geq_head = p; + }else{ + geq_tail->next = p; + } + geq_tail = p; + } + } + if(!lt_head){ + head = geq_head; + }else{ + head = lt_head; + lt_tail->next = geq_head; + } + if(geq_tail){ + geq_tail->next = NULL; + } + return head; + } +}; \ No newline at end of file diff --git a/Leet Code/Pascal's Triangle II/Main.cpp b/Leet Code/Pascal's Triangle II/Main.cpp new file mode 100644 index 00000000..dde8f1a5 --- /dev/null +++ b/Leet Code/Pascal's Triangle II/Main.cpp @@ -0,0 +1,22 @@ +#include +using namespace std; +#include +#include +#include "../+Helper/Helper.h" +#include "Pascal's Triangle II.cpp" + +int main(){ + freopen("in.txt", "r", stdin); + CLK_INIT; + Solution s; + CASET{ + int n; + cin >> n; + PRINTCASE_; + CLK_START; + printVector(s.getRow(n)); + CLK_END; + } + + return 0; +} \ No newline at end of file diff --git a/Leet Code/Pascal's Triangle II/Pascal's Triangle II.cpp b/Leet Code/Pascal's Triangle II/Pascal's Triangle II.cpp new file mode 100644 index 00000000..28c8c66c --- /dev/null +++ b/Leet Code/Pascal's Triangle II/Pascal's Triangle II.cpp @@ -0,0 +1,17 @@ +#include +using namespace std; + +class Solution { +public: + vector getRow(int rowIndex) { + if(rowIndex < 0) return vector(); + vector v(rowIndex + 1, 1); + unsigned long long val = 1, a = rowIndex, b = 1; + for(int i = 1; i <= rowIndex; ++i){ + val *= a--; + val /= b++; + v[i] = val; + } + return v; + } +}; \ No newline at end of file diff --git a/Leet Code/Pascal's Triangle II/in.txt b/Leet Code/Pascal's Triangle II/in.txt new file mode 100644 index 00000000..0ef1ea8d --- /dev/null +++ b/Leet Code/Pascal's Triangle II/in.txt @@ -0,0 +1,7 @@ +6 +0 +1 +2 +3 +4 +30 \ No newline at end of file diff --git a/Leet Code/Pascal's Triangle/Main.cpp b/Leet Code/Pascal's Triangle/Main.cpp new file mode 100644 index 00000000..91a4b91a --- /dev/null +++ b/Leet Code/Pascal's Triangle/Main.cpp @@ -0,0 +1,22 @@ +#include +using namespace std; +#include +#include +#include "../+Helper/Helper.h" +#include "Pascal's Triangle.cpp" + +int main(){ + freopen("in.txt", "r", stdin); + CLK_INIT; + Solution s; + CASET{ + int n; + cin >> n; + PRINTCASE_; + CLK_START; + printVector(s.generate(n)); + CLK_END; + } + + return 0; +} \ No newline at end of file diff --git a/Leet Code/Pascal's Triangle/Pascal's Triangle.cpp b/Leet Code/Pascal's Triangle/Pascal's Triangle.cpp new file mode 100644 index 00000000..70473fd5 --- /dev/null +++ b/Leet Code/Pascal's Triangle/Pascal's Triangle.cpp @@ -0,0 +1,18 @@ +#include +using namespace std; + +class Solution { +public: + vector > generate(int numRows) { + if(numRows <= 0) return vector >(); + vector > v(numRows, vector(1, 1)); + for(int n = 1; n < numRows; ++n){ + vector &v1 = v[n], v0 = v[n - 1]; + for(int i = 1; i < n; ++i){ + v1.push_back(v0[i - 1] + v0[i]); + } + v1.push_back(1); + } + return v; + } +}; \ No newline at end of file diff --git a/Leet Code/Pascal's Triangle/in.txt b/Leet Code/Pascal's Triangle/in.txt new file mode 100644 index 00000000..7d3b5f41 --- /dev/null +++ b/Leet Code/Pascal's Triangle/in.txt @@ -0,0 +1,7 @@ +6 +1 +2 +3 +4 +5 +6 \ No newline at end of file diff --git a/Leet Code/Path Sum/Path Sum - 1.cpp b/Leet Code/Path Sum/Path Sum - 1.cpp new file mode 100644 index 00000000..298478d7 --- /dev/null +++ b/Leet Code/Path Sum/Path Sum - 1.cpp @@ -0,0 +1,9 @@ +class Solution { +public: + bool hasPathSum(TreeNode *root, int sum) { + if(!root) return false; + sum -= root->val; + if(!root->left && !root->right && !sum) return true; + return hasPathSum(root->left, sum) || hasPathSum(root->right, sum); + } +}; \ No newline at end of file diff --git a/Leet Code/Path Sum/Path Sum.cpp b/Leet Code/Path Sum/Path Sum.cpp new file mode 100644 index 00000000..be9cacff --- /dev/null +++ b/Leet Code/Path Sum/Path Sum.cpp @@ -0,0 +1,16 @@ +#include "../+Helper/BinaryTree.h" + +class Solution { +public: + bool preorder(TreeNode *root, int sum, int cur){ + if(!root) return false; + cur += root->val; + if(!root->left && !root->right && cur == sum) return true; + return preorder(root->left, sum, cur) || preorder(root->right, sum, cur); + } + + bool hasPathSum(TreeNode *root, int sum) { + if(!root) return false; + return preorder(root, sum, 0); + } +}; \ No newline at end of file diff --git a/Leet Code/Permutation Sequence/Permutation Sequence.cpp b/Leet Code/Permutation Sequence/Permutation Sequence.cpp new file mode 100644 index 00000000..7b519619 --- /dev/null +++ b/Leet Code/Permutation Sequence/Permutation Sequence.cpp @@ -0,0 +1,6 @@ +class Solution { +public: + string getPermutation(int n, int k) { + + } +}; \ No newline at end of file diff --git a/Leet Code/Permutations II/Main.cpp b/Leet Code/Permutations II/Main.cpp new file mode 100644 index 00000000..61ed256f --- /dev/null +++ b/Leet Code/Permutations II/Main.cpp @@ -0,0 +1,21 @@ +#include +using namespace std; +#include +#include +#include "../+Helper/Helper.h" +#include "Permutations II.cpp" + +int main(){ + freopen("in.txt", "r", stdin); + CLK_INIT; + Solution s; + CASET{ + vector v = scanVector(); + PRINTCASE_; + CLK_START; + printVector(s.permuteUnique(v)); + CLK_END; + } + + return 0; +} \ No newline at end of file diff --git a/Leet Code/Permutations II/Permutations II.cpp b/Leet Code/Permutations II/Permutations II.cpp new file mode 100644 index 00000000..cf356625 --- /dev/null +++ b/Leet Code/Permutations II/Permutations II.cpp @@ -0,0 +1,36 @@ +#include +using namespace std; + +#define SWAP(a, b) do{int tmp = a; a = b; b = tmp;}while(0) +class Solution { +public: + bool swaped(vector &num, int layer, int i){ + // the value of num[i] has been swaped, SKIP! + for(int j = layer; j < i; ++j){ + if(num[j] == num[i]){ + return true; + } + } + return false; + } + + void permute(int layer, vector > &v, vector &num){ + if(layer == num.size()){ + v.push_back(num); + return; + } + for(int i = layer; i < num.size(); ++i){ + if(!swaped(num, layer, i)){ + SWAP(num[layer], num[i]); + permute(layer + 1, v, num); + SWAP(num[layer], num[i]); + } + } + } + + vector > permuteUnique(vector &num) { + vector > v; + permute(0, v, num); + return v; + } +}; \ No newline at end of file diff --git a/Leet Code/Permutations II/in.txt b/Leet Code/Permutations II/in.txt new file mode 100644 index 00000000..f6397945 --- /dev/null +++ b/Leet Code/Permutations II/in.txt @@ -0,0 +1,4 @@ +3 +1,1,2 +1,1,1 +1,2,1,2 \ No newline at end of file diff --git a/Leet Code/Permutations/Main.cpp b/Leet Code/Permutations/Main.cpp new file mode 100644 index 00000000..86391131 --- /dev/null +++ b/Leet Code/Permutations/Main.cpp @@ -0,0 +1,21 @@ +#include +using namespace std; +#include +#include +#include "../+Helper/Helper.h" +#include "Permutations.cpp" + +int main(){ + freopen("in.txt", "r", stdin); + CLK_INIT; + Solution s; + CASET{ + vector v = scanVector(); + PRINTCASE_; + CLK_START; + printVector(s.permute(v)); + CLK_END; + } + + return 0; +} \ No newline at end of file diff --git a/Leet Code/Permutations/Permutations.cpp b/Leet Code/Permutations/Permutations.cpp new file mode 100644 index 00000000..79f9f775 --- /dev/null +++ b/Leet Code/Permutations/Permutations.cpp @@ -0,0 +1,24 @@ +#include +using namespace std; + +#define SWAP(a, b) do{int tmp = a; a = b; b = tmp;}while(0) +class Solution { +public: + void permute(int layer, vector > &v, vector &num){ + if(layer == num.size()){ + v.push_back(num); + return; + } + for(int i = layer; i < num.size(); ++i){ + SWAP(num[layer], num[i]); + permute(layer + 1, v, num); + SWAP(num[layer], num[i]); + } + } + + vector > permute(vector &num) { + vector > v; + permute(0, v, num); + return v; + } +}; \ No newline at end of file diff --git a/Leet Code/Permutations/in.txt b/Leet Code/Permutations/in.txt new file mode 100644 index 00000000..dc5f028f --- /dev/null +++ b/Leet Code/Permutations/in.txt @@ -0,0 +1,5 @@ +4 +1 +1,2 +1,2,3 +1,2,3,4 \ No newline at end of file diff --git a/Leet Code/Plus One/Main.cpp b/Leet Code/Plus One/Main.cpp new file mode 100644 index 00000000..485a76ed --- /dev/null +++ b/Leet Code/Plus One/Main.cpp @@ -0,0 +1,11 @@ +#include +using namespace std; +#include "Plus One.h" + +int main(){ + vector v; + v.push_back(1); + v.push_back(1); + Solution s; + s.plusOne(v); +} \ No newline at end of file diff --git a/Leet Code/Plus One/Plus One.h b/Leet Code/Plus One/Plus One.h new file mode 100644 index 00000000..a36666ee --- /dev/null +++ b/Leet Code/Plus One/Plus One.h @@ -0,0 +1,19 @@ +#include +using namespace std; +class Solution { +public: + vector plusOne(vector &digits) { + vector::reverse_iterator i; + i = digits.rbegin(); + int carry = 1; + for(; i != digits.rend(); ++i){ + carry += *i; + *i = carry % 10; + carry /= 10; + } + if(carry){ + digits.insert(digits.begin(), carry); + } + return digits; + } +}; \ No newline at end of file diff --git a/Leet Code/Populating Next Right Pointers in Each Node II/Populating Next Right Pointers in Each Node II.cpp b/Leet Code/Populating Next Right Pointers in Each Node II/Populating Next Right Pointers in Each Node II.cpp new file mode 100644 index 00000000..8fafadc5 --- /dev/null +++ b/Leet Code/Populating Next Right Pointers in Each Node II/Populating Next Right Pointers in Each Node II.cpp @@ -0,0 +1,30 @@ +#include +using namespace std; +#include "../+Helper/TreeLinkNode.cpp" + +class Solution { +public: + void connect(TreeLinkNode *root) { + if(!root) return; + queue q; + q.push(root); + int n = 1; + while(n){ + TreeLinkNode *prev = NULL, *p = NULL; + int nextN = 0; + while(n--){ + prev = p; + p = q.front(); q.pop(); + if(prev) prev->next = p; + if(!n) p->next = NULL; + if(p->left){ + q.push(p->left); nextN++; + } + if(p->right){ + q.push(p->right); nextN++; + } + } + n = nextN; + } + } +}; \ No newline at end of file diff --git a/Leet Code/Populating Next Right Pointers in Each Node/Main.cpp b/Leet Code/Populating Next Right Pointers in Each Node/Main.cpp new file mode 100644 index 00000000..ad35bf68 --- /dev/null +++ b/Leet Code/Populating Next Right Pointers in Each Node/Main.cpp @@ -0,0 +1,24 @@ +#include +using namespace std; +#include +#include +#include "../+Helper/Helper.h" +#include "Populating Next Right Pointers in Each Node.cpp" + +int main(){ + freopen("in.txt", "r", stdin); + CLK_INIT; + Solution s; + CASET{ + string str; + cin >> str; + TreeLinkNode *root = deserialize(str); + PRINTCASE; + CLK_START; + s.connect(root); + cout << serialize(root) << endl; + CLK_END; + } + + return 0; +} \ No newline at end of file diff --git a/Leet Code/Populating Next Right Pointers in Each Node/Populating Next Right Pointers in Each Node.cpp b/Leet Code/Populating Next Right Pointers in Each Node/Populating Next Right Pointers in Each Node.cpp new file mode 100644 index 00000000..8fafadc5 --- /dev/null +++ b/Leet Code/Populating Next Right Pointers in Each Node/Populating Next Right Pointers in Each Node.cpp @@ -0,0 +1,30 @@ +#include +using namespace std; +#include "../+Helper/TreeLinkNode.cpp" + +class Solution { +public: + void connect(TreeLinkNode *root) { + if(!root) return; + queue q; + q.push(root); + int n = 1; + while(n){ + TreeLinkNode *prev = NULL, *p = NULL; + int nextN = 0; + while(n--){ + prev = p; + p = q.front(); q.pop(); + if(prev) prev->next = p; + if(!n) p->next = NULL; + if(p->left){ + q.push(p->left); nextN++; + } + if(p->right){ + q.push(p->right); nextN++; + } + } + n = nextN; + } + } +}; \ No newline at end of file diff --git a/Leet Code/Populating Next Right Pointers in Each Node/in.txt b/Leet Code/Populating Next Right Pointers in Each Node/in.txt new file mode 100644 index 00000000..9f54175c --- /dev/null +++ b/Leet Code/Populating Next Right Pointers in Each Node/in.txt @@ -0,0 +1,3 @@ +2 +3,9,20,#,#,15,7 +1,2,3,#,#,4,#,#,5 \ No newline at end of file diff --git a/Leet Code/Remove Duplicates from Sorted Array II/Remove Duplicates from Sorted Array II.cpp b/Leet Code/Remove Duplicates from Sorted Array II/Remove Duplicates from Sorted Array II.cpp new file mode 100644 index 00000000..fdc2d320 --- /dev/null +++ b/Leet Code/Remove Duplicates from Sorted Array II/Remove Duplicates from Sorted Array II.cpp @@ -0,0 +1,16 @@ +class Solution { +public: + int removeDuplicates(int A[], int n) { + int p, q; + p = q = 0; + while(q < n){ + A[p] = A[q++]; + if(q < n && A[q] == A[p]){ + A[++p] = A[q++]; + while(q < n && A[q] == A[p]) q++; + } + p++; + } + return p; + } +}; \ No newline at end of file diff --git a/Leet Code/Remove Duplicates from Sorted List II/Remove Duplicates from Sorted List II.cpp b/Leet Code/Remove Duplicates from Sorted List II/Remove Duplicates from Sorted List II.cpp new file mode 100644 index 00000000..ebfdd5d2 --- /dev/null +++ b/Leet Code/Remove Duplicates from Sorted List II/Remove Duplicates from Sorted List II.cpp @@ -0,0 +1,42 @@ +/** + * Definition for singly-linked list. + * struct ListNode { + * int val; + * ListNode *next; + * ListNode(int x) : val(x), next(NULL) {} + * }; + */ +class Solution { +public: + ListNode *deleteDuplicates(ListNode *head) { + ListNode fake_head(0); + fake_head.next = head; + head = &fake_head; + ListNode *prev, *p, *cur_prev, *cur; + cur_prev = head; + cur = head->next; + while(cur){ + prev = cur; p = cur->next; + while(p && p->val != cur->val){ + prev = p; p = p->next; + } + if(!p){ + cur_prev = cur; + }else{ + while(p){ + if(p->val == cur->val){ + prev->next = p->next; + free(p); + }else{ + prev = p; + } + p = prev->next; + } + cur_prev->next = cur->next; + free(cur); + } + cur = cur_prev->next; + } + return fake_head.next; + } +}; \ No newline at end of file diff --git a/Leet Code/Remove Duplicates from Sorted List/Remove Duplicates from Sorted List.cpp b/Leet Code/Remove Duplicates from Sorted List/Remove Duplicates from Sorted List.cpp new file mode 100644 index 00000000..5b0929fa --- /dev/null +++ b/Leet Code/Remove Duplicates from Sorted List/Remove Duplicates from Sorted List.cpp @@ -0,0 +1,30 @@ +/** + * Definition for singly-linked list. + * struct ListNode { + * int val; + * ListNode *next; + * ListNode(int x) : val(x), next(NULL) {} + * }; + */ +class Solution { +public: + ListNode *deleteDuplicates(ListNode *head) { + if(!head) return NULL; + ListNode *prev, *p, *cur; + cur = head; + while(cur){ + prev = cur; p = cur->next; + while(p){ + if(p->val == cur->val){ + prev->next = p->next; + free(p); + }else{ + prev = p; + } + p = prev->next; + } + cur = cur->next; + } + return head; + } +}; \ No newline at end of file diff --git a/Leet Code/Remove Element/Remove Element.cpp b/Leet Code/Remove Element/Remove Element.cpp new file mode 100644 index 00000000..75b65dc0 --- /dev/null +++ b/Leet Code/Remove Element/Remove Element.cpp @@ -0,0 +1,15 @@ +#define SWAP_INT(a, b) do{int tmp = a; a = b; b = tmp;}while(0) +class Solution { +public: + int removeElement(int A[], int n, int elem) { + for(int i = 0; i < n; ){ + if(A[i] == elem){ + SWAP_INT(A[i], A[n - 1]); + n--; + }else{ + i++; + } + } + return n; + } +}; \ No newline at end of file diff --git a/Leet Code/Remove Nth Node From End of List/Remove Nth Node From End of List.cpp b/Leet Code/Remove Nth Node From End of List/Remove Nth Node From End of List.cpp new file mode 100644 index 00000000..3d3bd8a1 --- /dev/null +++ b/Leet Code/Remove Nth Node From End of List/Remove Nth Node From End of List.cpp @@ -0,0 +1,30 @@ +/** + * Definition for singly-linked list. + * struct ListNode { + * int val; + * ListNode *next; + * ListNode(int x) : val(x), next(NULL) {} + * }; + */ +class Solution { +public: + ListNode *removeNthFromEnd(ListNode *head, int n) { + if(!head) return NULL; + ListNode *last = head; + while(n--) last = last->next; + ListNode *prev = head; + if(last){ // remove node in middle of list + while(last->next){ + prev = prev->next; + last = last->next; + } + last = prev->next; + prev->next = last->next; + free(last); + }else{ // remove head + head = head->next; + free(prev); + } + return head; + } +}; \ No newline at end of file diff --git a/Leet Code/Reorder List/Reorder List - Fast and Slow Pointer.cpp b/Leet Code/Reorder List/Reorder List - Fast and Slow Pointer.cpp new file mode 100644 index 00000000..108d2bc4 --- /dev/null +++ b/Leet Code/Reorder List/Reorder List - Fast and Slow Pointer.cpp @@ -0,0 +1,103 @@ +/** + * Definition for singly-linked list. + * struct ListNode { + * int val; + * ListNode *next; + * ListNode(int x) : val(x), next(NULL) {} + * }; + */ +#include +#include +struct ListNode{ + int val; + ListNode *next; + ListNode(int x) : val(x), next(NULL) {} +}; + +ListNode* listnode_create(int val){ + ListNode *p = (ListNode*)malloc(sizeof *p); + p->val = val; + p->next = NULL; + return p; +} + +void list_destroy(ListNode *head){ + ListNode *next; + if(!head) return; + while(head){ + next = head->next; + free(head); + head = next; + } +} + +void listnode_append(ListNode *head, int val){ + if(!head) return; + while(head->next){ + head = head->next; + } + head->next = listnode_create(val); +} + +void print_list(ListNode *head){ + while(head){ + printf("[%d] ", head->val); + head = head->next; + } + printf("\n"); +} + +/******************************************************/ +static ListNode* reverseList(ListNode *head){ + if(!head) return NULL; + ListNode *prev, *next = head->next; + head->next = NULL; + while(next){ + prev = head; + head = next; + next = head->next; + head->next = prev; + } + return head; +} + +class Solution { +public: + void reorderList(ListNode *head) { + if(!head) return; + ListNode *fast, *slow; + fast = slow = head; + while(fast && fast->next){ + slow = slow->next; + fast = fast->next->next; + } + ListNode *reversed_list = slow->next; + slow->next = NULL; + reversed_list = reverseList(reversed_list); + + ListNode *p = reversed_list; + while(p){ + reversed_list = reversed_list->next; + p->next = head->next; + head->next = p; + head = p->next; + p = reversed_list; + } + } +}; + +int main(){ + ListNode *head; + head = listnode_create(1); + listnode_append(head, 2); + listnode_append(head, 3); + listnode_append(head, 4); + listnode_append(head, 5); + listnode_append(head, 6); + listnode_append(head, 7); + print_list(head); + Solution s; + s.reorderList(head); + print_list(head); + return 0; +} \ No newline at end of file diff --git a/Leet Code/Reorder List/Reorder List - TLE.cpp b/Leet Code/Reorder List/Reorder List - TLE.cpp new file mode 100644 index 00000000..7e511471 --- /dev/null +++ b/Leet Code/Reorder List/Reorder List - TLE.cpp @@ -0,0 +1,102 @@ +/** + * Definition for singly-linked list. + * struct ListNode { + * int val; + * ListNode *next; + * ListNode(int x) : val(x), next(NULL) {} + * }; + */ +#include +#include +struct ListNode{ + int val; + ListNode *next; + ListNode(int x) : val(x), next(NULL) {} +}; + +ListNode* listnode_create(int val){ + ListNode *p = (ListNode*)malloc(sizeof *p); + p->val = val; + p->next = NULL; + return p; +} + +void list_destroy(ListNode *head){ + ListNode *next; + if(!head) return; + while(head){ + next = head->next; + free(head); + head = next; + } +} + +void listnode_append(ListNode *head, int val){ + if(!head) return; + while(head->next){ + head = head->next; + } + head->next = listnode_create(val); +} + +void print_list(ListNode *head){ + while(head){ + printf("[%d] ", head->val); + head = head->next; + } + printf("\n"); +} + +class Solution { +public: + void reorderList(ListNode *head) { + if(!head) return; + ListNode *p, *prev, *last; + int len = 0, pi = 0, i; + last = p = head; + while(p && p->next){ + last = last->next; + p = p->next->next; + pi++; + } + len = pi << 1; + if(p) len++; // list length is odd + + p = last->next; + pi++; + while(p){ + last->next = p->next; + prev = head; + i = len - pi - 1; + while(i--){ + prev = prev->next; + } + p->next = prev->next; + prev->next = p; + p = last->next; + pi++; + } + last->next = NULL; + } +}; + +int main(){ + ListNode *head; + head = listnode_create(0); + listnode_append(head, 1); + listnode_append(head, 2); + listnode_append(head, 3); + listnode_append(head, 4); + + print_list(head); + Solution s; + s.reorderList(head); + print_list(head); + return 0; +} + +/* + * last 指针指示新链表的尾节点, index[last] 为 len/2 向下取整. + * 每次将 node[last->next] 摘下, 记其对应的 index 为 pi, + * 将该节点插入到 index 为 len - pi - 1 的节点之后. + */ \ No newline at end of file diff --git a/Leet Code/Reorder List/Reorder List.cpp b/Leet Code/Reorder List/Reorder List.cpp new file mode 100644 index 00000000..af3684e2 --- /dev/null +++ b/Leet Code/Reorder List/Reorder List.cpp @@ -0,0 +1,109 @@ +/** + * Definition for singly-linked list. + * struct ListNode { + * int val; + * ListNode *next; + * ListNode(int x) : val(x), next(NULL) {} + * }; + */ +#include +#include +struct ListNode{ + int val; + ListNode *next; + ListNode(int x) : val(x), next(NULL) {} +}; + +ListNode* listnode_create(int val){ + ListNode *p = (ListNode*)malloc(sizeof *p); + p->val = val; + p->next = NULL; + return p; +} + +void list_destroy(ListNode *head){ + ListNode *next; + if(!head) return; + while(head){ + next = head->next; + free(head); + head = next; + } +} + +void listnode_append(ListNode *head, int val){ + if(!head) return; + while(head->next){ + head = head->next; + } + head->next = listnode_create(val); +} + +void print_list(ListNode *head){ + while(head){ + printf("[%d] ", head->val); + head = head->next; + } + printf("\n"); +} + +/******************************************************/ +static int count_length(ListNode *head){ + int len = 0; + while(head){ + head = head->next; + len++; + } + return len; +} + +static ListNode* reverseList(ListNode *head){ + if(!head) return NULL; + ListNode *prev, *next = head->next; + head->next = NULL; + while(next){ + prev = head; + head = next; + next = head->next; + head->next = prev; + } + return head; +} + +class Solution { +public: + void reorderList(ListNode *head) { + if(!head) return; + int len = count_length(head), last_index; + last_index = len >> 1; + ListNode *last = head, *reversed_list, *p; + for(int i = 0; i < last_index; ++i) last = last->next; + reversed_list = last->next; + last->next = NULL; + reversed_list = reverseList(reversed_list); + p = reversed_list; + while(p){ + reversed_list = reversed_list->next; + p->next = head->next; + head->next = p; + head = p->next; + p = reversed_list; + } + } +}; + +int main(){ + ListNode *head; + head = listnode_create(1); + listnode_append(head, 2); + listnode_append(head, 3); + listnode_append(head, 4); + listnode_append(head, 5); + listnode_append(head, 6); + listnode_append(head, 7); + print_list(head); + Solution s; + s.reorderList(head); + print_list(head); + return 0; +} \ No newline at end of file diff --git a/Leet Code/Reverse Integer/Reverse Integer.cpp b/Leet Code/Reverse Integer/Reverse Integer.cpp new file mode 100644 index 00000000..9c5aabb0 --- /dev/null +++ b/Leet Code/Reverse Integer/Reverse Integer.cpp @@ -0,0 +1,13 @@ +class Solution { +public: + int reverse(int x) { + int y = 0, sgn = x > 0 ? 1 : -1; + x = sgn * x; + while(x){ + y *= 10; + y += x % 10; + x /= 10; + } + return sgn * y; + } +}; \ No newline at end of file diff --git a/Leet Code/Reverse Linked List II/Reverse Linked List II.cpp b/Leet Code/Reverse Linked List II/Reverse Linked List II.cpp new file mode 100644 index 00000000..33732748 --- /dev/null +++ b/Leet Code/Reverse Linked List II/Reverse Linked List II.cpp @@ -0,0 +1,97 @@ +/** + * Definition for singly-linked list. + * struct ListNode { + * int val; + * ListNode *next; + * ListNode(int x) : val(x), next(NULL) {} + * }; + */ + +#include +#include +struct ListNode{ + int val; + ListNode *next; + ListNode(int x) : val(x), next(NULL) {} +}; + +ListNode* listnode_create(int val){ + ListNode *p = (ListNode*)malloc(sizeof *p); + p->val = val; + p->next = NULL; + return p; +} + +void list_destroy(ListNode *head){ + ListNode *next; + if(!head) return; + while(head){ + next = head->next; + free(head); + head = next; + } +} + +void listnode_append(ListNode *head, int val){ + if(!head) return; + while(head->next){ + head = head->next; + } + head->next = listnode_create(val); +} + +void print_list(ListNode *head){ + while(head){ + printf("[%d] ", head->val); + head = head->next; + } + printf("\n"); +} + +class Solution { +public: + ListNode *reverseBetween(ListNode *head, int m, int n) { + if(!head) return NULL; + ListNode *prev, *next, *mid_head, *mid_last, *prev_m; + if(m == 1){ + mid_head = head; + }else{ + prev_m = head; + for(int i = m - 2; i > 0; --i){ + prev_m = prev_m->next; + } + mid_head = prev_m->next; + } + mid_last = prev = mid_head; + next = mid_head->next; + while(n-- > m){ + mid_head = next; + next = mid_head->next; + mid_head->next = prev; + prev = mid_head; + } + if(m != 1){ + prev_m->next = mid_head; + }else{ + head = mid_head; + } + mid_last->next = next; + return head; + } +}; + +int main(){ + ListNode *head; + head = listnode_create(1); + listnode_append(head, 2); + listnode_append(head, 3); + listnode_append(head, 4); + listnode_append(head, 5); + listnode_append(head, 6); + listnode_append(head, 7); + print_list(head); + Solution s; + head = s.reverseBetween(head, 1, 7); + print_list(head); + return 0; +} \ No newline at end of file diff --git a/Leet Code/Roman to Integer/Main.cpp b/Leet Code/Roman to Integer/Main.cpp new file mode 100644 index 00000000..6c54c412 --- /dev/null +++ b/Leet Code/Roman to Integer/Main.cpp @@ -0,0 +1,24 @@ +#include +using namespace std; +#include +#include +#include "../+Helper/Helper.h" +#include "Roman to Integer - 2.cpp" + +#include +#include +int main(){ + freopen("in.txt", "r", stdin); + CLK_INIT; + Solution s; + CASET{ + string rm; + cin >> rm; + PRINTCASE; + CLK_START; + cout << s.romanToInt(rm) << endl; + CLK_END; + } + + return 0; +} \ No newline at end of file diff --git a/Leet Code/Roman to Integer/Roman to Integer - 1.cpp b/Leet Code/Roman to Integer/Roman to Integer - 1.cpp new file mode 100644 index 00000000..84581bad --- /dev/null +++ b/Leet Code/Roman to Integer/Roman to Integer - 1.cpp @@ -0,0 +1,21 @@ +#include +using namespace std; + +class Solution { +public: + int romanToInt(string s) { + int ret = 0, i = s.size() - 1; + while(i >= 0){ + switch(s[i--]){ + case 'M': ret += 1000; break; + case 'D': ret += 500; break; + case 'C': ret += ret >= 500 ? -100 : 100; break; + case 'L': ret += 50; break; + case 'X': ret += ret >= 50 ? -10 : 10; break; + case 'V': ret += 5; break; + case 'I': ret += ret >= 5 ? -1 : 1; break; + } + } + return ret; + } +}; \ No newline at end of file diff --git a/Leet Code/Roman to Integer/Roman to Integer - 2.cpp b/Leet Code/Roman to Integer/Roman to Integer - 2.cpp new file mode 100644 index 00000000..9821daab --- /dev/null +++ b/Leet Code/Roman to Integer/Roman to Integer - 2.cpp @@ -0,0 +1,24 @@ +#include +#include +using namespace std; + +// unordered_map is in the C++ 2011 standard. +// To enable the standard, you have to "g++ Main.cpp -std=c++11" +class Solution { +public: + int romanToInt(string s) { + unordered_map m = {{'I', 1}, {'V', 5}, {'X', 10}, {'L', 50}, {'C', 100}, + {'D', 500}, {'M', 1000}}; + int ret = 0, i = s.size() - 1, last = 0; + while(i >= 0){ + int cur = m[s[i--]]; + if(cur < last){ + ret -= cur; + }else{ + ret += cur; + } + last = cur; + } + return ret; + } +}; \ No newline at end of file diff --git a/Leet Code/Roman to Integer/Roman to Integer.cpp b/Leet Code/Roman to Integer/Roman to Integer.cpp new file mode 100644 index 00000000..52e91481 --- /dev/null +++ b/Leet Code/Roman to Integer/Roman to Integer.cpp @@ -0,0 +1,43 @@ +#include +using namespace std; + +class Solution { +public: + int romanToInt(string s) { + int ret = 0, i = 0; + char last = '\0'; + while(i < s.size()){ + switch(s[i]){ + case 'M': + if(last == 'C') ret -= 200; + ret += 1000; + break; + case 'D': + if(last == 'C') ret -= 200; + ret += 500; + break; + case 'C': + if(last == 'X') ret -= 20; + ret += 100; + break; + case 'L': + if(last == 'X') ret -= 20; + ret += 50; + break; + case 'X': + if(last == 'I') ret -= 2; + ret += 10; + break; + case 'V': + if(last == 'I') ret -=2; + ret += 5; + break; + case 'I': + ret += 1; + break; + } + last = s[i++]; + } + return ret; + } +}; \ No newline at end of file diff --git a/Leet Code/Roman to Integer/in.txt b/Leet Code/Roman to Integer/in.txt new file mode 100644 index 00000000..ccd219fe --- /dev/null +++ b/Leet Code/Roman to Integer/in.txt @@ -0,0 +1,15 @@ +14 +M +IV +V +IX +XIX +XLIX +XCIX +CMXCIX +VIII +LXXXVIII +DCCCLXXXVIII +MDCCCLXXXVIII +MCMXC +MMMCMXCIX \ No newline at end of file diff --git a/Leet Code/Roman to Integer/sample - out.txt b/Leet Code/Roman to Integer/sample - out.txt new file mode 100644 index 00000000..5b2f9088 --- /dev/null +++ b/Leet Code/Roman to Integer/sample - out.txt @@ -0,0 +1,14 @@ +1000 +4 +5 +9 +19 +49 +99 +999 +8 +88 +888 +1888 +1990 +3999 \ No newline at end of file diff --git a/Leet Code/Rotate Image/Rotate Image.h b/Leet Code/Rotate Image/Rotate Image.h new file mode 100644 index 00000000..cb174948 --- /dev/null +++ b/Leet Code/Rotate Image/Rotate Image.h @@ -0,0 +1,17 @@ +#include +using namespace std; +class Solution { +public: + void rotate(vector > &matrix) { + int N = matrix.size(); + for(int i = 0; i < (N >> 1); ++i){ + for(int j = i; j < N - i - 1; ++j){ + int tmp = matrix[i][j]; + matrix[i][j] = matrix[N - j - 1][i]; + matrix[N - j - 1][i] = matrix[N - i - 1][N - j - 1]; + matrix[N - i - 1][N - j - 1] = matrix[j][N - i - 1]; + matrix[j][N - i - 1] = tmp; + } + } + } +}; \ No newline at end of file diff --git a/Leet Code/Rotate Image/Rotate Image.h.gch b/Leet Code/Rotate Image/Rotate Image.h.gch new file mode 100644 index 00000000..6b419b37 Binary files /dev/null and b/Leet Code/Rotate Image/Rotate Image.h.gch differ diff --git a/Leet Code/Rotate List/Rotate List.cpp b/Leet Code/Rotate List/Rotate List.cpp new file mode 100644 index 00000000..c40a3f80 --- /dev/null +++ b/Leet Code/Rotate List/Rotate List.cpp @@ -0,0 +1,39 @@ +/** + * Definition for singly-linked list. + * struct ListNode { + * int val; + * ListNode *next; + * ListNode(int x) : val(x), next(NULL) {} + * }; + */ + + static int list_length(ListNode *head){ + int len = 0; + while(head){ + head = head->next; + len++; + } + return len; + } + +class Solution { +public: + ListNode *rotateRight(ListNode *head, int k) { + if(!head) return NULL; + int len = list_length(head); + k %= len; + if(k == 0) return head; + ListNode *old_last, *new_last; + old_last = head; + while(k--) old_last = old_last->next; + new_last = head; + while(old_last->next){ + old_last = old_last->next; + new_last = new_last->next; + } + old_last->next = head; + head = new_last->next; + new_last->next = NULL; + return head; + } +}; \ No newline at end of file diff --git a/Leet Code/Same Tree/Same Tree.cpp b/Leet Code/Same Tree/Same Tree.cpp new file mode 100644 index 00000000..4be055de --- /dev/null +++ b/Leet Code/Same Tree/Same Tree.cpp @@ -0,0 +1,8 @@ +class Solution { +public + bool isSameTree(TreeNode p, TreeNode q) { + if(!p && !q) return true; + if(p && q && p-val == q-val) return isSameTree(p-left, q-left) && isSameTree(p-right, q-right); + return false; + } +}; \ No newline at end of file diff --git a/Leet Code/Search Insert Position/Search Insert Position.cpp b/Leet Code/Search Insert Position/Search Insert Position.cpp new file mode 100644 index 00000000..870b5db5 --- /dev/null +++ b/Leet Code/Search Insert Position/Search Insert Position.cpp @@ -0,0 +1,8 @@ +class Solution { +public: + int searchInsert(int A[], int n, int target) { + int i = 0; + while(i < n && A[i] < target) i++; + return i; + } +}; \ No newline at end of file diff --git a/Leet Code/Search a 2D Matrix/Search a 2D Matrix.cpp b/Leet Code/Search a 2D Matrix/Search a 2D Matrix.cpp new file mode 100644 index 00000000..43b7ad9c --- /dev/null +++ b/Leet Code/Search a 2D Matrix/Search a 2D Matrix.cpp @@ -0,0 +1,15 @@ +class Solution { +public: + bool searchMatrix(vector > &matrix, int target) { + int m = matrix.size(); + if(m == 0) return false; + int n = matrix[0].size(); + int i = 0; + while(i < m && matrix[i][n - 1] < target) i++; + if(i == m) return false; + int j = 0; + while(j < n && matrix[i][j] < target) j++; + if(j == n) return false; + return matrix[i][j] == target; + } +}; \ No newline at end of file diff --git a/Leet Code/Search for a Range/Search for a Range.cpp b/Leet Code/Search for a Range/Search for a Range.cpp new file mode 100644 index 00000000..255b3402 --- /dev/null +++ b/Leet Code/Search for a Range/Search for a Range.cpp @@ -0,0 +1,40 @@ +class Solution { +public: + int findLeftBound(int A[], int n, int target){ + int L = 0, R = n - 1; + while(L <= R){ + int M = L + (R - L) / 2; + if(target == A[M]){ + if(M == 0 || A[M - 1] != target) return M; + else R = M - 1; + }else if(target > A[M]){ + L = M + 1; + }else{ + R = M - 1; + } + } + return -1; + } + + int findRightBound(int A[], int n, int target){ + int L = 0, R = n - 1; + while(L <= R){ + int M = L + (R - L) / 2; + if(target == A[M]){ + if(M == n - 1 || A[M + 1] != target) return M; + else L = M + 1; + }else if(target > A[M]){ + L = M + 1; + }else{ + R = M - 1; + } + } + return -1; + } + vector searchRange(int A[], int n, int target) { + vector v; + v.push_back(findLeftBound(A, n, target)); + v.push_back(findRightBound(A, n, target)); + return v; + } +}; \ No newline at end of file diff --git a/Leet Code/Search in Rotated Sorted Array/Main.cpp b/Leet Code/Search in Rotated Sorted Array/Main.cpp new file mode 100644 index 00000000..ebe6d47e --- /dev/null +++ b/Leet Code/Search in Rotated Sorted Array/Main.cpp @@ -0,0 +1,25 @@ +#include +using namespace std; +#include +#include +#include "../+Helper/Helper.h" +#include "Search in Rotated Sorted Array - binary.cpp" + +int main(){ + freopen("in.txt", "r", stdin); + CLK_INIT; + Solution s; + CASET{ + int n, *A, t; + cin >> n; + A = new int[n]; + for(int i = 0; i < n; ++i) cin >> A[i]; + cin >> t; + PRINTCASE; + CLK_START; + cout << s.search(A, n, t) << endl; + CLK_END; + } + + return 0; +} \ No newline at end of file diff --git a/Leet Code/Search in Rotated Sorted Array/Search in Rotated Sorted Array - binary.cpp b/Leet Code/Search in Rotated Sorted Array/Search in Rotated Sorted Array - binary.cpp new file mode 100644 index 00000000..5aa908ec --- /dev/null +++ b/Leet Code/Search in Rotated Sorted Array/Search in Rotated Sorted Array - binary.cpp @@ -0,0 +1,31 @@ +class Solution { +public: + int binarySearch(int A[], int low, int high, int target){ + int mid; + while(low <= high){ + mid = (low + high) / 2; + if(A[mid] == target) return mid; + else if(target > A[mid]) low = mid + 1; + else high = mid - 1; + } + return -1; + } + int search(int A[], int n, int target) { + if(n <= 0) return -1; + int low = 0, high = n - 1, mid; + while(low <= high){ + mid = (low + high) / 2; + if(A[mid] == target) return mid; + if(A[mid] >= A[low] && A[mid] > A[high]){ + if(target <= A[mid] && target >= A[low]) high = mid - 1; + else low = mid + 1; + }else if(A[mid] <= A[low] && A[mid] < A[high]){ + if(target >= A[mid] && target <= A[high]) low = mid + 1; + else high = mid - 1; + }else{ + return binarySearch(A, low, high, target); + } + } + return -1; + } +}; \ No newline at end of file diff --git a/Leet Code/Search in Rotated Sorted Array/Search in Rotated Sorted Array - seq.cpp b/Leet Code/Search in Rotated Sorted Array/Search in Rotated Sorted Array - seq.cpp new file mode 100644 index 00000000..fb0c8d13 --- /dev/null +++ b/Leet Code/Search in Rotated Sorted Array/Search in Rotated Sorted Array - seq.cpp @@ -0,0 +1,14 @@ +class Solution { +public: + int search(int A[], int n, int target) { + if(n <= 0) return -1; + int i; + if(target >= A[0]){ + for(i = 0; i < n && A[i] >= A[0] && A[i] < target; i++); + }else{ + for(i = n - 1; i >= 0 && A[i] <= A[n - 1] && A[i] > target; i--); + } + if(i >= 0 && i < n && A[i] == target) return i; + return -1; + } +}; \ No newline at end of file diff --git a/Leet Code/Search in Rotated Sorted Array/in.txt b/Leet Code/Search in Rotated Sorted Array/in.txt new file mode 100644 index 00000000..c4d2710e --- /dev/null +++ b/Leet Code/Search in Rotated Sorted Array/in.txt @@ -0,0 +1,34 @@ +11 +2 +1 3 +0 +7 +4 5 6 7 0 1 2 +-1 +7 +4 5 6 7 0 1 2 +0 +7 +4 5 6 7 0 1 2 +1 +7 +4 5 6 7 0 1 2 +2 +7 +4 5 6 7 0 1 2 +3 +7 +4 5 6 7 0 1 2 +4 +7 +4 5 6 7 0 1 2 +5 +7 +4 5 6 7 0 1 2 +6 +7 +4 5 6 7 0 1 2 +7 +7 +4 5 6 7 0 1 2 +8 \ No newline at end of file diff --git a/Leet Code/Single Number/Single Number.cpp b/Leet Code/Single Number/Single Number.cpp new file mode 100644 index 00000000..cd20d1ad --- /dev/null +++ b/Leet Code/Single Number/Single Number.cpp @@ -0,0 +1,11 @@ +class Solution { +public: + int singleNumber(int A[], int n) { + if(!A || n <= 0) return 0; + int x = 0; + while(n--){ + x ^= A[n]; + } + return x; + } + }; \ No newline at end of file diff --git a/Leet Code/Sort Colors/Main.cpp b/Leet Code/Sort Colors/Main.cpp new file mode 100644 index 00000000..416ecb8d --- /dev/null +++ b/Leet Code/Sort Colors/Main.cpp @@ -0,0 +1,26 @@ +#include +using namespace std; +#include +#include +#include "../+Helper/Helper.h" +#include "Sort Colors.cpp" + +int main(){ + freopen("in.txt", "r", stdin); + CLK_INIT; + Solution s; + CASET{ + vector v = scanVector(); + int *A = new int[v.size()]; + for(int i = 0; i < v.size(); ++i) A[i] = v[i]; + PRINTCASE; + CLK_START; + s.sortColors(A, v.size()); + for(int i = 0; i < v.size(); ++i) cout << A[i] << " "; + cout << endl; + CLK_END; + delete A; + } + + return 0; +} \ No newline at end of file diff --git a/Leet Code/Sort Colors/Sort Colors.cpp b/Leet Code/Sort Colors/Sort Colors.cpp new file mode 100644 index 00000000..134263c8 --- /dev/null +++ b/Leet Code/Sort Colors/Sort Colors.cpp @@ -0,0 +1,23 @@ +class Solution { +public: + void sortColors(int A[], int n) { + int P0 = 0, P1 = 0, P2 = 0; + for(int i = 0; i < n; ++i){ + switch(A[i]){ + case 0: + A[P2++] = 2; + A[P1++] = 1; + A[P0++] = 0; + break; + case 1: + A[P2++] = 2; + A[P1++] = 1; + break; + case 2: + A[P2++] = 2; + break; + default: break; + } + } + } +}; \ No newline at end of file diff --git a/Leet Code/Sort Colors/in.txt b/Leet Code/Sort Colors/in.txt new file mode 100644 index 00000000..c4c7c540 --- /dev/null +++ b/Leet Code/Sort Colors/in.txt @@ -0,0 +1,2 @@ +1 +1,0,2,0,1,1,2,2,0,1,2,1,1,1 \ No newline at end of file diff --git a/Leet Code/Sort List/Sort List.cpp b/Leet Code/Sort List/Sort List.cpp new file mode 100644 index 00000000..112dcedc --- /dev/null +++ b/Leet Code/Sort List/Sort List.cpp @@ -0,0 +1,90 @@ +#include +#include +using namespace std; + +#define CASET int ___T, case_n = 1; cin >> ___T; while (___T-- > 0) +#define PRINTCASE cout << "Case #" << case_n++ << ": " + +struct ListNode { + int val; + ListNode *next; + ListNode(int x) : val(x), next(NULL) {} + }; + +class Solution { +public: + // Node[start] is chosen as sentinel, i.e. node[mid]. + // Nodes whose data are smaller than sentinel are append to start_prev. + // Other nodes are kept in place. + static void sort(ListNode *start_prev, ListNode *start, ListNode* end){ + if(start == end) return; + ListNode *cur, *prev, *mid; + mid = start; + prev = mid; + cur = prev->next; + while(cur != end){ + if(cur->val < mid->val){ + prev->next = cur->next; + cur->next = start_prev->next; + start_prev->next = cur; + }else{ + prev = cur; + } + cur = prev->next; + } + sort(start_prev, start_prev->next, mid); + sort(mid, mid->next, end); + } + + ListNode *sortList(ListNode *head) { + ListNode *fake_head = new ListNode(0); + fake_head->next = head; + sort(fake_head, head, NULL); + head = fake_head->next; + delete fake_head; + return head; + } +}; + +int main(){ + ifstream fin("in.txt"); + ofstream fout("out.txt"); + if(!fin.is_open() || !fout.is_open()){ + cout << "Failed to open file\n" << endl; + return 1; + } + cin.rdbuf(fin.rdbuf()); + cout.rdbuf(fout.rdbuf()); + CASET{ + ListNode *head = NULL, *tail = NULL; + int N = 0; + cin >> N; + while(N--){ + int data; + cin >> data; + if(!head){ + head = tail = new ListNode(data); + }else{ + tail->next = new ListNode(data); + tail = tail->next; + } + } + Solution s; + head = s.sortList(head); + tail = head; + PRINTCASE; + while(tail){ + cout << tail->val << " "; + tail = tail->next; + } + cout << endl; + } + fin.close(); + fout.close(); + return 0; +} + +/* + * 单链表要尽量用append, 要排序需要prepend, 因此需要设置一个start_prev节点用于append + * + */ \ No newline at end of file diff --git a/Leet Code/Sort List/in.txt b/Leet Code/Sort List/in.txt new file mode 100644 index 00000000..eea2f0af --- /dev/null +++ b/Leet Code/Sort List/in.txt @@ -0,0 +1,5 @@ +2 +10 +5 3 1 8 7 9 0 6 4 2 +30293 +1 3 3 1 3 1 3 3 2 3 2 2 1 1 1 3 2 2 1 1 2 2 2 3 3 1 1 2 2 2 1 2 1 1 2 3 3 2 2 3 2 3 2 2 2 1 1 3 2 3 3 1 1 1 2 2 1 2 2 2 2 3 1 3 1 1 1 2 1 2 2 2 1 3 2 2 2 3 3 2 3 3 1 1 2 2 1 2 1 3 2 1 3 3 1 2 1 1 1 1 1 2 1 2 2 2 2 3 3 3 1 1 3 2 1 1 2 1 3 3 2 2 1 3 1 3 1 3 2 2 3 2 3 2 2 1 2 3 1 3 1 2 3 3 2 3 3 3 1 1 2 3 1 2 3 2 1 1 2 3 1 1 3 1 2 2 3 2 1 3 1 2 1 3 2 1 1 2 2 2 1 3 1 3 2 3 3 1 1 3 1 2 1 2 3 1 2 1 1 3 1 3 3 1 1 1 2 2 1 3 1 2 2 3 2 1 3 2 1 3 2 2 3 3 2 2 1 3 2 2 2 2 2 3 2 2 3 1 3 2 1 3 2 1 2 3 3 3 1 2 2 3 1 1 2 2 3 2 1 1 1 1 1 3 2 2 2 1 3 2 1 2 3 2 1 1 2 1 3 3 1 3 1 2 2 1 2 3 2 3 3 1 2 3 2 2 3 3 2 1 3 2 2 2 3 3 3 1 1 2 1 1 2 3 3 3 1 3 2 2 1 2 2 1 2 3 1 3 2 2 3 3 3 1 2 3 2 1 3 1 1 2 2 1 1 1 2 2 3 1 3 1 2 3 3 3 2 2 3 1 1 1 3 2 1 1 3 1 2 3 3 3 2 1 2 3 2 3 2 1 3 2 2 2 2 1 1 3 1 1 1 3 2 2 2 1 2 3 2 3 2 2 1 2 3 2 1 1 3 1 3 3 1 1 1 1 1 2 3 3 3 1 3 2 2 3 1 1 3 1 1 1 3 1 1 2 2 2 1 1 1 1 2 1 3 3 3 1 2 2 2 2 3 3 1 2 2 3 1 3 1 2 1 2 2 3 3 1 3 3 2 1 3 1 1 3 1 2 3 3 3 3 1 1 3 3 3 3 2 2 2 1 1 3 2 2 2 3 1 3 3 3 1 1 3 1 3 2 3 1 2 3 2 2 3 3 3 1 2 1 2 1 2 3 1 2 2 2 1 1 1 2 2 1 2 1 1 1 3 2 1 2 3 2 2 2 1 2 3 2 2 1 3 3 3 1 2 3 3 1 1 3 3 1 1 2 1 2 3 1 2 3 2 2 3 2 1 3 1 3 1 2 2 2 2 1 2 3 3 2 2 2 3 2 2 1 2 2 3 1 3 1 1 1 2 3 3 2 2 3 3 2 3 1 1 2 2 2 3 2 2 1 1 3 2 2 3 3 3 3 1 2 3 3 1 3 3 1 2 2 1 3 2 3 3 2 3 2 1 2 1 2 2 3 3 2 3 3 1 1 2 1 3 2 2 3 1 2 1 3 1 1 3 3 3 3 2 3 3 3 1 3 2 2 2 3 3 1 2 1 2 3 2 2 2 2 3 3 1 1 3 3 2 1 3 2 2 3 2 3 2 2 2 3 1 2 1 3 2 2 1 2 2 3 2 2 2 2 2 1 1 2 1 3 3 2 2 2 1 3 3 3 3 2 3 3 2 3 3 1 3 3 1 3 2 2 2 2 2 1 2 2 3 3 3 1 2 3 1 3 2 2 2 2 3 1 1 1 3 2 3 3 2 3 1 2 1 2 2 1 2 2 3 3 1 2 3 2 2 3 3 1 1 1 2 1 2 3 3 2 2 2 2 3 1 1 1 3 3 1 1 1 3 3 3 2 3 3 1 1 1 2 3 2 2 2 2 1 2 2 3 1 3 1 2 3 1 3 3 1 2 3 2 2 3 3 1 1 2 1 2 3 3 3 2 1 2 1 2 3 1 2 2 1 2 2 2 1 2 3 3 3 3 1 2 1 3 1 1 2 1 3 1 3 2 3 2 3 3 1 2 2 2 3 3 2 1 1 3 1 2 1 3 1 2 1 2 2 2 1 3 1 1 2 2 1 2 1 2 3 3 1 1 3 1 1 1 2 2 3 1 3 3 3 3 2 2 1 3 2 3 2 2 1 3 3 2 1 2 1 2 2 3 1 2 2 1 2 2 3 1 3 3 2 3 1 1 1 3 3 3 3 3 3 1 1 1 3 3 2 2 1 1 3 2 2 2 3 3 3 1 2 2 1 1 3 3 3 2 2 2 2 3 1 2 1 2 2 3 3 3 2 2 2 1 1 1 3 1 1 1 1 1 1 1 2 3 1 3 1 1 3 1 2 1 3 2 2 3 1 2 3 3 2 3 1 1 2 2 3 3 2 2 1 2 2 1 2 2 1 2 1 3 2 1 2 3 1 1 2 3 2 2 2 3 2 3 3 1 1 1 3 3 1 1 2 1 1 1 2 3 3 2 3 3 3 1 2 3 2 2 2 2 2 2 2 1 1 2 2 1 3 1 1 2 3 1 2 3 2 1 2 2 1 3 3 2 2 1 2 1 3 1 3 2 1 1 3 2 3 1 1 2 3 1 1 1 3 2 2 3 2 3 1 2 2 3 1 3 2 1 1 3 2 2 1 3 2 1 2 3 3 1 3 3 3 1 1 2 1 1 2 3 3 2 2 3 2 1 1 2 3 1 1 3 2 3 2 1 2 3 2 1 1 1 1 3 2 3 2 3 1 3 2 1 3 1 3 3 2 2 3 2 3 1 3 2 1 2 2 2 3 3 2 1 2 3 1 1 3 1 2 2 2 3 2 3 1 1 2 1 1 3 1 3 2 1 1 1 3 1 1 3 3 3 3 1 2 3 2 3 2 1 2 1 3 1 3 1 2 2 3 2 3 2 3 3 3 3 1 1 2 2 3 1 1 3 2 1 1 2 1 2 1 1 1 1 1 1 2 3 3 3 3 2 3 1 2 3 3 1 1 3 1 1 1 2 1 1 2 2 2 2 2 1 2 2 2 2 2 2 1 3 3 1 2 2 1 2 1 1 1 1 2 2 3 2 2 2 3 1 3 1 2 2 2 3 3 3 2 1 2 1 1 3 3 2 3 1 2 1 2 2 3 2 3 3 3 3 1 1 1 1 1 1 2 3 1 1 3 1 3 2 3 1 1 1 2 1 1 2 2 2 3 2 2 2 1 3 1 1 1 1 2 3 2 3 2 2 1 3 1 2 1 2 1 2 2 3 1 2 3 3 2 1 1 3 2 3 1 3 1 1 1 2 3 2 1 3 3 1 3 3 3 3 2 2 3 3 1 3 2 2 3 3 2 3 3 3 1 1 2 2 2 2 1 3 3 1 3 2 2 3 1 2 1 1 3 1 1 2 1 1 3 1 1 3 2 2 2 2 2 3 2 1 3 3 2 1 1 2 2 3 2 1 2 1 2 1 2 1 1 1 3 2 2 2 1 3 3 2 3 2 1 1 3 3 1 3 1 3 3 3 3 3 3 3 3 3 2 3 2 2 2 2 2 2 1 1 1 2 3 1 2 2 2 3 1 2 2 1 2 2 1 1 2 3 1 2 2 2 3 3 1 1 3 2 3 2 2 3 1 2 1 1 1 2 3 3 1 1 2 1 2 3 3 2 2 3 1 3 3 3 3 1 1 3 2 2 3 2 1 3 1 3 2 1 2 1 2 1 3 2 3 1 3 2 2 3 3 3 1 2 3 3 1 1 2 1 2 1 3 2 1 1 1 2 2 2 2 2 1 2 1 3 2 1 2 2 1 1 2 3 3 1 3 2 2 3 3 2 1 3 2 1 3 3 2 2 1 3 2 1 3 2 3 2 2 1 2 1 1 3 1 1 3 3 3 3 1 2 3 3 3 3 2 3 2 3 3 3 3 1 1 2 2 1 2 2 2 3 2 1 2 1 2 3 1 1 1 3 1 2 3 2 3 2 2 2 3 1 2 3 2 1 1 1 1 1 2 3 1 3 2 2 3 3 3 2 1 2 2 1 3 2 2 1 2 3 1 3 3 1 3 3 2 2 1 1 2 3 1 1 3 3 1 3 3 3 3 2 3 1 2 2 1 1 1 1 1 3 1 3 2 3 2 1 2 2 1 2 3 2 1 1 3 2 3 2 3 3 1 2 1 2 3 3 2 3 3 2 3 2 3 3 3 1 2 3 2 1 2 3 2 2 1 3 3 3 1 2 3 3 1 2 1 1 2 1 2 1 2 2 3 3 2 1 3 1 1 1 2 2 1 3 3 1 1 2 2 3 2 3 2 3 3 1 3 1 2 3 3 1 2 2 1 1 2 1 1 3 3 2 3 3 1 2 3 3 2 2 3 1 2 3 3 3 3 1 2 3 1 2 2 1 1 3 1 2 3 3 1 2 2 1 3 2 3 2 1 2 1 3 2 3 1 1 1 2 3 1 3 2 2 2 2 2 3 1 2 2 1 2 2 3 2 2 1 3 1 2 2 2 1 2 3 1 1 3 2 3 2 3 3 2 1 3 2 1 3 2 2 3 1 1 3 3 1 2 3 2 1 3 3 3 3 1 1 3 1 3 2 2 3 3 1 3 1 1 2 1 1 3 1 1 2 3 3 1 1 3 2 2 3 3 3 3 2 2 2 2 3 2 1 3 1 2 1 3 3 1 3 3 2 2 2 3 1 3 1 2 2 2 3 1 3 3 1 3 3 2 3 1 1 2 2 2 2 3 1 1 2 3 1 1 3 1 3 1 1 3 3 2 2 1 3 2 2 2 2 3 1 1 1 2 1 1 1 2 2 3 2 1 2 1 1 2 3 2 1 1 1 2 2 3 3 1 3 1 2 2 1 2 2 1 1 1 1 2 1 1 1 1 3 2 3 1 3 3 1 3 1 2 1 1 1 2 3 3 2 1 1 3 2 3 2 3 3 2 3 3 2 2 1 3 2 2 2 3 2 1 1 3 2 1 2 2 1 1 2 1 2 3 2 1 3 2 2 2 3 1 3 2 1 3 2 1 1 1 3 1 1 1 2 2 2 2 2 3 2 3 1 3 1 3 3 2 3 3 2 3 3 3 2 2 3 3 3 1 3 2 1 1 3 2 3 3 2 2 3 1 1 1 2 3 1 3 3 3 3 1 1 3 3 3 1 1 2 1 2 3 2 1 3 1 1 3 3 3 2 3 1 2 2 2 2 1 2 3 3 3 2 1 3 2 1 3 3 3 1 2 3 3 2 1 1 3 1 1 3 1 3 2 3 1 3 2 2 3 2 3 3 2 1 2 3 1 1 1 3 3 3 3 1 2 2 1 3 2 1 3 3 1 1 2 2 1 1 1 2 1 3 2 1 2 3 2 1 1 3 2 2 3 1 1 1 2 2 2 2 3 2 1 3 3 2 3 2 3 2 3 1 1 3 2 1 2 3 1 2 2 1 3 3 2 2 1 3 3 1 3 1 1 3 2 3 2 2 1 2 2 3 2 2 1 3 1 2 1 3 2 1 3 1 3 2 3 2 2 2 1 3 1 1 2 2 3 2 1 2 1 2 3 1 1 3 1 3 2 3 1 1 1 3 1 2 1 3 1 1 2 2 1 2 1 1 2 1 3 1 2 2 2 2 2 1 2 3 2 1 3 1 2 1 2 2 2 1 1 1 2 3 1 1 3 2 3 2 2 2 2 2 2 2 1 2 2 3 3 3 2 1 1 1 3 2 2 3 2 2 1 2 2 2 3 3 3 1 3 3 2 3 1 2 3 1 3 2 1 1 2 1 1 2 1 1 3 3 2 2 3 2 1 2 3 2 1 3 1 2 3 1 3 3 3 2 1 2 2 1 1 1 3 3 2 1 1 1 3 1 2 1 2 2 3 2 3 3 3 2 3 3 1 2 3 2 1 1 1 2 3 1 2 3 1 2 3 1 3 1 3 1 2 2 1 1 3 1 1 3 1 2 3 2 1 3 3 2 2 2 2 2 3 3 2 1 1 1 2 2 3 2 3 3 2 3 1 3 2 2 2 1 2 2 2 2 3 2 1 1 2 2 3 3 2 1 2 3 2 2 3 2 3 2 3 3 1 3 3 3 2 3 1 2 3 3 2 3 1 2 2 1 1 3 3 2 3 2 1 3 2 3 3 1 3 1 2 3 1 2 2 2 3 3 2 1 3 1 3 2 2 3 2 2 2 2 2 2 2 3 3 1 3 2 3 2 1 1 2 1 2 1 1 2 2 3 3 2 1 1 1 3 3 2 1 1 3 1 3 1 3 3 2 2 2 3 1 1 2 3 3 1 2 2 2 1 3 3 1 3 3 1 2 3 3 2 3 3 2 1 3 1 2 1 3 1 1 1 3 3 2 1 1 1 2 2 3 3 2 3 3 1 3 2 3 3 3 2 2 1 2 3 2 3 3 2 2 2 1 2 3 3 3 2 3 3 1 1 3 3 1 2 1 3 3 3 1 3 3 3 2 1 3 3 1 3 2 3 1 2 1 3 3 3 3 1 3 3 1 1 3 2 3 2 1 3 1 1 2 2 1 1 3 1 3 1 3 1 2 2 2 2 3 2 1 3 3 1 2 3 2 3 2 3 1 2 2 2 2 3 1 1 1 3 2 2 3 1 2 2 3 3 2 1 2 1 3 2 1 3 2 1 3 1 1 2 1 2 3 2 3 1 1 2 3 1 1 2 2 2 2 3 2 2 1 2 1 2 1 1 1 1 1 3 1 1 3 3 3 1 3 2 3 3 1 2 1 2 2 3 1 3 3 1 3 3 3 1 1 2 2 3 2 2 3 2 1 3 3 3 3 3 2 1 2 2 3 1 1 1 1 1 3 3 2 3 3 3 2 3 2 1 2 3 2 2 1 2 2 1 2 3 3 1 3 3 2 1 1 1 2 3 2 3 1 3 2 2 3 1 1 2 1 3 2 2 2 2 1 2 2 1 1 2 1 1 2 1 1 2 2 3 2 2 2 1 2 3 2 3 2 3 2 1 2 3 3 3 1 1 2 1 3 1 2 1 1 3 3 1 1 3 2 2 1 3 2 2 2 2 1 3 2 2 2 2 2 3 2 3 2 3 3 3 1 3 3 1 1 3 1 2 2 1 1 2 3 2 3 2 1 3 1 2 3 2 3 3 3 2 1 2 1 3 2 2 1 2 3 3 1 2 2 1 3 3 3 3 1 3 3 2 2 3 2 1 3 2 2 1 3 1 3 2 1 2 3 1 3 3 1 2 2 3 1 1 3 3 1 3 3 3 1 1 1 2 3 3 2 3 3 1 2 1 2 3 3 2 2 3 3 3 3 2 2 3 3 3 1 1 1 1 1 1 2 3 2 2 1 2 1 3 1 2 3 3 1 1 3 1 2 2 1 1 1 2 1 3 3 1 1 1 3 2 1 3 2 2 3 3 2 2 1 1 3 1 2 2 2 1 2 1 2 2 1 3 3 1 2 3 3 3 1 3 3 1 3 3 2 2 2 3 2 2 3 1 3 2 1 3 2 2 1 1 1 2 2 2 1 1 3 1 3 3 2 2 1 2 2 3 3 2 2 2 2 1 1 2 3 1 3 3 2 3 2 3 1 2 2 2 2 2 3 3 2 1 2 2 3 2 3 2 2 1 1 1 2 2 3 1 3 1 2 3 2 1 3 3 1 1 2 3 3 2 1 3 1 2 2 3 1 1 1 3 2 3 1 3 1 3 2 2 3 3 3 2 3 3 3 2 3 3 2 2 1 2 1 3 3 1 1 3 3 2 2 3 2 1 2 3 1 1 2 3 2 1 2 3 1 1 3 1 3 1 3 2 2 1 2 1 2 2 1 2 3 3 1 3 2 2 1 2 2 3 3 3 1 2 1 2 2 3 1 3 1 2 1 3 1 2 1 2 2 1 2 3 3 1 3 3 1 3 2 1 2 3 3 3 3 3 1 2 1 2 2 3 1 2 3 1 3 3 1 1 2 1 1 1 3 2 1 3 3 1 3 2 1 2 1 1 1 1 2 1 3 1 2 1 1 3 2 1 1 2 3 1 1 3 3 3 1 1 2 2 3 1 2 1 3 2 3 3 3 3 1 1 3 3 3 1 2 3 3 3 3 3 1 3 2 2 1 3 1 3 1 3 2 1 1 1 1 1 3 1 1 2 1 2 2 2 3 3 2 3 2 3 2 3 3 1 2 2 3 2 2 1 3 3 3 2 3 1 3 3 2 2 1 2 3 2 3 3 2 1 1 3 1 2 2 2 1 2 1 1 2 2 2 1 2 1 3 1 3 3 1 2 2 3 1 3 1 2 1 2 1 3 3 1 3 2 3 2 1 1 3 2 1 1 2 2 2 1 3 3 3 1 3 3 2 3 3 1 2 3 2 3 2 2 1 2 2 3 1 3 2 3 1 2 2 1 3 3 3 2 2 3 2 2 2 1 3 3 1 1 1 2 3 1 2 3 1 1 1 1 3 3 1 1 3 1 1 3 1 1 1 2 2 1 1 1 1 2 1 1 2 3 1 2 1 2 2 2 3 2 1 1 1 1 2 2 3 2 3 1 1 3 3 2 2 1 2 1 1 1 2 2 2 2 3 2 3 3 2 2 1 1 3 1 3 2 1 2 2 2 3 1 2 1 3 1 3 3 3 1 2 1 1 2 3 2 3 2 3 3 1 3 3 3 2 2 3 3 3 3 3 3 3 2 1 1 3 1 1 3 2 1 2 3 2 3 2 3 3 1 2 3 2 3 2 1 2 3 3 2 3 1 2 1 2 1 2 1 2 3 2 2 2 3 1 2 3 3 1 1 1 3 2 2 3 1 3 2 3 1 2 1 1 2 3 3 3 1 1 1 3 2 1 2 1 2 3 3 3 3 1 1 1 3 2 2 2 3 1 2 1 2 3 1 2 1 2 1 3 1 1 1 2 1 1 3 2 2 3 1 3 1 1 3 3 1 3 1 3 2 2 3 1 2 3 3 3 3 2 2 1 1 3 2 1 3 1 1 2 3 2 2 2 2 3 1 2 2 1 1 2 2 2 1 1 2 3 1 2 2 1 2 3 3 2 1 2 2 1 3 2 1 3 2 1 3 2 3 2 3 1 2 2 2 1 2 3 1 2 2 1 1 1 3 2 3 2 3 3 1 3 3 3 1 3 1 1 1 2 1 3 2 3 1 1 1 1 2 2 3 3 1 1 3 1 3 2 1 2 2 2 1 2 3 1 1 2 3 2 3 3 1 3 2 1 2 2 3 3 1 3 2 2 2 1 1 2 2 2 3 1 3 2 1 3 3 2 3 3 3 2 2 3 2 1 3 2 2 2 3 2 1 2 2 3 2 2 2 3 2 3 1 2 1 1 1 3 1 2 2 2 1 3 1 2 3 1 2 1 1 1 1 3 3 2 2 1 3 2 2 2 3 1 3 3 2 2 2 3 2 3 1 2 2 2 3 2 3 2 2 3 2 3 1 3 1 2 2 3 2 1 1 1 2 3 1 2 3 1 3 1 1 3 1 2 1 1 3 1 2 3 2 1 3 3 3 1 1 2 3 3 1 2 1 2 3 3 3 1 1 2 1 3 2 3 3 3 3 2 3 3 1 1 2 2 3 1 3 2 3 1 2 3 3 2 2 1 2 3 2 1 2 2 2 2 3 2 2 2 1 2 3 3 1 1 2 3 2 2 3 3 3 1 3 2 2 2 1 1 3 2 1 1 1 3 2 1 2 1 2 2 1 2 3 1 2 2 1 1 3 1 2 3 3 3 1 1 3 1 3 3 1 3 2 2 3 1 3 3 3 3 3 3 1 3 2 1 2 3 2 2 2 2 3 3 1 2 3 1 3 3 3 2 2 3 1 3 1 2 2 1 1 2 1 2 1 3 3 2 1 3 1 1 2 1 2 3 1 2 2 2 3 3 3 1 1 1 1 3 2 1 2 2 3 1 3 3 2 2 2 2 1 2 3 1 3 3 2 2 3 1 2 3 2 3 2 1 2 3 2 3 3 1 3 1 2 3 2 3 3 1 1 3 3 3 1 3 1 2 2 3 1 3 1 1 3 1 1 3 3 3 2 2 1 1 3 2 1 2 3 2 3 3 2 1 2 2 1 3 3 2 3 2 3 2 2 3 2 1 1 2 2 1 3 3 3 3 2 3 1 3 1 1 1 3 3 2 1 3 1 3 2 1 3 2 1 3 3 1 3 1 3 3 1 2 2 2 3 1 3 2 2 1 2 1 3 2 2 2 1 2 3 3 3 1 1 2 3 3 1 3 1 2 3 1 1 1 3 1 3 2 3 2 3 1 3 3 1 2 2 1 1 2 1 2 3 3 1 2 2 1 2 2 1 1 1 1 2 2 1 2 3 3 2 1 3 2 1 2 1 1 1 1 2 1 2 3 1 2 3 2 1 3 2 1 3 3 3 1 3 1 2 2 3 1 3 2 1 1 1 2 2 2 3 2 2 3 3 2 2 2 1 2 2 2 1 3 3 2 1 3 2 3 2 2 1 3 1 3 2 3 1 3 3 1 1 3 3 3 1 2 3 1 2 3 1 3 1 2 2 3 1 3 3 3 2 3 3 3 2 3 2 3 1 3 2 3 3 3 3 2 1 1 1 1 2 2 1 1 3 2 3 2 3 3 2 3 3 2 2 3 2 3 3 1 3 3 2 2 2 3 3 1 1 2 1 1 3 3 3 2 3 3 1 1 2 3 2 2 2 2 1 1 1 3 3 1 3 2 1 1 1 1 3 3 1 3 1 2 2 3 2 1 1 2 1 3 2 3 2 1 3 3 3 2 3 2 3 3 2 2 3 1 3 2 2 2 3 3 1 1 2 2 3 1 2 2 2 3 3 3 1 2 3 3 1 3 2 2 1 2 1 2 3 1 3 3 1 2 2 2 2 2 1 3 2 2 3 2 1 1 1 3 3 2 1 1 2 2 3 3 3 1 2 1 3 2 2 1 3 1 2 3 1 3 1 2 1 3 3 1 2 2 3 2 1 1 1 2 3 3 3 3 1 1 1 2 2 2 2 1 1 1 3 2 3 2 2 3 2 1 1 1 2 2 3 2 2 3 3 2 3 2 1 1 1 3 1 1 1 2 1 2 1 1 3 2 2 1 2 2 3 3 1 3 1 3 2 1 2 3 1 1 1 3 2 1 2 2 1 1 1 1 2 1 3 3 1 1 1 1 2 2 1 1 1 2 1 3 2 2 3 1 1 1 1 2 3 2 2 1 2 3 1 1 2 3 3 1 1 3 3 2 1 2 3 2 3 3 2 3 3 1 1 2 1 2 2 3 2 3 2 3 1 1 2 2 1 1 1 1 2 3 1 2 2 1 2 1 3 3 3 3 2 3 3 2 1 2 1 2 3 2 1 2 2 3 1 1 2 2 2 3 3 2 3 1 3 2 2 2 1 1 2 1 2 1 1 1 1 2 2 1 1 1 2 1 3 2 2 1 1 2 1 1 1 2 2 2 2 3 3 2 1 1 3 3 2 3 2 2 1 3 1 1 2 1 1 3 3 2 2 1 2 2 1 1 3 2 3 1 2 2 1 3 3 2 1 1 2 2 2 2 2 1 3 1 3 3 3 3 1 3 2 3 2 3 1 3 1 3 2 2 3 1 1 1 1 3 2 2 2 1 3 1 2 1 3 2 3 1 2 2 3 3 2 2 1 3 1 3 3 3 3 2 3 1 2 1 3 3 3 2 1 3 2 2 3 1 1 2 3 3 1 1 2 2 3 3 3 3 3 3 2 3 1 3 1 1 1 2 1 3 1 3 1 1 3 1 3 1 1 2 1 2 2 3 1 2 1 3 1 2 3 2 2 2 2 2 3 1 1 2 2 3 3 1 1 2 2 3 3 3 1 3 2 3 1 3 1 3 1 3 1 1 3 3 3 1 1 3 3 3 2 2 1 2 2 3 1 2 2 3 3 1 2 1 2 3 3 1 2 2 3 2 2 2 1 1 2 2 2 2 3 3 1 2 2 2 1 2 1 1 3 1 1 1 1 2 2 2 1 1 1 2 3 1 2 3 1 3 3 3 2 1 1 1 1 2 3 3 1 3 1 1 2 2 2 3 2 2 2 3 1 1 1 3 2 2 1 2 3 1 2 1 3 3 3 1 1 3 3 1 1 3 3 1 2 3 1 3 2 2 2 2 3 3 2 3 3 2 2 3 2 2 1 3 1 1 1 3 3 2 2 1 1 1 3 2 1 3 1 3 2 3 2 1 3 3 3 2 2 3 2 2 1 3 1 1 3 2 2 3 2 1 3 3 1 1 3 1 3 1 1 3 1 2 1 2 3 1 3 3 3 3 2 2 3 3 3 3 2 3 1 1 3 1 1 3 3 1 3 3 3 3 1 1 2 2 1 3 3 2 2 3 3 3 3 1 1 1 2 2 3 2 3 1 1 2 3 1 3 3 2 2 2 1 3 1 1 3 3 1 1 2 2 2 3 1 3 2 2 2 3 1 1 3 3 2 2 1 2 1 2 2 1 3 1 3 1 3 2 1 3 3 3 3 2 2 2 3 3 2 2 1 1 2 3 2 1 3 3 1 2 1 2 3 1 1 2 3 3 1 3 2 2 1 3 3 1 1 1 2 1 2 2 1 1 1 2 2 3 1 2 1 3 2 3 1 1 3 1 2 1 3 3 2 2 1 1 1 3 1 2 2 2 3 2 3 2 2 3 1 2 2 1 1 3 3 3 1 3 1 2 2 2 3 1 3 2 1 1 1 3 1 3 2 3 3 3 1 1 2 2 2 3 2 2 2 2 1 1 2 1 1 2 2 2 1 1 1 2 1 3 3 1 3 2 1 2 2 1 2 3 1 1 2 2 3 3 2 2 1 3 3 1 3 2 2 3 2 1 1 3 2 3 1 1 2 3 2 2 2 1 2 2 3 3 2 2 1 1 2 1 1 1 2 1 1 2 3 2 2 2 3 2 2 2 2 2 1 3 1 3 3 3 3 2 3 3 3 2 1 1 1 3 2 3 3 1 1 1 3 1 3 3 2 1 1 2 3 2 3 2 3 2 1 3 3 1 1 2 2 2 1 1 2 3 2 1 1 3 1 3 1 1 3 2 3 2 3 1 1 3 1 3 3 2 3 2 3 1 1 3 1 3 2 3 1 3 2 1 2 1 1 2 2 3 2 1 2 1 1 2 1 2 1 1 2 3 3 3 3 2 2 3 3 2 1 1 1 3 3 3 2 1 2 2 1 2 2 1 3 2 1 2 1 1 1 3 1 2 1 3 3 3 2 3 1 3 2 1 1 2 3 1 3 2 3 3 1 2 1 3 3 1 1 1 2 2 3 2 1 3 2 2 1 2 2 1 3 3 1 2 2 3 3 2 2 1 3 3 2 2 1 1 3 2 3 2 2 1 2 1 3 3 2 1 3 2 3 3 1 3 2 2 3 2 3 3 2 3 1 2 3 3 1 2 1 1 2 3 3 2 2 2 3 1 2 1 3 2 1 3 3 2 1 1 3 3 1 3 3 1 2 1 2 2 3 2 3 2 1 1 3 1 3 3 1 2 2 2 3 2 3 2 3 3 1 2 3 3 2 2 3 1 1 2 3 1 2 3 2 1 1 2 1 1 1 3 3 3 3 1 2 2 2 3 3 2 1 3 1 1 2 3 3 3 3 1 3 2 2 1 2 3 3 3 3 1 3 3 3 1 2 1 2 1 1 1 3 3 1 1 1 2 2 1 3 3 2 3 1 3 2 1 2 1 1 1 1 1 1 2 3 2 1 3 3 2 2 1 1 3 2 1 1 3 2 1 2 1 2 3 1 2 2 3 3 2 3 3 1 2 2 1 3 1 2 3 3 3 2 2 2 3 3 2 2 3 3 2 1 3 3 3 1 3 1 2 3 2 1 2 1 2 2 3 1 2 3 2 3 3 3 1 3 3 3 1 2 3 2 3 3 2 1 2 1 3 1 3 3 2 3 3 2 1 3 3 1 1 3 1 2 3 3 2 3 3 1 2 1 2 1 3 3 3 1 3 3 2 1 2 1 1 1 2 3 1 1 2 3 3 1 1 1 3 2 1 1 1 2 1 2 3 2 2 1 1 3 3 1 3 3 3 1 2 2 2 1 1 1 2 1 1 2 1 1 2 1 1 1 3 3 3 1 3 1 2 2 2 2 1 2 2 1 1 3 3 1 2 2 1 1 3 1 1 3 1 2 2 3 1 3 1 2 3 2 1 3 3 3 1 2 2 1 2 1 1 3 2 1 1 1 3 1 2 1 2 2 3 1 1 3 3 3 3 3 3 1 3 3 2 1 3 2 2 2 1 3 2 1 3 3 2 2 2 1 1 3 1 3 1 2 2 3 2 2 3 3 1 3 3 2 1 3 1 3 3 1 3 2 2 3 3 1 3 3 3 3 3 1 2 3 3 3 3 3 3 1 3 1 3 1 3 2 1 2 1 1 1 1 3 3 2 3 2 3 2 2 2 1 3 2 3 2 2 3 3 2 1 2 2 2 3 2 1 3 1 3 1 2 1 2 3 2 3 1 1 3 1 1 1 1 1 1 2 3 1 2 3 2 2 2 1 3 1 1 1 1 2 1 2 3 2 2 2 1 2 3 1 1 1 3 2 1 1 3 2 1 2 1 2 2 3 3 1 3 1 3 1 1 1 3 2 2 3 2 2 2 3 2 2 3 3 3 1 2 2 2 3 1 3 3 3 3 1 1 1 2 1 2 2 1 3 2 2 2 2 1 2 3 3 1 1 1 1 1 3 3 3 3 1 1 1 3 3 2 3 2 1 2 2 3 2 2 3 1 2 3 1 3 1 3 2 3 1 3 1 1 2 2 1 2 3 3 3 2 3 3 2 2 3 1 2 3 2 2 3 3 3 1 2 1 1 2 3 1 3 1 3 3 1 1 2 2 3 3 2 2 1 2 1 1 3 2 2 1 1 2 3 2 2 1 1 3 2 3 3 3 2 3 1 1 1 2 1 2 3 2 3 2 3 1 2 3 2 3 1 1 2 2 3 1 1 2 1 3 3 1 3 2 2 2 3 1 1 1 1 1 2 2 2 3 2 1 2 2 2 1 2 1 3 1 3 1 3 2 1 2 3 1 3 1 2 3 2 3 1 2 3 2 1 2 2 3 3 3 1 3 3 3 2 2 3 1 3 1 2 3 2 3 2 3 3 2 3 3 2 2 2 1 1 2 2 2 3 3 1 2 1 1 3 1 1 2 1 2 1 3 2 1 1 2 2 1 3 1 3 2 1 1 3 1 2 3 3 2 3 3 1 1 3 3 1 1 1 2 1 2 1 2 2 1 3 2 1 2 2 1 1 2 2 2 2 3 1 3 1 2 3 1 2 1 2 3 3 1 1 3 1 1 2 1 3 3 1 1 1 1 3 2 2 3 2 2 1 2 1 1 3 1 1 1 1 1 1 2 3 3 1 3 2 2 2 3 2 2 3 3 3 2 2 3 2 3 2 2 1 3 3 3 3 3 3 3 1 1 3 1 2 2 1 2 2 1 2 2 3 3 3 2 1 3 2 1 3 3 1 3 2 3 3 3 2 1 1 3 3 3 2 2 3 1 3 1 3 3 1 3 3 3 3 2 1 1 1 2 3 3 2 2 2 2 3 2 2 3 1 1 3 2 2 2 1 2 2 2 1 3 1 2 1 1 1 1 3 2 3 3 2 1 3 1 2 3 3 2 3 1 3 2 3 1 1 1 3 3 1 2 1 1 2 1 3 1 3 3 1 1 1 2 2 2 2 1 3 2 3 3 3 2 3 1 3 2 2 1 1 3 1 3 2 2 1 3 1 3 3 1 2 2 2 1 1 2 2 3 2 2 2 2 1 3 1 1 3 3 1 1 1 1 2 3 1 2 3 1 1 2 2 1 2 1 3 3 2 2 2 2 2 3 2 2 3 2 2 2 3 1 2 2 2 1 1 1 1 3 3 1 1 3 3 2 2 2 3 3 3 1 3 3 2 1 1 2 3 2 1 3 1 1 2 1 2 1 1 2 3 1 1 1 1 3 3 1 2 1 2 1 1 2 3 1 1 1 1 2 1 3 1 3 2 2 3 1 1 3 3 1 1 1 2 2 3 1 2 1 1 2 3 2 3 1 1 3 1 3 3 1 1 1 3 3 3 3 1 3 2 2 1 1 2 1 2 2 3 1 3 1 1 1 3 2 3 2 1 1 3 1 2 2 3 3 3 3 2 3 1 2 2 3 2 3 2 1 3 1 2 2 3 2 3 3 3 3 3 1 3 2 1 3 2 3 1 1 2 1 3 2 1 1 1 1 1 3 1 1 2 2 2 3 3 2 2 1 1 1 1 3 1 3 3 3 2 3 1 2 1 1 3 3 3 2 1 3 2 2 2 2 1 2 2 1 3 1 2 3 2 1 3 1 3 3 1 1 3 2 1 1 3 2 3 2 3 2 3 1 2 2 1 2 2 2 3 1 2 2 3 3 2 3 3 2 3 2 3 2 3 3 1 3 1 1 1 3 3 3 2 2 2 1 2 1 3 1 2 1 3 2 2 3 1 1 3 1 1 2 3 2 3 2 3 1 2 1 2 1 3 1 3 2 1 2 3 3 2 2 1 1 3 3 3 1 3 2 2 2 2 1 2 2 3 2 1 1 3 2 1 2 3 2 1 3 1 3 3 2 1 1 3 3 1 3 3 3 1 2 1 2 2 3 2 1 3 1 2 2 3 1 1 3 3 1 3 1 3 3 1 1 1 3 3 1 1 2 3 3 2 1 1 3 3 1 1 1 2 2 1 3 1 3 3 3 2 2 2 2 3 1 1 3 1 3 1 3 2 3 3 2 2 1 1 1 2 3 2 3 2 3 2 2 2 1 3 3 2 3 1 2 3 3 3 3 1 1 1 3 2 1 3 2 2 3 3 2 1 1 2 1 1 2 3 1 2 1 2 3 1 2 3 3 1 2 2 1 1 2 3 3 3 3 3 1 2 2 2 2 1 1 2 3 2 2 1 3 2 3 1 3 3 2 3 3 2 3 2 3 2 3 3 1 2 1 3 3 3 3 1 2 1 3 2 1 3 2 1 1 3 2 3 1 3 1 2 2 1 3 1 3 2 2 3 2 3 1 2 1 2 1 1 3 2 3 3 1 2 2 2 1 1 1 1 1 3 2 2 1 2 2 2 3 3 2 1 3 1 2 2 3 2 1 3 2 1 1 2 2 1 3 3 1 2 2 2 2 1 2 3 2 2 2 3 3 1 2 1 1 3 3 2 2 2 3 3 2 1 3 2 2 3 3 3 3 3 1 1 3 2 1 2 1 2 2 1 3 3 1 3 2 1 1 3 2 3 3 3 2 2 3 1 1 3 1 3 3 1 3 2 3 1 2 1 3 2 3 3 3 3 1 1 1 1 3 1 3 1 3 1 2 2 3 3 2 2 1 3 1 3 1 3 1 1 2 3 2 3 2 2 1 2 3 2 1 2 3 3 3 3 2 2 2 1 3 2 1 1 1 3 2 2 2 1 1 1 2 2 1 1 1 1 1 1 2 3 2 2 1 3 3 1 3 3 3 1 3 3 1 3 3 3 3 1 2 2 3 1 3 1 3 1 2 3 1 2 2 2 2 3 1 3 2 1 3 2 1 1 1 3 3 3 3 2 3 3 3 1 1 2 1 2 1 3 3 1 3 3 1 2 3 3 2 1 1 2 2 3 3 3 1 1 1 1 1 3 3 3 1 2 3 1 2 1 2 3 2 1 3 2 3 1 1 2 2 1 1 3 2 2 1 1 1 3 3 2 2 1 3 2 1 2 3 2 3 2 1 3 1 3 3 3 3 2 2 3 1 2 3 2 2 2 1 2 1 2 2 2 3 1 2 2 2 2 2 1 2 2 2 2 1 3 3 1 2 2 1 2 2 2 3 3 3 2 2 1 3 3 3 3 1 3 2 3 3 2 2 3 1 1 1 2 2 2 3 3 3 2 2 1 3 2 1 2 3 2 1 3 1 3 2 2 1 1 1 3 1 2 1 2 2 3 3 2 3 3 3 3 2 1 1 1 1 1 2 1 1 3 3 2 3 3 3 3 1 1 3 3 2 3 3 2 1 1 1 2 3 2 2 2 2 2 2 1 1 3 3 1 3 3 2 1 1 3 1 3 1 3 2 2 2 3 2 2 3 3 1 1 2 1 1 2 1 3 2 3 1 3 2 1 1 2 1 3 3 1 1 1 2 3 2 3 2 3 3 2 2 3 3 2 1 3 2 2 2 2 1 2 2 2 2 2 2 3 2 1 2 1 2 3 3 2 2 2 3 1 3 1 3 2 2 1 3 2 3 2 2 2 1 2 2 1 3 3 3 3 3 2 3 2 1 1 3 1 1 1 3 3 1 3 3 3 3 2 2 3 1 2 3 3 2 2 1 2 3 3 1 1 2 2 1 2 1 1 1 2 2 3 1 1 3 1 1 2 2 3 2 1 1 2 2 2 3 2 2 2 3 1 3 2 1 1 2 2 1 1 1 1 1 1 1 3 3 3 2 1 1 1 2 2 2 3 2 2 3 1 2 1 3 3 2 3 1 1 3 3 3 1 2 3 2 1 1 3 3 2 3 3 1 2 2 1 2 1 1 2 1 1 2 2 3 1 1 2 2 1 1 1 3 1 2 3 2 2 2 1 1 1 3 2 3 3 1 2 2 2 3 1 3 2 2 3 2 1 2 3 2 3 2 3 2 1 1 3 3 1 1 2 3 3 2 2 3 3 2 2 2 1 3 3 3 3 1 2 1 2 3 3 2 3 1 1 2 3 1 3 1 1 3 1 1 3 2 3 3 2 3 3 1 1 1 1 1 2 1 1 2 2 2 2 2 1 1 3 2 1 3 2 1 2 2 2 3 3 2 2 2 1 1 3 1 1 2 3 2 2 3 2 1 2 1 3 1 1 1 2 1 1 3 1 1 1 2 2 2 3 2 1 2 3 1 2 3 1 2 1 2 2 2 1 1 3 1 3 3 3 1 3 3 2 3 3 3 1 3 3 1 1 2 1 1 3 1 2 3 1 3 3 1 1 2 2 2 1 2 2 2 2 2 3 1 2 3 3 1 1 2 1 1 1 2 2 1 1 1 3 1 2 2 1 1 3 2 1 1 2 2 3 1 3 1 2 3 1 3 3 2 3 3 1 3 2 3 1 3 2 3 2 1 1 1 1 3 1 1 3 3 1 1 2 2 2 3 3 1 3 2 1 2 3 1 3 3 2 3 2 1 2 1 1 1 3 3 2 1 1 2 1 1 2 2 3 3 2 1 2 2 3 3 1 1 1 3 2 1 2 2 2 2 3 2 2 3 2 3 3 1 2 2 1 3 3 1 1 2 2 1 3 2 2 1 1 1 1 2 1 1 1 3 3 2 3 1 2 1 1 2 1 1 1 2 2 1 3 1 2 2 2 1 1 1 1 3 1 2 2 3 1 1 2 1 2 2 1 2 2 2 2 2 2 3 2 1 2 1 1 2 2 1 3 3 3 2 1 1 3 2 2 1 2 1 2 1 2 3 1 2 3 2 1 3 2 1 2 3 2 3 2 1 1 3 1 1 1 2 1 1 3 1 3 1 3 2 3 2 2 2 2 1 2 1 1 1 3 3 3 3 3 1 2 3 1 2 3 3 2 1 3 3 3 3 3 2 3 3 3 2 2 1 3 1 1 2 2 3 1 1 2 3 1 3 1 2 1 1 2 2 3 2 3 1 3 2 1 1 2 1 2 3 2 2 1 2 3 3 1 1 2 2 3 3 3 3 1 2 1 3 1 2 3 2 3 2 3 3 3 2 1 1 3 1 2 2 2 1 2 1 3 2 2 3 2 1 2 2 2 2 3 3 2 3 2 2 1 1 2 1 2 2 2 3 3 3 3 1 1 2 1 3 1 2 1 3 2 3 2 1 1 3 2 1 1 1 2 1 3 3 1 2 3 1 2 2 3 2 2 1 3 1 2 3 2 3 3 3 1 1 3 1 3 2 1 1 2 1 1 2 1 1 1 1 2 3 2 3 2 2 1 1 1 1 2 1 1 3 1 3 1 1 2 1 3 3 3 2 3 2 2 1 3 2 1 1 3 2 1 3 1 1 2 3 1 3 1 2 2 3 3 1 3 3 2 1 3 3 1 1 3 1 2 2 3 1 2 2 3 3 2 1 2 2 1 1 2 2 2 3 3 1 1 2 1 3 3 3 1 2 1 2 1 3 1 1 1 1 1 2 1 2 3 3 3 1 2 3 1 1 2 2 2 1 3 2 2 3 3 1 2 2 2 3 1 1 2 2 2 1 2 1 1 2 2 2 1 3 1 1 3 1 3 2 1 1 1 1 1 3 3 2 1 1 1 1 2 1 3 3 1 2 1 3 1 1 2 2 3 2 2 2 1 1 1 3 2 3 2 1 3 1 3 3 2 2 2 2 1 1 3 1 1 2 2 1 2 1 1 3 1 2 1 3 3 1 2 1 1 1 3 3 2 3 1 2 1 3 2 1 2 3 2 3 1 1 2 1 2 1 1 2 2 3 2 3 3 3 1 3 2 3 1 3 2 2 3 2 2 1 3 2 3 2 2 1 1 1 1 1 3 3 1 2 1 2 1 3 2 2 2 1 1 1 2 1 2 2 1 3 3 3 3 2 1 3 3 1 2 2 3 1 1 2 2 3 1 1 1 1 1 2 3 3 2 3 3 2 2 3 1 3 2 2 2 1 1 2 2 3 2 2 2 3 3 2 2 2 2 2 3 1 1 2 3 2 3 2 2 1 3 1 3 2 2 2 3 1 2 3 2 3 1 2 3 2 2 1 3 2 2 3 3 1 2 3 1 2 3 3 2 2 3 1 2 3 3 3 1 1 1 3 3 1 2 1 1 3 3 2 3 3 1 2 2 2 1 3 1 3 3 3 3 2 1 2 2 2 2 1 1 2 3 1 1 2 1 1 1 2 1 3 1 1 1 1 1 2 2 3 2 3 3 2 2 3 3 3 2 3 1 1 1 1 1 2 1 1 2 1 3 3 1 3 2 2 1 3 2 2 3 2 3 2 2 1 1 3 2 2 3 1 1 3 2 2 2 3 1 3 3 1 2 2 3 2 2 1 3 2 1 1 2 3 1 3 1 2 2 1 1 2 3 3 1 1 2 3 2 3 1 1 1 2 2 3 3 2 3 2 2 1 1 3 3 3 2 1 1 2 1 1 2 2 2 1 3 2 3 3 2 2 3 3 1 3 2 1 3 2 1 1 2 1 3 2 2 2 1 3 3 3 3 2 1 2 3 3 3 2 3 3 1 2 1 2 2 2 3 1 2 3 1 2 3 1 2 2 1 1 1 2 2 1 1 3 1 2 2 2 3 3 1 3 3 2 2 1 2 3 1 1 2 2 2 3 3 2 2 2 1 2 2 2 1 3 1 1 3 3 2 1 1 3 2 1 2 3 3 3 2 3 2 1 1 2 1 3 3 2 2 2 3 3 3 3 1 3 2 1 1 3 1 2 3 1 1 1 2 3 3 3 3 1 1 3 3 3 3 1 1 1 3 3 2 3 3 3 2 1 2 3 3 2 2 2 1 2 1 1 1 1 3 3 2 3 1 3 2 2 2 3 1 2 1 2 2 2 3 1 3 1 1 1 1 1 2 2 1 1 2 1 2 2 2 2 1 1 3 1 3 1 3 1 1 1 2 2 2 2 2 1 3 1 2 1 3 2 2 1 2 3 2 2 1 3 1 3 1 1 1 2 2 3 2 3 1 3 3 1 2 1 2 3 3 2 2 3 1 3 2 3 1 3 1 3 1 2 3 2 2 1 2 2 2 3 1 2 3 3 3 2 2 2 2 2 2 3 1 2 3 1 3 2 2 1 3 3 2 3 3 2 1 3 1 2 2 3 1 3 3 3 3 2 1 3 2 3 3 3 2 3 2 3 3 1 1 1 1 3 3 2 2 3 1 2 2 1 1 3 3 3 3 2 3 2 3 3 1 2 3 2 2 3 1 3 2 3 2 3 3 2 3 1 3 1 1 3 2 3 2 3 2 1 1 3 3 3 2 2 3 2 3 3 1 3 2 1 1 3 3 1 3 3 1 3 1 3 3 2 3 3 2 2 1 2 1 1 2 1 2 2 1 2 2 1 1 1 2 1 1 2 2 1 3 1 1 1 3 3 3 2 3 1 2 3 1 3 1 3 1 3 2 1 1 3 2 3 2 1 2 1 2 2 3 1 3 3 2 2 2 3 2 2 2 1 3 2 1 1 3 3 3 2 3 1 1 1 2 2 3 2 2 3 2 1 3 1 3 3 1 1 2 1 3 3 2 2 3 2 3 2 2 1 2 1 2 2 2 3 1 3 2 1 1 3 3 1 2 1 2 3 3 1 2 1 2 1 2 3 2 3 2 2 2 1 2 1 2 2 3 2 1 3 2 1 3 3 1 2 2 3 1 2 1 1 2 2 1 1 2 3 3 3 3 1 1 1 3 1 3 3 3 1 3 2 3 1 3 1 1 1 3 2 2 2 3 2 3 3 2 1 1 2 3 1 3 1 3 3 2 1 2 3 1 3 1 2 3 3 1 2 2 2 3 2 3 2 3 1 2 2 2 2 3 1 2 2 1 3 2 3 3 1 3 1 2 2 1 2 1 1 1 2 1 1 3 1 3 3 2 3 3 1 3 1 2 3 3 3 1 2 2 1 2 1 2 3 2 3 2 1 2 1 1 3 3 2 1 1 2 3 3 1 1 3 2 2 3 1 2 3 2 2 1 2 3 1 1 1 2 2 3 2 3 3 3 2 1 1 3 1 3 2 3 1 3 3 1 2 1 1 2 3 3 2 1 2 3 2 2 1 1 1 3 3 3 3 2 1 3 3 1 1 2 2 1 1 3 1 2 3 2 1 3 3 3 1 1 2 2 3 3 3 3 1 2 2 2 2 1 1 3 1 2 1 2 2 2 3 3 1 3 2 1 2 1 2 1 1 1 3 3 2 3 3 3 3 1 3 1 3 2 3 1 3 3 1 3 2 3 1 1 3 3 1 2 3 2 1 1 1 3 3 2 3 1 3 1 1 3 3 2 2 1 2 2 3 2 3 3 3 2 1 1 2 3 3 1 2 1 3 2 3 1 3 1 2 2 2 2 1 1 2 1 1 3 2 3 1 2 1 3 3 1 1 2 2 2 2 1 3 2 2 3 3 3 3 1 3 1 1 2 2 1 1 1 3 3 1 3 1 3 1 1 1 2 3 2 3 3 2 3 3 2 2 2 3 2 1 3 1 2 3 1 1 3 3 2 2 3 2 3 2 2 2 1 2 2 2 2 2 1 3 2 1 2 1 2 3 2 1 1 3 1 1 2 2 2 3 2 1 1 3 2 2 2 2 3 2 2 3 2 3 1 3 2 1 3 1 2 2 3 2 1 3 1 2 1 1 1 3 3 3 1 2 1 3 3 2 3 1 3 3 1 1 1 3 2 3 3 3 1 2 1 1 1 2 3 2 2 2 3 1 1 2 3 2 1 1 1 2 1 1 3 1 3 2 3 2 1 2 3 2 1 1 3 1 3 3 2 2 2 3 1 3 2 2 3 3 3 2 3 2 2 3 3 2 3 3 3 2 3 1 1 2 2 3 3 2 2 3 2 3 2 2 1 2 1 2 1 2 1 3 1 2 1 1 2 2 3 2 1 2 2 3 3 1 2 3 2 2 3 2 1 1 2 1 3 1 2 3 1 1 3 3 3 3 1 3 3 2 2 2 1 2 3 3 1 3 3 1 1 3 1 2 1 3 3 2 1 2 1 1 2 1 2 3 1 3 2 1 2 2 1 2 3 1 1 3 1 3 3 2 1 2 3 1 3 2 3 3 2 3 1 1 3 3 1 3 2 1 1 2 3 3 3 3 2 3 1 2 2 2 2 2 2 2 2 1 2 2 2 2 3 3 3 3 2 2 1 2 1 1 3 1 2 1 2 1 2 1 2 1 2 3 3 1 3 2 3 2 1 1 2 3 2 1 2 2 1 2 1 1 3 3 2 1 1 2 3 3 2 2 3 2 1 3 3 1 2 1 3 3 3 2 1 3 1 1 2 2 3 2 1 1 2 2 2 1 2 1 3 3 2 2 2 2 2 3 1 2 1 1 1 1 1 3 3 3 1 3 3 3 1 3 2 3 3 2 1 1 2 3 1 1 2 1 3 2 2 2 1 1 2 2 2 2 1 3 2 3 2 3 3 3 2 3 3 3 2 3 3 2 2 1 1 3 1 1 2 3 2 3 1 1 3 1 3 1 3 2 3 1 2 3 3 3 3 1 3 2 1 1 1 1 1 2 1 2 3 3 2 2 3 3 1 3 1 3 3 1 3 1 2 2 3 3 3 2 1 3 2 1 1 3 3 3 3 3 1 2 1 1 2 3 1 3 3 2 1 3 1 2 1 3 3 3 3 3 2 1 2 1 2 2 1 3 3 2 1 2 3 2 2 1 1 1 1 2 1 3 2 3 2 3 3 3 1 1 3 1 2 1 2 1 2 2 3 1 2 2 1 3 2 1 1 1 1 1 1 2 3 2 2 2 3 3 2 1 1 3 3 3 3 1 1 1 1 2 2 1 1 3 2 2 2 3 2 2 3 2 1 3 1 3 3 1 3 3 3 3 1 3 3 3 1 1 1 1 1 1 1 3 2 3 1 2 2 3 3 1 3 3 2 2 3 2 1 3 2 2 2 1 2 2 2 3 3 3 1 2 1 1 1 2 2 1 1 2 1 1 2 2 3 2 2 3 3 1 1 1 3 3 2 2 3 3 3 2 1 3 1 1 3 3 2 2 2 1 3 3 1 3 1 1 3 3 2 3 2 1 2 2 1 3 3 1 1 2 1 2 2 3 3 1 3 3 3 1 1 2 2 3 1 1 3 3 2 2 2 1 3 2 1 3 2 1 3 1 2 3 2 2 2 1 3 3 2 3 1 1 2 3 3 2 3 2 2 3 3 3 2 2 1 2 1 1 3 1 2 3 1 1 1 2 2 3 2 1 3 3 3 2 2 3 3 2 3 3 3 3 1 1 2 1 2 1 2 2 1 2 3 1 1 1 3 2 1 2 2 1 3 3 2 2 3 1 2 3 3 3 3 3 1 3 2 3 3 3 3 2 3 3 1 2 3 1 3 1 3 3 1 2 1 1 2 3 2 1 2 3 2 3 1 2 3 3 1 2 3 3 2 1 1 2 2 3 1 2 1 1 3 2 1 2 1 3 2 3 2 2 3 2 3 3 1 1 3 1 2 3 1 1 2 3 1 3 1 2 1 1 2 1 1 1 2 1 3 1 2 2 2 1 2 1 1 1 3 3 3 1 3 1 2 2 2 2 2 1 3 1 3 2 2 2 3 2 1 2 3 1 1 1 1 3 1 1 1 3 1 1 1 1 2 1 1 3 1 1 1 3 1 3 1 2 1 3 3 3 3 1 2 1 2 1 3 1 2 3 1 1 3 3 3 3 3 2 3 3 2 1 3 3 3 2 3 3 1 2 1 1 1 3 2 1 3 2 3 3 3 3 2 1 1 3 2 3 2 3 3 1 1 2 1 1 2 2 2 3 3 3 2 2 3 2 2 3 2 2 1 1 3 1 1 3 1 3 2 2 2 1 2 2 2 2 2 1 2 3 1 2 3 2 3 1 3 2 1 1 1 3 1 3 1 1 2 2 2 2 2 2 1 1 2 2 1 3 2 1 2 2 3 3 1 3 3 3 3 1 2 1 3 1 1 2 1 3 2 3 2 2 1 1 2 3 1 3 3 3 1 2 3 2 2 3 1 3 1 1 2 3 3 3 1 1 1 1 2 1 3 1 2 1 3 1 3 2 3 1 2 2 1 1 3 1 1 1 3 2 1 3 3 2 3 2 2 2 3 3 1 3 2 1 2 3 1 1 2 3 3 1 3 3 2 1 1 3 1 2 3 1 3 3 3 1 1 2 3 2 2 1 2 1 2 2 1 3 3 2 2 1 3 2 1 3 1 1 3 2 2 1 2 3 2 2 2 3 1 3 1 1 2 1 1 1 3 2 3 2 1 2 2 2 1 3 1 2 3 1 3 2 2 1 2 3 2 3 3 1 3 2 3 1 2 1 1 1 2 2 3 3 2 3 3 3 1 2 2 2 1 1 1 1 2 3 1 2 3 1 2 1 1 1 2 3 3 3 2 2 3 1 2 3 3 3 2 2 1 1 2 3 2 2 1 2 1 1 3 1 2 1 2 2 2 3 1 1 3 2 3 3 2 2 3 1 2 3 2 2 2 3 3 2 3 2 2 1 3 3 1 2 1 3 1 2 1 2 3 1 3 2 3 1 3 3 3 2 3 2 3 3 1 1 3 2 1 2 1 3 2 1 3 1 3 2 2 3 1 1 3 2 1 1 3 2 3 3 2 1 3 1 1 3 2 1 2 2 2 2 1 1 2 2 2 2 2 1 3 1 3 3 3 3 1 1 3 1 1 3 2 2 2 2 2 1 3 3 1 3 2 1 3 3 3 3 2 1 2 2 1 1 2 2 3 1 2 3 3 2 1 1 3 2 3 2 1 1 1 3 1 1 1 2 1 1 1 2 3 1 1 1 2 2 1 1 3 1 2 3 3 2 2 1 1 2 2 1 1 1 2 1 3 1 1 2 2 3 3 2 1 1 1 2 3 3 3 3 1 3 3 1 2 1 1 1 3 3 2 3 3 3 3 2 1 3 2 1 1 2 3 3 3 3 3 3 1 1 3 2 1 2 1 2 1 3 3 2 3 2 2 1 3 3 2 3 2 2 2 2 1 2 1 3 1 1 2 3 2 2 2 1 1 3 3 3 3 1 2 3 1 1 1 1 3 3 2 1 1 1 2 2 3 2 2 1 1 2 3 3 2 2 2 2 2 3 1 1 3 1 3 3 2 1 1 1 2 1 1 1 3 1 3 3 2 2 3 1 2 1 3 2 2 3 2 2 2 3 1 2 1 1 3 3 2 2 1 3 1 3 3 1 1 1 2 3 1 1 1 2 3 2 2 2 1 3 2 1 2 3 1 1 1 2 2 2 3 2 2 3 3 2 3 1 1 2 1 3 2 1 2 1 1 3 2 3 2 3 2 3 3 3 3 1 2 2 1 3 1 1 3 3 2 1 2 3 3 3 2 2 3 3 3 3 2 1 3 2 3 3 3 3 3 2 2 2 2 1 3 1 2 1 3 2 1 2 1 1 2 2 1 2 1 3 1 3 1 2 1 3 1 2 3 1 1 3 1 1 3 2 1 2 1 2 2 1 3 1 2 1 1 1 2 3 1 1 3 1 1 1 3 2 2 3 2 1 2 3 2 2 3 3 3 3 1 3 1 2 2 2 3 1 2 3 3 1 2 3 2 1 1 2 1 3 1 3 1 2 3 1 2 1 3 1 3 1 2 1 3 2 2 1 2 2 2 1 2 3 1 2 1 1 2 1 3 2 2 1 1 2 1 3 3 3 1 3 1 1 3 1 2 2 1 3 1 1 3 3 2 1 1 1 2 3 1 3 2 2 2 3 3 2 2 1 1 1 1 3 3 1 2 3 3 1 2 3 3 3 3 2 2 3 3 3 3 3 2 2 3 2 1 2 3 3 1 1 1 1 1 3 1 3 1 3 1 3 2 2 1 2 3 2 2 2 3 2 1 3 3 2 1 1 3 2 3 2 3 2 3 1 1 2 1 1 2 1 2 2 3 1 3 1 1 3 3 2 1 1 1 2 2 2 1 2 3 2 3 2 1 1 3 2 1 1 2 1 3 3 1 3 1 1 2 1 3 3 1 1 2 2 2 2 3 1 1 3 1 1 1 1 1 1 3 1 1 2 1 3 1 1 3 1 1 2 1 2 1 1 3 1 1 2 2 3 3 1 3 2 2 3 1 2 2 1 2 2 3 2 2 3 1 2 2 1 2 2 3 3 1 3 3 2 2 2 2 1 3 3 3 1 2 3 2 2 3 1 1 1 2 3 1 1 1 2 1 1 2 3 2 2 3 3 3 2 2 1 2 1 3 1 3 3 2 1 2 2 3 3 3 2 2 2 1 3 2 2 2 3 3 1 1 3 2 2 1 3 1 2 2 2 1 2 3 3 2 1 2 3 3 2 2 2 3 3 3 2 2 2 1 3 2 2 2 1 2 2 2 2 3 2 1 2 1 2 2 3 3 1 3 2 2 2 2 3 2 1 3 3 2 2 1 1 3 2 3 1 1 1 1 3 2 2 3 3 1 2 3 2 3 2 3 2 3 3 2 2 2 1 1 2 2 3 1 3 1 2 2 2 3 3 3 1 2 1 1 3 2 2 1 1 1 1 3 1 2 3 1 3 2 3 2 3 2 1 3 1 2 3 3 1 3 2 3 2 2 1 1 2 3 2 1 3 3 3 2 3 3 1 1 2 1 2 3 1 3 3 1 3 2 2 3 1 3 3 1 1 1 3 1 3 3 1 3 1 2 2 2 3 3 1 3 2 3 2 1 1 2 1 2 1 3 3 3 2 1 3 1 3 1 2 2 2 2 3 2 1 1 1 3 3 2 1 3 2 1 2 2 1 3 2 1 2 2 1 3 1 1 1 2 1 3 3 1 1 3 2 3 3 3 1 1 1 2 1 2 2 1 2 2 3 2 1 3 1 2 1 1 2 1 2 1 1 1 2 3 1 1 3 1 3 1 3 1 1 3 2 1 1 3 2 2 1 2 3 3 1 2 3 3 2 1 3 1 1 1 2 2 3 2 3 1 2 2 2 3 3 3 1 3 2 3 3 3 2 2 2 3 2 2 2 3 3 2 2 3 3 3 2 1 1 2 2 3 3 2 3 2 1 2 2 3 3 1 1 3 3 3 1 2 2 2 1 3 1 1 3 2 3 3 2 2 3 1 2 3 2 1 2 2 3 2 2 1 3 1 1 1 1 2 2 3 2 3 3 2 3 2 3 2 1 1 1 3 1 1 1 2 2 3 2 3 3 1 3 1 1 2 1 1 1 1 2 3 2 3 1 2 2 1 3 3 2 2 2 3 2 3 1 1 1 1 1 2 2 2 2 2 2 3 2 3 2 3 3 2 3 2 2 2 1 3 1 3 3 1 3 1 3 2 3 1 1 1 2 1 1 1 1 2 1 1 2 2 3 3 2 2 3 1 2 2 1 1 1 2 3 2 2 2 3 3 3 2 1 3 2 2 3 3 1 2 2 3 2 2 1 2 1 1 2 1 3 1 3 2 3 2 1 2 3 1 2 1 2 1 1 1 1 2 1 3 2 3 2 1 1 2 3 3 2 1 1 1 2 1 2 3 1 2 3 3 3 3 2 2 1 1 3 2 1 3 1 2 1 1 1 3 3 1 3 3 2 2 1 1 1 2 3 3 3 2 1 2 3 1 1 3 1 3 1 2 2 1 2 3 2 2 1 2 3 2 1 3 3 3 2 2 2 3 3 2 2 3 1 1 2 2 3 2 3 2 2 2 2 3 1 2 1 3 2 1 1 2 2 3 3 2 2 2 3 2 1 3 3 3 1 2 3 3 1 1 3 3 3 1 3 3 1 3 1 2 2 2 1 3 3 3 2 2 2 2 3 2 2 3 3 2 2 2 3 2 2 2 2 3 2 2 1 1 3 2 1 1 3 3 3 1 3 3 2 1 1 2 2 3 2 3 3 1 3 3 1 1 1 3 1 3 1 2 3 3 2 2 3 3 2 2 3 1 1 1 2 3 1 2 3 3 3 2 2 3 1 1 1 2 1 2 3 1 1 2 3 1 2 2 3 2 2 3 2 2 2 1 3 1 3 1 1 2 1 2 1 1 2 2 3 3 2 3 3 3 2 2 3 2 2 1 3 2 3 3 1 2 1 3 1 2 1 3 3 1 1 3 3 1 3 3 3 1 2 1 3 1 1 2 3 2 2 2 3 2 1 2 1 3 2 2 1 3 3 2 2 1 2 2 1 2 2 1 1 2 3 2 3 2 3 3 2 2 1 3 3 2 1 3 1 3 3 2 1 2 2 2 2 1 3 2 2 1 2 3 1 1 3 3 2 3 1 3 1 3 2 2 2 3 2 1 3 3 3 2 3 3 3 1 3 1 3 2 2 1 2 3 3 2 3 2 2 2 2 1 2 2 2 3 2 3 1 1 1 1 2 2 3 1 1 1 3 3 3 1 3 2 1 2 2 1 3 3 3 2 1 2 1 3 3 3 2 2 3 3 1 3 2 1 1 3 3 3 3 3 2 1 3 2 2 3 1 1 1 1 2 1 1 1 2 3 1 3 1 3 1 3 1 2 2 2 1 1 3 1 2 2 2 2 3 2 2 3 1 3 2 2 3 2 2 1 3 1 2 3 3 1 1 2 3 2 3 1 3 1 2 1 3 3 3 2 2 2 3 2 3 3 2 1 3 2 3 2 3 2 3 3 1 1 1 2 1 1 3 1 2 3 2 2 2 2 3 3 2 3 2 1 2 3 1 2 1 3 1 1 2 3 1 2 2 3 1 1 2 2 3 2 1 3 2 1 2 2 3 1 3 2 2 1 1 3 3 2 2 2 1 2 2 2 1 2 2 3 1 2 1 2 3 2 2 3 3 3 2 2 1 3 1 2 2 1 2 3 1 2 2 3 1 1 2 2 1 3 3 1 1 1 3 1 2 3 2 2 3 3 1 3 1 2 1 2 2 2 2 3 2 1 3 1 1 2 3 3 3 3 3 1 2 1 2 3 2 1 2 3 1 1 1 3 1 3 3 3 2 3 3 3 3 2 2 3 3 3 3 2 3 2 1 3 3 3 1 3 3 3 3 2 2 2 2 3 2 3 1 1 2 1 2 3 2 2 1 1 2 1 3 2 1 1 2 2 2 2 1 2 1 2 3 1 3 3 1 3 3 2 3 3 1 3 1 3 2 3 1 1 1 1 2 2 2 2 3 2 2 1 2 2 1 2 3 1 1 3 3 3 2 1 3 3 2 2 1 3 2 2 1 1 1 1 3 3 2 2 2 3 2 2 3 3 3 3 1 3 3 1 1 3 2 2 3 1 3 1 2 3 3 2 3 3 3 3 2 1 2 3 1 2 2 3 2 1 2 2 3 3 1 3 1 3 2 3 1 1 3 2 3 3 3 3 2 3 2 2 3 3 2 2 1 3 3 2 1 3 3 1 3 2 2 1 3 1 1 3 3 1 2 2 3 1 2 2 1 3 2 3 2 3 2 2 1 2 1 3 2 3 3 3 2 1 3 1 3 2 3 1 2 2 2 1 3 1 2 3 1 3 1 2 3 2 3 2 1 2 2 1 1 1 2 3 3 2 3 3 2 2 1 1 1 2 2 3 3 2 2 2 2 2 1 1 1 1 3 3 2 3 2 3 3 2 1 1 1 3 3 2 1 3 2 2 2 3 1 3 3 2 1 3 1 1 3 2 3 1 2 2 1 3 1 3 1 2 1 2 1 3 3 3 2 1 2 1 3 2 1 3 1 2 3 2 3 2 2 2 1 2 2 2 1 2 1 1 2 3 3 1 2 3 1 2 3 3 3 3 1 2 1 3 1 1 1 1 2 3 1 1 2 1 1 2 2 1 2 2 3 2 3 3 1 2 2 1 3 3 3 3 1 1 1 2 1 3 1 1 1 1 1 1 3 3 2 2 2 1 2 3 3 3 3 2 2 2 2 2 1 1 3 2 1 2 3 3 3 3 1 3 3 2 2 2 3 1 2 1 1 3 1 1 1 2 2 2 3 3 2 2 2 2 2 3 1 2 1 1 1 2 1 1 2 1 1 3 3 1 2 3 2 2 3 2 2 1 2 3 2 1 1 3 2 1 1 2 2 2 2 2 2 1 3 3 2 1 2 1 1 1 1 3 2 3 1 2 3 2 2 2 2 2 3 2 3 3 3 1 2 2 3 3 1 3 1 3 2 3 3 1 1 3 1 1 2 3 2 2 3 2 3 2 3 1 3 1 2 2 2 1 3 3 3 1 1 2 2 1 3 3 2 2 1 2 2 3 1 2 2 2 2 3 3 3 3 1 1 3 3 2 1 2 3 3 1 3 1 3 3 3 2 1 3 3 2 2 2 2 1 1 1 1 2 3 3 2 1 3 2 2 3 3 1 2 1 3 3 3 2 2 3 2 3 1 3 1 2 3 1 2 1 1 2 2 2 1 1 1 1 2 1 3 1 2 1 1 3 3 2 3 2 2 1 1 2 3 2 2 3 1 3 3 2 2 2 2 3 3 2 1 3 2 1 2 1 2 3 1 3 3 2 1 2 3 3 2 2 2 3 1 3 3 2 1 1 3 1 3 2 2 2 1 2 3 1 2 2 3 3 1 3 2 1 2 3 2 3 1 1 3 3 1 2 1 3 1 2 3 2 1 2 3 2 1 1 1 1 3 1 2 3 2 3 2 3 1 3 3 1 2 3 3 3 1 1 1 3 1 1 2 1 1 3 1 1 2 1 2 1 2 1 2 2 3 3 3 1 1 3 2 2 3 1 1 3 1 1 3 2 1 2 1 3 3 2 3 1 2 1 1 3 1 1 1 2 3 2 1 2 1 2 2 1 3 3 3 1 1 2 3 1 1 3 2 3 2 1 1 2 1 2 2 1 3 1 3 1 3 3 2 3 3 3 1 2 3 1 1 3 2 2 3 3 3 1 1 1 2 2 2 1 3 3 3 2 3 2 2 2 2 1 2 2 3 1 1 1 1 2 1 3 1 1 1 1 1 1 2 1 3 3 2 1 3 3 2 2 1 3 1 3 3 3 3 1 1 3 3 1 2 3 2 1 1 2 1 2 3 2 2 3 3 1 1 3 1 2 3 2 2 3 3 2 1 1 3 3 2 3 1 3 2 1 2 3 1 1 2 2 2 2 3 2 1 3 2 1 3 1 1 1 3 2 1 1 1 1 1 2 2 2 1 3 1 3 3 1 1 1 3 3 2 3 3 1 3 1 1 2 3 1 1 2 1 1 1 2 3 3 2 1 2 3 1 1 1 3 2 1 2 2 3 1 2 3 2 1 3 2 2 3 2 2 2 2 3 1 3 3 2 3 1 3 2 1 3 1 3 1 2 1 2 1 2 2 1 3 2 2 2 1 1 1 3 1 2 3 3 1 2 3 3 1 1 1 2 3 1 2 2 1 2 1 1 2 3 3 3 3 3 3 3 3 3 3 2 1 1 2 3 2 2 1 3 3 3 2 1 3 3 1 2 1 3 1 2 1 1 1 2 3 3 2 3 3 1 2 1 3 3 1 3 2 1 2 1 2 2 1 1 1 3 1 2 2 1 1 1 1 3 1 2 3 2 1 1 1 2 2 2 2 2 3 3 2 3 1 1 2 1 2 3 1 3 1 2 2 1 1 2 1 3 1 3 3 2 1 2 1 2 2 3 3 2 2 2 2 2 3 1 1 1 2 2 1 3 1 2 1 3 2 1 1 3 1 1 1 1 3 2 1 1 2 3 3 1 1 2 2 1 3 3 2 2 2 1 1 2 1 2 2 1 2 3 1 3 3 3 1 3 1 2 3 3 2 3 3 2 1 1 1 2 3 1 3 2 3 1 2 1 3 2 2 3 2 2 2 1 3 2 3 3 3 1 1 2 1 1 3 3 2 3 1 1 3 3 1 1 2 3 3 1 2 3 3 2 1 2 1 2 3 1 3 1 1 3 1 2 3 3 2 3 1 3 3 3 3 2 3 2 1 1 2 3 1 3 2 2 3 3 2 2 2 1 1 3 1 3 3 3 3 3 3 3 1 3 3 3 3 1 1 2 2 2 3 2 1 2 3 2 3 3 3 1 2 3 2 1 2 1 3 2 2 2 1 2 1 2 1 3 2 2 2 3 1 3 1 2 3 1 2 2 3 2 3 3 1 3 3 2 1 3 3 1 1 1 1 2 3 1 1 2 3 3 3 1 1 1 2 2 3 1 3 1 1 1 3 2 1 3 2 3 2 1 1 3 2 3 3 3 2 3 3 2 1 1 2 1 3 2 1 3 1 2 2 1 1 1 1 3 1 1 2 1 1 3 2 3 3 2 3 1 1 2 3 1 2 3 3 1 3 1 1 2 1 3 2 3 1 1 2 1 1 1 2 2 3 1 3 2 3 1 2 2 3 1 1 1 1 1 3 2 3 2 2 2 1 1 2 1 2 3 1 3 2 1 1 2 3 2 2 2 3 2 1 1 2 2 2 1 3 1 1 3 3 1 3 1 3 2 3 2 2 2 1 2 2 1 1 1 1 1 1 2 2 3 3 2 1 3 3 3 3 2 2 1 3 1 3 1 3 1 2 2 2 2 2 1 2 2 2 3 3 1 1 3 3 2 2 2 3 1 2 1 3 3 2 2 1 2 3 3 1 3 2 3 2 1 3 1 2 3 2 3 1 2 1 1 1 2 1 2 3 2 2 1 3 1 2 1 3 3 3 2 1 3 2 3 3 2 3 3 2 3 1 1 3 2 3 3 2 3 2 3 3 1 3 3 2 3 3 2 2 1 3 2 2 1 3 3 2 3 2 3 1 3 2 1 2 3 1 3 1 3 1 1 2 2 3 1 3 3 2 3 2 1 2 1 1 3 3 2 1 2 2 3 2 2 1 1 1 3 2 2 3 2 1 1 3 2 1 1 1 2 2 2 3 2 3 3 2 3 1 2 3 3 1 3 1 1 1 2 2 2 1 2 1 3 1 2 2 3 1 3 2 1 1 3 2 1 2 1 2 2 1 2 1 1 3 1 1 2 3 2 2 2 3 1 1 3 1 1 2 1 2 3 1 3 2 1 1 2 1 2 3 1 3 1 3 1 2 2 1 2 1 2 3 2 3 1 1 2 3 3 3 2 2 3 1 3 3 1 1 3 3 3 2 2 2 2 3 1 2 3 1 3 2 3 2 3 3 1 1 2 2 2 2 2 1 2 2 3 1 1 2 2 1 1 1 2 1 1 2 3 1 3 1 2 1 1 2 2 3 1 3 3 2 2 3 2 1 1 3 1 2 1 1 1 1 2 1 3 3 3 2 3 3 2 1 2 1 2 3 3 1 2 3 3 1 3 3 1 2 1 1 1 2 1 2 3 1 2 2 3 1 2 3 2 1 3 2 3 1 2 1 2 2 1 1 3 2 1 3 2 3 3 2 1 2 2 3 1 3 1 2 3 2 2 2 1 2 2 1 2 1 1 2 1 1 1 3 2 2 3 3 3 3 1 2 2 2 2 1 2 2 1 1 1 3 2 2 1 2 3 3 1 1 2 2 2 2 3 1 1 3 2 3 1 2 2 3 1 2 3 3 2 3 2 1 3 3 1 2 3 2 2 2 1 1 2 3 3 3 2 1 2 2 3 3 1 3 3 3 2 2 3 1 1 2 1 1 1 1 3 1 2 3 3 3 3 2 2 2 2 1 1 2 3 1 3 3 3 2 2 1 3 3 1 3 1 1 1 3 3 1 2 3 1 2 2 3 3 3 1 3 1 1 2 3 2 3 3 1 2 3 3 3 3 1 2 2 3 2 3 1 1 1 3 3 3 3 2 3 2 3 3 1 2 3 1 2 3 3 3 3 1 3 2 1 3 1 3 1 3 3 1 1 2 3 3 2 3 2 2 1 2 2 2 3 2 3 1 1 3 3 2 2 2 3 2 1 3 3 2 2 1 3 3 3 3 1 2 1 3 1 2 1 3 2 2 2 2 1 1 3 1 1 3 1 1 1 3 1 1 2 2 3 1 3 1 1 2 1 3 2 1 2 1 2 3 3 3 2 3 3 2 1 1 1 3 1 1 1 2 3 1 2 2 2 1 1 2 2 3 2 3 1 1 1 3 2 2 1 3 2 3 3 1 1 2 3 2 1 2 3 2 3 3 2 1 2 3 1 2 3 1 3 2 1 1 2 3 2 2 3 1 3 2 1 1 2 3 3 1 3 3 1 3 2 2 1 2 3 1 2 2 1 2 1 3 1 2 1 1 1 2 1 2 2 3 2 2 1 3 1 1 2 3 2 1 1 3 1 3 2 1 2 3 1 3 2 1 2 3 1 2 2 2 3 3 3 2 2 1 3 3 3 3 3 2 3 3 2 2 1 1 1 3 1 3 1 3 1 3 3 3 1 1 3 2 2 2 2 3 1 3 3 2 1 2 3 1 1 2 3 2 2 3 2 1 2 3 1 1 1 3 2 1 3 3 2 3 3 3 2 1 1 1 3 1 2 1 2 1 2 2 3 3 1 3 2 2 3 1 3 1 2 1 1 2 1 3 1 2 3 1 2 2 2 3 3 2 2 1 3 3 3 2 3 2 3 3 1 1 3 3 2 3 2 2 1 2 1 2 1 2 1 2 3 3 1 2 1 3 3 2 2 3 2 1 2 1 2 3 2 3 3 1 1 2 1 3 2 3 3 1 2 2 1 1 1 1 3 2 3 3 2 2 1 1 1 3 3 2 3 2 1 2 2 2 3 2 2 3 2 1 2 3 1 3 3 3 2 2 2 2 1 1 3 1 3 3 2 3 1 3 1 1 1 1 3 2 1 2 1 1 3 3 2 1 3 3 1 1 1 1 2 2 1 1 3 3 2 2 3 2 3 3 3 2 2 1 3 2 3 1 2 1 1 2 1 1 3 2 2 3 3 1 1 1 2 2 3 2 3 3 3 2 2 3 1 3 1 2 2 3 2 1 1 3 2 1 3 3 3 2 3 3 2 1 2 2 1 2 1 1 1 1 3 1 2 3 3 3 3 1 2 1 2 2 2 3 1 1 1 2 1 3 2 3 2 1 3 3 2 2 3 3 1 3 2 2 2 1 1 1 2 2 1 1 2 2 2 3 3 3 1 3 2 2 2 3 2 1 2 1 3 1 3 3 3 2 1 3 1 1 3 3 1 2 2 2 2 3 2 3 3 2 1 3 1 2 3 3 1 2 1 2 1 2 1 2 2 3 1 1 3 1 2 2 3 1 2 2 1 3 3 1 1 3 2 3 2 1 1 1 2 3 1 2 1 3 3 3 2 2 2 1 3 2 3 2 3 3 3 3 3 2 3 1 1 3 2 1 2 2 3 2 1 3 1 1 3 2 2 1 1 3 1 2 1 1 3 3 1 3 2 3 3 2 3 1 1 3 2 1 3 2 1 2 2 1 1 2 3 2 2 3 2 2 1 3 3 3 3 2 1 2 3 1 3 3 3 3 1 3 2 2 2 1 2 2 2 3 2 3 2 2 3 2 2 3 3 3 2 1 2 3 3 2 3 1 2 1 2 2 2 3 2 3 2 2 3 1 2 1 1 1 1 3 1 1 1 3 1 1 3 3 1 2 3 1 3 2 1 2 1 3 1 3 3 3 3 3 1 3 3 2 3 3 2 1 2 2 1 2 1 1 3 1 3 2 1 1 1 3 1 3 3 2 3 1 3 3 2 1 2 2 3 3 3 1 3 2 2 2 3 2 2 1 2 3 2 3 1 1 1 2 1 2 3 3 2 3 2 3 1 1 2 1 2 2 1 1 1 2 3 1 2 1 2 1 3 3 3 1 2 1 3 1 1 3 1 3 1 1 2 3 3 2 3 3 3 3 2 3 1 2 2 2 1 2 1 2 1 3 2 2 2 1 2 1 1 1 2 1 2 3 3 2 3 3 1 3 1 1 2 2 2 1 3 2 3 3 1 1 3 1 3 1 2 3 2 3 1 2 1 3 1 2 3 2 2 2 2 1 2 2 3 1 2 3 2 2 2 2 2 2 1 3 1 3 2 2 3 1 2 3 2 2 3 2 2 3 3 3 2 1 1 3 3 1 1 1 2 2 1 2 2 2 1 1 3 3 3 1 1 3 1 3 1 3 2 2 2 3 2 3 1 2 3 2 3 2 1 1 2 1 2 1 3 3 1 2 3 3 1 1 2 1 3 2 1 2 2 3 1 1 1 2 2 1 1 2 3 1 2 2 1 2 1 2 3 2 2 2 1 2 2 3 2 3 3 3 2 2 2 1 2 3 1 1 1 3 3 2 1 3 1 3 1 1 1 1 3 1 1 2 1 1 1 2 1 1 3 1 1 1 1 3 1 3 2 3 2 3 1 3 3 1 1 1 1 2 3 3 2 1 2 1 1 1 3 2 1 2 1 3 1 3 3 2 3 1 2 1 3 2 1 1 2 1 2 1 2 1 3 2 3 1 1 1 1 1 1 3 3 1 1 2 1 2 2 2 1 3 3 3 3 1 2 2 2 1 3 3 3 1 1 3 1 2 3 2 3 2 1 3 1 3 1 2 2 1 3 2 2 3 3 1 3 2 1 3 2 1 3 2 3 2 3 1 1 3 1 1 2 1 3 1 1 2 2 2 1 1 3 1 3 2 3 1 2 1 1 1 1 3 1 1 1 3 2 2 3 1 2 3 2 2 3 2 2 3 1 1 2 3 3 2 3 2 2 3 2 2 1 3 1 2 3 1 3 1 3 3 3 1 3 1 3 1 3 2 1 3 2 1 3 3 1 2 3 3 1 1 1 3 1 3 3 1 3 3 1 2 2 3 1 2 3 3 3 2 1 2 1 3 2 2 3 1 2 3 3 2 3 2 3 1 2 1 1 3 2 2 3 3 2 1 3 1 1 2 1 2 2 3 3 3 2 1 3 2 1 3 1 1 2 3 1 2 2 1 3 1 3 2 1 3 3 1 2 2 2 2 3 3 3 2 2 3 2 2 3 2 1 3 3 1 2 2 1 1 2 3 1 1 2 1 1 2 3 1 3 1 1 1 2 1 3 2 1 3 1 2 1 1 1 1 2 1 3 1 3 1 2 2 2 3 1 2 2 1 2 2 3 2 3 2 2 1 3 2 3 3 1 1 2 3 2 1 2 1 3 2 1 1 3 3 1 3 1 3 1 1 1 3 1 1 2 2 2 3 3 1 2 3 2 2 3 3 3 2 2 2 2 3 1 3 2 1 2 3 1 2 1 1 2 1 3 2 1 3 2 2 1 3 1 3 1 2 2 2 2 1 2 2 3 3 2 2 3 3 3 2 3 1 1 2 3 1 2 1 2 1 2 3 3 2 3 3 2 1 1 1 3 1 2 1 2 2 3 2 1 1 2 2 2 1 3 3 2 2 3 2 1 1 1 1 2 2 3 1 3 3 3 2 2 1 1 1 3 3 3 2 3 1 3 2 3 2 3 2 2 1 2 2 1 3 3 1 3 1 1 3 1 1 1 3 1 3 2 1 2 1 2 2 3 2 3 3 2 2 2 2 1 2 3 3 1 3 3 1 3 1 2 1 3 2 1 1 2 2 3 2 1 1 2 3 1 3 1 2 1 1 2 1 3 3 2 3 1 3 1 3 2 2 2 2 1 3 1 3 2 2 2 1 1 3 3 1 3 3 3 1 2 1 2 2 2 3 2 2 1 2 3 3 1 1 3 2 1 3 3 3 3 1 2 2 1 2 3 2 2 3 3 3 3 2 1 3 2 2 2 2 3 3 2 1 2 3 3 2 3 2 3 2 1 2 1 3 3 3 2 3 3 2 3 3 2 1 1 2 2 2 1 2 2 3 2 1 2 2 2 3 1 3 3 3 2 1 1 2 2 3 1 2 3 2 3 1 2 1 1 2 2 3 1 1 1 2 3 2 3 1 2 3 1 3 2 1 3 1 2 3 3 2 3 1 1 2 2 2 3 1 1 2 2 1 2 2 2 1 2 3 1 1 3 1 3 2 3 2 3 2 3 1 1 2 2 3 1 3 2 2 1 3 3 1 2 1 1 3 2 2 3 2 2 3 3 2 2 1 2 3 2 2 2 3 2 2 1 2 2 1 2 3 1 1 2 1 2 2 1 3 1 3 1 1 1 2 3 1 1 2 3 3 2 2 2 3 2 2 3 2 2 1 1 1 2 2 1 1 1 3 3 2 2 3 1 3 1 1 2 1 2 2 3 2 2 3 3 3 3 1 1 3 1 1 1 2 3 3 3 1 2 3 1 2 1 2 2 2 1 1 3 1 2 1 1 2 2 1 1 1 2 2 3 3 2 2 3 3 1 2 3 1 1 2 1 2 2 2 2 1 1 1 1 2 2 2 2 3 3 1 3 1 3 2 3 2 1 3 1 1 1 1 3 1 3 1 2 2 3 1 3 3 2 3 1 2 2 2 2 2 2 1 1 2 1 3 2 3 1 2 2 1 2 2 2 3 3 1 1 1 1 1 3 2 3 1 1 1 3 2 1 2 1 3 3 1 3 3 1 3 3 2 3 2 1 1 3 1 2 3 2 1 1 2 1 1 2 3 1 2 3 3 3 3 1 2 3 1 3 3 1 3 3 2 3 2 1 1 2 2 3 3 3 2 3 3 1 2 3 2 2 2 3 2 1 2 3 2 2 2 3 1 1 1 2 3 2 3 1 3 1 2 3 2 1 3 3 2 2 3 2 2 2 1 1 2 1 1 2 3 2 3 2 3 2 3 3 3 2 1 3 3 3 1 3 2 2 2 2 2 1 3 1 3 3 3 1 1 2 3 3 1 3 1 1 3 3 3 3 1 3 1 2 1 2 1 2 3 3 1 2 2 1 1 2 2 2 2 2 2 1 2 2 3 3 1 3 1 1 1 1 2 3 3 2 1 1 1 3 1 3 1 3 2 2 1 2 3 1 1 3 3 2 1 3 1 1 3 2 3 1 1 2 2 1 2 2 2 1 3 3 3 2 3 3 2 3 1 2 1 1 3 2 2 1 1 1 3 1 1 1 2 3 2 1 3 3 2 3 3 2 1 1 3 2 2 1 2 1 3 3 1 2 2 3 3 2 2 3 3 1 3 2 1 2 2 3 1 1 1 3 2 3 3 3 1 3 3 2 1 3 2 1 1 1 2 1 2 1 3 2 1 2 3 1 1 2 2 2 2 2 3 3 3 3 1 3 1 1 3 1 3 1 3 3 2 2 2 2 1 2 1 3 1 1 3 1 3 2 2 1 1 1 1 3 1 1 1 1 2 1 1 1 1 1 1 3 1 3 3 2 2 2 2 3 2 3 1 1 1 1 3 2 1 1 2 1 1 3 1 3 3 1 3 1 3 1 3 2 2 2 1 2 2 3 3 3 1 1 2 2 1 1 2 3 3 2 1 1 1 1 3 1 3 3 3 1 1 1 3 1 3 1 2 2 3 2 1 3 1 2 3 1 2 2 3 3 2 2 1 2 3 1 1 2 3 1 1 2 2 2 1 1 1 2 2 2 1 3 3 3 1 3 1 2 3 2 1 2 1 3 1 1 2 2 2 3 3 2 2 3 2 3 2 3 2 2 2 3 1 3 2 3 3 3 2 2 3 3 1 1 3 2 3 1 2 1 2 3 1 3 1 3 2 2 1 1 2 1 3 1 1 3 1 2 3 2 2 2 3 2 2 2 2 1 1 3 3 1 2 2 2 3 2 1 1 3 1 2 3 3 1 3 1 1 3 3 2 2 2 1 3 1 1 3 1 1 2 3 2 1 2 3 3 3 3 3 2 3 2 3 3 3 1 2 3 3 1 2 1 1 2 3 1 3 1 1 3 2 2 2 3 1 1 3 3 3 3 3 1 3 3 3 1 2 2 1 3 1 3 2 1 3 1 1 2 3 3 3 2 1 1 2 2 1 2 3 3 2 3 2 1 3 1 1 1 1 3 2 1 3 1 1 1 2 2 1 1 2 3 1 3 2 3 1 1 3 1 1 2 2 2 2 2 3 1 3 3 3 1 3 2 2 1 3 2 3 3 3 1 3 2 2 1 2 1 1 3 2 3 2 1 1 2 1 1 3 3 2 1 3 2 3 1 2 1 2 2 1 1 3 1 3 2 3 3 3 1 1 3 3 1 3 3 3 1 2 2 2 3 1 3 1 1 1 1 3 2 3 3 2 1 2 3 3 1 1 2 1 3 2 1 3 1 3 2 3 3 1 1 1 3 2 1 3 1 3 3 2 2 3 3 2 2 2 2 1 3 1 3 3 3 3 1 2 2 1 3 1 2 1 3 2 2 1 1 1 1 2 1 2 2 1 3 3 3 1 3 2 2 1 1 3 3 3 1 3 2 3 3 1 2 3 3 2 1 3 2 1 3 2 2 2 1 2 3 1 3 2 2 3 1 2 3 2 1 3 3 1 1 2 1 2 2 3 2 2 2 1 1 3 1 3 2 3 3 1 2 1 2 3 1 1 2 2 1 2 1 3 1 3 3 1 2 1 1 3 3 3 3 3 1 3 1 1 3 1 3 1 3 3 3 3 1 1 3 3 2 3 1 1 1 2 3 3 1 1 2 3 1 2 1 2 2 2 1 1 2 1 3 1 3 1 3 1 2 2 2 3 1 3 2 2 1 3 3 2 3 1 1 2 3 3 1 2 2 3 3 2 1 1 2 3 2 3 2 1 1 1 2 2 2 1 3 1 1 3 1 2 3 2 2 1 2 3 3 2 3 2 2 2 3 3 2 2 3 3 1 1 3 2 2 3 1 1 2 2 2 3 3 3 1 3 3 3 1 2 2 3 3 3 1 2 1 2 3 3 3 2 3 1 2 2 3 1 1 1 3 1 3 2 1 1 3 3 3 1 3 1 3 1 1 1 2 1 3 1 2 3 1 3 2 3 3 3 2 3 1 1 1 1 3 2 1 3 1 1 1 3 3 2 1 1 2 1 1 2 2 2 2 1 3 3 2 3 2 2 3 1 1 1 3 3 3 2 1 1 1 1 2 2 3 1 3 1 2 2 1 3 3 1 3 3 2 1 3 2 3 3 1 2 2 1 2 2 3 2 2 2 3 2 2 2 3 3 2 2 1 1 3 1 1 2 3 3 2 3 2 3 1 3 1 1 3 1 2 1 2 3 2 1 1 2 3 2 3 3 3 2 2 2 2 1 3 1 1 1 3 3 2 2 1 2 2 2 1 3 2 2 1 1 2 3 2 1 1 2 2 2 2 2 1 2 1 2 1 2 3 1 3 2 2 2 1 1 3 1 3 1 3 2 2 3 3 1 1 2 3 3 2 2 2 3 3 2 2 3 3 1 1 3 3 2 2 1 3 2 1 2 2 2 2 3 1 2 3 2 2 1 3 2 2 2 2 3 1 3 3 3 2 3 2 2 3 3 1 1 1 1 1 3 1 1 1 3 2 3 2 1 3 2 2 2 2 1 2 2 2 3 2 3 1 3 2 1 3 1 3 2 2 2 3 1 1 3 2 3 3 1 1 1 3 3 3 2 3 2 1 3 3 3 1 1 3 1 1 3 3 2 3 1 2 1 1 1 2 2 3 1 3 1 1 3 3 1 2 3 3 3 3 1 2 3 1 2 3 3 1 2 3 1 2 3 1 2 2 3 1 1 1 2 2 2 1 1 1 1 3 1 2 3 2 1 3 2 2 1 1 3 2 2 3 3 2 2 2 1 1 3 3 1 2 3 2 3 2 3 2 1 3 1 2 3 2 1 3 2 3 3 2 3 3 2 2 3 3 3 3 2 2 1 1 3 3 2 1 1 2 1 1 2 2 1 2 1 3 2 3 1 2 2 2 1 1 1 1 2 2 2 1 3 3 3 2 3 2 2 1 2 2 2 2 1 2 3 1 1 2 2 3 2 3 2 2 3 2 2 3 3 3 2 1 1 1 2 2 1 2 3 3 2 3 1 1 1 1 1 1 3 1 1 1 1 3 2 1 2 1 1 2 2 3 1 3 2 2 3 1 1 3 2 1 1 1 1 2 3 2 1 2 3 3 1 3 2 1 1 2 1 1 2 2 2 1 3 1 1 3 1 2 3 1 2 2 3 2 1 2 2 3 2 3 1 3 1 1 2 1 2 3 1 1 2 2 2 2 2 2 2 1 3 1 2 2 1 3 3 2 1 1 1 2 1 1 1 1 3 3 2 3 3 1 3 3 1 3 2 2 3 3 3 3 1 2 1 3 2 2 2 1 3 3 3 1 3 3 3 2 1 1 3 3 3 3 2 2 3 3 2 3 2 3 2 2 2 2 2 2 2 1 2 3 2 2 1 3 1 1 3 3 2 1 1 3 3 2 1 1 1 3 2 3 3 2 1 1 2 1 2 2 1 2 3 3 3 1 1 3 3 3 3 1 3 2 2 2 1 2 3 3 3 3 2 3 1 3 2 2 2 3 3 3 2 2 2 1 3 3 3 3 2 3 3 1 3 2 3 2 1 2 1 2 2 2 3 1 3 1 2 2 1 3 2 3 1 1 1 2 3 3 1 1 1 2 1 3 2 2 3 1 1 2 3 3 1 3 2 2 3 3 3 3 1 3 1 1 2 1 3 3 2 1 2 3 1 2 3 1 2 2 2 1 3 3 1 3 2 3 2 2 3 1 2 3 3 1 1 1 3 1 2 1 2 3 2 3 3 3 2 3 3 2 2 1 3 1 1 2 2 2 1 2 1 1 2 3 3 3 1 3 2 2 1 2 2 1 2 3 3 1 2 1 2 1 2 2 1 3 3 3 2 1 2 1 2 3 3 2 3 1 2 3 1 1 2 2 2 2 1 2 1 3 1 2 3 1 3 3 2 3 1 1 2 3 1 3 3 3 3 3 1 3 1 2 1 1 1 2 3 3 3 2 2 3 1 2 1 3 1 2 2 3 3 3 1 1 1 3 3 1 1 3 1 3 1 1 2 1 1 1 3 1 3 3 2 3 1 1 2 2 3 1 2 1 1 2 2 2 3 1 2 3 2 3 3 3 1 1 3 1 2 2 2 3 1 2 2 2 1 3 3 1 1 3 2 1 3 2 1 1 3 3 2 2 2 2 3 3 1 1 3 2 2 1 2 2 2 2 2 3 3 2 1 3 1 3 2 2 1 3 3 2 2 1 1 1 2 1 3 2 1 1 3 1 1 1 3 1 3 2 1 3 3 1 2 1 3 2 3 2 3 2 2 2 1 3 1 1 1 3 3 2 3 2 3 3 3 1 3 2 3 1 3 1 1 3 1 2 1 3 1 3 3 2 2 1 3 2 3 1 1 3 2 2 1 1 2 3 1 3 2 3 1 3 1 3 3 3 3 3 1 1 1 3 3 2 1 2 1 3 1 3 3 1 3 3 3 3 3 3 2 1 3 1 2 2 3 1 3 3 2 3 3 1 2 1 1 1 2 1 1 3 3 1 1 3 2 3 2 3 2 1 3 1 3 1 3 1 1 1 3 2 2 3 3 2 2 3 2 1 3 1 3 1 1 2 3 1 3 2 2 1 1 2 1 1 2 2 3 1 2 3 3 1 3 1 1 2 1 1 1 3 2 1 3 2 1 2 1 1 2 2 1 3 3 1 2 1 2 1 1 3 3 2 2 3 3 1 2 1 2 3 1 3 2 1 2 3 2 3 3 3 2 2 3 2 1 2 3 2 2 3 3 1 2 3 1 3 1 2 1 3 2 2 1 2 1 2 1 1 2 1 2 1 2 2 3 1 2 1 3 2 3 1 3 1 3 1 3 3 2 1 1 3 2 3 1 3 2 3 1 2 1 1 2 1 1 1 3 2 2 3 1 3 2 3 2 2 3 1 1 3 2 1 2 2 2 1 1 3 1 1 1 1 1 1 1 1 3 3 2 3 1 3 1 1 1 3 1 1 3 3 2 3 3 3 3 3 1 3 3 3 2 2 2 1 2 1 2 2 2 3 2 1 3 3 3 1 2 3 3 1 1 3 3 1 2 2 1 3 3 2 3 3 2 3 3 3 2 3 1 3 1 3 1 1 2 1 3 2 1 1 3 2 2 3 2 1 2 2 3 1 1 1 3 3 2 3 2 3 1 1 1 3 3 3 3 2 1 1 1 1 3 1 1 2 3 2 2 1 1 1 2 3 1 3 3 1 3 1 3 3 2 1 1 2 1 1 2 3 2 3 2 2 2 3 1 1 2 2 2 1 2 3 1 2 3 2 3 3 1 2 3 1 2 1 1 1 2 1 2 2 3 3 3 1 1 2 1 1 3 3 1 1 2 3 2 3 3 2 1 3 3 1 3 2 1 2 2 3 1 1 2 1 1 1 1 3 2 3 2 1 3 2 2 3 3 3 1 1 3 3 2 2 3 3 1 3 3 3 1 1 3 1 3 1 3 1 2 3 2 1 1 2 1 2 2 2 2 3 2 3 3 3 2 1 3 1 1 1 2 3 1 3 1 1 3 1 3 3 2 3 3 3 2 1 2 1 2 2 1 3 3 2 1 3 3 1 2 2 3 1 1 2 2 1 3 2 1 1 2 3 3 3 3 1 3 1 2 1 3 1 2 3 2 2 1 3 3 1 1 2 2 1 3 3 1 2 1 3 3 3 2 1 2 3 3 1 2 3 3 1 3 1 3 3 2 2 2 1 1 1 1 3 1 2 1 3 1 2 2 1 1 2 1 1 3 3 1 1 2 1 2 1 2 3 3 1 2 3 3 3 1 3 1 1 1 3 3 2 3 2 3 3 1 2 2 1 1 3 1 2 1 2 3 1 1 1 2 2 1 2 1 3 1 2 2 3 3 1 1 3 2 3 2 3 3 3 3 3 3 3 1 3 2 2 2 1 2 1 1 2 2 1 3 1 3 3 1 1 1 2 3 3 1 3 3 1 1 1 1 3 3 2 2 1 2 3 2 1 2 2 3 3 1 2 2 3 3 3 1 2 1 1 2 1 2 3 1 3 1 1 3 2 2 2 2 2 1 1 1 2 1 3 3 2 1 1 1 2 3 3 1 1 2 3 2 2 1 3 2 1 3 2 2 2 1 3 3 3 2 3 1 1 1 1 3 2 3 1 3 2 3 3 2 2 1 1 2 1 2 3 1 3 3 3 1 1 2 3 1 3 2 1 1 3 3 3 3 1 1 1 3 1 1 3 3 3 2 2 2 3 3 3 3 2 2 1 3 3 2 3 3 3 1 2 3 3 2 1 1 3 2 3 3 2 3 1 1 2 1 3 2 1 3 2 1 3 1 1 2 1 1 2 3 2 2 3 2 1 1 3 2 3 3 2 2 2 3 1 2 1 3 2 1 1 2 2 3 2 2 1 1 1 3 1 1 1 2 3 1 2 1 1 3 1 2 1 2 3 3 2 3 3 3 2 1 1 1 3 1 1 1 2 1 3 3 3 3 1 2 2 1 1 2 3 2 2 3 2 1 2 1 3 1 3 3 2 1 3 2 1 3 2 1 2 2 2 1 1 2 3 3 3 2 3 1 3 2 3 2 3 3 1 2 3 2 3 3 1 1 2 2 3 2 2 1 1 3 2 3 2 2 3 1 1 3 3 3 2 1 2 3 1 1 2 1 3 1 2 3 1 1 2 1 2 2 3 1 1 2 2 2 3 1 2 2 3 2 1 3 1 1 3 3 3 3 1 3 1 2 2 3 3 1 2 1 1 3 1 3 3 3 3 2 2 1 1 1 1 1 3 1 3 3 2 2 1 3 2 1 2 1 1 1 2 1 3 1 3 1 2 2 3 2 3 3 3 3 2 3 3 2 1 1 1 1 1 1 1 2 3 2 1 2 1 2 1 3 3 2 3 1 2 1 1 1 2 2 2 2 2 1 1 3 1 1 3 2 3 3 2 3 1 1 1 2 1 3 2 3 2 1 2 3 3 3 1 1 2 3 3 1 1 2 1 1 2 1 2 3 2 2 2 1 3 1 2 3 1 2 3 1 3 3 3 2 2 2 1 3 2 1 3 3 2 2 2 1 1 2 3 2 1 2 1 1 2 2 1 2 3 3 1 2 2 3 3 1 3 3 2 1 1 2 1 2 2 1 3 3 2 3 2 1 2 3 3 2 1 3 1 3 2 3 1 1 1 1 1 1 3 2 3 3 2 2 3 2 3 1 1 2 3 1 3 3 2 2 2 3 3 1 3 2 1 1 1 3 3 1 3 1 1 2 3 3 1 2 3 3 2 2 3 3 1 2 2 3 2 2 3 2 1 2 1 2 3 1 2 1 2 1 3 3 3 3 3 3 2 2 1 1 3 2 2 3 3 3 1 3 3 1 2 3 1 2 2 1 3 3 1 1 2 1 3 2 3 1 1 2 1 2 3 3 1 3 1 3 1 1 1 2 2 3 2 1 3 2 3 1 3 2 2 1 2 2 1 1 2 1 2 1 2 1 2 3 1 2 2 3 1 1 1 2 2 1 3 3 1 1 3 2 2 2 2 2 1 3 3 3 1 3 1 3 2 1 1 3 2 1 1 1 3 1 2 2 2 3 2 2 2 1 3 1 1 3 1 3 2 1 2 2 2 2 1 1 1 1 3 3 2 2 2 2 3 1 1 2 1 1 3 3 3 2 3 1 1 2 2 1 3 3 3 2 2 3 2 2 3 2 3 2 1 1 2 2 1 1 2 2 2 3 3 3 3 1 3 1 1 1 3 1 1 1 2 3 3 2 3 3 1 3 1 2 1 3 1 3 1 3 1 2 1 1 3 2 3 2 3 2 1 3 3 1 1 1 1 1 3 2 1 3 3 1 1 3 1 1 2 3 3 3 1 3 2 3 1 2 1 2 1 2 2 3 1 1 2 2 3 2 3 2 2 1 2 2 2 2 3 2 1 2 1 2 2 3 3 2 2 1 3 3 3 3 1 1 3 3 2 3 2 3 1 3 3 2 1 3 2 2 3 2 2 3 2 3 3 2 2 3 3 1 2 3 2 1 2 1 1 2 3 3 2 3 2 3 2 3 1 2 2 1 3 1 1 2 1 3 3 3 1 2 1 1 3 2 2 2 3 2 2 1 2 1 2 2 1 3 2 3 3 3 2 1 2 1 3 2 3 3 2 2 3 2 3 3 2 2 1 2 1 3 1 2 3 2 1 2 1 1 1 1 1 2 2 1 1 1 1 2 3 2 1 2 2 1 2 2 3 3 3 2 3 2 3 1 2 1 1 1 3 2 3 2 3 1 2 2 2 2 3 2 2 1 2 1 1 2 2 3 1 2 3 3 3 2 3 3 2 3 2 2 1 1 1 3 1 2 3 2 1 3 2 1 2 3 2 3 3 3 2 3 1 3 1 3 1 3 1 1 1 1 3 1 1 2 2 3 3 2 1 1 3 3 1 3 3 1 1 2 3 1 3 2 2 3 1 3 3 2 2 2 3 3 2 2 3 2 3 3 3 1 1 1 1 3 2 3 3 3 3 3 2 1 2 2 2 1 3 3 3 3 2 3 1 1 2 1 2 2 3 1 1 3 3 2 3 3 2 1 1 2 3 2 2 2 3 3 1 2 2 2 1 3 1 1 2 1 1 1 1 2 1 1 2 2 2 3 3 2 1 3 3 1 2 2 2 1 1 1 3 1 1 3 2 1 2 2 3 1 1 2 2 3 2 1 3 3 2 2 2 2 3 1 2 2 2 2 3 3 1 2 3 1 1 3 1 3 3 1 1 2 3 1 1 3 3 3 3 2 2 1 3 1 2 1 3 1 1 3 2 3 2 1 1 1 3 1 2 1 2 3 1 1 2 1 1 2 1 3 3 2 1 2 3 3 2 1 1 2 3 2 2 1 1 1 3 3 3 3 1 1 3 3 3 2 3 1 2 3 1 2 2 2 1 3 2 1 3 3 2 1 2 2 2 1 1 2 1 1 3 1 2 3 2 3 1 3 2 3 1 2 1 3 1 2 2 2 3 1 3 2 2 2 3 2 1 1 3 2 1 3 1 1 2 1 2 2 1 1 3 2 1 3 3 1 3 2 1 3 1 2 3 1 2 2 3 2 2 2 2 1 1 1 3 2 3 3 1 1 1 3 3 3 2 2 1 3 3 3 3 2 1 1 2 3 2 1 1 2 3 2 1 1 3 3 1 3 3 3 3 3 2 3 2 3 1 2 3 3 1 2 2 2 1 3 2 2 1 2 3 2 1 3 3 3 1 3 2 1 3 3 1 2 3 1 3 1 2 2 2 3 3 1 1 1 2 3 1 3 2 3 3 1 3 2 1 1 3 3 1 3 1 2 3 1 1 3 2 2 2 3 2 2 2 2 3 2 3 2 3 3 3 2 2 1 2 3 3 1 3 1 1 3 2 3 2 2 2 2 1 1 1 3 3 2 2 3 1 2 3 3 3 3 1 3 3 3 2 1 2 1 2 3 1 2 3 2 2 3 1 2 2 1 1 3 1 1 2 2 1 2 3 2 3 2 2 1 2 1 3 2 3 2 3 2 1 2 3 2 1 2 1 1 1 1 2 3 3 1 1 1 2 2 1 2 2 2 3 2 1 3 3 3 3 1 2 2 3 1 3 3 1 2 2 1 3 2 2 3 1 3 3 2 3 2 3 2 2 1 2 3 3 1 1 2 1 2 2 1 3 3 1 3 2 3 1 3 2 3 2 3 2 3 2 2 2 2 2 3 3 2 2 2 1 1 3 3 1 3 3 1 2 1 1 3 1 3 2 1 2 3 3 3 1 1 2 3 2 1 1 2 1 1 1 3 2 3 3 2 3 1 2 3 3 2 1 1 3 3 3 2 3 1 3 1 2 1 2 1 2 3 1 2 2 1 3 3 2 3 1 3 1 3 3 2 1 1 3 1 3 3 2 3 1 3 2 2 1 2 2 3 2 3 2 1 1 1 3 2 1 2 2 2 2 3 1 1 1 1 2 3 2 1 3 1 3 1 1 3 3 2 3 1 1 2 2 1 1 1 2 2 1 3 1 1 1 2 2 3 2 2 1 2 3 1 3 3 1 2 2 3 3 3 3 3 2 3 2 1 3 2 1 1 2 1 3 3 3 2 3 2 1 2 1 2 2 2 2 2 2 2 1 2 3 2 1 2 3 2 1 2 2 1 3 3 1 3 2 3 2 3 1 3 2 3 2 1 2 3 2 1 1 2 2 1 3 3 1 2 1 3 2 3 1 3 2 1 1 2 1 1 3 3 3 3 3 3 1 1 2 2 1 1 2 1 3 3 2 3 2 1 2 2 2 2 2 1 1 1 1 1 3 2 1 1 1 1 1 3 1 2 2 1 3 2 3 1 3 1 2 3 1 2 2 1 2 2 2 3 1 3 1 2 2 3 2 1 3 3 1 2 3 1 2 1 1 3 2 1 3 1 1 1 3 3 3 1 3 2 3 3 1 3 1 1 1 3 1 3 3 1 3 1 3 2 2 1 2 3 1 1 3 2 1 1 2 1 2 3 2 1 3 3 1 3 3 3 3 3 1 2 1 1 2 2 2 1 1 1 2 3 2 2 3 2 1 1 1 3 3 1 3 2 2 1 3 2 1 1 3 3 2 1 3 1 3 3 2 1 3 2 2 1 1 2 3 1 3 1 2 1 1 3 1 2 1 2 3 1 1 1 1 3 2 3 3 3 2 2 2 2 2 2 3 2 1 2 3 1 3 1 1 1 3 1 1 3 1 3 1 3 3 2 3 1 1 1 3 1 2 2 3 3 1 3 2 1 2 1 2 2 1 2 2 1 3 2 1 2 3 2 3 1 3 1 1 1 3 3 1 2 2 3 3 1 3 3 1 3 1 1 3 1 3 1 1 3 3 2 2 3 3 3 1 1 1 3 1 2 2 2 3 1 1 2 1 2 2 1 2 3 3 3 2 2 2 2 2 2 3 1 3 3 3 2 3 2 2 3 1 2 2 2 3 3 3 1 2 3 1 2 3 3 1 2 2 2 1 1 1 1 3 1 1 2 3 1 1 1 1 3 3 3 3 1 1 3 2 2 1 3 2 2 1 1 3 3 2 3 1 3 2 2 2 2 2 1 2 2 1 1 2 1 1 3 3 2 1 3 3 2 2 1 3 3 3 3 3 1 1 1 1 1 2 3 3 3 1 3 3 3 3 3 3 2 1 3 2 3 3 1 2 3 2 2 3 3 3 3 1 3 3 1 2 1 1 2 1 3 3 1 3 1 3 3 3 1 3 2 2 2 1 3 2 2 2 2 3 3 1 2 1 2 1 3 2 2 1 2 1 1 1 3 3 2 1 2 3 2 1 3 1 3 2 1 3 1 1 2 3 1 1 2 3 2 2 1 1 2 1 2 2 2 1 1 3 3 1 2 2 2 2 1 3 1 2 1 1 3 1 3 1 2 3 1 3 2 1 2 1 1 2 1 3 3 1 2 1 2 1 1 3 3 1 3 3 2 3 1 1 1 3 3 1 1 2 2 1 3 2 3 1 2 3 3 2 3 1 3 2 1 2 1 3 3 1 3 2 3 1 1 2 2 3 3 1 1 1 1 1 1 3 2 2 2 3 1 2 1 1 1 2 1 2 2 3 2 2 3 2 1 1 3 2 1 2 3 2 3 1 2 3 3 2 3 1 1 1 3 2 2 3 2 1 3 1 2 2 3 2 2 3 3 2 2 2 2 1 1 1 3 1 3 1 3 3 1 1 3 3 3 2 1 1 1 1 3 2 2 3 3 3 2 3 1 1 1 3 3 3 1 3 3 3 1 3 2 1 3 1 1 1 1 2 1 3 2 1 3 2 1 1 3 3 1 2 1 1 3 2 3 3 1 3 3 2 2 2 3 1 3 1 1 1 2 2 1 1 3 3 3 1 3 3 1 1 3 3 1 2 3 3 1 3 3 3 2 2 1 3 2 2 3 1 2 1 3 2 2 1 2 3 3 2 2 3 1 2 3 1 1 1 2 3 1 1 3 3 3 3 3 1 1 2 2 2 3 2 3 2 2 1 3 3 1 1 3 2 3 1 1 2 3 2 1 2 1 3 2 3 1 3 1 3 3 2 3 3 1 1 3 3 3 3 2 1 3 2 1 2 3 3 1 3 2 2 1 2 2 1 1 1 2 3 2 2 1 2 1 2 3 1 2 3 1 2 1 1 3 2 3 1 3 3 2 1 3 2 1 2 3 1 1 1 1 1 2 3 2 3 2 2 2 3 3 3 3 1 3 3 2 3 1 1 2 3 1 2 3 1 1 2 1 2 1 1 1 2 2 2 3 1 3 2 3 3 3 2 1 1 3 1 1 3 2 1 3 2 1 1 1 3 2 1 1 2 1 2 2 1 1 1 3 3 3 1 1 1 1 3 2 1 1 1 3 2 1 1 1 3 3 3 1 2 2 2 2 1 2 1 3 1 2 3 3 2 1 2 1 3 3 3 2 2 1 3 1 3 1 3 3 3 3 2 1 2 3 1 1 3 1 3 2 2 2 2 2 2 3 1 1 2 2 3 1 3 1 3 3 3 2 1 2 1 2 3 2 1 3 3 2 2 2 3 3 1 2 3 2 2 3 2 3 3 3 2 2 1 1 3 1 1 3 1 1 2 1 2 1 1 3 3 3 3 2 1 1 2 1 2 3 3 2 1 2 1 3 1 3 3 3 3 1 1 2 2 3 1 1 3 3 2 2 1 1 3 3 3 2 2 3 2 3 3 2 2 2 2 3 1 1 3 2 3 1 2 2 2 3 1 1 2 2 2 2 2 1 2 1 2 2 3 2 1 2 1 2 2 3 2 3 1 1 3 1 2 3 1 1 3 3 2 2 1 2 2 2 2 2 3 1 1 2 1 2 3 3 2 3 2 2 3 3 3 1 2 2 2 1 1 3 3 3 2 1 3 3 1 3 3 2 2 3 1 1 3 1 2 2 2 2 2 3 3 3 2 1 3 1 2 2 2 3 3 2 2 1 2 3 1 1 3 1 1 3 3 3 2 1 2 3 1 2 3 2 2 2 2 3 1 3 2 1 3 3 1 2 1 1 3 1 2 1 3 3 2 2 1 1 1 2 2 3 2 2 1 3 3 1 1 3 1 2 3 2 3 3 2 2 3 3 3 2 2 2 1 3 1 1 1 2 1 2 3 1 1 1 2 1 3 1 1 3 3 2 3 1 3 3 1 1 1 3 2 2 1 2 1 2 2 2 1 1 2 3 2 2 2 2 3 2 1 3 1 3 2 1 2 2 1 3 2 1 2 1 2 2 3 1 1 2 1 2 3 1 1 1 3 3 3 2 1 1 2 2 1 2 2 3 1 3 3 3 1 3 3 1 1 1 3 1 3 1 3 1 1 2 1 1 3 2 3 3 3 2 3 1 1 3 2 2 3 1 1 3 2 1 1 2 2 1 1 3 2 2 3 1 3 3 3 2 2 1 3 3 2 2 3 2 1 3 3 1 1 2 1 3 3 1 1 3 2 1 2 2 2 1 2 3 3 2 2 3 3 3 2 1 2 3 2 3 3 2 1 3 1 2 2 3 3 3 1 2 1 2 1 2 2 3 1 3 2 1 2 3 1 1 3 3 2 2 2 3 2 3 3 3 1 1 2 3 3 2 3 3 3 1 1 3 3 3 1 3 2 1 3 3 3 2 2 1 1 3 1 1 2 1 1 3 1 1 3 3 3 3 2 2 3 1 3 3 1 3 2 2 3 2 1 3 1 1 1 1 3 2 3 1 2 1 2 3 3 3 1 1 3 3 1 3 1 1 3 3 2 3 1 2 1 2 3 3 2 3 2 1 2 1 3 2 3 2 1 3 2 2 3 3 1 1 2 1 3 1 3 3 1 2 2 1 1 2 2 2 2 3 1 2 3 1 3 1 3 2 3 3 3 1 2 3 2 3 1 3 1 3 3 1 2 1 3 2 3 3 3 1 2 1 1 3 1 2 3 2 2 1 2 3 2 2 1 1 2 2 1 1 2 2 3 2 2 1 1 2 1 3 2 3 3 2 2 3 1 1 1 3 3 3 2 1 2 2 1 1 2 2 1 1 2 3 2 1 3 2 1 2 3 2 3 2 3 2 3 3 1 1 3 2 1 3 1 3 1 2 3 2 1 2 2 2 1 1 3 1 2 3 2 1 1 3 2 2 3 2 2 2 1 2 2 3 1 1 1 1 2 2 1 2 1 1 3 1 3 2 3 3 3 3 3 3 3 3 1 3 2 1 3 1 2 3 1 1 1 1 3 3 2 1 1 1 1 1 1 2 3 2 3 2 1 3 3 3 2 1 3 1 2 2 2 3 2 3 3 1 1 1 3 2 2 2 1 2 3 3 2 3 3 1 1 2 1 2 1 3 2 1 2 1 2 2 2 3 2 2 1 1 1 2 1 3 3 3 3 2 1 1 1 3 1 2 1 1 3 1 3 3 2 3 1 2 1 1 2 3 3 1 3 3 3 1 2 3 2 2 2 3 3 3 1 1 2 3 1 2 3 2 2 3 2 2 1 3 1 2 3 3 1 2 3 3 1 3 1 2 1 3 1 3 1 1 3 2 1 1 3 1 1 1 3 1 1 3 2 3 1 1 2 2 3 2 1 1 1 3 1 1 1 3 3 2 3 1 2 1 1 2 1 3 1 2 3 2 1 3 2 2 2 3 1 1 2 3 1 3 3 2 1 3 2 2 1 3 2 3 1 2 1 2 3 3 3 2 1 2 1 1 1 3 2 2 1 2 2 2 2 1 1 1 3 2 1 3 3 2 1 2 2 3 2 1 1 3 3 1 3 2 2 3 2 1 2 3 2 3 3 3 1 1 1 3 3 3 2 1 2 3 1 2 3 3 1 1 1 3 3 1 1 1 3 1 3 3 2 3 1 2 3 2 2 3 1 3 2 3 1 2 2 1 3 2 1 2 3 1 1 2 2 3 1 2 1 1 2 1 2 2 3 1 2 1 3 1 1 3 2 2 3 1 1 1 3 3 3 3 1 2 1 1 1 1 1 2 1 3 2 1 1 2 3 1 1 1 1 3 1 2 1 1 1 1 3 2 2 2 1 2 2 1 3 3 2 2 1 3 2 3 3 2 1 1 2 3 3 3 2 1 3 1 3 3 2 1 1 1 1 2 1 2 1 3 3 1 3 3 1 3 3 2 2 3 3 3 1 3 1 3 3 1 2 2 2 2 3 3 3 3 1 2 1 1 1 3 1 3 2 3 1 1 1 2 1 2 1 1 2 3 1 2 3 1 3 3 1 2 3 3 3 3 1 2 3 1 3 2 3 3 3 3 3 2 3 1 1 3 3 2 1 2 3 1 3 3 3 2 3 2 1 2 1 1 2 1 2 2 2 1 3 1 1 2 3 3 1 3 2 3 1 1 1 3 1 1 2 1 2 1 3 3 3 1 2 3 1 3 3 1 2 1 2 1 3 3 3 1 1 1 1 3 2 3 3 3 2 2 1 2 3 1 3 1 1 2 3 3 3 1 1 1 1 3 1 1 1 2 3 2 2 3 1 1 2 1 2 1 2 1 2 3 2 2 2 2 2 3 3 3 3 2 2 2 2 1 3 3 1 3 3 2 1 2 2 2 1 2 1 3 3 3 2 3 1 1 1 1 2 2 2 1 2 3 3 3 1 3 3 1 2 3 2 3 1 3 3 2 1 1 3 1 2 3 2 3 2 2 3 1 1 2 3 2 2 2 3 3 2 3 3 2 3 1 3 1 2 3 1 2 2 1 1 1 1 1 3 3 3 3 2 3 3 2 3 1 1 2 1 3 1 3 2 2 1 1 2 2 1 3 1 2 2 2 1 1 1 2 1 1 1 3 3 3 3 2 2 3 3 1 2 3 2 3 1 3 3 1 2 1 1 2 2 1 2 3 2 2 1 3 2 2 1 2 1 1 3 3 3 3 1 2 1 2 2 2 1 1 1 1 3 2 3 3 3 3 3 1 1 3 2 3 1 2 3 2 3 3 3 2 3 1 2 1 3 3 3 2 2 1 3 1 3 3 2 3 3 1 3 1 1 1 3 1 3 1 2 2 2 1 3 1 2 1 2 1 2 1 3 2 3 3 3 2 2 2 1 2 2 2 1 1 2 2 3 1 1 3 2 3 2 2 3 1 3 3 1 2 1 2 2 3 2 3 1 3 1 2 1 1 2 1 1 1 2 3 3 2 1 1 2 3 1 2 2 2 2 2 3 1 2 2 1 3 1 3 3 3 2 2 2 1 1 1 2 1 2 1 1 1 2 3 1 3 3 3 1 2 2 1 2 2 3 2 2 1 1 3 1 3 3 3 3 2 3 3 3 1 1 2 1 3 2 1 1 1 1 3 2 2 2 3 3 1 1 1 3 2 1 2 1 2 3 2 1 2 1 3 1 1 3 2 1 3 3 2 2 1 2 2 1 1 1 1 1 2 2 2 2 2 1 1 2 3 3 2 3 2 3 3 2 3 3 1 1 3 1 1 1 3 2 3 1 3 2 2 1 3 3 2 3 1 3 3 2 1 2 1 1 3 2 3 1 1 1 3 1 3 1 3 2 1 3 1 2 2 1 1 1 1 2 1 1 3 3 1 2 2 1 1 3 2 3 2 2 3 2 1 1 3 1 2 1 3 2 2 1 3 3 1 1 2 3 3 1 1 2 2 3 2 3 2 1 2 3 2 1 2 2 3 3 3 3 3 3 3 1 3 1 1 1 2 2 1 2 2 1 1 3 3 1 1 1 2 1 1 2 3 2 3 3 2 3 1 2 3 2 3 1 1 3 1 1 1 2 2 1 2 2 2 3 2 2 1 2 3 3 3 3 3 3 1 1 2 3 2 1 1 3 3 3 3 3 2 1 2 3 2 2 2 3 2 2 3 1 1 1 3 3 2 1 1 2 3 1 3 1 3 2 2 2 3 1 1 1 3 2 3 3 3 1 2 2 2 2 3 2 2 1 2 1 3 3 2 3 2 3 1 2 1 1 2 3 3 2 2 1 3 1 2 3 1 1 3 2 2 1 1 3 3 1 3 2 2 3 2 1 1 1 3 2 2 3 3 2 2 2 3 2 1 2 1 1 1 2 1 1 3 3 1 3 3 2 1 3 3 3 2 3 1 2 2 3 3 1 1 1 3 1 3 3 2 2 3 2 1 3 2 1 3 1 3 3 1 2 2 1 1 2 3 2 3 1 3 1 2 2 2 1 1 3 3 3 2 3 1 3 3 2 3 1 2 1 3 3 2 3 1 3 3 3 2 1 2 3 3 3 3 1 2 3 2 3 1 2 3 1 2 1 3 2 1 1 2 2 1 2 1 2 2 3 1 1 2 3 3 2 1 1 2 3 2 3 2 2 2 3 1 3 3 2 2 3 1 1 1 2 1 2 3 2 1 3 1 3 3 3 3 2 1 1 1 2 2 3 2 1 2 3 3 1 2 1 2 2 1 1 2 2 1 3 2 1 3 1 1 1 3 1 1 1 3 2 1 3 2 1 2 1 2 1 3 1 1 3 2 2 3 3 3 3 3 2 1 2 2 2 1 3 2 2 3 1 3 3 1 3 1 2 2 2 3 1 1 1 2 2 2 1 2 3 3 3 1 1 1 1 1 2 1 1 2 2 1 1 3 1 2 2 3 3 3 3 3 3 3 1 3 1 1 1 3 2 1 1 2 2 3 2 2 3 2 3 2 2 1 1 3 3 2 2 2 1 2 3 1 3 2 2 1 3 1 2 2 1 3 3 3 3 1 2 1 3 3 1 1 2 3 1 3 1 3 3 2 3 2 1 2 1 1 1 2 3 2 1 3 3 1 3 3 2 2 1 3 1 1 2 2 1 2 2 1 2 3 1 1 3 2 3 1 1 2 2 3 1 2 3 3 2 1 3 1 1 2 2 3 3 3 1 1 1 1 1 1 3 2 1 1 3 2 2 1 1 2 1 3 3 2 2 1 3 2 1 2 2 2 1 2 1 1 2 1 2 2 3 1 1 1 2 2 1 3 2 2 1 2 3 3 2 3 1 1 3 1 1 2 2 3 1 2 3 2 2 3 2 3 3 3 1 3 2 2 2 3 2 1 2 1 2 2 2 3 2 1 2 1 1 3 3 3 1 2 1 3 1 3 3 3 1 3 2 3 1 3 3 1 1 3 2 1 2 2 3 3 1 3 2 3 3 3 3 3 1 3 1 1 2 3 2 1 2 3 3 2 3 3 1 2 1 1 2 1 1 2 2 3 2 2 1 3 3 1 3 2 3 1 3 2 2 1 2 3 1 3 3 1 2 3 3 2 3 2 2 2 2 1 3 1 1 2 1 3 3 1 1 3 2 2 2 2 3 3 2 2 3 2 3 1 3 1 3 2 1 2 3 3 1 1 1 1 1 1 2 2 2 1 2 3 1 2 3 1 2 2 1 2 1 1 2 2 1 2 3 2 3 3 3 2 3 2 1 3 3 1 1 3 1 1 3 2 1 2 1 2 1 1 3 1 2 3 2 1 1 3 2 1 3 3 2 2 3 1 1 1 1 3 3 3 2 3 1 1 1 1 2 3 3 2 2 1 3 2 1 2 3 2 3 3 1 2 3 3 2 1 1 2 3 2 1 3 2 2 1 1 3 2 3 3 3 3 2 2 2 1 3 3 2 3 2 1 1 2 2 1 3 1 1 2 3 1 2 3 1 3 1 3 2 3 3 3 3 1 1 3 3 3 3 2 1 2 1 1 2 3 2 1 3 1 2 3 1 2 1 3 2 2 3 2 3 3 1 3 1 1 1 3 3 2 1 1 1 2 3 2 2 1 3 1 3 3 2 2 1 2 1 3 1 1 2 1 2 2 3 1 1 1 2 2 1 1 1 2 3 3 2 3 2 2 3 2 2 3 2 2 3 3 3 1 2 1 3 1 3 1 1 2 3 1 2 1 2 2 1 1 1 1 1 3 2 1 2 2 3 1 1 3 2 3 1 3 2 1 3 3 2 2 2 1 1 1 3 2 2 2 3 2 1 1 2 1 3 2 3 2 2 2 2 3 1 2 3 2 2 1 1 3 2 1 1 3 2 3 2 2 3 2 1 2 3 1 1 3 1 3 1 1 1 3 2 1 1 3 1 3 2 2 3 3 1 2 2 1 2 3 3 3 1 1 1 2 2 1 1 1 1 1 3 1 1 3 3 2 2 2 3 1 3 2 1 3 3 2 1 1 2 3 1 1 2 1 2 3 2 2 2 3 3 1 3 2 2 3 3 3 1 1 2 2 1 3 3 3 1 3 3 3 3 1 1 1 1 1 1 3 2 3 2 3 3 1 1 2 1 1 1 2 3 3 1 2 3 2 1 3 1 1 2 3 1 3 3 1 3 3 3 1 2 3 2 3 3 1 2 3 2 1 3 3 3 2 1 3 2 1 2 2 2 3 1 2 2 1 2 3 2 3 2 3 1 3 1 1 1 3 2 1 2 2 3 3 3 1 2 2 2 1 2 1 2 2 1 3 1 1 1 2 3 2 2 2 3 2 3 1 1 3 3 1 1 2 1 1 3 1 1 2 2 3 3 3 1 2 1 2 1 2 3 3 2 2 2 3 1 2 3 3 2 2 1 2 2 3 1 2 3 2 1 3 2 2 2 1 2 3 3 3 3 1 2 1 2 2 3 3 1 3 2 1 3 1 2 2 3 2 1 1 3 1 2 1 2 3 2 3 3 2 3 1 1 1 3 1 1 1 3 2 1 1 2 1 2 2 1 2 2 3 1 3 3 3 1 3 1 2 2 2 2 2 1 2 3 1 3 2 3 1 1 1 1 2 3 2 1 1 1 2 2 1 2 3 1 1 3 3 3 1 1 2 2 2 1 3 1 1 3 3 1 1 2 1 2 2 3 3 3 3 1 2 3 3 3 1 1 1 1 1 3 1 1 2 3 2 2 1 2 2 3 3 2 3 2 3 2 2 2 3 3 1 1 1 1 2 1 2 1 3 1 2 3 3 2 1 1 3 2 1 3 1 2 3 1 2 2 2 1 2 2 2 3 1 2 3 3 1 1 2 2 1 3 1 2 2 2 3 3 3 3 2 3 3 2 1 2 1 1 3 2 3 2 2 1 3 1 2 3 3 1 3 3 2 2 1 1 3 1 3 2 3 3 2 2 1 3 1 2 1 1 1 2 2 3 2 1 2 2 2 3 1 3 3 1 3 3 2 1 2 1 2 1 2 3 1 3 2 1 3 3 3 2 3 2 1 3 1 2 3 1 1 3 1 3 1 2 2 1 3 2 1 1 3 2 3 2 3 2 2 2 2 3 3 1 1 2 3 1 3 3 2 3 1 3 1 1 1 2 1 2 3 1 3 2 1 2 3 3 3 3 3 2 1 2 3 3 2 2 3 1 3 3 2 3 3 2 1 3 2 2 2 3 1 2 2 2 3 3 2 2 2 2 2 3 2 1 2 3 2 2 3 3 3 3 3 3 2 2 1 1 3 1 3 3 3 2 3 1 2 2 2 3 2 2 1 1 3 2 1 3 2 3 2 2 1 1 3 1 1 1 2 2 1 1 2 1 3 3 2 2 3 3 2 1 1 2 2 3 2 3 2 3 3 3 3 1 3 1 2 2 3 1 2 3 2 2 1 2 2 1 2 1 3 2 3 2 3 3 2 1 3 3 2 2 1 1 2 3 1 2 2 2 3 1 2 2 2 3 1 3 2 3 2 2 3 2 2 2 1 1 1 2 2 2 3 1 1 2 3 3 2 2 3 1 1 3 1 1 1 1 1 1 3 3 2 3 1 3 1 2 2 1 2 3 3 1 3 1 2 3 1 2 2 2 2 1 2 1 1 3 2 1 1 2 2 3 3 3 1 3 1 2 2 3 1 2 1 2 3 3 1 2 3 3 2 2 1 1 2 3 1 1 3 2 1 2 3 2 2 1 3 3 1 2 1 1 3 2 2 2 3 3 3 3 3 2 1 3 2 2 3 1 1 2 3 3 1 1 3 3 3 2 2 2 2 2 2 1 2 1 3 3 3 2 1 2 3 1 3 3 1 3 2 1 3 3 1 3 1 3 2 2 2 2 1 3 3 3 2 1 2 3 2 1 1 2 1 1 2 3 2 1 1 3 3 3 1 1 3 1 1 1 1 1 2 2 1 3 1 2 3 3 2 2 1 2 2 1 1 2 2 2 2 1 2 1 3 2 2 2 2 3 3 2 1 3 2 2 1 3 1 1 1 1 3 2 2 2 3 2 1 3 3 1 2 2 2 3 1 3 2 2 2 2 1 1 3 3 3 3 3 1 3 2 3 1 3 3 2 1 2 1 2 1 3 3 2 3 1 2 3 1 1 1 1 3 1 3 3 1 2 1 3 2 3 2 1 2 2 3 2 2 2 1 3 3 2 2 1 3 3 3 3 2 2 1 1 2 3 3 3 3 2 2 1 2 3 2 1 3 3 3 1 1 1 2 2 3 2 2 3 3 3 2 2 3 1 1 1 2 3 1 2 2 1 1 3 1 2 3 1 2 2 3 2 1 2 2 1 1 3 3 3 3 1 3 2 3 1 1 1 1 2 2 2 1 1 3 3 2 1 2 2 2 1 3 1 3 3 3 3 3 1 2 3 1 1 1 1 2 2 2 2 3 3 1 1 3 3 2 1 1 3 3 1 1 1 2 2 1 2 2 1 1 3 3 3 1 1 2 3 1 3 2 1 2 3 1 3 1 1 3 1 2 3 1 2 3 3 2 1 1 3 3 1 2 3 1 3 3 3 3 1 1 3 3 2 2 2 2 3 3 3 2 2 1 2 1 2 3 3 2 2 1 2 3 2 1 3 3 1 3 2 3 2 1 3 1 3 3 2 1 1 1 3 1 3 3 1 3 3 3 1 3 3 2 3 1 1 3 2 1 2 1 3 1 3 1 3 1 2 1 2 1 3 1 2 1 2 1 1 1 3 2 2 2 1 1 3 3 1 1 2 3 2 3 2 1 1 2 2 1 2 1 1 1 1 1 3 3 2 1 3 2 1 1 1 1 1 1 1 3 2 2 1 2 3 2 1 2 2 2 1 1 1 1 3 1 1 1 2 1 1 3 1 3 1 3 2 1 2 3 3 3 1 2 2 1 2 1 1 3 3 3 2 3 2 3 1 3 2 1 3 3 1 3 3 2 3 2 2 1 3 3 1 1 3 2 1 3 3 3 2 3 1 3 1 1 1 3 2 1 3 2 3 1 2 2 1 2 1 2 1 1 2 1 3 1 2 1 1 2 2 2 1 1 1 1 1 3 3 2 3 1 3 1 2 3 3 1 2 3 1 3 3 3 3 1 3 1 2 2 3 3 3 2 2 3 2 2 2 1 3 1 3 3 2 3 2 1 2 3 2 2 1 3 1 2 2 2 3 2 2 1 3 1 2 3 2 2 2 2 2 1 2 3 3 1 3 1 3 3 2 3 3 1 2 2 2 2 3 2 2 1 3 1 1 3 2 1 3 3 3 1 1 2 3 1 1 3 1 2 1 1 2 3 3 3 1 3 3 3 1 1 3 2 3 1 1 3 2 1 2 3 3 1 1 3 1 1 1 3 1 3 1 3 1 1 1 1 2 2 2 2 2 1 2 3 2 2 3 1 1 2 2 3 3 2 1 1 1 1 2 1 2 2 1 2 2 1 1 2 2 1 3 2 1 2 2 2 3 3 3 2 2 2 1 3 1 3 3 1 2 2 3 3 3 2 3 3 1 2 1 2 1 2 1 1 2 3 2 1 2 1 1 3 2 1 1 3 2 1 3 2 1 3 1 1 3 3 3 3 3 1 2 3 2 1 2 3 1 2 3 2 3 2 1 1 2 1 1 2 1 2 1 2 1 1 2 3 3 2 2 3 1 3 3 3 3 1 2 3 2 3 3 3 3 2 1 3 3 2 3 1 3 3 1 3 3 3 1 2 2 1 3 1 1 2 3 3 3 3 1 1 2 1 1 2 3 2 1 2 2 1 3 1 2 2 2 2 1 3 3 2 2 2 2 2 3 3 2 1 2 1 1 2 2 1 2 1 3 1 3 3 3 1 3 2 1 1 2 2 3 1 2 3 3 2 1 2 3 2 2 1 2 1 2 3 3 2 1 2 3 2 1 3 1 1 2 2 3 1 2 2 1 2 2 2 1 3 1 1 3 2 3 1 1 2 2 2 3 2 1 3 1 2 2 1 3 1 3 3 2 2 1 1 1 1 1 2 2 1 2 3 3 2 1 1 3 1 3 1 3 1 1 1 2 2 3 1 3 2 2 2 1 1 1 2 2 1 1 2 3 2 3 1 2 3 3 3 1 3 3 3 3 2 2 2 2 2 3 2 2 3 2 2 1 1 2 3 2 1 2 2 1 2 2 2 3 1 3 3 3 2 3 2 1 2 1 1 3 3 2 2 2 3 1 1 2 3 1 2 3 2 1 3 1 1 2 2 2 1 1 2 3 1 2 2 2 3 1 3 2 3 2 1 1 1 1 2 1 3 1 1 2 1 2 2 1 2 3 1 2 3 1 3 2 3 1 1 2 3 1 2 1 1 1 1 3 2 1 1 3 3 1 3 3 3 1 1 3 1 2 2 1 3 1 3 1 3 3 3 2 3 1 3 3 3 3 2 1 1 2 2 3 3 2 3 2 2 1 2 3 2 2 2 1 2 1 3 3 2 2 3 1 2 2 2 2 3 3 2 1 2 2 1 2 2 3 2 2 2 2 3 2 2 2 3 1 1 2 1 1 2 1 3 1 1 2 3 3 3 3 3 3 1 3 1 2 2 3 2 1 3 3 1 1 1 3 3 2 3 1 2 3 2 3 3 3 3 1 2 2 1 1 2 1 2 3 1 2 1 3 2 2 3 2 2 3 1 3 1 1 3 3 2 1 2 3 3 1 2 3 3 1 2 3 3 1 2 1 3 2 2 1 3 2 1 1 1 3 3 2 3 1 2 3 1 3 2 1 3 3 1 3 1 1 3 3 3 2 3 1 2 2 1 2 2 2 2 2 2 1 2 2 2 3 1 2 3 3 2 2 3 1 2 2 3 3 1 2 2 3 1 1 2 2 3 1 1 2 1 3 1 3 1 3 3 3 3 3 3 1 1 1 3 1 2 2 1 2 3 2 3 3 2 3 1 2 2 2 2 3 1 3 2 3 2 1 2 2 1 3 3 2 3 2 3 1 3 1 3 1 3 2 2 2 2 3 1 1 1 3 1 3 2 2 1 3 3 1 1 3 1 2 3 2 1 1 3 1 3 1 1 3 3 1 3 1 1 1 1 1 2 3 1 3 2 3 2 2 3 2 1 2 1 1 3 2 1 1 3 1 3 3 3 1 2 2 3 2 1 1 3 3 1 3 1 1 2 1 3 2 2 1 1 3 1 3 2 1 2 2 2 3 1 2 1 3 3 2 2 3 2 1 2 2 3 3 1 3 2 3 2 3 3 1 2 1 2 3 2 1 2 3 1 3 3 3 2 1 1 3 3 2 2 3 1 1 3 3 2 3 2 1 3 2 2 1 1 3 3 2 2 3 3 2 3 3 1 2 1 3 2 2 3 3 3 1 2 2 2 2 1 1 2 2 3 3 2 1 2 3 1 1 3 2 1 2 2 1 1 3 1 1 2 2 1 3 3 3 1 1 2 1 3 3 3 3 2 1 2 1 1 2 1 1 3 2 3 1 1 2 1 1 3 2 3 1 3 1 2 3 3 2 1 3 2 2 2 3 1 1 3 1 1 3 2 1 1 3 3 1 2 1 1 3 3 2 2 1 2 1 3 3 1 3 2 3 2 1 1 3 3 2 3 2 1 3 3 3 2 1 1 1 3 1 2 1 3 2 2 1 1 2 3 1 3 3 1 3 2 3 3 2 2 2 1 1 1 1 1 1 1 3 1 3 2 3 1 2 3 3 1 1 1 1 1 3 1 2 1 3 1 3 2 1 2 2 2 3 3 1 3 1 2 3 1 1 2 3 1 3 3 3 2 1 2 1 2 2 2 2 1 3 2 1 1 1 3 3 1 3 2 3 1 1 1 3 2 2 3 3 3 3 3 1 1 1 2 2 1 3 1 2 1 3 3 2 1 3 2 1 3 1 2 1 2 1 1 1 2 3 1 1 1 2 2 2 3 1 1 2 2 3 3 3 1 3 3 1 2 2 1 2 3 1 2 3 1 3 3 1 3 3 3 2 3 3 3 3 3 3 2 3 3 3 3 1 1 3 2 1 2 1 3 2 3 1 1 2 2 1 1 1 1 2 1 1 3 2 1 3 3 3 2 1 3 1 2 3 2 3 2 2 2 3 1 1 3 3 3 2 3 3 2 1 1 3 3 3 1 1 3 2 3 1 3 3 2 2 2 2 1 2 3 1 2 3 2 1 1 3 2 2 1 2 3 2 1 1 1 3 3 3 1 3 3 2 3 1 2 3 3 3 2 1 2 2 1 3 3 2 2 2 1 1 3 2 1 3 2 3 2 2 1 3 2 3 1 3 3 1 1 1 2 1 2 2 2 3 1 1 2 3 3 3 3 1 3 3 1 3 2 2 1 3 1 2 3 1 2 1 3 1 2 2 3 2 2 1 2 1 2 3 3 3 1 2 1 3 1 1 3 1 3 1 1 3 1 3 1 2 1 3 3 2 2 1 1 2 3 2 2 1 3 2 1 2 3 1 2 3 2 2 1 3 1 3 2 1 1 3 2 3 1 1 2 2 2 3 3 1 1 3 2 2 1 2 2 1 1 2 2 3 1 1 2 2 2 1 1 3 1 1 3 2 3 1 2 1 2 1 2 1 1 2 2 3 3 2 2 2 3 1 3 2 2 2 1 1 1 2 2 3 1 1 2 3 1 1 2 2 1 2 1 1 1 1 3 1 2 3 1 2 1 3 1 3 1 2 3 1 3 3 2 2 3 1 3 2 2 3 3 1 1 3 3 2 1 2 3 2 2 1 3 1 3 3 2 2 1 3 1 1 3 2 3 3 2 2 3 1 2 3 2 1 1 3 3 3 2 3 1 1 3 3 2 2 2 1 2 1 3 1 1 2 3 3 1 1 3 3 1 3 3 1 2 1 2 2 2 3 2 2 3 1 1 2 1 3 2 2 1 1 3 3 3 3 2 2 1 2 1 1 3 3 1 1 2 3 1 3 1 1 3 2 3 1 3 2 2 2 2 3 1 1 1 2 1 3 1 2 1 1 3 3 2 2 1 1 1 2 2 1 1 1 2 3 2 2 3 2 1 2 2 3 2 1 3 3 2 2 1 3 3 1 2 1 3 3 3 3 1 2 2 1 1 1 3 2 2 2 2 1 3 3 2 1 3 2 2 3 2 2 1 2 1 2 1 1 1 3 2 3 1 2 2 2 2 3 2 2 3 3 1 2 3 3 3 3 1 2 3 3 3 1 2 1 1 3 1 2 2 3 1 3 2 2 3 2 3 3 2 3 1 2 2 2 2 2 2 1 3 1 2 1 3 3 3 2 3 1 1 2 3 3 1 2 1 1 2 3 2 3 3 2 1 3 3 3 1 2 2 2 3 2 3 3 1 3 1 3 1 3 2 3 3 1 3 2 2 2 2 1 3 1 2 2 3 3 1 2 2 3 2 2 1 1 1 3 2 3 3 2 3 1 1 1 2 1 2 1 3 1 1 1 1 1 1 2 3 2 3 1 3 3 2 1 3 3 2 2 3 2 3 1 2 1 2 1 2 2 3 2 1 3 2 2 3 3 1 1 1 3 3 3 2 2 3 2 2 2 3 1 2 1 1 3 1 3 3 3 2 1 3 2 2 3 1 3 3 2 1 2 3 3 1 2 3 2 1 1 3 1 2 1 3 2 1 1 3 1 3 2 1 2 1 1 2 2 2 3 1 3 1 3 1 1 1 2 3 2 1 3 2 1 3 2 2 2 1 1 1 3 3 1 1 3 3 2 2 2 1 1 2 1 2 1 3 3 3 1 1 1 1 2 1 1 3 2 1 1 3 3 3 3 1 2 3 3 2 1 2 1 3 2 3 1 2 1 1 2 3 2 3 2 3 3 2 1 1 3 2 1 2 2 3 3 3 3 2 2 2 1 3 3 3 2 1 3 3 2 1 1 3 2 1 2 2 2 3 1 1 1 3 3 2 3 3 3 3 2 3 2 2 3 1 1 1 3 2 3 2 2 1 1 3 1 3 1 1 2 2 1 3 3 3 2 1 1 3 3 1 2 2 3 3 1 1 1 3 2 3 2 3 3 2 1 1 1 1 2 3 2 3 3 1 1 3 1 2 1 1 2 2 2 2 1 3 1 3 3 3 3 3 3 3 1 3 3 2 1 1 2 2 1 2 3 2 3 1 3 1 1 3 2 1 2 1 2 2 3 1 2 1 3 2 1 3 2 3 3 2 3 3 1 3 2 2 1 3 2 2 3 2 2 2 1 2 3 2 3 3 3 2 3 1 3 3 1 3 3 3 3 1 2 2 2 1 3 3 3 2 3 1 1 2 3 3 3 1 3 3 1 2 3 1 3 1 3 2 1 1 3 3 3 2 2 3 3 \ No newline at end of file diff --git a/Leet Code/Sort List/out.txt b/Leet Code/Sort List/out.txt new file mode 100644 index 00000000..341dc884 --- /dev/null +++ b/Leet Code/Sort List/out.txt @@ -0,0 +1,2 @@ +Case #1: 0 1 2 3 4 5 6 7 8 9 +Case #2: 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 diff --git a/Leet Code/Spiral Matrix II/Spiral Matrix II.cpp b/Leet Code/Spiral Matrix II/Spiral Matrix II.cpp new file mode 100644 index 00000000..abd1e6e9 --- /dev/null +++ b/Leet Code/Spiral Matrix II/Spiral Matrix II.cpp @@ -0,0 +1,19 @@ +class Solution { +public: + vector > generateMatrix(int n) { + if(n <= 0) return vector >(); + vector > m(n, vector(n, 0)); + int k, v = 1; + for(k = 0; k < (n >> 1); ++k){ + int x = k, y = k, b = n - k - 1; + while(y < b) m[x][y++] = v++; + while(x < b) m[x++][y] = v++; + while(y > k) m[x][y--] = v++; + while(x > k) m[x--][y] = v++; + } + if(n%2){ + m[k][k] = v; + } + return m; + } +}; \ No newline at end of file diff --git a/Leet Code/Spiral Matrix/Main.cpp b/Leet Code/Spiral Matrix/Main.cpp new file mode 100644 index 00000000..c39acd1d --- /dev/null +++ b/Leet Code/Spiral Matrix/Main.cpp @@ -0,0 +1,37 @@ +#include +using namespace std; +#include +#include +#include "../+Helper/Helper.h" +#include "Spiral Matrix.cpp" + +vector > scanVector(int m, int n){ + vector > v; + for(int i = 0; i < m; ++i){ + vector v1; + for(int j = 0; j < n; ++j){ + int d; + cin >> d; + v1.push_back(d); + } + v.push_back(v1); + } + return v; +} + +int main(){ + freopen("in.txt", "r", stdin); + CLK_INIT; + Solution s; + CASET{ + int m, n; + RDD(m, n); + vector > v = scanVector(m, n); + PRINTCASE_; + CLK_START; + printVector(s.spiralOrder(v)); + CLK_END; + } + + return 0; +} \ No newline at end of file diff --git a/Leet Code/Spiral Matrix/Spiral Matrix.cpp b/Leet Code/Spiral Matrix/Spiral Matrix.cpp new file mode 100644 index 00000000..0c860566 --- /dev/null +++ b/Leet Code/Spiral Matrix/Spiral Matrix.cpp @@ -0,0 +1,35 @@ +#include +using namespace std; + +// 问题可以简化为扫描矩阵的最外层一圈 +// 警惕特殊情形: 仅有一行或仅有一列 +class Solution { +public: + vector spiralOrder(vector > &matrix) { + vector v; + int m = matrix.size(); + if(!m) return v; + int n = matrix[0].size(); + int xl = 0, xh = m - 1, yl = 0, yh = n - 1; + while(xl <= xh && yl <= yh){ + int x = xl, y = yl; + if(xl == xh){ // only one row + while(y <= yh) v.push_back(matrix[x][y++]); + break; + }else if(yl == yh){ // only one column + while(x <= xh) v.push_back(matrix[x++][y]); + break; + }else{ + while(y < yh) v.push_back(matrix[x][y++]); + yh--; + while(x < xh) v.push_back(matrix[x++][y]); + xh--; + while(y > yl) v.push_back(matrix[x][y--]); + yl++; + while(x > xl) v.push_back(matrix[x--][y]); + xl++; + } + } + return v; + } +}; \ No newline at end of file diff --git a/Leet Code/Spiral Matrix/in.txt b/Leet Code/Spiral Matrix/in.txt new file mode 100644 index 00000000..6fe52391 --- /dev/null +++ b/Leet Code/Spiral Matrix/in.txt @@ -0,0 +1,21 @@ +7 +0 0 +1 1 +1 +3 3 +1 2 3 +4 5 6 +7 8 9 +1 3 +1 2 3 +3 1 +1 +2 +3 +2 3 +1 2 3 +4 5 6 +3 2 +1 2 +3 4 +5 6 \ No newline at end of file diff --git a/Leet Code/Sqrt(x)/Sqrt(x).cpp b/Leet Code/Sqrt(x)/Sqrt(x).cpp new file mode 100644 index 00000000..367d8f6d --- /dev/null +++ b/Leet Code/Sqrt(x)/Sqrt(x).cpp @@ -0,0 +1,39 @@ +#include +#include +using namespace std; + +// sqrt(int x): http://www.2cto.com/kf/201304/202852.html +// C 语言Printf cout 输出格式【转】: http://anwj336.blog.163.com/blog/static/8941520920109141031882/ +class Solution { +public: + int sqrt(int x) { + long long int low = 0, high = x - 1, mid; + while(low < high){ + mid = (low + high) >> 1; + if(mid * mid < x){ + low = mid + 1; + }else{ + high = mid - 1; + } + } + if(low * low > x){ + do{ low--; }while(low * low > x); + }else if(low * low < x){ + low++; + if(low * low > x) low--; + } + return low; + } +}; + +int main(){ + for(int i = 0; i < 20; ++i) + cout << setw(3) << i; + cout << endl; + Solution s; + for(int i = 0; i < 20; ++i) + cout << setw(3) << s.sqrt(i); + cout << endl; + cout << s.sqrt(2147395599) << endl; + return 0; +} \ No newline at end of file diff --git a/Leet Code/Subsets/Main.cpp b/Leet Code/Subsets/Main.cpp new file mode 100644 index 00000000..634b033f --- /dev/null +++ b/Leet Code/Subsets/Main.cpp @@ -0,0 +1,21 @@ +#include +using namespace std; +#include +#include +#include "../+Helper/Helper.h" +#include "Subsets.cpp" + +int main(){ + freopen("in.txt", "r", stdin); + CLK_INIT; + Solution s; + CASET{ + vector v = scanVector(); + PRINTCASE; + CLK_START; + printVector(s.subsets(v)); + CLK_END; + } + + return 0; +} \ No newline at end of file diff --git a/Leet Code/Subsets/Subsets.cpp b/Leet Code/Subsets/Subsets.cpp new file mode 100644 index 00000000..65ccc4e3 --- /dev/null +++ b/Leet Code/Subsets/Subsets.cpp @@ -0,0 +1,56 @@ +class Solution { +private: + vector > v; +public: + bool isAscending(vector &S){ + for(int i = 1; i < S.size(); ++i){ + if(S[i - 1] > S[i]) return false; + } + return true; + } + + bool isDescending(vector &S){ + for(int i = 1; i < S.size(); ++i){ + if(S[i - 1] < S[i]) return false; + } + return true; + } + + void quickSort(vector &S, int L, int R){ + if(L >= R) return; + int A = S[L], i = L, j = R; + while(i < j){ + while(i < j && S[j] >= A) j--; + if(i < j) S[i] = S[j]; + while(i < j && S[i] <= A) i++; + if(i < j) S[j] = S[i]; + } + S[i] = A; + quickSort(S, L, i - 1); + quickSort(S, i + 1, R); + } + + void subsets(vector &S, vector &v1, int layer, int n){ + if(layer == n + 1){ + v.push_back(v1); + return; + } + for(int i = layer; i < S.size() - (n - layer); ++i){ + v1.push_back(S[i]); + subsets(S, v1, layer + i + 1, n); + v1.pop_back(); + } + } + + vector > subsets(vector &S) { + v.clear(); + if(!isAscending(S) && !isDescending(S)){ + quickSort(S, 0, S.size() - 1); + } + for(int n = 0; n <= S.size(); ++n){ + vector v1; + subsets(S, v1, 0, n); + } + return v; + } +}; \ No newline at end of file diff --git a/Leet Code/Subsets/in.txt b/Leet Code/Subsets/in.txt new file mode 100644 index 00000000..c32102e7 --- /dev/null +++ b/Leet Code/Subsets/in.txt @@ -0,0 +1,2 @@ +1 +1,3,2,4 \ No newline at end of file diff --git a/Leet Code/Swap Nodes in Pairs/Swap Nodes in Pairs.cpp b/Leet Code/Swap Nodes in Pairs/Swap Nodes in Pairs.cpp new file mode 100644 index 00000000..83e3b384 --- /dev/null +++ b/Leet Code/Swap Nodes in Pairs/Swap Nodes in Pairs.cpp @@ -0,0 +1,20 @@ +class Solution { +public: + ListNode *swapPairs(ListNode *head) { + ListNode *prev, *p, *q; + prev = NULL; p = head; + while(p && p->next){ + q = p->next; + if(prev){ + prev->next = q; + }else{ + head = q; + } + p->next = q->next; + q->next = p; + prev = p; + p = p->next; + } + return head; + } +}; \ No newline at end of file diff --git a/Leet Code/Symmetric Tree/Symmetric Tree - ite.cpp b/Leet Code/Symmetric Tree/Symmetric Tree - ite.cpp new file mode 100644 index 00000000..9d3e29fb --- /dev/null +++ b/Leet Code/Symmetric Tree/Symmetric Tree - ite.cpp @@ -0,0 +1,21 @@ +class Solution { +public: + bool isSymmetric(TreeNode *root) { + if(!root) return true; + stack q1, q2; + q1.push(root); q2.push(root); + while(!q1.empty() && !q2.empty()){ + TreeNode *r1 = q1.top(), *r2 = q2.top(); + q1.pop(); q2.pop(); + if(r1->val != r2->val) return false; + if(r1->left && !r2->right || !r1->left && r2->right) return false; + if(r1->right && !r2->left || !r1->right && r2->left) return false; + if(r1->right) q1.push(r1->right); + if(r1->left) q1.push(r1->left); + if(r2->left) q2.push(r2->left); + if(r2->right) q2.push(r2->right); + } + if(!q1.empty() || !q2.empty()) return false; + return true; + } +}; \ No newline at end of file diff --git a/Leet Code/Symmetric Tree/Symmetric Tree - rec.cpp b/Leet Code/Symmetric Tree/Symmetric Tree - rec.cpp new file mode 100644 index 00000000..3d9104d3 --- /dev/null +++ b/Leet Code/Symmetric Tree/Symmetric Tree - rec.cpp @@ -0,0 +1,12 @@ +class Solution { +public: + bool isSymmetric(TreeNode *r1, TreeNode *r2){ + if(!r1 && !r2) return true; + if(r1 && r2 && r1->val == r2->val) return isSymmetric(r1->left, r2->right) && isSymmetric(r1->right, r2->left); + return false; + } + + bool isSymmetric(TreeNode *root) { + return isSymmetric(root, root); + } +}; \ No newline at end of file diff --git a/Leet Code/Symmetric Tree/in.txt b/Leet Code/Symmetric Tree/in.txt new file mode 100644 index 00000000..faaa9b2b --- /dev/null +++ b/Leet Code/Symmetric Tree/in.txt @@ -0,0 +1,4 @@ +3 +1,2,2 +1,2 +1,2,2,#,3,#,3 \ No newline at end of file diff --git a/Leet Code/Unique Paths/Unique Paths.cpp b/Leet Code/Unique Paths/Unique Paths.cpp new file mode 100644 index 00000000..95ac6c35 --- /dev/null +++ b/Leet Code/Unique Paths/Unique Paths.cpp @@ -0,0 +1,22 @@ +#include +using namespace std; + +class Solution { +public: + int uniquePaths(int m, int n) { + int pow_n = n, coef = 1 << (m - 2), result = 0; + for(int i = 1; i <= m - 2; ++i){ + coef >>= 1; + result += pow_n * coef; + pow_n *= n; + } + result += pow_n; + return result >> (m - 2); + } +}; + +int main(){ + Solution s; + cout << s.uniquePaths(4, 4) << endl; + return 0; +} \ No newline at end of file diff --git a/Leet Code/Valid Parentheses/Valid Parentheses.cpp b/Leet Code/Valid Parentheses/Valid Parentheses.cpp new file mode 100644 index 00000000..8e24f7c6 --- /dev/null +++ b/Leet Code/Valid Parentheses/Valid Parentheses.cpp @@ -0,0 +1,25 @@ +class Solution { +public: + // parentheses (), brackets [], braces {} + bool isValid(string str) { + char dic[] = "{[("; + stack s; + string::iterator i = str.begin(); + for(; i != str.end(); ++i){ + int j = 0; + switch(*i){ + case '(': + case '[': + case '{': + s.push(*i); break; + case ')': j++; + case ']': j++; + case '}': + if(s.empty() || s.top() != dic[j]) return false; + s.pop(); break; + default: break; + } + } + return s.empty(); + } +}; \ No newline at end of file diff --git a/Leet Code/Valid Sudoku/Valid Sudoku.cpp b/Leet Code/Valid Sudoku/Valid Sudoku.cpp new file mode 100644 index 00000000..a3fe6fd7 --- /dev/null +++ b/Leet Code/Valid Sudoku/Valid Sudoku.cpp @@ -0,0 +1,37 @@ +class Solution { +public: + bool isValidSudoku(vector > &board) { + vector tag; + for(int i = 0; i < 9; ++i){ + tag = vector(10, false); + for(int j = 0; j < 9; ++j){ + char c = board[i][j]; + if(c != '.'){ + if(tag[c - '0']) return false; + else tag[c - '0'] = true; + } + } + } + for(int j = 0; j < 9; ++j){ + tag = vector(10, false); + for(int i = 0; i < 9; ++i){ + char c = board[i][j]; + if(c != '.'){ + if(tag[c - '0']) return false; + else tag[c - '0'] = true; + } + } + } + for(int i = 0; i < 9; ++i){ + tag = vector(10, false); + for(int j = 0; j < 9; ++j){ + char c = board[i/3*3 + j/3][i%3*3 + j%3]; + if(c != '.'){ + if(tag[c - '0']) return false; + else tag[c - '0'] = true; + } + } + } + return true; + } +}; \ No newline at end of file diff --git a/Leet Code/Validate Binary Search Tree/Main.cpp b/Leet Code/Validate Binary Search Tree/Main.cpp new file mode 100644 index 00000000..6145a51f --- /dev/null +++ b/Leet Code/Validate Binary Search Tree/Main.cpp @@ -0,0 +1,23 @@ +#include +using namespace std; +#include +#include +#include "../+Helper/Helper.h" +#include "Validate Binary Search Tree.cpp" + +int main(){ + freopen("in.txt", "r", stdin); + CLK_INIT; + Solution s; + CASET{ + string str; + cin >> str; + TreeNode *root = deserialize(str); + PRINTCASE; + CLK_START; + cout << boolalpha << s.isValidBST(root) << endl; + CLK_END; + } + + return 0; +} \ No newline at end of file diff --git a/Leet Code/Validate Binary Search Tree/Validate Binary Search Tree.cpp b/Leet Code/Validate Binary Search Tree/Validate Binary Search Tree.cpp new file mode 100644 index 00000000..1e68a447 --- /dev/null +++ b/Leet Code/Validate Binary Search Tree/Validate Binary Search Tree.cpp @@ -0,0 +1,14 @@ +#include "../+Helper/BinaryTree.h" + +class Solution { +public: + bool recursiveTest(TreeNode *root, TreeNode *LB, TreeNode *RB){ + if(!root) return true; + if(LB && root->val <= LB->val) return false; + if(RB && root->val >= RB->val) return false; + return recursiveTest(root->left, LB, root) && recursiveTest(root->right, root, RB); + } + bool isValidBST(TreeNode *root) { + return recursiveTest(root, NULL, NULL); + } +}; \ No newline at end of file diff --git a/Leet Code/Validate Binary Search Tree/in.txt b/Leet Code/Validate Binary Search Tree/in.txt new file mode 100644 index 00000000..8f528954 --- /dev/null +++ b/Leet Code/Validate Binary Search Tree/in.txt @@ -0,0 +1,2 @@ +1 +10,5,15,#,#,6,20 \ No newline at end of file diff --git a/Leet Code/ZigZag Conversion/Main.cpp b/Leet Code/ZigZag Conversion/Main.cpp new file mode 100644 index 00000000..0ecd0ecf --- /dev/null +++ b/Leet Code/ZigZag Conversion/Main.cpp @@ -0,0 +1,22 @@ +#include +using namespace std; +#include +#include +#include "../+Helper/Helper.h" +#include "ZigZag Conversion.cpp" + +int main(){ + freopen("in.txt", "r", stdin); + CLK_INIT; + Solution s; + CASET{ + string str; int nRows; + cin >> str >> nRows; + PRINTCASE; + CLK_START; + cout << s.convert(str, nRows) << endl; + CLK_END; + } + + return 0; +} \ No newline at end of file diff --git a/Leet Code/ZigZag Conversion/ZigZag Conversion.cpp b/Leet Code/ZigZag Conversion/ZigZag Conversion.cpp new file mode 100644 index 00000000..581707a1 --- /dev/null +++ b/Leet Code/ZigZag Conversion/ZigZag Conversion.cpp @@ -0,0 +1,25 @@ +#include +using namespace std; + +class Solution { +public: + string convert(string s, int nRows) { + string ret; + if(nRows <= 0) return ret; + if(nRows == 1) return s; + int length = s.size(); + int offset2 = (nRows - 1) * 2; + for(int i = 0; i < nRows && i < length; ++i){ + int p = i; + int offset1 = offset2 - i * 2; + while(p < length){ + ret += s[p]; + if(offset1 && offset1 != offset2 && p + offset1 < length){ + ret += s[p + offset1]; + } + p += offset2; + } + } + return ret; + } +}; \ No newline at end of file diff --git a/Leet Code/ZigZag Conversion/in.txt b/Leet Code/ZigZag Conversion/in.txt new file mode 100644 index 00000000..765fbcf0 --- /dev/null +++ b/Leet Code/ZigZag Conversion/in.txt @@ -0,0 +1,8 @@ +7 +PAYPALISHIRING 0 +PAYPALISHIRING 1 +PAYPALISHIRING 2 +PAYPALISHIRING 3 +PAYPALISHIRING 7 +PAYPALISHIRING 14 +PAYPALISHIRING 15 \ No newline at end of file