From 29bee14ec2f546ebbe33f2232fca30c3cbb3a5c0 Mon Sep 17 00:00:00 2001 From: FreezePhoenix <24441367+FreezePhoenix@users.noreply.github.com> Date: Sun, 13 Jul 2025 14:41:05 -0400 Subject: [PATCH 01/10] Update worker.js Improve performance in scenarios where a pair of terms must be used. --- js/worker/worker.js | 24 +++++++++++++++++------- 1 file changed, 17 insertions(+), 7 deletions(-) diff --git a/js/worker/worker.js b/js/worker/worker.js index e5ba3fd..60b436c 100644 --- a/js/worker/worker.js +++ b/js/worker/worker.js @@ -148,19 +148,29 @@ onmessage = (e) => { }); postMessage({ action: "result", results: results }); } else { + // Preprocessing... + let maskedDictionaryMap = new Map(); + for(let i = 0; i < maskedDictionary.length; i++) { + let [term, complexity] = maskedDictionary[i]; + if(maskedDictionaryMap.has(term)) { + if(complexity < maskedDictionaryMap.get(term)) { + maskedDictionaryMap.set(term, complexity); + } + } else { + maskedDictionaryMap.set(term, complexity); + } + } // find the two terms of the shortest combined complexity that, when XOR'ed together, give the searched term let pair = [], min = Infinity; for (let i = 0; i < maskedDictionary.length; i++) { let term0 = maskedDictionary[i]; let complementary = (e.data.term ^ term0[0]) | e.data.mask; - for(let j = i + 1; j < maskedDictionary.length; j++) { - let term1 = maskedDictionary[j]; - if(term1[0] == complementary) { - if (term1[1] + term0[1] < min) { - pair = [term1[0], term0[0]]; - min = term1[1] + term0[1]; - } + if(maskedDictionaryMap.has(complementary)) { + let term1Complexity = maskedDictionaryMap.get(complementary); + if (term1Complexity + term0[1] < min) { + pair = [complementary, term0[0]]; + min = term1Complexity + term0[1]; } } } From 70f38301fb86f7a09843ac1fe970a01f91979548 Mon Sep 17 00:00:00 2001 From: FreezePhoenix <24441367+FreezePhoenix@users.noreply.github.com> Date: Mon, 14 Jul 2025 19:23:44 -0400 Subject: [PATCH 02/10] Update worker.js to further improve performance (1/2) This is the first commit out of a two-part series that improves performance further. This PR caches gate results to avoid recomputing a significant amount of data, and significantly reduces the amount of memory used by consolidating values (terms stay in the term dictionary, and we only store their identifier). --- js/worker/worker.js | 109 +++++++++++++++++++++++--------------------- 1 file changed, 57 insertions(+), 52 deletions(-) diff --git a/js/worker/worker.js b/js/worker/worker.js index 60b436c..7d8386e 100644 --- a/js/worker/worker.js +++ b/js/worker/worker.js @@ -5,14 +5,15 @@ import { Queue } from "../model/Queue.js"; /** * Creates the lookup table from dictionary.js + * @param {Array. terms: The dictionary of terms. * @param {number} varCount: number of variables (2 to 4) - * @param {Array.<{string, number}>} val: combinations of [Printable expression, Truth table value] + * @param {Object} val: An object describing the current term being investigated. * @param {number} count: the number of terms in the expression * @param {Array.<{number, number}>} solutions: array of [boolean function, min depth to solve] */ -const testfunc = ({ varCount, val, count, solutions }) => { +const testfunc = (terms, varCount, val, count, solutions) => { for (let gate of Gates) { - let term = gate.combine(val, varCount); + let term = gate.combine(terms, val, varCount); solutions[term] = solutions[term] ? [term, Math.min(solutions[term][1], count)] : [term, count]; @@ -25,31 +26,37 @@ const testfunc = ({ varCount, val, count, solutions }) => { /** * Default validation function. Pushes valid text based expressions to the solutions array. - * @param {number} varCount: number of variables (2 to 4) - * @param {number} term: the term to be expressed - * @param {number} mask: a mask taking care of don't cares - * @param {Array.} val: combinations of [Printable expression, Truth table value] + * @param {Array.} terms: The dictionary of terms. + * @param {Object} val: An object describing the current term being investigated. * @param {number} count: the number of terms in the expression - * @param {string[]} solutions: the array of solutions + * @param {Array.<{string, number[]}>} solutions: array of [representative string, list of wire lamp configurations] + * @param {number} term: The desired term to reach + * @param {number} neg_term: The complement of the desired term to reach, in case we can reach it using a negated output + * @param {number} mask: a mask taking care of don't cares */ -const identity = ({ varCount, term, neg_term, mask, val, count, solutions }) => { +const identity = (terms, val, count, solutions, term, neg_term, mask) => { + let vterm = terms[val.idx]; if (count === 1) { - if ((val.mask | mask) == term) { - solutions.push([val.symbol, val.wire_lamp]); + for (let gate of Gates) { + gate.combine(terms, val); + } + if ((vterm[1] | mask) == term) { + solutions.push([vterm[0], vterm[2]]); } } else { for (let gate of Gates) { - const t = gate.combine(val, varCount); + const t = gate.combine(terms, val); const t_m = t | mask; if (t_m == term || t_m == neg_term) { - let symbol_string = val.symbol; + let symbol_string = vterm[0]; let current = val.prev; - let wire_lamps = new Array(val.depth); - let index = val.depth; + let wire_lamps = new Array(count); + let index = count; do { - symbol_string = current.symbol + ", " + symbol_string; - wire_lamps[--index] = current.wire_lamp; + let cterm = terms[current.idx]; + symbol_string = cterm[0] + ", " + symbol_string; + wire_lamps[--index] = cterm[2]; current = current.prev; } while(current != null); @@ -63,6 +70,7 @@ const identity = ({ varCount, term, neg_term, mask, val, count, solutions }) => } }; + /** * Generates all possible expressions for a given term, combinations generated in breadth-first-like order. * @param {number} varCount: number of variables (2 to 4) @@ -81,49 +89,46 @@ function makeExpressionsBFS({ }) { const neg_term = negate(term ^ mask, varCount) | mask; const legalTerms = Terms[varCount]; + // Initialize the queue with the individual terms. let queue = new Queue(); + let next_queue = new Queue(); + for(let i = 0; i < legalTerms.length; i++) { - let v = legalTerms[i]; - queue.enqueue({ - val: { - symbol: v[0], - mask: v[1], - wire_lamp: v[2], - depth: 1, - prev: null - }, + next_queue.enqueue({ + XOR_CACHE_O: 0, + XOR_CACHE_E: 0, + AND_CACHE: 0, + prev: null, + next: null, idx: i, - count: 1, - next: null }); } + let solutions = []; - - while (!queue.empty()) { - let { val, idx, count } = queue.dequeue(); - - callback({ - varCount: varCount, - neg_term: neg_term, - term: term, - mask: mask, - val: val, - count: count, - solutions: solutions, - }); - - if (count < maxDepth) { - for (let i = idx + 1; i < legalTerms.length; i++) { - let term = legalTerms[i]; - let newVal = { - symbol: term[0], - mask: term[1], - wire_lamp: term[2], - depth: val.depth + 1, - prev: val + let count = 0; + + while(!next_queue.empty()) { + let temp = next_queue; + next_queue = queue; + queue = temp; + + count++; + + while (!queue.empty()) { + let val = queue.dequeue(); + callback(legalTerms, val, count, solutions, term, neg_term, mask); + if (count < maxDepth) { + for (let i = val.idx + 1; i < legalTerms.length; i++) { + next_queue.enqueue({ + XOR_CACHE_O: 0, + XOR_CACHE_E: 0, + AND_CACHE: 0, + prev: val, + next: null, + idx: i, + }); } - queue.enqueue({ val: newVal, idx: i, count: count + 1, next: null }); } } } From 76934f20970c631bf51c924b68160f19a955e93c Mon Sep 17 00:00:00 2001 From: FreezePhoenix <24441367+FreezePhoenix@users.noreply.github.com> Date: Mon, 14 Jul 2025 19:24:24 -0400 Subject: [PATCH 03/10] Update gates.js (2/2) This is the second commit out of a two-part series that improves performance further. This PR caches gate results to avoid recomputing a significant amount of data, and significantly reduces the amount of memory used by consolidating values (terms stay in the term dictionary, and we only store their identifier). --- js/data/gates.js | 30 ++++++++++++++++-------------- 1 file changed, 16 insertions(+), 14 deletions(-) diff --git a/js/data/gates.js b/js/data/gates.js index e480a7b..aa20d06 100644 --- a/js/data/gates.js +++ b/js/data/gates.js @@ -10,26 +10,28 @@ export const Gates = [ // }, { symbol:"⊕", - combine: (numbers) => { - let encountered = 0; - let over = 0; - while(numbers) { - over |= numbers.mask & encountered; - encountered |= numbers.mask; - numbers = numbers.prev; + combine: (terms, numbers) => { + let mask = terms[numbers.idx][1]; + if(numbers.prev) { + let over = numbers.prev.XOR_CACHE_O | (mask & numbers.prev.XOR_CACHE_E); + let encountered = mask | numbers.prev.XOR_CACHE_E; + numbers.XOR_CACHE_O = over; + numbers.XOR_CACHE_E = encountered; + return ~over & encountered; } - return ~over & encountered; + numbers.XOR_CACHE_O = 0; + numbers.XOR_CACHE_E = mask; + return mask; } }, { symbol:"∧", - combine: (numbers) => { - let result = ~0; - while(numbers) { - result &= numbers.mask; - numbers = numbers.prev; + combine: (terms, numbers) => { + let mask = terms[numbers.idx][1]; + if(numbers.prev) { + return numbers.AND_CACHE = numbers.prev.AND_CACHE & mask; } - return result; + return numbers.AND_CACHE = mask; } }, // { From dda94802913f279b05407ca601a7e67970837477 Mon Sep 17 00:00:00 2001 From: FreezePhoenix <24441367+FreezePhoenix@users.noreply.github.com> Date: Fri, 18 Jul 2025 16:38:59 -0400 Subject: [PATCH 04/10] Update main.js (Rework + Performance Improvements, 1/5) --- js/main.js | 14 ++++++++------ 1 file changed, 8 insertions(+), 6 deletions(-) diff --git a/js/main.js b/js/main.js index c11898d..30d995d 100644 --- a/js/main.js +++ b/js/main.js @@ -154,9 +154,10 @@ worker.onmessage = (e) => { }; let index = 0; -let matrices = JSON.parse(localStorage.getItem("matrices")); +let matrixResults = JSON.parse(localStorage.getItem("matrices")); +let matrices = matrixResults?.matrices; UI.setNextPrevState(index, matrices); -if (matrices != null) UI.displayMatrix(matrices[index]); +if (matrixResults != null) UI.displayMatrix(matrices[index], matrixResults.varCount, matrixResults.outputs); // Multi input worker. Generates transition matrices. transmatrix.onmessage = (e) => transmatrix_onmessage(e); @@ -167,10 +168,11 @@ function transmatrix_onmessage(e) { if (e.data.results) { localStorage.setItem("matrices", JSON.stringify(e.data.results)); - matrices = e.data.results; + matrixResults = e.data.results; + matrices = matrixResults.matrices; index = 0; UI.setNextPrevState(index, matrices); - UI.displayMatrix(matrices[index]); + UI.displayMatrix(matrices[index], matrixResults.varCount, matrixResults.outputs); } break; case "count": @@ -183,13 +185,13 @@ function next() { if (matrices != null && index < matrices.length - 1) index++; UI.setNextPrevState(index, matrices); - UI.displayMatrix(matrices[index]); + UI.displayMatrix(matrices[index], matrixResults.varCount, matrixResults.outputs); } function prev() { if (index > 0) index--; UI.setNextPrevState(index, matrices); - UI.displayMatrix(matrices[index]); + UI.displayMatrix(matrices[index], matrixResults.varCount, matrixResults.outputs); } function display() { From 597fc1c7fe8887c47c94879839cdcee83649b1f5 Mon Sep 17 00:00:00 2001 From: FreezePhoenix <24441367+FreezePhoenix@users.noreply.github.com> Date: Fri, 18 Jul 2025 16:39:20 -0400 Subject: [PATCH 05/10] Update worker.js (2/5) --- js/worker/worker.js | 99 ++++++++++++++++++++++++--------------------- 1 file changed, 53 insertions(+), 46 deletions(-) diff --git a/js/worker/worker.js b/js/worker/worker.js index 7d8386e..7ec5fa4 100644 --- a/js/worker/worker.js +++ b/js/worker/worker.js @@ -34,29 +34,31 @@ const testfunc = (terms, varCount, val, count, solutions) => { * @param {number} neg_term: The complement of the desired term to reach, in case we can reach it using a negated output * @param {number} mask: a mask taking care of don't cares */ -const identity = (terms, val, count, solutions, term, neg_term, mask) => { +const identity = (terms, val, count, solutions, term, neg_term, mask, symbols) => { let vterm = terms[val.idx]; if (count === 1) { - for (let gate of Gates) { - gate.combine(terms, val); + for(let i = 0; i < Gates.length; i++) { + let gate = Gates[i]; + gate.combine(val, vterm); } - if ((vterm[1] | mask) == term) { - solutions.push([vterm[0], vterm[2]]); + if (vterm == term) { + solutions.push([symbols[val.idx][0], [symbols[val.idx][1]]]); } } else { - for (let gate of Gates) { - const t = gate.combine(terms, val); - const t_m = t | mask; + for(let i = 0; i < Gates.length; i++) { + let gate = Gates[i]; + const t = gate.combine(val, vterm); + const t_m = t; if (t_m == term || t_m == neg_term) { - let symbol_string = vterm[0]; + let symbol_string = symbols[val.idx][0]; let current = val.prev; let wire_lamps = new Array(count); let index = count; - + wire_lamps[--index] = symbols[val.idx][1]; do { - let cterm = terms[current.idx]; + let cterm = symbols[current.idx]; symbol_string = cterm[0] + ", " + symbol_string; - wire_lamps[--index] = cterm[2]; + wire_lamps[--index] = cterm[1]; current = current.prev; } while(current != null); @@ -87,18 +89,23 @@ function makeExpressionsBFS({ mask, callback = identity, }) { - const neg_term = negate(term ^ mask, varCount) | mask; - const legalTerms = Terms[varCount]; - + let legalTerms = Terms[varCount]; + let neg_term; + let symbols; + if(callback == identity) { + neg_term = negate(term, varCount); + term = term ^ mask; + symbols = legalTerms.map(term => [term[0], term[2]]); + legalTerms = legalTerms.map(term => term[1] & ~mask); + } // Initialize the queue with the individual terms. let queue = new Queue(); let next_queue = new Queue(); for(let i = 0; i < legalTerms.length; i++) { next_queue.enqueue({ - XOR_CACHE_O: 0, - XOR_CACHE_E: 0, - AND_CACHE: 0, + CACHE_0: 0, + CACHE_1: 0, prev: null, next: null, idx: i, @@ -117,13 +124,15 @@ function makeExpressionsBFS({ while (!queue.empty()) { let val = queue.dequeue(); - callback(legalTerms, val, count, solutions, term, neg_term, mask); + callback(legalTerms, val, count, solutions, term, neg_term, mask, symbols); if (count < maxDepth) { + if((val.CACHE_1 & term) && (val.CACHE_1 & neg_term)) { + continue; + } for (let i = val.idx + 1; i < legalTerms.length; i++) { next_queue.enqueue({ - XOR_CACHE_O: 0, - XOR_CACHE_E: 0, - AND_CACHE: 0, + CACHE_0: 0, + CACHE_1: 0, prev: val, next: null, idx: i, @@ -139,40 +148,38 @@ function makeExpressionsBFS({ onmessage = (e) => { switch (e.data.action) { case "search": - const maskedDictionary = Dictionary[e.data.varCount - 2].map((a) => [ - a[0] | e.data.mask, - a[1], - ]); - if (maskedDictionary.find((a) => a[0] == e.data.term)) { - const results = makeExpressionsBFS({ - varCount: e.data.varCount, - maxDepth: e.data.maxDepth, - term: e.data.term, - mask: e.data.mask, - }); - postMessage({ action: "result", results: results }); + let results = makeExpressionsBFS({ + varCount: e.data.varCount, + maxDepth: e.data.maxDepth, + term: e.data.term, + mask: e.data.mask, + }); + + if(results != undefined) { + postMessage({ action: "result", results }); } else { - // Preprocessing... - let maskedDictionaryMap = new Map(); - for(let i = 0; i < maskedDictionary.length; i++) { - let [term, complexity] = maskedDictionary[i]; - if(maskedDictionaryMap.has(term)) { - if(complexity < maskedDictionaryMap.get(term)) { - maskedDictionaryMap.set(term, complexity); + let dictionary = Dictionary[e.data.varCount - 2]; + let maskedDictionary = new Map(); + for(let i = 0; i < dictionary.length; i++) { + let dict = dictionary[i]; + let maskedTerm = dict[0] | e.data.mask; + let complexity = dict[1]; + if(maskedDictionary.has(maskedTerm)) { + if(complexity < maskedDictionary.get(maskedTerm)) { + maskedDictionary.set(maskedTerm, complexity); } } else { - maskedDictionaryMap.set(term, complexity); + maskedDictionary.set(maskedTerm, complexity); } } // find the two terms of the shortest combined complexity that, when XOR'ed together, give the searched term let pair = [], min = Infinity; - for (let i = 0; i < maskedDictionary.length; i++) { - let term0 = maskedDictionary[i]; + for (let term0 of maskedDictionary) { let complementary = (e.data.term ^ term0[0]) | e.data.mask; - if(maskedDictionaryMap.has(complementary)) { - let term1Complexity = maskedDictionaryMap.get(complementary); + if(maskedDictionary.has(complementary)) { + let term1Complexity = maskedDictionary.get(complementary); if (term1Complexity + term0[1] < min) { pair = [complementary, term0[0]]; min = term1Complexity + term0[1]; From 06cc93de3b34d3b9fd40f957b9f90c5dd255ba01 Mon Sep 17 00:00:00 2001 From: FreezePhoenix <24441367+FreezePhoenix@users.noreply.github.com> Date: Fri, 18 Jul 2025 16:39:36 -0400 Subject: [PATCH 06/10] Update transmatrix.js (3/5) --- js/worker/transmatrix.js | 50 ++++++++++++++++++++++++++++++++++------ 1 file changed, 43 insertions(+), 7 deletions(-) diff --git a/js/worker/transmatrix.js b/js/worker/transmatrix.js index 7da286e..17ef2d1 100644 --- a/js/worker/transmatrix.js +++ b/js/worker/transmatrix.js @@ -61,6 +61,22 @@ function transition(rows, terms) { return newTerms; } +/** + * We are tasked with transposing an array of numbers as if the bits formed a matrix. + * We assume they are square, but that's fine for the uses we have. + */ +function transpose(arrayOfNums) { + let result = []; + for(let i = 0; i < arrayOfNums.length; i++) { + let beginning = (arrayOfNums[0] >> i) & 1; + for(let j = 1; j < arrayOfNums.length; j++) { + beginning |= ((arrayOfNums[j] >> i) & 1) << j; + } + result[i] = beginning; + } + return result; +} + /** * @typedef {Map} TermMap * @description Transitioned term as key, lamp count as value, ordered by lamp count @@ -146,16 +162,32 @@ function combinations({ varCount, terms, mask = 0, hardLimit = 20 }) { // Check the matrix and add it to possible solutions list. if (isInvertible(lin_combinations)) { const transitioned = transition(lin_combinations, terms); - const lampSum = transitioned.reduce( + const inverse = getInverseMatrix(lin_combinations); + let rows = transpose(inverse); + let new_transitioned = []; + let transitionedMap = new Map(); + for(let i = 0; i < transitioned.length; i++) { + let itransition = transitioned[i]; + if(transitionedMap.has(itransition)) { + // We XOR instead of OR here, even though they *should* be identical, but just in case the system decides to use the same term twice for some reason. + transitionedMap.set(itransition, transitionedMap.get(itransition) ^ rows[i]); + } else { + transitionedMap.set(itransition, rows[i]); + new_transitioned.push(itransition); + } + } + let new_rows = []; + for(let i = 0; i < new_transitioned.length; i++) { + new_rows.push(transitionedMap.get(new_transitioned[i])); + } + const lampSum = new_transitioned.reduce( (acc, term) => acc + goodTermsMap.get(term), 0 ); - const inverse = getInverseMatrix(lin_combinations); - BigRes.push({ complexity: lampSum, - rows: inverse, - transitioned: transitioned, + rows: new_rows, + transitioned: new_transitioned, mask: mask, }); } @@ -212,10 +244,14 @@ onmessage = (e) => { mask: e.data.mask, hardLimit: e.data.hardLimit, }); - matrices.sort((a, b) => a[0] - b[0]); + matrices.sort((a, b) => a.complexity - b.complexity); postMessage({ action: "matrices", - results: matrices, + results: { + varCount: e.data.varCount, + matrices, + outputs: e.data.terms.length + }, }); break; default: From aa905e76ad207b05b033573dfffd83d803271d12 Mon Sep 17 00:00:00 2001 From: FreezePhoenix <24441367+FreezePhoenix@users.noreply.github.com> Date: Fri, 18 Jul 2025 16:40:09 -0400 Subject: [PATCH 07/10] Update handler.js (4/5) --- js/state/handler.js | 17 ++++++++--------- 1 file changed, 8 insertions(+), 9 deletions(-) diff --git a/js/state/handler.js b/js/state/handler.js index 24b4ccc..5000f00 100644 --- a/js/state/handler.js +++ b/js/state/handler.js @@ -205,18 +205,17 @@ export default class UIStateHandler { } } - static displayMatrix({ complexity, rows, transitioned, mask }) { + static displayMatrix({ complexity, rows, transitioned, mask }, varCount, outputs) { let text = ``; - for (let i in rows) { - let num = transitioned[i].toString(2).padStart(16, "0"); + for (let i = 0; i < rows.length; i++) { + let num = transitioned[i].toString(2).padStart(2 ** varCount, "0"); let txtMask = mask.toString(2).padStart(16, "0"); num = num.split('').map((a, idx) => (txtMask[idx] == "1" ? "x" : a)).join(''); - text += ``; - text += ``; + text += ``; + for(let j = 0; j < outputs; j++) { + text += ``; + } + text += ``; } text += `
${(rows[i] + 2 ** transitioned.length) - .toString(2) - .substring(1) - .split("") - .join("")}${num}
${num}${((rows[i] >> j) & 1).toString(2)}
`; From 15b65f14ea1f87f28bc57accbba44879e614d1cd Mon Sep 17 00:00:00 2001 From: FreezePhoenix <24441367+FreezePhoenix@users.noreply.github.com> Date: Fri, 18 Jul 2025 16:40:31 -0400 Subject: [PATCH 08/10] Update gates.js (5/5) --- js/data/gates.js | 25 ++++++++++--------------- 1 file changed, 10 insertions(+), 15 deletions(-) diff --git a/js/data/gates.js b/js/data/gates.js index aa20d06..0b737df 100644 --- a/js/data/gates.js +++ b/js/data/gates.js @@ -10,28 +10,23 @@ export const Gates = [ // }, { symbol:"⊕", - combine: (terms, numbers) => { - let mask = terms[numbers.idx][1]; + combine: (numbers, mask) => { if(numbers.prev) { - let over = numbers.prev.XOR_CACHE_O | (mask & numbers.prev.XOR_CACHE_E); - let encountered = mask | numbers.prev.XOR_CACHE_E; - numbers.XOR_CACHE_O = over; - numbers.XOR_CACHE_E = encountered; + let over = numbers.prev.CACHE_1 | (mask & numbers.prev.CACHE_0); + let encountered = mask | numbers.prev.CACHE_0; + numbers.CACHE_1 = over; + numbers.CACHE_0 = encountered; return ~over & encountered; } - numbers.XOR_CACHE_O = 0; - numbers.XOR_CACHE_E = mask; + numbers.CACHE_1 = 0; + numbers.CACHE_0 = mask; return mask; } }, { - symbol:"∧", - combine: (terms, numbers) => { - let mask = terms[numbers.idx][1]; - if(numbers.prev) { - return numbers.AND_CACHE = numbers.prev.AND_CACHE & mask; - } - return numbers.AND_CACHE = mask; + symbol:"∨", + combine: (numbers, mask) => { + return numbers.CACHE_0; } }, // { From 4de42ceca507c377505ff36f41e84789bf7b7d18 Mon Sep 17 00:00:00 2001 From: FreezePhoenix Date: Sun, 3 Aug 2025 16:24:47 -0400 Subject: [PATCH 09/10] WebAssembly port complete --- js/data/gates.js | 28 +- js/main.js | 14 +- js/state/handler.js | 17 +- js/worker/transmatrix.cpp | 6893 +++++++++++++++++++++++++++++++ js/worker/transmatrix.js | 65 +- js/worker/transmatrix_wasm.mjs | 1744 ++++++++ js/worker/transmatrix_wasm.wasm | Bin 0 -> 100275 bytes js/worker/worker.cpp | 369 ++ js/worker/worker.js | 109 +- js/worker/worker_wasm.mjs | 1788 ++++++++ js/worker/worker_wasm.wasm | Bin 0 -> 26346 bytes 11 files changed, 10934 insertions(+), 93 deletions(-) create mode 100644 js/worker/transmatrix.cpp create mode 100644 js/worker/transmatrix_wasm.mjs create mode 100644 js/worker/transmatrix_wasm.wasm create mode 100644 js/worker/worker.cpp create mode 100644 js/worker/worker_wasm.mjs create mode 100644 js/worker/worker_wasm.wasm diff --git a/js/data/gates.js b/js/data/gates.js index aa20d06..5c16f8d 100644 --- a/js/data/gates.js +++ b/js/data/gates.js @@ -1,5 +1,4 @@ -// Special negation function, since js stores 32 bit integers, but we need 4/8/16 bits. -export function negate(term,var_count){ +export function negate(term, var_count) { return ~term & ((1 << (2 ** var_count)) - 1); } @@ -10,28 +9,23 @@ export const Gates = [ // }, { symbol:"⊕", - combine: (terms, numbers) => { - let mask = terms[numbers.idx][1]; + combine: (numbers, mask) => { if(numbers.prev) { - let over = numbers.prev.XOR_CACHE_O | (mask & numbers.prev.XOR_CACHE_E); - let encountered = mask | numbers.prev.XOR_CACHE_E; - numbers.XOR_CACHE_O = over; - numbers.XOR_CACHE_E = encountered; + let over = numbers.prev.CACHE_1 | (mask & numbers.prev.CACHE_0); + let encountered = mask | numbers.prev.CACHE_0; + numbers.CACHE_1 = over; + numbers.CACHE_0 = encountered; return ~over & encountered; } - numbers.XOR_CACHE_O = 0; - numbers.XOR_CACHE_E = mask; + numbers.CACHE_1 = 0; + numbers.CACHE_0 = mask; return mask; } }, { - symbol:"∧", - combine: (terms, numbers) => { - let mask = terms[numbers.idx][1]; - if(numbers.prev) { - return numbers.AND_CACHE = numbers.prev.AND_CACHE & mask; - } - return numbers.AND_CACHE = mask; + symbol:"∨", + combine: (numbers, mask) => { + return numbers.CACHE_0; } }, // { diff --git a/js/main.js b/js/main.js index c11898d..30d995d 100644 --- a/js/main.js +++ b/js/main.js @@ -154,9 +154,10 @@ worker.onmessage = (e) => { }; let index = 0; -let matrices = JSON.parse(localStorage.getItem("matrices")); +let matrixResults = JSON.parse(localStorage.getItem("matrices")); +let matrices = matrixResults?.matrices; UI.setNextPrevState(index, matrices); -if (matrices != null) UI.displayMatrix(matrices[index]); +if (matrixResults != null) UI.displayMatrix(matrices[index], matrixResults.varCount, matrixResults.outputs); // Multi input worker. Generates transition matrices. transmatrix.onmessage = (e) => transmatrix_onmessage(e); @@ -167,10 +168,11 @@ function transmatrix_onmessage(e) { if (e.data.results) { localStorage.setItem("matrices", JSON.stringify(e.data.results)); - matrices = e.data.results; + matrixResults = e.data.results; + matrices = matrixResults.matrices; index = 0; UI.setNextPrevState(index, matrices); - UI.displayMatrix(matrices[index]); + UI.displayMatrix(matrices[index], matrixResults.varCount, matrixResults.outputs); } break; case "count": @@ -183,13 +185,13 @@ function next() { if (matrices != null && index < matrices.length - 1) index++; UI.setNextPrevState(index, matrices); - UI.displayMatrix(matrices[index]); + UI.displayMatrix(matrices[index], matrixResults.varCount, matrixResults.outputs); } function prev() { if (index > 0) index--; UI.setNextPrevState(index, matrices); - UI.displayMatrix(matrices[index]); + UI.displayMatrix(matrices[index], matrixResults.varCount, matrixResults.outputs); } function display() { diff --git a/js/state/handler.js b/js/state/handler.js index 24b4ccc..5000f00 100644 --- a/js/state/handler.js +++ b/js/state/handler.js @@ -205,18 +205,17 @@ export default class UIStateHandler { } } - static displayMatrix({ complexity, rows, transitioned, mask }) { + static displayMatrix({ complexity, rows, transitioned, mask }, varCount, outputs) { let text = ``; - for (let i in rows) { - let num = transitioned[i].toString(2).padStart(16, "0"); + for (let i = 0; i < rows.length; i++) { + let num = transitioned[i].toString(2).padStart(2 ** varCount, "0"); let txtMask = mask.toString(2).padStart(16, "0"); num = num.split('').map((a, idx) => (txtMask[idx] == "1" ? "x" : a)).join(''); - text += ``; - text += ``; + text += ``; + for(let j = 0; j < outputs; j++) { + text += ``; + } + text += ``; } text += `
${(rows[i] + 2 ** transitioned.length) - .toString(2) - .substring(1) - .split("") - .join("")}${num}
${num}${((rows[i] >> j) & 1).toString(2)}
`; diff --git a/js/worker/transmatrix.cpp b/js/worker/transmatrix.cpp new file mode 100644 index 0000000..5381a7e --- /dev/null +++ b/js/worker/transmatrix.cpp @@ -0,0 +1,6893 @@ +#include +#include +#include + +#ifdef __EMSCRIPTEN__ +#include +#else +#include +#endif + +#include +#include +#include +#include +#include +#include + +constexpr std::pair Dictionary[][12960] = { + {{0b00, 1}, + {0b01, 2}, + {0b10, 2}, + {0b11, 1}, + {0b100, 2}, + {0b101, 1}, + {0b110, 1}, + {0b111, 2}, + {0b1000, 2}, + {0b1001, 1}, + {0b1010, 1}, + {0b1011, 2}, + {0b1100, 1}, + {0b1101, 2}, + {0b1110, 2}, + {0b1111, 1}}, + {{0b0000, 1}, {0b0001, 3}, {0b0010, 3}, {0b0011, 2}, + {0b0100, 3}, {0b0101, 2}, {0b0110, 2}, {0b0111, 3}, + {0b1000, 3}, {0b1001, 2}, {0b1010, 2}, {0b1011, 3}, + {0b1100, 2}, {0b1101, 3}, {0b1110, 3}, {0b1111, 1}, + {0b10000, 3}, {0b10001, 2}, {0b10010, 2}, {0b10011, 3}, + {0b10100, 2}, {0b10101, 3}, {0b10110, 3}, {0b10111, 4}, + {0b11000, 2}, {0b11001, 3}, {0b11010, 3}, {0b11011, 4}, + {0b11100, 3}, {0b11101, 4}, {0b11110, 4}, {0b11111, 3}, + {0b100000, 3}, {0b100001, 2}, {0b100010, 2}, {0b100011, 3}, + {0b100100, 2}, {0b100101, 3}, {0b100110, 3}, {0b100111, 4}, + {0b101000, 2}, {0b101001, 3}, {0b101010, 3}, {0b101011, 4}, + {0b101100, 3}, {0b101101, 4}, {0b101110, 4}, {0b101111, 3}, + {0b110000, 2}, {0b110001, 3}, {0b110010, 3}, {0b110011, 1}, + {0b110100, 3}, {0b110101, 4}, {0b110110, 4}, {0b110111, 3}, + {0b111000, 3}, {0b111001, 4}, {0b111010, 4}, {0b111011, 3}, + {0b111100, 1}, {0b111101, 3}, {0b111110, 3}, {0b111111, 2}, + {0b1000000, 3}, {0b1000001, 2}, {0b1000010, 2}, {0b1000011, 3}, + {0b1000100, 2}, {0b1000101, 3}, {0b1000110, 3}, {0b1000111, 4}, + {0b1001000, 2}, {0b1001001, 3}, {0b1001010, 3}, {0b1001011, 4}, + {0b1001100, 3}, {0b1001101, 4}, {0b1001110, 4}, {0b1001111, 3}, + {0b1010000, 2}, {0b1010001, 3}, {0b1010010, 3}, {0b1010011, 4}, + {0b1010100, 3}, {0b1010101, 1}, {0b1010110, 4}, {0b1010111, 3}, + {0b1011000, 3}, {0b1011001, 4}, {0b1011010, 1}, {0b1011011, 3}, + {0b1011100, 4}, {0b1011101, 3}, {0b1011110, 3}, {0b1011111, 2}, + {0b1100000, 2}, {0b1100001, 3}, {0b1100010, 3}, {0b1100011, 4}, + {0b1100100, 3}, {0b1100101, 4}, {0b1100110, 1}, {0b1100111, 3}, + {0b1101000, 3}, {0b1101001, 1}, {0b1101010, 4}, {0b1101011, 3}, + {0b1101100, 4}, {0b1101101, 3}, {0b1101110, 3}, {0b1101111, 2}, + {0b1110000, 3}, {0b1110001, 4}, {0b1110010, 4}, {0b1110011, 3}, + {0b1110100, 4}, {0b1110101, 3}, {0b1110110, 3}, {0b1110111, 2}, + {0b1111000, 4}, {0b1111001, 3}, {0b1111010, 3}, {0b1111011, 2}, + {0b1111100, 3}, {0b1111101, 2}, {0b1111110, 2}, {0b1111111, 3}, + {0b10000000, 3}, {0b10000001, 2}, {0b10000010, 2}, {0b10000011, 3}, + {0b10000100, 2}, {0b10000101, 3}, {0b10000110, 3}, {0b10000111, 4}, + {0b10001000, 2}, {0b10001001, 3}, {0b10001010, 3}, {0b10001011, 4}, + {0b10001100, 3}, {0b10001101, 4}, {0b10001110, 4}, {0b10001111, 3}, + {0b10010000, 2}, {0b10010001, 3}, {0b10010010, 3}, {0b10010011, 4}, + {0b10010100, 3}, {0b10010101, 4}, {0b10010110, 1}, {0b10010111, 3}, + {0b10011000, 3}, {0b10011001, 1}, {0b10011010, 4}, {0b10011011, 3}, + {0b10011100, 4}, {0b10011101, 3}, {0b10011110, 3}, {0b10011111, 2}, + {0b10100000, 2}, {0b10100001, 3}, {0b10100010, 3}, {0b10100011, 4}, + {0b10100100, 3}, {0b10100101, 1}, {0b10100110, 4}, {0b10100111, 3}, + {0b10101000, 3}, {0b10101001, 4}, {0b10101010, 1}, {0b10101011, 3}, + {0b10101100, 4}, {0b10101101, 3}, {0b10101110, 3}, {0b10101111, 2}, + {0b10110000, 3}, {0b10110001, 4}, {0b10110010, 4}, {0b10110011, 3}, + {0b10110100, 4}, {0b10110101, 3}, {0b10110110, 3}, {0b10110111, 2}, + {0b10111000, 4}, {0b10111001, 3}, {0b10111010, 3}, {0b10111011, 2}, + {0b10111100, 3}, {0b10111101, 2}, {0b10111110, 2}, {0b10111111, 3}, + {0b11000000, 2}, {0b11000001, 3}, {0b11000010, 3}, {0b11000011, 1}, + {0b11000100, 3}, {0b11000101, 4}, {0b11000110, 4}, {0b11000111, 3}, + {0b11001000, 3}, {0b11001001, 4}, {0b11001010, 4}, {0b11001011, 3}, + {0b11001100, 1}, {0b11001101, 3}, {0b11001110, 3}, {0b11001111, 2}, + {0b11010000, 3}, {0b11010001, 4}, {0b11010010, 4}, {0b11010011, 3}, + {0b11010100, 4}, {0b11010101, 3}, {0b11010110, 3}, {0b11010111, 2}, + {0b11011000, 4}, {0b11011001, 3}, {0b11011010, 3}, {0b11011011, 2}, + {0b11011100, 3}, {0b11011101, 2}, {0b11011110, 2}, {0b11011111, 3}, + {0b11100000, 3}, {0b11100001, 4}, {0b11100010, 4}, {0b11100011, 3}, + {0b11100100, 4}, {0b11100101, 3}, {0b11100110, 3}, {0b11100111, 2}, + {0b11101000, 4}, {0b11101001, 3}, {0b11101010, 3}, {0b11101011, 2}, + {0b11101100, 3}, {0b11101101, 2}, {0b11101110, 2}, {0b11101111, 3}, + {0b11110000, 1}, {0b11110001, 3}, {0b11110010, 3}, {0b11110011, 2}, + {0b11110100, 3}, {0b11110101, 2}, {0b11110110, 2}, {0b11110111, 3}, + {0b11111000, 3}, {0b11111001, 2}, {0b11111010, 2}, {0b11111011, 3}, + {0b11111100, 2}, {0b11111101, 3}, {0b11111110, 3}, {0b11111111, 1}}, + {{0b00000000, 1}, {0b00000001, 4}, + {0b00000010, 4}, {0b00000011, 3}, + {0b00000100, 4}, {0b00000101, 3}, + {0b00000110, 3}, {0b00000111, 5}, + {0b00001000, 4}, {0b00001001, 3}, + {0b00001010, 3}, {0b00001011, 5}, + {0b00001100, 3}, {0b00001101, 5}, + {0b00001110, 5}, {0b00001111, 2}, + {0b00010000, 4}, {0b00010001, 3}, + {0b00010010, 3}, {0b00010011, 5}, + {0b00010100, 3}, {0b00010101, 5}, + {0b00010110, 5}, {0b00010111, 4}, + {0b00011000, 3}, {0b00011001, 5}, + {0b00011010, 5}, {0b00011011, 4}, + {0b00011100, 5}, {0b00011101, 4}, + {0b00011110, 4}, {0b00100000, 4}, + {0b00100001, 3}, {0b00100010, 3}, + {0b00100011, 5}, {0b00100100, 3}, + {0b00100101, 5}, {0b00100110, 5}, + {0b00100111, 4}, {0b00101000, 3}, + {0b00101001, 5}, {0b00101010, 5}, + {0b00101011, 4}, {0b00101100, 5}, + {0b00101101, 4}, {0b00101110, 4}, + {0b00110000, 3}, {0b00110001, 5}, + {0b00110010, 5}, {0b00110011, 2}, + {0b00110100, 5}, {0b00110101, 4}, + {0b00110110, 4}, {0b00111000, 5}, + {0b00111001, 4}, {0b00111010, 4}, + {0b00111100, 2}, {0b00111111, 3}, + {0b01000000, 4}, {0b01000001, 3}, + {0b01000010, 3}, {0b01000011, 5}, + {0b01000100, 3}, {0b01000101, 5}, + {0b01000110, 5}, {0b01000111, 4}, + {0b01001000, 3}, {0b01001001, 5}, + {0b01001010, 5}, {0b01001011, 4}, + {0b01001100, 5}, {0b01001101, 4}, + {0b01001110, 4}, {0b01010000, 3}, + {0b01010001, 5}, {0b01010010, 5}, + {0b01010011, 4}, {0b01010100, 5}, + {0b01010101, 2}, {0b01010110, 4}, + {0b01011000, 5}, {0b01011001, 4}, + {0b01011010, 2}, {0b01011100, 4}, + {0b01011111, 3}, {0b01100000, 3}, + {0b01100001, 5}, {0b01100010, 5}, + {0b01100011, 4}, {0b01100100, 5}, + {0b01100101, 4}, {0b01100110, 2}, + {0b01101000, 5}, {0b01101001, 2}, + {0b01101010, 4}, {0b01101100, 4}, + {0b01101111, 3}, {0b01110000, 5}, + {0b01110001, 4}, {0b01110010, 4}, + {0b01110100, 4}, {0b01110111, 3}, + {0b01111000, 4}, {0b01111011, 3}, + {0b01111101, 3}, {0b01111110, 3}, + {0b10000000, 4}, {0b10000001, 3}, + {0b10000010, 3}, {0b10000011, 5}, + {0b10000100, 3}, {0b10000101, 5}, + {0b10000110, 5}, {0b10000111, 4}, + {0b10001000, 3}, {0b10001001, 5}, + {0b10001010, 5}, {0b10001011, 4}, + {0b10001100, 5}, {0b10001101, 4}, + {0b10001110, 4}, {0b10010000, 3}, + {0b10010001, 5}, {0b10010010, 5}, + {0b10010011, 4}, {0b10010100, 5}, + {0b10010101, 4}, {0b10010110, 2}, + {0b10011000, 5}, {0b10011001, 2}, + {0b10011010, 4}, {0b10011100, 4}, + {0b10011111, 3}, {0b10100000, 3}, + {0b10100001, 5}, {0b10100010, 5}, + {0b10100011, 4}, {0b10100100, 5}, + {0b10100101, 2}, {0b10100110, 4}, + {0b10101000, 5}, {0b10101001, 4}, + {0b10101010, 2}, {0b10101100, 4}, + {0b10101111, 3}, {0b10110000, 5}, + {0b10110001, 4}, {0b10110010, 4}, + {0b10110100, 4}, {0b10110111, 3}, + {0b10111000, 4}, {0b10111011, 3}, + {0b10111101, 3}, {0b10111110, 3}, + {0b11000000, 3}, {0b11000001, 5}, + {0b11000010, 5}, {0b11000011, 2}, + {0b11000100, 5}, {0b11000101, 4}, + {0b11000110, 4}, {0b11001000, 5}, + {0b11001001, 4}, {0b11001010, 4}, + {0b11001100, 2}, {0b11001111, 3}, + {0b11010000, 5}, {0b11010001, 4}, + {0b11010010, 4}, {0b11010100, 4}, + {0b11010111, 3}, {0b11011000, 4}, + {0b11011011, 3}, {0b11011101, 3}, + {0b11011110, 3}, {0b11100000, 5}, + {0b11100001, 4}, {0b11100010, 4}, + {0b11100100, 4}, {0b11100111, 3}, + {0b11101000, 4}, {0b11101011, 3}, + {0b11101101, 3}, {0b11101110, 3}, + {0b11110000, 2}, {0b11110011, 3}, + {0b11110101, 3}, {0b11110110, 3}, + {0b11111001, 3}, {0b11111010, 3}, + {0b11111100, 3}, {0b11111111, 1}, + {0b100000000, 4}, {0b100000001, 3}, + {0b100000010, 3}, {0b100000011, 5}, + {0b100000100, 3}, {0b100000101, 5}, + {0b100000110, 5}, {0b100000111, 4}, + {0b100001000, 3}, {0b100001001, 5}, + {0b100001010, 5}, {0b100001011, 4}, + {0b100001100, 5}, {0b100001101, 4}, + {0b100001110, 4}, {0b100010000, 3}, + {0b100010001, 5}, {0b100010010, 5}, + {0b100010011, 4}, {0b100010100, 5}, + {0b100010101, 4}, {0b100010110, 4}, + {0b100010111, 5}, {0b100011000, 5}, + {0b100011001, 4}, {0b100011010, 4}, + {0b100011011, 5}, {0b100011100, 4}, + {0b100011101, 5}, {0b100011110, 5}, + {0b100100000, 3}, {0b100100001, 5}, + {0b100100010, 5}, {0b100100011, 4}, + {0b100100100, 5}, {0b100100101, 4}, + {0b100100110, 4}, {0b100100111, 5}, + {0b100101000, 5}, {0b100101001, 4}, + {0b100101010, 4}, {0b100101011, 5}, + {0b100101100, 4}, {0b100101101, 5}, + {0b100101110, 5}, {0b100110000, 5}, + {0b100110001, 4}, {0b100110010, 4}, + {0b100110100, 4}, {0b100110101, 5}, + {0b100110110, 5}, {0b100111000, 4}, + {0b100111001, 5}, {0b100111010, 5}, + {0b101000000, 3}, {0b101000001, 5}, + {0b101000010, 5}, {0b101000011, 4}, + {0b101000100, 5}, {0b101000101, 4}, + {0b101000110, 4}, {0b101000111, 5}, + {0b101001000, 5}, {0b101001001, 4}, + {0b101001010, 4}, {0b101001011, 5}, + {0b101001100, 4}, {0b101001101, 5}, + {0b101001110, 5}, {0b101010000, 5}, + {0b101010001, 4}, {0b101010010, 4}, + {0b101010011, 5}, {0b101010100, 4}, + {0b101010110, 5}, {0b101011000, 4}, + {0b101011001, 5}, {0b101011100, 5}, + {0b101100000, 5}, {0b101100001, 4}, + {0b101100010, 4}, {0b101100011, 5}, + {0b101100100, 4}, {0b101100101, 5}, + {0b101101000, 4}, {0b101101010, 5}, + {0b101101100, 5}, {0b101110000, 4}, + {0b101110001, 5}, {0b101110010, 5}, + {0b101110100, 5}, {0b101111000, 5}, + {0b110000000, 3}, {0b110000001, 5}, + {0b110000010, 5}, {0b110000011, 4}, + {0b110000100, 5}, {0b110000101, 4}, + {0b110000110, 4}, {0b110000111, 5}, + {0b110001000, 5}, {0b110001001, 4}, + {0b110001010, 4}, {0b110001011, 5}, + {0b110001100, 4}, {0b110001101, 5}, + {0b110001110, 5}, {0b110010000, 5}, + {0b110010001, 4}, {0b110010010, 4}, + {0b110010011, 5}, {0b110010100, 4}, + {0b110010101, 5}, {0b110011000, 4}, + {0b110011010, 5}, {0b110011100, 5}, + {0b110100000, 5}, {0b110100001, 4}, + {0b110100010, 4}, {0b110100011, 5}, + {0b110100100, 4}, {0b110100110, 5}, + {0b110101000, 4}, {0b110101001, 5}, + {0b110101100, 5}, {0b110110000, 4}, + {0b110110001, 5}, {0b110110010, 5}, + {0b110110100, 5}, {0b110111000, 5}, + {0b111000000, 5}, {0b111000001, 4}, + {0b111000010, 4}, {0b111000100, 4}, + {0b111000101, 5}, {0b111000110, 5}, + {0b111001000, 4}, {0b111001001, 5}, + {0b111001010, 5}, {0b111010000, 4}, + {0b111010001, 5}, {0b111010010, 5}, + {0b111010100, 5}, {0b111011000, 5}, + {0b111100000, 4}, {0b111100001, 5}, + {0b111100010, 5}, {0b111100100, 5}, + {0b111101000, 5}, {0b1000000000, 4}, + {0b1000000001, 3}, {0b1000000010, 3}, + {0b1000000011, 5}, {0b1000000100, 3}, + {0b1000000101, 5}, {0b1000000110, 5}, + {0b1000000111, 4}, {0b1000001000, 3}, + {0b1000001001, 5}, {0b1000001010, 5}, + {0b1000001011, 4}, {0b1000001100, 5}, + {0b1000001101, 4}, {0b1000001110, 4}, + {0b1000010000, 3}, {0b1000010001, 5}, + {0b1000010010, 5}, {0b1000010011, 4}, + {0b1000010100, 5}, {0b1000010101, 4}, + {0b1000010110, 4}, {0b1000010111, 5}, + {0b1000011000, 5}, {0b1000011001, 4}, + {0b1000011010, 4}, {0b1000011011, 5}, + {0b1000011100, 4}, {0b1000011101, 5}, + {0b1000011110, 5}, {0b1000100000, 3}, + {0b1000100001, 5}, {0b1000100010, 5}, + {0b1000100011, 4}, {0b1000100100, 5}, + {0b1000100101, 4}, {0b1000100110, 4}, + {0b1000100111, 5}, {0b1000101000, 5}, + {0b1000101001, 4}, {0b1000101010, 4}, + {0b1000101011, 5}, {0b1000101100, 4}, + {0b1000101101, 5}, {0b1000101110, 5}, + {0b1000110000, 5}, {0b1000110001, 4}, + {0b1000110010, 4}, {0b1000110100, 4}, + {0b1000110101, 5}, {0b1000110110, 5}, + {0b1000111000, 4}, {0b1000111001, 5}, + {0b1000111010, 5}, {0b1001000000, 3}, + {0b1001000001, 5}, {0b1001000010, 5}, + {0b1001000011, 4}, {0b1001000100, 5}, + {0b1001000101, 4}, {0b1001000110, 4}, + {0b1001000111, 5}, {0b1001001000, 5}, + {0b1001001001, 4}, {0b1001001010, 4}, + {0b1001001011, 5}, {0b1001001100, 4}, + {0b1001001101, 5}, {0b1001001110, 5}, + {0b1001010000, 5}, {0b1001010001, 4}, + {0b1001010010, 4}, {0b1001010011, 5}, + {0b1001010100, 4}, {0b1001010110, 5}, + {0b1001011000, 4}, {0b1001011001, 5}, + {0b1001011100, 5}, {0b1001100000, 5}, + {0b1001100001, 4}, {0b1001100010, 4}, + {0b1001100011, 5}, {0b1001100100, 4}, + {0b1001100101, 5}, {0b1001101000, 4}, + {0b1001101010, 5}, {0b1001101100, 5}, + {0b1001110000, 4}, {0b1001110001, 5}, + {0b1001110010, 5}, {0b1001110100, 5}, + {0b1001111000, 5}, {0b1010000000, 3}, + {0b1010000001, 5}, {0b1010000010, 5}, + {0b1010000011, 4}, {0b1010000100, 5}, + {0b1010000101, 4}, {0b1010000110, 4}, + {0b1010000111, 5}, {0b1010001000, 5}, + {0b1010001001, 4}, {0b1010001010, 4}, + {0b1010001011, 5}, {0b1010001100, 4}, + {0b1010001101, 5}, {0b1010001110, 5}, + {0b1010010000, 5}, {0b1010010001, 4}, + {0b1010010010, 4}, {0b1010010011, 5}, + {0b1010010100, 4}, {0b1010010101, 5}, + {0b1010011000, 4}, {0b1010011010, 5}, + {0b1010011100, 5}, {0b1010100000, 5}, + {0b1010100001, 4}, {0b1010100010, 4}, + {0b1010100011, 5}, {0b1010100100, 4}, + {0b1010100110, 5}, {0b1010101000, 4}, + {0b1010101001, 5}, {0b1010101100, 5}, + {0b1010110000, 4}, {0b1010110001, 5}, + {0b1010110010, 5}, {0b1010110100, 5}, + {0b1010111000, 5}, {0b1011000000, 5}, + {0b1011000001, 4}, {0b1011000010, 4}, + {0b1011000100, 4}, {0b1011000101, 5}, + {0b1011000110, 5}, {0b1011001000, 4}, + {0b1011001001, 5}, {0b1011001010, 5}, + {0b1011010000, 4}, {0b1011010001, 5}, + {0b1011010010, 5}, {0b1011010100, 5}, + {0b1011011000, 5}, {0b1011100000, 4}, + {0b1011100001, 5}, {0b1011100010, 5}, + {0b1011100100, 5}, {0b1011101000, 5}, + {0b1100000000, 3}, {0b1100000001, 5}, + {0b1100000010, 5}, {0b1100000011, 2}, + {0b1100000100, 5}, {0b1100000101, 4}, + {0b1100000110, 4}, {0b1100001000, 5}, + {0b1100001001, 4}, {0b1100001010, 4}, + {0b1100001100, 2}, {0b1100001111, 3}, + {0b1100010000, 5}, {0b1100010001, 4}, + {0b1100010010, 4}, {0b1100010100, 4}, + {0b1100010101, 5}, {0b1100010110, 5}, + {0b1100011000, 4}, {0b1100011001, 5}, + {0b1100011010, 5}, {0b1100100000, 5}, + {0b1100100001, 4}, {0b1100100010, 4}, + {0b1100100100, 4}, {0b1100100101, 5}, + {0b1100100110, 5}, {0b1100101000, 4}, + {0b1100101001, 5}, {0b1100101010, 5}, + {0b1100110000, 2}, {0b1100110011, 3}, + {0b1100111100, 3}, {0b1100111111, 4}, + {0b1101000000, 5}, {0b1101000001, 4}, + {0b1101000010, 4}, {0b1101000100, 4}, + {0b1101000101, 5}, {0b1101000110, 5}, + {0b1101001000, 4}, {0b1101001001, 5}, + {0b1101001010, 5}, {0b1101010000, 4}, + {0b1101010001, 5}, {0b1101010010, 5}, + {0b1101010100, 5}, {0b1101011000, 5}, + {0b1101100000, 4}, {0b1101100001, 5}, + {0b1101100010, 5}, {0b1101100100, 5}, + {0b1101101000, 5}, {0b1110000000, 5}, + {0b1110000001, 4}, {0b1110000010, 4}, + {0b1110000100, 4}, {0b1110000101, 5}, + {0b1110000110, 5}, {0b1110001000, 4}, + {0b1110001001, 5}, {0b1110001010, 5}, + {0b1110010000, 4}, {0b1110010001, 5}, + {0b1110010010, 5}, {0b1110010100, 5}, + {0b1110011000, 5}, {0b1110100000, 4}, + {0b1110100001, 5}, {0b1110100010, 5}, + {0b1110100100, 5}, {0b1110101000, 5}, + {0b1111000000, 2}, {0b1111000011, 3}, + {0b1111001100, 3}, {0b1111001111, 4}, + {0b1111110000, 3}, {0b1111110011, 4}, + {0b1111111100, 4}, {0b1111111111, 3}, + {0b10000000000, 4}, {0b10000000001, 3}, + {0b10000000010, 3}, {0b10000000011, 5}, + {0b10000000100, 3}, {0b10000000101, 5}, + {0b10000000110, 5}, {0b10000000111, 4}, + {0b10000001000, 3}, {0b10000001001, 5}, + {0b10000001010, 5}, {0b10000001011, 4}, + {0b10000001100, 5}, {0b10000001101, 4}, + {0b10000001110, 4}, {0b10000010000, 3}, + {0b10000010001, 5}, {0b10000010010, 5}, + {0b10000010011, 4}, {0b10000010100, 5}, + {0b10000010101, 4}, {0b10000010110, 4}, + {0b10000010111, 5}, {0b10000011000, 5}, + {0b10000011001, 4}, {0b10000011010, 4}, + {0b10000011011, 5}, {0b10000011100, 4}, + {0b10000011101, 5}, {0b10000011110, 5}, + {0b10000100000, 3}, {0b10000100001, 5}, + {0b10000100010, 5}, {0b10000100011, 4}, + {0b10000100100, 5}, {0b10000100101, 4}, + {0b10000100110, 4}, {0b10000100111, 5}, + {0b10000101000, 5}, {0b10000101001, 4}, + {0b10000101010, 4}, {0b10000101011, 5}, + {0b10000101100, 4}, {0b10000101101, 5}, + {0b10000101110, 5}, {0b10000110000, 5}, + {0b10000110001, 4}, {0b10000110010, 4}, + {0b10000110100, 4}, {0b10000110101, 5}, + {0b10000110110, 5}, {0b10000111000, 4}, + {0b10000111001, 5}, {0b10000111010, 5}, + {0b10001000000, 3}, {0b10001000001, 5}, + {0b10001000010, 5}, {0b10001000011, 4}, + {0b10001000100, 5}, {0b10001000101, 4}, + {0b10001000110, 4}, {0b10001000111, 5}, + {0b10001001000, 5}, {0b10001001001, 4}, + {0b10001001010, 4}, {0b10001001011, 5}, + {0b10001001100, 4}, {0b10001001101, 5}, + {0b10001001110, 5}, {0b10001010000, 5}, + {0b10001010001, 4}, {0b10001010010, 4}, + {0b10001010011, 5}, {0b10001010100, 4}, + {0b10001010110, 5}, {0b10001011000, 4}, + {0b10001011001, 5}, {0b10001011100, 5}, + {0b10001100000, 5}, {0b10001100001, 4}, + {0b10001100010, 4}, {0b10001100011, 5}, + {0b10001100100, 4}, {0b10001100101, 5}, + {0b10001101000, 4}, {0b10001101010, 5}, + {0b10001101100, 5}, {0b10001110000, 4}, + {0b10001110001, 5}, {0b10001110010, 5}, + {0b10001110100, 5}, {0b10001111000, 5}, + {0b10010000000, 3}, {0b10010000001, 5}, + {0b10010000010, 5}, {0b10010000011, 4}, + {0b10010000100, 5}, {0b10010000101, 4}, + {0b10010000110, 4}, {0b10010000111, 5}, + {0b10010001000, 5}, {0b10010001001, 4}, + {0b10010001010, 4}, {0b10010001011, 5}, + {0b10010001100, 4}, {0b10010001101, 5}, + {0b10010001110, 5}, {0b10010010000, 5}, + {0b10010010001, 4}, {0b10010010010, 4}, + {0b10010010011, 5}, {0b10010010100, 4}, + {0b10010010101, 5}, {0b10010011000, 4}, + {0b10010011010, 5}, {0b10010011100, 5}, + {0b10010100000, 5}, {0b10010100001, 4}, + {0b10010100010, 4}, {0b10010100011, 5}, + {0b10010100100, 4}, {0b10010100110, 5}, + {0b10010101000, 4}, {0b10010101001, 5}, + {0b10010101100, 5}, {0b10010110000, 4}, + {0b10010110001, 5}, {0b10010110010, 5}, + {0b10010110100, 5}, {0b10010111000, 5}, + {0b10011000000, 5}, {0b10011000001, 4}, + {0b10011000010, 4}, {0b10011000100, 4}, + {0b10011000101, 5}, {0b10011000110, 5}, + {0b10011001000, 4}, {0b10011001001, 5}, + {0b10011001010, 5}, {0b10011010000, 4}, + {0b10011010001, 5}, {0b10011010010, 5}, + {0b10011010100, 5}, {0b10011011000, 5}, + {0b10011100000, 4}, {0b10011100001, 5}, + {0b10011100010, 5}, {0b10011100100, 5}, + {0b10011101000, 5}, {0b10100000000, 3}, + {0b10100000001, 5}, {0b10100000010, 5}, + {0b10100000011, 4}, {0b10100000100, 5}, + {0b10100000101, 2}, {0b10100000110, 4}, + {0b10100001000, 5}, {0b10100001001, 4}, + {0b10100001010, 2}, {0b10100001100, 4}, + {0b10100001111, 3}, {0b10100010000, 5}, + {0b10100010001, 4}, {0b10100010010, 4}, + {0b10100010011, 5}, {0b10100010100, 4}, + {0b10100010110, 5}, {0b10100011000, 4}, + {0b10100011001, 5}, {0b10100011100, 5}, + {0b10100100000, 5}, {0b10100100001, 4}, + {0b10100100010, 4}, {0b10100100011, 5}, + {0b10100100100, 4}, {0b10100100110, 5}, + {0b10100101000, 4}, {0b10100101001, 5}, + {0b10100101100, 5}, {0b10100110000, 4}, + {0b10100110001, 5}, {0b10100110010, 5}, + {0b10100110100, 5}, {0b10100111000, 5}, + {0b10101000000, 5}, {0b10101000001, 4}, + {0b10101000010, 4}, {0b10101000011, 5}, + {0b10101000100, 4}, {0b10101000110, 5}, + {0b10101001000, 4}, {0b10101001001, 5}, + {0b10101001100, 5}, {0b10101010000, 2}, + {0b10101010101, 3}, {0b10101011010, 3}, + {0b10101011111, 4}, {0b10101100000, 4}, + {0b10101100001, 5}, {0b10101100010, 5}, + {0b10101100100, 5}, {0b10101101000, 5}, + {0b10110000000, 5}, {0b10110000001, 4}, + {0b10110000010, 4}, {0b10110000011, 5}, + {0b10110000100, 4}, {0b10110000110, 5}, + {0b10110001000, 4}, {0b10110001001, 5}, + {0b10110001100, 5}, {0b10110010000, 4}, + {0b10110010001, 5}, {0b10110010010, 5}, + {0b10110010100, 5}, {0b10110011000, 5}, + {0b10110100000, 2}, {0b10110100101, 3}, + {0b10110101010, 3}, {0b10110101111, 4}, + {0b10111000000, 4}, {0b10111000001, 5}, + {0b10111000010, 5}, {0b10111000100, 5}, + {0b10111001000, 5}, {0b10111110000, 3}, + {0b10111110101, 4}, {0b10111111010, 4}, + {0b10111111111, 3}, {0b11000000000, 3}, + {0b11000000001, 5}, {0b11000000010, 5}, + {0b11000000011, 4}, {0b11000000100, 5}, + {0b11000000101, 4}, {0b11000000110, 2}, + {0b11000001000, 5}, {0b11000001001, 2}, + {0b11000001010, 4}, {0b11000001100, 4}, + {0b11000001111, 3}, {0b11000010000, 5}, + {0b11000010001, 4}, {0b11000010010, 4}, + {0b11000010011, 5}, {0b11000010100, 4}, + {0b11000010101, 5}, {0b11000011000, 4}, + {0b11000011010, 5}, {0b11000011100, 5}, + {0b11000100000, 5}, {0b11000100001, 4}, + {0b11000100010, 4}, {0b11000100011, 5}, + {0b11000100100, 4}, {0b11000100101, 5}, + {0b11000101000, 4}, {0b11000101010, 5}, + {0b11000101100, 5}, {0b11000110000, 4}, + {0b11000110001, 5}, {0b11000110010, 5}, + {0b11000110100, 5}, {0b11000111000, 5}, + {0b11001000000, 5}, {0b11001000001, 4}, + {0b11001000010, 4}, {0b11001000011, 5}, + {0b11001000100, 4}, {0b11001000101, 5}, + {0b11001001000, 4}, {0b11001001010, 5}, + {0b11001001100, 5}, {0b11001010000, 4}, + {0b11001010001, 5}, {0b11001010010, 5}, + {0b11001010100, 5}, {0b11001011000, 5}, + {0b11001100000, 2}, {0b11001100110, 3}, + {0b11001101001, 3}, {0b11001101111, 4}, + {0b11010000000, 5}, {0b11010000001, 4}, + {0b11010000010, 4}, {0b11010000011, 5}, + {0b11010000100, 4}, {0b11010000101, 5}, + {0b11010001000, 4}, {0b11010001010, 5}, + {0b11010001100, 5}, {0b11010010000, 2}, + {0b11010010110, 3}, {0b11010011001, 3}, + {0b11010011111, 4}, {0b11010100000, 4}, + {0b11010100001, 5}, {0b11010100010, 5}, + {0b11010100100, 5}, {0b11010101000, 5}, + {0b11011000000, 4}, {0b11011000001, 5}, + {0b11011000010, 5}, {0b11011000100, 5}, + {0b11011001000, 5}, {0b11011110000, 3}, + {0b11011110110, 4}, {0b11011111001, 4}, + {0b11011111111, 3}, {0b11100000000, 5}, + {0b11100000001, 4}, {0b11100000010, 4}, + {0b11100000100, 4}, {0b11100000111, 3}, + {0b11100001000, 4}, {0b11100001011, 3}, + {0b11100001101, 3}, {0b11100001110, 3}, + {0b11100010000, 4}, {0b11100010001, 5}, + {0b11100010010, 5}, {0b11100010100, 5}, + {0b11100011000, 5}, {0b11100100000, 4}, + {0b11100100001, 5}, {0b11100100010, 5}, + {0b11100100100, 5}, {0b11100101000, 5}, + {0b11101000000, 4}, {0b11101000001, 5}, + {0b11101000010, 5}, {0b11101000100, 5}, + {0b11101001000, 5}, {0b11101110000, 3}, + {0b11110000000, 4}, {0b11110000001, 5}, + {0b11110000010, 5}, {0b11110000100, 5}, + {0b11110001000, 5}, {0b11110110000, 3}, + {0b11111010000, 3}, {0b11111100000, 3}, + {0b100000000000, 4}, {0b100000000001, 3}, + {0b100000000010, 3}, {0b100000000011, 5}, + {0b100000000100, 3}, {0b100000000101, 5}, + {0b100000000110, 5}, {0b100000000111, 4}, + {0b100000001000, 3}, {0b100000001001, 5}, + {0b100000001010, 5}, {0b100000001011, 4}, + {0b100000001100, 5}, {0b100000001101, 4}, + {0b100000001110, 4}, {0b100000010000, 3}, + {0b100000010001, 5}, {0b100000010010, 5}, + {0b100000010011, 4}, {0b100000010100, 5}, + {0b100000010101, 4}, {0b100000010110, 4}, + {0b100000010111, 5}, {0b100000011000, 5}, + {0b100000011001, 4}, {0b100000011010, 4}, + {0b100000011011, 5}, {0b100000011100, 4}, + {0b100000011101, 5}, {0b100000011110, 5}, + {0b100000100000, 3}, {0b100000100001, 5}, + {0b100000100010, 5}, {0b100000100011, 4}, + {0b100000100100, 5}, {0b100000100101, 4}, + {0b100000100110, 4}, {0b100000100111, 5}, + {0b100000101000, 5}, {0b100000101001, 4}, + {0b100000101010, 4}, {0b100000101011, 5}, + {0b100000101100, 4}, {0b100000101101, 5}, + {0b100000101110, 5}, {0b100000110000, 5}, + {0b100000110001, 4}, {0b100000110010, 4}, + {0b100000110100, 4}, {0b100000110101, 5}, + {0b100000110110, 5}, {0b100000111000, 4}, + {0b100000111001, 5}, {0b100000111010, 5}, + {0b100001000000, 3}, {0b100001000001, 5}, + {0b100001000010, 5}, {0b100001000011, 4}, + {0b100001000100, 5}, {0b100001000101, 4}, + {0b100001000110, 4}, {0b100001000111, 5}, + {0b100001001000, 5}, {0b100001001001, 4}, + {0b100001001010, 4}, {0b100001001011, 5}, + {0b100001001100, 4}, {0b100001001101, 5}, + {0b100001001110, 5}, {0b100001010000, 5}, + {0b100001010001, 4}, {0b100001010010, 4}, + {0b100001010011, 5}, {0b100001010100, 4}, + {0b100001010110, 5}, {0b100001011000, 4}, + {0b100001011001, 5}, {0b100001011100, 5}, + {0b100001100000, 5}, {0b100001100001, 4}, + {0b100001100010, 4}, {0b100001100011, 5}, + {0b100001100100, 4}, {0b100001100101, 5}, + {0b100001101000, 4}, {0b100001101010, 5}, + {0b100001101100, 5}, {0b100001110000, 4}, + {0b100001110001, 5}, {0b100001110010, 5}, + {0b100001110100, 5}, {0b100001111000, 5}, + {0b100010000000, 3}, {0b100010000001, 5}, + {0b100010000010, 5}, {0b100010000011, 4}, + {0b100010000100, 5}, {0b100010000101, 4}, + {0b100010000110, 4}, {0b100010000111, 5}, + {0b100010001000, 5}, {0b100010001001, 4}, + {0b100010001010, 4}, {0b100010001011, 5}, + {0b100010001100, 4}, {0b100010001101, 5}, + {0b100010001110, 5}, {0b100010010000, 5}, + {0b100010010001, 4}, {0b100010010010, 4}, + {0b100010010011, 5}, {0b100010010100, 4}, + {0b100010010101, 5}, {0b100010011000, 4}, + {0b100010011010, 5}, {0b100010011100, 5}, + {0b100010100000, 5}, {0b100010100001, 4}, + {0b100010100010, 4}, {0b100010100011, 5}, + {0b100010100100, 4}, {0b100010100110, 5}, + {0b100010101000, 4}, {0b100010101001, 5}, + {0b100010101100, 5}, {0b100010110000, 4}, + {0b100010110001, 5}, {0b100010110010, 5}, + {0b100010110100, 5}, {0b100010111000, 5}, + {0b100011000000, 5}, {0b100011000001, 4}, + {0b100011000010, 4}, {0b100011000100, 4}, + {0b100011000101, 5}, {0b100011000110, 5}, + {0b100011001000, 4}, {0b100011001001, 5}, + {0b100011001010, 5}, {0b100011010000, 4}, + {0b100011010001, 5}, {0b100011010010, 5}, + {0b100011010100, 5}, {0b100011011000, 5}, + {0b100011100000, 4}, {0b100011100001, 5}, + {0b100011100010, 5}, {0b100011100100, 5}, + {0b100011101000, 5}, {0b100100000000, 3}, + {0b100100000001, 5}, {0b100100000010, 5}, + {0b100100000011, 4}, {0b100100000100, 5}, + {0b100100000101, 4}, {0b100100000110, 2}, + {0b100100001000, 5}, {0b100100001001, 2}, + {0b100100001010, 4}, {0b100100001100, 4}, + {0b100100001111, 3}, {0b100100010000, 5}, + {0b100100010001, 4}, {0b100100010010, 4}, + {0b100100010011, 5}, {0b100100010100, 4}, + {0b100100010101, 5}, {0b100100011000, 4}, + {0b100100011010, 5}, {0b100100011100, 5}, + {0b100100100000, 5}, {0b100100100001, 4}, + {0b100100100010, 4}, {0b100100100011, 5}, + {0b100100100100, 4}, {0b100100100101, 5}, + {0b100100101000, 4}, {0b100100101010, 5}, + {0b100100101100, 5}, {0b100100110000, 4}, + {0b100100110001, 5}, {0b100100110010, 5}, + {0b100100110100, 5}, {0b100100111000, 5}, + {0b100101000000, 5}, {0b100101000001, 4}, + {0b100101000010, 4}, {0b100101000011, 5}, + {0b100101000100, 4}, {0b100101000101, 5}, + {0b100101001000, 4}, {0b100101001010, 5}, + {0b100101001100, 5}, {0b100101010000, 4}, + {0b100101010001, 5}, {0b100101010010, 5}, + {0b100101010100, 5}, {0b100101011000, 5}, + {0b100101100000, 2}, {0b100101100110, 3}, + {0b100101101001, 3}, {0b100101101111, 4}, + {0b100110000000, 5}, {0b100110000001, 4}, + {0b100110000010, 4}, {0b100110000011, 5}, + {0b100110000100, 4}, {0b100110000101, 5}, + {0b100110001000, 4}, {0b100110001010, 5}, + {0b100110001100, 5}, {0b100110010000, 2}, + {0b100110010110, 3}, {0b100110011001, 3}, + {0b100110011111, 4}, {0b100110100000, 4}, + {0b100110100001, 5}, {0b100110100010, 5}, + {0b100110100100, 5}, {0b100110101000, 5}, + {0b100111000000, 4}, {0b100111000001, 5}, + {0b100111000010, 5}, {0b100111000100, 5}, + {0b100111001000, 5}, {0b100111110000, 3}, + {0b100111110110, 4}, {0b100111111001, 4}, + {0b100111111111, 3}, {0b101000000000, 3}, + {0b101000000001, 5}, {0b101000000010, 5}, + {0b101000000011, 4}, {0b101000000100, 5}, + {0b101000000101, 2}, {0b101000000110, 4}, + {0b101000001000, 5}, {0b101000001001, 4}, + {0b101000001010, 2}, {0b101000001100, 4}, + {0b101000001111, 3}, {0b101000010000, 5}, + {0b101000010001, 4}, {0b101000010010, 4}, + {0b101000010011, 5}, {0b101000010100, 4}, + {0b101000010110, 5}, {0b101000011000, 4}, + {0b101000011001, 5}, {0b101000011100, 5}, + {0b101000100000, 5}, {0b101000100001, 4}, + {0b101000100010, 4}, {0b101000100011, 5}, + {0b101000100100, 4}, {0b101000100110, 5}, + {0b101000101000, 4}, {0b101000101001, 5}, + {0b101000101100, 5}, {0b101000110000, 4}, + {0b101000110001, 5}, {0b101000110010, 5}, + {0b101000110100, 5}, {0b101000111000, 5}, + {0b101001000000, 5}, {0b101001000001, 4}, + {0b101001000010, 4}, {0b101001000011, 5}, + {0b101001000100, 4}, {0b101001000110, 5}, + {0b101001001000, 4}, {0b101001001001, 5}, + {0b101001001100, 5}, {0b101001010000, 2}, + {0b101001010101, 3}, {0b101001011010, 3}, + {0b101001011111, 4}, {0b101001100000, 4}, + {0b101001100001, 5}, {0b101001100010, 5}, + {0b101001100100, 5}, {0b101001101000, 5}, + {0b101010000000, 5}, {0b101010000001, 4}, + {0b101010000010, 4}, {0b101010000011, 5}, + {0b101010000100, 4}, {0b101010000110, 5}, + {0b101010001000, 4}, {0b101010001001, 5}, + {0b101010001100, 5}, {0b101010010000, 4}, + {0b101010010001, 5}, {0b101010010010, 5}, + {0b101010010100, 5}, {0b101010011000, 5}, + {0b101010100000, 2}, {0b101010100101, 3}, + {0b101010101010, 3}, {0b101010101111, 4}, + {0b101011000000, 4}, {0b101011000001, 5}, + {0b101011000010, 5}, {0b101011000100, 5}, + {0b101011001000, 5}, {0b101011110000, 3}, + {0b101011110101, 4}, {0b101011111010, 4}, + {0b101011111111, 3}, {0b101100000000, 5}, + {0b101100000001, 4}, {0b101100000010, 4}, + {0b101100000100, 4}, {0b101100000111, 3}, + {0b101100001000, 4}, {0b101100001011, 3}, + {0b101100001101, 3}, {0b101100001110, 3}, + {0b101100010000, 4}, {0b101100010001, 5}, + {0b101100010010, 5}, {0b101100010100, 5}, + {0b101100011000, 5}, {0b101100100000, 4}, + {0b101100100001, 5}, {0b101100100010, 5}, + {0b101100100100, 5}, {0b101100101000, 5}, + {0b101101000000, 4}, {0b101101000001, 5}, + {0b101101000010, 5}, {0b101101000100, 5}, + {0b101101001000, 5}, {0b101101110000, 3}, + {0b101110000000, 4}, {0b101110000001, 5}, + {0b101110000010, 5}, {0b101110000100, 5}, + {0b101110001000, 5}, {0b101110110000, 3}, + {0b101111010000, 3}, {0b101111100000, 3}, + {0b110000000000, 3}, {0b110000000001, 5}, + {0b110000000010, 5}, {0b110000000011, 2}, + {0b110000000100, 5}, {0b110000000101, 4}, + {0b110000000110, 4}, {0b110000001000, 5}, + {0b110000001001, 4}, {0b110000001010, 4}, + {0b110000001100, 2}, {0b110000001111, 3}, + {0b110000010000, 5}, {0b110000010001, 4}, + {0b110000010010, 4}, {0b110000010100, 4}, + {0b110000010101, 5}, {0b110000010110, 5}, + {0b110000011000, 4}, {0b110000011001, 5}, + {0b110000011010, 5}, {0b110000100000, 5}, + {0b110000100001, 4}, {0b110000100010, 4}, + {0b110000100100, 4}, {0b110000100101, 5}, + {0b110000100110, 5}, {0b110000101000, 4}, + {0b110000101001, 5}, {0b110000101010, 5}, + {0b110000110000, 2}, {0b110000110011, 3}, + {0b110000111100, 3}, {0b110000111111, 4}, + {0b110001000000, 5}, {0b110001000001, 4}, + {0b110001000010, 4}, {0b110001000100, 4}, + {0b110001000101, 5}, {0b110001000110, 5}, + {0b110001001000, 4}, {0b110001001001, 5}, + {0b110001001010, 5}, {0b110001010000, 4}, + {0b110001010001, 5}, {0b110001010010, 5}, + {0b110001010100, 5}, {0b110001011000, 5}, + {0b110001100000, 4}, {0b110001100001, 5}, + {0b110001100010, 5}, {0b110001100100, 5}, + {0b110001101000, 5}, {0b110010000000, 5}, + {0b110010000001, 4}, {0b110010000010, 4}, + {0b110010000100, 4}, {0b110010000101, 5}, + {0b110010000110, 5}, {0b110010001000, 4}, + {0b110010001001, 5}, {0b110010001010, 5}, + {0b110010010000, 4}, {0b110010010001, 5}, + {0b110010010010, 5}, {0b110010010100, 5}, + {0b110010011000, 5}, {0b110010100000, 4}, + {0b110010100001, 5}, {0b110010100010, 5}, + {0b110010100100, 5}, {0b110010101000, 5}, + {0b110011000000, 2}, {0b110011000011, 3}, + {0b110011001100, 3}, {0b110011001111, 4}, + {0b110011110000, 3}, {0b110011110011, 4}, + {0b110011111100, 4}, {0b110011111111, 3}, + {0b110100000000, 5}, {0b110100000001, 4}, + {0b110100000010, 4}, {0b110100000100, 4}, + {0b110100000111, 3}, {0b110100001000, 4}, + {0b110100001011, 3}, {0b110100001101, 3}, + {0b110100001110, 3}, {0b110100010000, 4}, + {0b110100010001, 5}, {0b110100010010, 5}, + {0b110100010100, 5}, {0b110100011000, 5}, + {0b110100100000, 4}, {0b110100100001, 5}, + {0b110100100010, 5}, {0b110100100100, 5}, + {0b110100101000, 5}, {0b110101000000, 4}, + {0b110101000001, 5}, {0b110101000010, 5}, + {0b110101000100, 5}, {0b110101001000, 5}, + {0b110101110000, 3}, {0b110110000000, 4}, + {0b110110000001, 5}, {0b110110000010, 5}, + {0b110110000100, 5}, {0b110110001000, 5}, + {0b110110110000, 3}, {0b110111010000, 3}, + {0b110111100000, 3}, {0b111000000000, 5}, + {0b111000000001, 4}, {0b111000000010, 4}, + {0b111000000100, 4}, {0b111000000111, 3}, + {0b111000001000, 4}, {0b111000001011, 3}, + {0b111000001101, 3}, {0b111000001110, 3}, + {0b111000010000, 4}, {0b111000010001, 5}, + {0b111000010010, 5}, {0b111000010100, 5}, + {0b111000011000, 5}, {0b111000100000, 4}, + {0b111000100001, 5}, {0b111000100010, 5}, + {0b111000100100, 5}, {0b111000101000, 5}, + {0b111001000000, 4}, {0b111001000001, 5}, + {0b111001000010, 5}, {0b111001000100, 5}, + {0b111001001000, 5}, {0b111001110000, 3}, + {0b111010000000, 4}, {0b111010000001, 5}, + {0b111010000010, 5}, {0b111010000100, 5}, + {0b111010001000, 5}, {0b111010110000, 3}, + {0b111011010000, 3}, {0b111011100000, 3}, + {0b111100000000, 2}, {0b111100000011, 3}, + {0b111100000101, 3}, {0b111100000110, 3}, + {0b111100001001, 3}, {0b111100001010, 3}, + {0b111100001100, 3}, {0b111100001111, 1}, + {0b111100110000, 3}, {0b111100110011, 4}, + {0b111100111100, 4}, {0b111100111111, 3}, + {0b111101010000, 3}, {0b111101010101, 4}, + {0b111101011010, 4}, {0b111101011111, 3}, + {0b111101100000, 3}, {0b111101100110, 4}, + {0b111101101001, 4}, {0b111101101111, 3}, + {0b111110010000, 3}, {0b111110010110, 4}, + {0b111110011001, 4}, {0b111110011111, 3}, + {0b111110100000, 3}, {0b111110100101, 4}, + {0b111110101010, 4}, {0b111110101111, 3}, + {0b111111000000, 3}, {0b111111000011, 4}, + {0b111111001100, 4}, {0b111111001111, 3}, + {0b111111110000, 1}, {0b111111110011, 3}, + {0b111111110101, 3}, {0b111111110110, 3}, + {0b111111111001, 3}, {0b111111111010, 3}, + {0b111111111100, 3}, {0b111111111111, 2}, + {0b1000000000000, 4}, {0b1000000000001, 3}, + {0b1000000000010, 3}, {0b1000000000011, 5}, + {0b1000000000100, 3}, {0b1000000000101, 5}, + {0b1000000000110, 5}, {0b1000000000111, 4}, + {0b1000000001000, 3}, {0b1000000001001, 5}, + {0b1000000001010, 5}, {0b1000000001011, 4}, + {0b1000000001100, 5}, {0b1000000001101, 4}, + {0b1000000001110, 4}, {0b1000000010000, 3}, + {0b1000000010001, 5}, {0b1000000010010, 5}, + {0b1000000010011, 4}, {0b1000000010100, 5}, + {0b1000000010101, 4}, {0b1000000010110, 4}, + {0b1000000010111, 5}, {0b1000000011000, 5}, + {0b1000000011001, 4}, {0b1000000011010, 4}, + {0b1000000011011, 5}, {0b1000000011100, 4}, + {0b1000000011101, 5}, {0b1000000011110, 5}, + {0b1000000100000, 3}, {0b1000000100001, 5}, + {0b1000000100010, 5}, {0b1000000100011, 4}, + {0b1000000100100, 5}, {0b1000000100101, 4}, + {0b1000000100110, 4}, {0b1000000100111, 5}, + {0b1000000101000, 5}, {0b1000000101001, 4}, + {0b1000000101010, 4}, {0b1000000101011, 5}, + {0b1000000101100, 4}, {0b1000000101101, 5}, + {0b1000000101110, 5}, {0b1000000110000, 5}, + {0b1000000110001, 4}, {0b1000000110010, 4}, + {0b1000000110100, 4}, {0b1000000110101, 5}, + {0b1000000110110, 5}, {0b1000000111000, 4}, + {0b1000000111001, 5}, {0b1000000111010, 5}, + {0b1000001000000, 3}, {0b1000001000001, 5}, + {0b1000001000010, 5}, {0b1000001000011, 4}, + {0b1000001000100, 5}, {0b1000001000101, 4}, + {0b1000001000110, 4}, {0b1000001000111, 5}, + {0b1000001001000, 5}, {0b1000001001001, 4}, + {0b1000001001010, 4}, {0b1000001001011, 5}, + {0b1000001001100, 4}, {0b1000001001101, 5}, + {0b1000001001110, 5}, {0b1000001010000, 5}, + {0b1000001010001, 4}, {0b1000001010010, 4}, + {0b1000001010011, 5}, {0b1000001010100, 4}, + {0b1000001010110, 5}, {0b1000001011000, 4}, + {0b1000001011001, 5}, {0b1000001011100, 5}, + {0b1000001100000, 5}, {0b1000001100001, 4}, + {0b1000001100010, 4}, {0b1000001100011, 5}, + {0b1000001100100, 4}, {0b1000001100101, 5}, + {0b1000001101000, 4}, {0b1000001101010, 5}, + {0b1000001101100, 5}, {0b1000001110000, 4}, + {0b1000001110001, 5}, {0b1000001110010, 5}, + {0b1000001110100, 5}, {0b1000001111000, 5}, + {0b1000010000000, 3}, {0b1000010000001, 5}, + {0b1000010000010, 5}, {0b1000010000011, 4}, + {0b1000010000100, 5}, {0b1000010000101, 4}, + {0b1000010000110, 4}, {0b1000010000111, 5}, + {0b1000010001000, 5}, {0b1000010001001, 4}, + {0b1000010001010, 4}, {0b1000010001011, 5}, + {0b1000010001100, 4}, {0b1000010001101, 5}, + {0b1000010001110, 5}, {0b1000010010000, 5}, + {0b1000010010001, 4}, {0b1000010010010, 4}, + {0b1000010010011, 5}, {0b1000010010100, 4}, + {0b1000010010101, 5}, {0b1000010011000, 4}, + {0b1000010011010, 5}, {0b1000010011100, 5}, + {0b1000010100000, 5}, {0b1000010100001, 4}, + {0b1000010100010, 4}, {0b1000010100011, 5}, + {0b1000010100100, 4}, {0b1000010100110, 5}, + {0b1000010101000, 4}, {0b1000010101001, 5}, + {0b1000010101100, 5}, {0b1000010110000, 4}, + {0b1000010110001, 5}, {0b1000010110010, 5}, + {0b1000010110100, 5}, {0b1000010111000, 5}, + {0b1000011000000, 5}, {0b1000011000001, 4}, + {0b1000011000010, 4}, {0b1000011000100, 4}, + {0b1000011000101, 5}, {0b1000011000110, 5}, + {0b1000011001000, 4}, {0b1000011001001, 5}, + {0b1000011001010, 5}, {0b1000011010000, 4}, + {0b1000011010001, 5}, {0b1000011010010, 5}, + {0b1000011010100, 5}, {0b1000011011000, 5}, + {0b1000011100000, 4}, {0b1000011100001, 5}, + {0b1000011100010, 5}, {0b1000011100100, 5}, + {0b1000011101000, 5}, {0b1000100000000, 3}, + {0b1000100000001, 5}, {0b1000100000010, 5}, + {0b1000100000011, 4}, {0b1000100000100, 5}, + {0b1000100000101, 4}, {0b1000100000110, 4}, + {0b1000100000111, 5}, {0b1000100001000, 5}, + {0b1000100001001, 4}, {0b1000100001010, 4}, + {0b1000100001011, 5}, {0b1000100001100, 4}, + {0b1000100001101, 5}, {0b1000100001110, 5}, + {0b1000100010000, 5}, {0b1000100010001, 2}, + {0b1000100010010, 4}, {0b1000100010100, 4}, + {0b1000100010110, 5}, {0b1000100011000, 4}, + {0b1000100011010, 5}, {0b1000100011100, 5}, + {0b1000100100000, 5}, {0b1000100100001, 4}, + {0b1000100100010, 2}, {0b1000100100100, 4}, + {0b1000100100101, 5}, {0b1000100101000, 4}, + {0b1000100101001, 5}, {0b1000100101100, 5}, + {0b1000100110000, 4}, {0b1000100110011, 3}, + {0b1000100110100, 5}, {0b1000100111000, 5}, + {0b1000101000000, 5}, {0b1000101000001, 4}, + {0b1000101000010, 4}, {0b1000101000011, 5}, + {0b1000101000100, 2}, {0b1000101001000, 4}, + {0b1000101001001, 5}, {0b1000101001010, 5}, + {0b1000101010000, 4}, {0b1000101010010, 5}, + {0b1000101010101, 3}, {0b1000101011000, 5}, + {0b1000101100000, 4}, {0b1000101100001, 5}, + {0b1000101100110, 3}, {0b1000101101000, 5}, + {0b1000101110000, 5}, {0b1000101110111, 4}, + {0b1000110000000, 5}, {0b1000110000001, 4}, + {0b1000110000010, 4}, {0b1000110000011, 5}, + {0b1000110000100, 4}, {0b1000110000101, 5}, + {0b1000110000110, 5}, {0b1000110001000, 2}, + {0b1000110010000, 4}, {0b1000110010010, 5}, + {0b1000110010100, 5}, {0b1000110011001, 3}, + {0b1000110100000, 4}, {0b1000110100001, 5}, + {0b1000110100100, 5}, {0b1000110101010, 3}, + {0b1000110110000, 5}, {0b1000110111011, 4}, + {0b1000111000000, 4}, {0b1000111000001, 5}, + {0b1000111000010, 5}, {0b1000111001100, 3}, + {0b1000111010000, 5}, {0b1000111011101, 4}, + {0b1000111100000, 5}, {0b1000111101110, 4}, + {0b1000111111111, 3}, {0b1001000000000, 3}, + {0b1001000000001, 5}, {0b1001000000010, 5}, + {0b1001000000011, 4}, {0b1001000000100, 5}, + {0b1001000000101, 4}, {0b1001000000110, 4}, + {0b1001000000111, 5}, {0b1001000001000, 5}, + {0b1001000001001, 4}, {0b1001000001010, 4}, + {0b1001000001011, 5}, {0b1001000001100, 4}, + {0b1001000001101, 5}, {0b1001000001110, 5}, + {0b1001000010000, 5}, {0b1001000010001, 4}, + {0b1001000010010, 2}, {0b1001000010100, 4}, + {0b1001000010101, 5}, {0b1001000011000, 4}, + {0b1001000011001, 5}, {0b1001000011100, 5}, + {0b1001000100000, 5}, {0b1001000100001, 2}, + {0b1001000100010, 4}, {0b1001000100100, 4}, + {0b1001000100110, 5}, {0b1001000101000, 4}, + {0b1001000101010, 5}, {0b1001000101100, 5}, + {0b1001000110000, 4}, {0b1001000110011, 3}, + {0b1001000110100, 5}, {0b1001000111000, 5}, + {0b1001001000000, 5}, {0b1001001000001, 4}, + {0b1001001000010, 4}, {0b1001001000011, 5}, + {0b1001001000100, 4}, {0b1001001000101, 5}, + {0b1001001000110, 5}, {0b1001001001000, 2}, + {0b1001001010000, 4}, {0b1001001010001, 5}, + {0b1001001010100, 5}, {0b1001001011010, 3}, + {0b1001001100000, 4}, {0b1001001100010, 5}, + {0b1001001100100, 5}, {0b1001001101001, 3}, + {0b1001001110000, 5}, {0b1001001111011, 4}, + {0b1001010000000, 5}, {0b1001010000001, 4}, + {0b1001010000010, 4}, {0b1001010000011, 5}, + {0b1001010000100, 2}, {0b1001010001000, 4}, + {0b1001010001001, 5}, {0b1001010001010, 5}, + {0b1001010010000, 4}, {0b1001010010001, 5}, + {0b1001010010110, 3}, {0b1001010011000, 5}, + {0b1001010100000, 4}, {0b1001010100010, 5}, + {0b1001010100101, 3}, {0b1001010101000, 5}, + {0b1001010110000, 5}, {0b1001010110111, 4}, + {0b1001011000000, 4}, {0b1001011000001, 5}, + {0b1001011000010, 5}, {0b1001011001100, 3}, + {0b1001011010000, 5}, {0b1001011011110, 4}, + {0b1001011100000, 5}, {0b1001011101101, 4}, + {0b1001011111111, 3}, {0b1001100000000, 5}, + {0b1001100000001, 4}, {0b1001100000010, 4}, + {0b1001100000100, 4}, {0b1001100000101, 5}, + {0b1001100000110, 5}, {0b1001100001000, 4}, + {0b1001100001001, 5}, {0b1001100001010, 5}, + {0b1001100010000, 4}, {0b1001100010011, 3}, + {0b1001100010100, 5}, {0b1001100011000, 5}, + {0b1001100100000, 4}, {0b1001100100011, 3}, + {0b1001100100100, 5}, {0b1001100101000, 5}, + {0b1001100110001, 3}, {0b1001100110010, 3}, + {0b1001101000000, 4}, {0b1001101000001, 5}, + {0b1001101000010, 5}, {0b1001101001100, 3}, + {0b1001101010000, 5}, {0b1001101100000, 5}, + {0b1001110000000, 4}, {0b1001110000001, 5}, + {0b1001110000010, 5}, {0b1001110001100, 3}, + {0b1001110010000, 5}, {0b1001110100000, 5}, + {0b1001111000100, 3}, {0b1001111001000, 3}, + {0b1010000000000, 3}, {0b1010000000001, 5}, + {0b1010000000010, 5}, {0b1010000000011, 4}, + {0b1010000000100, 5}, {0b1010000000101, 4}, + {0b1010000000110, 4}, {0b1010000000111, 5}, + {0b1010000001000, 5}, {0b1010000001001, 4}, + {0b1010000001010, 4}, {0b1010000001011, 5}, + {0b1010000001100, 4}, {0b1010000001101, 5}, + {0b1010000001110, 5}, {0b1010000010000, 5}, + {0b1010000010001, 4}, {0b1010000010010, 4}, + {0b1010000010011, 5}, {0b1010000010100, 2}, + {0b1010000011000, 4}, {0b1010000011001, 5}, + {0b1010000011010, 5}, {0b1010000100000, 5}, + {0b1010000100001, 4}, {0b1010000100010, 4}, + {0b1010000100011, 5}, {0b1010000100100, 4}, + {0b1010000100101, 5}, {0b1010000100110, 5}, + {0b1010000101000, 2}, {0b1010000110000, 4}, + {0b1010000110001, 5}, {0b1010000110010, 5}, + {0b1010000111100, 3}, {0b1010001000000, 5}, + {0b1010001000001, 2}, {0b1010001000010, 4}, + {0b1010001000100, 4}, {0b1010001000110, 5}, + {0b1010001001000, 4}, {0b1010001001010, 5}, + {0b1010001001100, 5}, {0b1010001010000, 4}, + {0b1010001010010, 5}, {0b1010001010101, 3}, + {0b1010001011000, 5}, {0b1010001100000, 4}, + {0b1010001100010, 5}, {0b1010001100100, 5}, + {0b1010001101001, 3}, {0b1010001110000, 5}, + {0b1010001111101, 4}, {0b1010010000000, 5}, + {0b1010010000001, 4}, {0b1010010000010, 2}, + {0b1010010000100, 4}, {0b1010010000101, 5}, + {0b1010010001000, 4}, {0b1010010001001, 5}, + {0b1010010001100, 5}, {0b1010010010000, 4}, + {0b1010010010001, 5}, {0b1010010010110, 3}, + {0b1010010011000, 5}, {0b1010010100000, 4}, + {0b1010010100001, 5}, {0b1010010100100, 5}, + {0b1010010101010, 3}, {0b1010010110000, 5}, + {0b1010010111110, 4}, {0b1010011000000, 4}, + {0b1010011000011, 3}, {0b1010011000100, 5}, + {0b1010011001000, 5}, {0b1010011010000, 5}, + {0b1010011010111, 4}, {0b1010011100000, 5}, + {0b1010011101011, 4}, {0b1010011111111, 3}, + {0b1010100000000, 5}, {0b1010100000001, 4}, + {0b1010100000010, 4}, {0b1010100000011, 5}, + {0b1010100000100, 4}, {0b1010100000110, 5}, + {0b1010100001000, 4}, {0b1010100001001, 5}, + {0b1010100001100, 5}, {0b1010100010000, 4}, + {0b1010100010010, 5}, {0b1010100010101, 3}, + {0b1010100011000, 5}, {0b1010100100000, 4}, + {0b1010100100001, 5}, {0b1010100100100, 5}, + {0b1010100101010, 3}, {0b1010100110000, 5}, + {0b1010101000000, 4}, {0b1010101000010, 5}, + {0b1010101000101, 3}, {0b1010101001000, 5}, + {0b1010101010001, 3}, {0b1010101010100, 3}, + {0b1010101100000, 5}, {0b1010110000000, 4}, + {0b1010110000001, 5}, {0b1010110000100, 5}, + {0b1010110001010, 3}, {0b1010110010000, 5}, + {0b1010110100010, 3}, {0b1010110101000, 3}, + {0b1010111000000, 5}, {0b1011000000000, 5}, + {0b1011000000001, 4}, {0b1011000000010, 4}, + {0b1011000000011, 5}, {0b1011000000100, 4}, + {0b1011000000101, 5}, {0b1011000001000, 4}, + {0b1011000001010, 5}, {0b1011000001100, 5}, + {0b1011000010000, 4}, {0b1011000010001, 5}, + {0b1011000010110, 3}, {0b1011000011000, 5}, + {0b1011000100000, 4}, {0b1011000100010, 5}, + {0b1011000100100, 5}, {0b1011000101001, 3}, + {0b1011000110000, 5}, {0b1011001000000, 4}, + {0b1011001000010, 5}, {0b1011001000100, 5}, + {0b1011001001001, 3}, {0b1011001010000, 5}, + {0b1011001100001, 3}, {0b1011001101000, 3}, + {0b1011010000000, 4}, {0b1011010000001, 5}, + {0b1011010000110, 3}, {0b1011010001000, 5}, + {0b1011010010010, 3}, {0b1011010010100, 3}, + {0b1011010100000, 5}, {0b1011011000000, 5}, + {0b1011100000000, 4}, {0b1011100000001, 5}, + {0b1011100000010, 5}, {0b1011100000100, 5}, + {0b1011100001000, 5}, {0b1011100010000, 5}, + {0b1011100010111, 4}, {0b1011100100000, 5}, + {0b1011100101011, 4}, {0b1011101000000, 5}, + {0b1011101001101, 4}, {0b1011101110001, 4}, + {0b1011101111111, 5}, {0b1011110000000, 5}, + {0b1011110001110, 4}, {0b1011110110010, 4}, + {0b1011110111111, 5}, {0b1011111010100, 4}, + {0b1011111011111, 5}, {0b1011111101000, 4}, + {0b1011111101111, 5}, {0b1011111110111, 5}, + {0b1011111111011, 5}, {0b1011111111101, 5}, + {0b1011111111110, 5}, {0b1011111111111, 4}, + {0b1100000000000, 3}, {0b1100000000001, 5}, + {0b1100000000010, 5}, {0b1100000000011, 4}, + {0b1100000000100, 5}, {0b1100000000101, 4}, + {0b1100000000110, 4}, {0b1100000000111, 5}, + {0b1100000001000, 5}, {0b1100000001001, 4}, + {0b1100000001010, 4}, {0b1100000001011, 5}, + {0b1100000001100, 4}, {0b1100000001101, 5}, + {0b1100000001110, 5}, {0b1100000010000, 5}, + {0b1100000010001, 4}, {0b1100000010010, 4}, + {0b1100000010011, 5}, {0b1100000010100, 4}, + {0b1100000010101, 5}, {0b1100000010110, 5}, + {0b1100000011000, 2}, {0b1100000100000, 5}, + {0b1100000100001, 4}, {0b1100000100010, 4}, + {0b1100000100011, 5}, {0b1100000100100, 2}, + {0b1100000101000, 4}, {0b1100000101001, 5}, + {0b1100000101010, 5}, {0b1100000110000, 4}, + {0b1100000110001, 5}, {0b1100000110010, 5}, + {0b1100000111100, 3}, {0b1100001000000, 5}, + {0b1100001000001, 4}, {0b1100001000010, 2}, + {0b1100001000100, 4}, {0b1100001000101, 5}, + {0b1100001001000, 4}, {0b1100001001001, 5}, + {0b1100001001100, 5}, {0b1100001010000, 4}, + {0b1100001010001, 5}, {0b1100001010100, 5}, + {0b1100001011010, 3}, {0b1100001100000, 4}, + {0b1100001100001, 5}, {0b1100001100110, 3}, + {0b1100001101000, 5}, {0b1100001110000, 5}, + {0b1100001111110, 4}, {0b1100010000000, 5}, + {0b1100010000001, 2}, {0b1100010000010, 4}, + {0b1100010000100, 4}, {0b1100010000110, 5}, + {0b1100010001000, 4}, {0b1100010001010, 5}, + {0b1100010001100, 5}, {0b1100010010000, 4}, + {0b1100010010010, 5}, {0b1100010010100, 5}, + {0b1100010011001, 3}, {0b1100010100000, 4}, + {0b1100010100010, 5}, {0b1100010100101, 3}, + {0b1100010101000, 5}, {0b1100010110000, 5}, + {0b1100010111101, 4}, {0b1100011000000, 4}, + {0b1100011000011, 3}, {0b1100011000100, 5}, + {0b1100011001000, 5}, {0b1100011010000, 5}, + {0b1100011011011, 4}, {0b1100011100000, 5}, + {0b1100011100111, 4}, {0b1100011111111, 3}, + {0b1100100000000, 5}, {0b1100100000001, 4}, + {0b1100100000010, 4}, {0b1100100000011, 5}, + {0b1100100000100, 4}, {0b1100100000101, 5}, + {0b1100100001000, 4}, {0b1100100001010, 5}, + {0b1100100001100, 5}, {0b1100100010000, 4}, + {0b1100100010010, 5}, {0b1100100010100, 5}, + {0b1100100011001, 3}, {0b1100100100000, 4}, + {0b1100100100001, 5}, {0b1100100100110, 3}, + {0b1100100101000, 5}, {0b1100100110000, 5}, + {0b1100101000000, 4}, {0b1100101000001, 5}, + {0b1100101000110, 3}, {0b1100101001000, 5}, + {0b1100101010000, 5}, {0b1100101100010, 3}, + {0b1100101100100, 3}, {0b1100110000000, 4}, + {0b1100110000010, 5}, {0b1100110000100, 5}, + {0b1100110001001, 3}, {0b1100110010001, 3}, + {0b1100110011000, 3}, {0b1100110100000, 5}, + {0b1100111000000, 5}, {0b1101000000000, 5}, + {0b1101000000001, 4}, {0b1101000000010, 4}, + {0b1101000000011, 5}, {0b1101000000100, 4}, + {0b1101000000110, 5}, {0b1101000001000, 4}, + {0b1101000001001, 5}, {0b1101000001100, 5}, + {0b1101000010000, 4}, {0b1101000010001, 5}, + {0b1101000010100, 5}, {0b1101000011010, 3}, + {0b1101000100000, 4}, {0b1101000100010, 5}, + {0b1101000100101, 3}, {0b1101000101000, 5}, + {0b1101000110000, 5}, {0b1101001000000, 4}, + {0b1101001000001, 5}, {0b1101001000100, 5}, + {0b1101001001010, 3}, {0b1101001010010, 3}, + {0b1101001011000, 3}, {0b1101001100000, 5}, + {0b1101010000000, 4}, {0b1101010000010, 5}, + {0b1101010000101, 3}, {0b1101010001000, 5}, + {0b1101010010000, 5}, {0b1101010100001, 3}, + {0b1101010100100, 3}, {0b1101011000000, 5}, + {0b1101100000000, 4}, {0b1101100000001, 5}, + {0b1101100000010, 5}, {0b1101100000100, 5}, + {0b1101100001000, 5}, {0b1101100010000, 5}, + {0b1101100011011, 4}, {0b1101100100000, 5}, + {0b1101100100111, 4}, {0b1101101000000, 5}, + {0b1101101001110, 4}, {0b1101101110010, 4}, + {0b1101101111111, 5}, {0b1101110000000, 5}, + {0b1101110001101, 4}, {0b1101110110001, 4}, + {0b1101110111111, 5}, {0b1101111011000, 4}, + {0b1101111011111, 5}, {0b1101111100100, 4}, + {0b1101111101111, 5}, {0b1101111110111, 5}, + {0b1101111111011, 5}, {0b1101111111101, 5}, + {0b1101111111110, 5}, {0b1101111111111, 4}, + {0b1110000000000, 5}, {0b1110000000001, 4}, + {0b1110000000010, 4}, {0b1110000000100, 4}, + {0b1110000000101, 5}, {0b1110000000110, 5}, + {0b1110000001000, 4}, {0b1110000001001, 5}, + {0b1110000001010, 5}, {0b1110000010000, 4}, + {0b1110000010001, 5}, {0b1110000010010, 5}, + {0b1110000011100, 3}, {0b1110000100000, 4}, + {0b1110000100001, 5}, {0b1110000100010, 5}, + {0b1110000101100, 3}, {0b1110000110100, 3}, + {0b1110000111000, 3}, {0b1110001000000, 4}, + {0b1110001000011, 3}, {0b1110001000100, 5}, + {0b1110001001000, 5}, {0b1110001010000, 5}, + {0b1110001100000, 5}, {0b1110010000000, 4}, + {0b1110010000011, 3}, {0b1110010000100, 5}, + {0b1110010001000, 5}, {0b1110010010000, 5}, + {0b1110010100000, 5}, {0b1110011000001, 3}, + {0b1110011000010, 3}, {0b1110100000000, 4}, + {0b1110100000001, 5}, {0b1110100000010, 5}, + {0b1110100000100, 5}, {0b1110100001000, 5}, + {0b1110100010000, 5}, {0b1110100011101, 4}, + {0b1110100100000, 5}, {0b1110100101110, 4}, + {0b1110101000000, 5}, {0b1110101000111, 4}, + {0b1110101110100, 4}, {0b1110101111111, 5}, + {0b1110110000000, 5}, {0b1110110001011, 4}, + {0b1110110111000, 4}, {0b1110110111111, 5}, + {0b1110111010001, 4}, {0b1110111011111, 5}, + {0b1110111100010, 4}, {0b1110111101111, 5}, + {0b1110111110111, 5}, {0b1110111111011, 5}, + {0b1110111111101, 5}, {0b1110111111110, 5}, + {0b1110111111111, 4}, {0b1111000000000, 4}, + {0b1111000000001, 5}, {0b1111000000010, 5}, + {0b1111000000100, 5}, {0b1111000001000, 5}, + {0b1111000010000, 5}, {0b1111000011110, 4}, + {0b1111000100000, 5}, {0b1111000101101, 4}, + {0b1111001000000, 5}, {0b1111001001011, 4}, + {0b1111001111000, 4}, {0b1111001111111, 5}, + {0b1111010000000, 5}, {0b1111010000111, 4}, + {0b1111010110100, 4}, {0b1111010111111, 5}, + {0b1111011010010, 4}, {0b1111011011111, 5}, + {0b1111011100001, 4}, {0b1111011101111, 5}, + {0b1111011110111, 5}, {0b1111011111011, 5}, + {0b1111011111101, 5}, {0b1111011111110, 5}, + {0b1111011111111, 4}, {0b1111100011111, 3}, + {0b1111100101111, 3}, {0b1111101001111, 3}, + {0b1111101110111, 5}, {0b1111101111011, 5}, + {0b1111101111101, 5}, {0b1111101111110, 5}, + {0b1111101111111, 4}, {0b1111110001111, 3}, + {0b1111110110111, 5}, {0b1111110111011, 5}, + {0b1111110111101, 5}, {0b1111110111110, 5}, + {0b1111110111111, 4}, {0b1111111010111, 5}, + {0b1111111011011, 5}, {0b1111111011101, 5}, + {0b1111111011110, 5}, {0b1111111011111, 4}, + {0b1111111100111, 5}, {0b1111111101011, 5}, + {0b1111111101101, 5}, {0b1111111101110, 5}, + {0b1111111101111, 4}, {0b1111111110001, 3}, + {0b1111111110010, 3}, {0b1111111110100, 3}, + {0b1111111110111, 4}, {0b1111111111000, 3}, + {0b1111111111011, 4}, {0b1111111111101, 4}, + {0b1111111111110, 4}, {0b1111111111111, 5}, + {0b10000000000000, 4}, {0b10000000000001, 3}, + {0b10000000000010, 3}, {0b10000000000011, 5}, + {0b10000000000100, 3}, {0b10000000000101, 5}, + {0b10000000000110, 5}, {0b10000000000111, 4}, + {0b10000000001000, 3}, {0b10000000001001, 5}, + {0b10000000001010, 5}, {0b10000000001011, 4}, + {0b10000000001100, 5}, {0b10000000001101, 4}, + {0b10000000001110, 4}, {0b10000000010000, 3}, + {0b10000000010001, 5}, {0b10000000010010, 5}, + {0b10000000010011, 4}, {0b10000000010100, 5}, + {0b10000000010101, 4}, {0b10000000010110, 4}, + {0b10000000010111, 5}, {0b10000000011000, 5}, + {0b10000000011001, 4}, {0b10000000011010, 4}, + {0b10000000011011, 5}, {0b10000000011100, 4}, + {0b10000000011101, 5}, {0b10000000011110, 5}, + {0b10000000100000, 3}, {0b10000000100001, 5}, + {0b10000000100010, 5}, {0b10000000100011, 4}, + {0b10000000100100, 5}, {0b10000000100101, 4}, + {0b10000000100110, 4}, {0b10000000100111, 5}, + {0b10000000101000, 5}, {0b10000000101001, 4}, + {0b10000000101010, 4}, {0b10000000101011, 5}, + {0b10000000101100, 4}, {0b10000000101101, 5}, + {0b10000000101110, 5}, {0b10000000110000, 5}, + {0b10000000110001, 4}, {0b10000000110010, 4}, + {0b10000000110100, 4}, {0b10000000110101, 5}, + {0b10000000110110, 5}, {0b10000000111000, 4}, + {0b10000000111001, 5}, {0b10000000111010, 5}, + {0b10000001000000, 3}, {0b10000001000001, 5}, + {0b10000001000010, 5}, {0b10000001000011, 4}, + {0b10000001000100, 5}, {0b10000001000101, 4}, + {0b10000001000110, 4}, {0b10000001000111, 5}, + {0b10000001001000, 5}, {0b10000001001001, 4}, + {0b10000001001010, 4}, {0b10000001001011, 5}, + {0b10000001001100, 4}, {0b10000001001101, 5}, + {0b10000001001110, 5}, {0b10000001010000, 5}, + {0b10000001010001, 4}, {0b10000001010010, 4}, + {0b10000001010011, 5}, {0b10000001010100, 4}, + {0b10000001010110, 5}, {0b10000001011000, 4}, + {0b10000001011001, 5}, {0b10000001011100, 5}, + {0b10000001100000, 5}, {0b10000001100001, 4}, + {0b10000001100010, 4}, {0b10000001100011, 5}, + {0b10000001100100, 4}, {0b10000001100101, 5}, + {0b10000001101000, 4}, {0b10000001101010, 5}, + {0b10000001101100, 5}, {0b10000001110000, 4}, + {0b10000001110001, 5}, {0b10000001110010, 5}, + {0b10000001110100, 5}, {0b10000001111000, 5}, + {0b10000010000000, 3}, {0b10000010000001, 5}, + {0b10000010000010, 5}, {0b10000010000011, 4}, + {0b10000010000100, 5}, {0b10000010000101, 4}, + {0b10000010000110, 4}, {0b10000010000111, 5}, + {0b10000010001000, 5}, {0b10000010001001, 4}, + {0b10000010001010, 4}, {0b10000010001011, 5}, + {0b10000010001100, 4}, {0b10000010001101, 5}, + {0b10000010001110, 5}, {0b10000010010000, 5}, + {0b10000010010001, 4}, {0b10000010010010, 4}, + {0b10000010010011, 5}, {0b10000010010100, 4}, + {0b10000010010101, 5}, {0b10000010011000, 4}, + {0b10000010011010, 5}, {0b10000010011100, 5}, + {0b10000010100000, 5}, {0b10000010100001, 4}, + {0b10000010100010, 4}, {0b10000010100011, 5}, + {0b10000010100100, 4}, {0b10000010100110, 5}, + {0b10000010101000, 4}, {0b10000010101001, 5}, + {0b10000010101100, 5}, {0b10000010110000, 4}, + {0b10000010110001, 5}, {0b10000010110010, 5}, + {0b10000010110100, 5}, {0b10000010111000, 5}, + {0b10000011000000, 5}, {0b10000011000001, 4}, + {0b10000011000010, 4}, {0b10000011000100, 4}, + {0b10000011000101, 5}, {0b10000011000110, 5}, + {0b10000011001000, 4}, {0b10000011001001, 5}, + {0b10000011001010, 5}, {0b10000011010000, 4}, + {0b10000011010001, 5}, {0b10000011010010, 5}, + {0b10000011010100, 5}, {0b10000011011000, 5}, + {0b10000011100000, 4}, {0b10000011100001, 5}, + {0b10000011100010, 5}, {0b10000011100100, 5}, + {0b10000011101000, 5}, {0b10000100000000, 3}, + {0b10000100000001, 5}, {0b10000100000010, 5}, + {0b10000100000011, 4}, {0b10000100000100, 5}, + {0b10000100000101, 4}, {0b10000100000110, 4}, + {0b10000100000111, 5}, {0b10000100001000, 5}, + {0b10000100001001, 4}, {0b10000100001010, 4}, + {0b10000100001011, 5}, {0b10000100001100, 4}, + {0b10000100001101, 5}, {0b10000100001110, 5}, + {0b10000100010000, 5}, {0b10000100010001, 4}, + {0b10000100010010, 2}, {0b10000100010100, 4}, + {0b10000100010101, 5}, {0b10000100011000, 4}, + {0b10000100011001, 5}, {0b10000100011100, 5}, + {0b10000100100000, 5}, {0b10000100100001, 2}, + {0b10000100100010, 4}, {0b10000100100100, 4}, + {0b10000100100110, 5}, {0b10000100101000, 4}, + {0b10000100101010, 5}, {0b10000100101100, 5}, + {0b10000100110000, 4}, {0b10000100110011, 3}, + {0b10000100110100, 5}, {0b10000100111000, 5}, + {0b10000101000000, 5}, {0b10000101000001, 4}, + {0b10000101000010, 4}, {0b10000101000011, 5}, + {0b10000101000100, 4}, {0b10000101000101, 5}, + {0b10000101000110, 5}, {0b10000101001000, 2}, + {0b10000101010000, 4}, {0b10000101010001, 5}, + {0b10000101010100, 5}, {0b10000101011010, 3}, + {0b10000101100000, 4}, {0b10000101100010, 5}, + {0b10000101100100, 5}, {0b10000101101001, 3}, + {0b10000101110000, 5}, {0b10000101111011, 4}, + {0b10000110000000, 5}, {0b10000110000001, 4}, + {0b10000110000010, 4}, {0b10000110000011, 5}, + {0b10000110000100, 2}, {0b10000110001000, 4}, + {0b10000110001001, 5}, {0b10000110001010, 5}, + {0b10000110010000, 4}, {0b10000110010001, 5}, + {0b10000110010110, 3}, {0b10000110011000, 5}, + {0b10000110100000, 4}, {0b10000110100010, 5}, + {0b10000110100101, 3}, {0b10000110101000, 5}, + {0b10000110110000, 5}, {0b10000110110111, 4}, + {0b10000111000000, 4}, {0b10000111000001, 5}, + {0b10000111000010, 5}, {0b10000111001100, 3}, + {0b10000111010000, 5}, {0b10000111011110, 4}, + {0b10000111100000, 5}, {0b10000111101101, 4}, + {0b10000111111111, 3}, {0b10001000000000, 3}, + {0b10001000000001, 5}, {0b10001000000010, 5}, + {0b10001000000011, 4}, {0b10001000000100, 5}, + {0b10001000000101, 4}, {0b10001000000110, 4}, + {0b10001000000111, 5}, {0b10001000001000, 5}, + {0b10001000001001, 4}, {0b10001000001010, 4}, + {0b10001000001011, 5}, {0b10001000001100, 4}, + {0b10001000001101, 5}, {0b10001000001110, 5}, + {0b10001000010000, 5}, {0b10001000010001, 2}, + {0b10001000010010, 4}, {0b10001000010100, 4}, + {0b10001000010110, 5}, {0b10001000011000, 4}, + {0b10001000011010, 5}, {0b10001000011100, 5}, + {0b10001000100000, 5}, {0b10001000100001, 4}, + {0b10001000100010, 2}, {0b10001000100100, 4}, + {0b10001000100101, 5}, {0b10001000101000, 4}, + {0b10001000101001, 5}, {0b10001000101100, 5}, + {0b10001000110000, 4}, {0b10001000110011, 3}, + {0b10001000110100, 5}, {0b10001000111000, 5}, + {0b10001001000000, 5}, {0b10001001000001, 4}, + {0b10001001000010, 4}, {0b10001001000011, 5}, + {0b10001001000100, 2}, {0b10001001001000, 4}, + {0b10001001001001, 5}, {0b10001001001010, 5}, + {0b10001001010000, 4}, {0b10001001010010, 5}, + {0b10001001010101, 3}, {0b10001001011000, 5}, + {0b10001001100000, 4}, {0b10001001100001, 5}, + {0b10001001100110, 3}, {0b10001001101000, 5}, + {0b10001001110000, 5}, {0b10001001110111, 4}, + {0b10001010000000, 5}, {0b10001010000001, 4}, + {0b10001010000010, 4}, {0b10001010000011, 5}, + {0b10001010000100, 4}, {0b10001010000101, 5}, + {0b10001010000110, 5}, {0b10001010001000, 2}, + {0b10001010010000, 4}, {0b10001010010010, 5}, + {0b10001010010100, 5}, {0b10001010011001, 3}, + {0b10001010100000, 4}, {0b10001010100001, 5}, + {0b10001010100100, 5}, {0b10001010101010, 3}, + {0b10001010110000, 5}, {0b10001010111011, 4}, + {0b10001011000000, 4}, {0b10001011000001, 5}, + {0b10001011000010, 5}, {0b10001011001100, 3}, + {0b10001011010000, 5}, {0b10001011011101, 4}, + {0b10001011100000, 5}, {0b10001011101110, 4}, + {0b10001011111111, 3}, {0b10001100000000, 5}, + {0b10001100000001, 4}, {0b10001100000010, 4}, + {0b10001100000100, 4}, {0b10001100000101, 5}, + {0b10001100000110, 5}, {0b10001100001000, 4}, + {0b10001100001001, 5}, {0b10001100001010, 5}, + {0b10001100010000, 4}, {0b10001100010011, 3}, + {0b10001100010100, 5}, {0b10001100011000, 5}, + {0b10001100100000, 4}, {0b10001100100011, 3}, + {0b10001100100100, 5}, {0b10001100101000, 5}, + {0b10001100110001, 3}, {0b10001100110010, 3}, + {0b10001101000000, 4}, {0b10001101000001, 5}, + {0b10001101000010, 5}, {0b10001101001100, 3}, + {0b10001101010000, 5}, {0b10001101100000, 5}, + {0b10001110000000, 4}, {0b10001110000001, 5}, + {0b10001110000010, 5}, {0b10001110001100, 3}, + {0b10001110010000, 5}, {0b10001110100000, 5}, + {0b10001111000100, 3}, {0b10001111001000, 3}, + {0b10010000000000, 3}, {0b10010000000001, 5}, + {0b10010000000010, 5}, {0b10010000000011, 4}, + {0b10010000000100, 5}, {0b10010000000101, 4}, + {0b10010000000110, 4}, {0b10010000000111, 5}, + {0b10010000001000, 5}, {0b10010000001001, 4}, + {0b10010000001010, 4}, {0b10010000001011, 5}, + {0b10010000001100, 4}, {0b10010000001101, 5}, + {0b10010000001110, 5}, {0b10010000010000, 5}, + {0b10010000010001, 4}, {0b10010000010010, 4}, + {0b10010000010011, 5}, {0b10010000010100, 4}, + {0b10010000010101, 5}, {0b10010000010110, 5}, + {0b10010000011000, 2}, {0b10010000100000, 5}, + {0b10010000100001, 4}, {0b10010000100010, 4}, + {0b10010000100011, 5}, {0b10010000100100, 2}, + {0b10010000101000, 4}, {0b10010000101001, 5}, + {0b10010000101010, 5}, {0b10010000110000, 4}, + {0b10010000110001, 5}, {0b10010000110010, 5}, + {0b10010000111100, 3}, {0b10010001000000, 5}, + {0b10010001000001, 4}, {0b10010001000010, 2}, + {0b10010001000100, 4}, {0b10010001000101, 5}, + {0b10010001001000, 4}, {0b10010001001001, 5}, + {0b10010001001100, 5}, {0b10010001010000, 4}, + {0b10010001010001, 5}, {0b10010001010100, 5}, + {0b10010001011010, 3}, {0b10010001100000, 4}, + {0b10010001100001, 5}, {0b10010001100110, 3}, + {0b10010001101000, 5}, {0b10010001110000, 5}, + {0b10010001111110, 4}, {0b10010010000000, 5}, + {0b10010010000001, 2}, {0b10010010000010, 4}, + {0b10010010000100, 4}, {0b10010010000110, 5}, + {0b10010010001000, 4}, {0b10010010001010, 5}, + {0b10010010001100, 5}, {0b10010010010000, 4}, + {0b10010010010010, 5}, {0b10010010010100, 5}, + {0b10010010011001, 3}, {0b10010010100000, 4}, + {0b10010010100010, 5}, {0b10010010100101, 3}, + {0b10010010101000, 5}, {0b10010010110000, 5}, + {0b10010010111101, 4}, {0b10010011000000, 4}, + {0b10010011000011, 3}, {0b10010011000100, 5}, + {0b10010011001000, 5}, {0b10010011010000, 5}, + {0b10010011011011, 4}, {0b10010011100000, 5}, + {0b10010011100111, 4}, {0b10010011111111, 3}, + {0b10010100000000, 5}, {0b10010100000001, 4}, + {0b10010100000010, 4}, {0b10010100000011, 5}, + {0b10010100000100, 4}, {0b10010100000110, 5}, + {0b10010100001000, 4}, {0b10010100001001, 5}, + {0b10010100001100, 5}, {0b10010100010000, 4}, + {0b10010100010001, 5}, {0b10010100010100, 5}, + {0b10010100011010, 3}, {0b10010100100000, 4}, + {0b10010100100010, 5}, {0b10010100100101, 3}, + {0b10010100101000, 5}, {0b10010100110000, 5}, + {0b10010101000000, 4}, {0b10010101000001, 5}, + {0b10010101000100, 5}, {0b10010101001010, 3}, + {0b10010101010010, 3}, {0b10010101011000, 3}, + {0b10010101100000, 5}, {0b10010110000000, 4}, + {0b10010110000010, 5}, {0b10010110000101, 3}, + {0b10010110001000, 5}, {0b10010110010000, 5}, + {0b10010110100001, 3}, {0b10010110100100, 3}, + {0b10010111000000, 5}, {0b10011000000000, 5}, + {0b10011000000001, 4}, {0b10011000000010, 4}, + {0b10011000000011, 5}, {0b10011000000100, 4}, + {0b10011000000101, 5}, {0b10011000001000, 4}, + {0b10011000001010, 5}, {0b10011000001100, 5}, + {0b10011000010000, 4}, {0b10011000010010, 5}, + {0b10011000010100, 5}, {0b10011000011001, 3}, + {0b10011000100000, 4}, {0b10011000100001, 5}, + {0b10011000100110, 3}, {0b10011000101000, 5}, + {0b10011000110000, 5}, {0b10011001000000, 4}, + {0b10011001000001, 5}, {0b10011001000110, 3}, + {0b10011001001000, 5}, {0b10011001010000, 5}, + {0b10011001100010, 3}, {0b10011001100100, 3}, + {0b10011010000000, 4}, {0b10011010000010, 5}, + {0b10011010000100, 5}, {0b10011010001001, 3}, + {0b10011010010001, 3}, {0b10011010011000, 3}, + {0b10011010100000, 5}, {0b10011011000000, 5}, + {0b10011100000000, 4}, {0b10011100000001, 5}, + {0b10011100000010, 5}, {0b10011100000100, 5}, + {0b10011100001000, 5}, {0b10011100010000, 5}, + {0b10011100011011, 4}, {0b10011100100000, 5}, + {0b10011100100111, 4}, {0b10011101000000, 5}, + {0b10011101001110, 4}, {0b10011101110010, 4}, + {0b10011101111111, 5}, {0b10011110000000, 5}, + {0b10011110001101, 4}, {0b10011110110001, 4}, + {0b10011110111111, 5}, {0b10011111011000, 4}, + {0b10011111011111, 5}, {0b10011111100100, 4}, + {0b10011111101111, 5}, {0b10011111110111, 5}, + {0b10011111111011, 5}, {0b10011111111101, 5}, + {0b10011111111110, 5}, {0b10011111111111, 4}, + {0b10100000000000, 3}, {0b10100000000001, 5}, + {0b10100000000010, 5}, {0b10100000000011, 4}, + {0b10100000000100, 5}, {0b10100000000101, 4}, + {0b10100000000110, 4}, {0b10100000000111, 5}, + {0b10100000001000, 5}, {0b10100000001001, 4}, + {0b10100000001010, 4}, {0b10100000001011, 5}, + {0b10100000001100, 4}, {0b10100000001101, 5}, + {0b10100000001110, 5}, {0b10100000010000, 5}, + {0b10100000010001, 4}, {0b10100000010010, 4}, + {0b10100000010011, 5}, {0b10100000010100, 2}, + {0b10100000011000, 4}, {0b10100000011001, 5}, + {0b10100000011010, 5}, {0b10100000100000, 5}, + {0b10100000100001, 4}, {0b10100000100010, 4}, + {0b10100000100011, 5}, {0b10100000100100, 4}, + {0b10100000100101, 5}, {0b10100000100110, 5}, + {0b10100000101000, 2}, {0b10100000110000, 4}, + {0b10100000110001, 5}, {0b10100000110010, 5}, + {0b10100000111100, 3}, {0b10100001000000, 5}, + {0b10100001000001, 2}, {0b10100001000010, 4}, + {0b10100001000100, 4}, {0b10100001000110, 5}, + {0b10100001001000, 4}, {0b10100001001010, 5}, + {0b10100001001100, 5}, {0b10100001010000, 4}, + {0b10100001010010, 5}, {0b10100001010101, 3}, + {0b10100001011000, 5}, {0b10100001100000, 4}, + {0b10100001100010, 5}, {0b10100001100100, 5}, + {0b10100001101001, 3}, {0b10100001110000, 5}, + {0b10100001111101, 4}, {0b10100010000000, 5}, + {0b10100010000001, 4}, {0b10100010000010, 2}, + {0b10100010000100, 4}, {0b10100010000101, 5}, + {0b10100010001000, 4}, {0b10100010001001, 5}, + {0b10100010001100, 5}, {0b10100010010000, 4}, + {0b10100010010001, 5}, {0b10100010010110, 3}, + {0b10100010011000, 5}, {0b10100010100000, 4}, + {0b10100010100001, 5}, {0b10100010100100, 5}, + {0b10100010101010, 3}, {0b10100010110000, 5}, + {0b10100010111110, 4}, {0b10100011000000, 4}, + {0b10100011000011, 3}, {0b10100011000100, 5}, + {0b10100011001000, 5}, {0b10100011010000, 5}, + {0b10100011010111, 4}, {0b10100011100000, 5}, + {0b10100011101011, 4}, {0b10100011111111, 3}, + {0b10100100000000, 5}, {0b10100100000001, 4}, + {0b10100100000010, 4}, {0b10100100000011, 5}, + {0b10100100000100, 4}, {0b10100100000101, 5}, + {0b10100100001000, 4}, {0b10100100001010, 5}, + {0b10100100001100, 5}, {0b10100100010000, 4}, + {0b10100100010001, 5}, {0b10100100010110, 3}, + {0b10100100011000, 5}, {0b10100100100000, 4}, + {0b10100100100010, 5}, {0b10100100100100, 5}, + {0b10100100101001, 3}, {0b10100100110000, 5}, + {0b10100101000000, 4}, {0b10100101000010, 5}, + {0b10100101000100, 5}, {0b10100101001001, 3}, + {0b10100101010000, 5}, {0b10100101100001, 3}, + {0b10100101101000, 3}, {0b10100110000000, 4}, + {0b10100110000001, 5}, {0b10100110000110, 3}, + {0b10100110001000, 5}, {0b10100110010010, 3}, + {0b10100110010100, 3}, {0b10100110100000, 5}, + {0b10100111000000, 5}, {0b10101000000000, 5}, + {0b10101000000001, 4}, {0b10101000000010, 4}, + {0b10101000000011, 5}, {0b10101000000100, 4}, + {0b10101000000110, 5}, {0b10101000001000, 4}, + {0b10101000001001, 5}, {0b10101000001100, 5}, + {0b10101000010000, 4}, {0b10101000010010, 5}, + {0b10101000010101, 3}, {0b10101000011000, 5}, + {0b10101000100000, 4}, {0b10101000100001, 5}, + {0b10101000100100, 5}, {0b10101000101010, 3}, + {0b10101000110000, 5}, {0b10101001000000, 4}, + {0b10101001000010, 5}, {0b10101001000101, 3}, + {0b10101001001000, 5}, {0b10101001010001, 3}, + {0b10101001010100, 3}, {0b10101001100000, 5}, + {0b10101010000000, 4}, {0b10101010000001, 5}, + {0b10101010000100, 5}, {0b10101010001010, 3}, + {0b10101010010000, 5}, {0b10101010100010, 3}, + {0b10101010101000, 3}, {0b10101011000000, 5}, + {0b10101100000000, 4}, {0b10101100000001, 5}, + {0b10101100000010, 5}, {0b10101100000100, 5}, + {0b10101100001000, 5}, {0b10101100010000, 5}, + {0b10101100010111, 4}, {0b10101100100000, 5}, + {0b10101100101011, 4}, {0b10101101000000, 5}, + {0b10101101001101, 4}, {0b10101101110001, 4}, + {0b10101101111111, 5}, {0b10101110000000, 5}, + {0b10101110001110, 4}, {0b10101110110010, 4}, + {0b10101110111111, 5}, {0b10101111010100, 4}, + {0b10101111011111, 5}, {0b10101111101000, 4}, + {0b10101111101111, 5}, {0b10101111110111, 5}, + {0b10101111111011, 5}, {0b10101111111101, 5}, + {0b10101111111110, 5}, {0b10101111111111, 4}, + {0b10110000000000, 5}, {0b10110000000001, 4}, + {0b10110000000010, 4}, {0b10110000000100, 4}, + {0b10110000000101, 5}, {0b10110000000110, 5}, + {0b10110000001000, 4}, {0b10110000001001, 5}, + {0b10110000001010, 5}, {0b10110000010000, 4}, + {0b10110000010001, 5}, {0b10110000010010, 5}, + {0b10110000011100, 3}, {0b10110000100000, 4}, + {0b10110000100001, 5}, {0b10110000100010, 5}, + {0b10110000101100, 3}, {0b10110000110100, 3}, + {0b10110000111000, 3}, {0b10110001000000, 4}, + {0b10110001000011, 3}, {0b10110001000100, 5}, + {0b10110001001000, 5}, {0b10110001010000, 5}, + {0b10110001100000, 5}, {0b10110010000000, 4}, + {0b10110010000011, 3}, {0b10110010000100, 5}, + {0b10110010001000, 5}, {0b10110010010000, 5}, + {0b10110010100000, 5}, {0b10110011000001, 3}, + {0b10110011000010, 3}, {0b10110100000000, 4}, + {0b10110100000001, 5}, {0b10110100000010, 5}, + {0b10110100000100, 5}, {0b10110100001000, 5}, + {0b10110100010000, 5}, {0b10110100011110, 4}, + {0b10110100100000, 5}, {0b10110100101101, 4}, + {0b10110101000000, 5}, {0b10110101001011, 4}, + {0b10110101111000, 4}, {0b10110101111111, 5}, + {0b10110110000000, 5}, {0b10110110000111, 4}, + {0b10110110110100, 4}, {0b10110110111111, 5}, + {0b10110111010010, 4}, {0b10110111011111, 5}, + {0b10110111100001, 4}, {0b10110111101111, 5}, + {0b10110111110111, 5}, {0b10110111111011, 5}, + {0b10110111111101, 5}, {0b10110111111110, 5}, + {0b10110111111111, 4}, {0b10111000000000, 4}, + {0b10111000000001, 5}, {0b10111000000010, 5}, + {0b10111000000100, 5}, {0b10111000001000, 5}, + {0b10111000010000, 5}, {0b10111000011101, 4}, + {0b10111000100000, 5}, {0b10111000101110, 4}, + {0b10111001000000, 5}, {0b10111001000111, 4}, + {0b10111001110100, 4}, {0b10111001111111, 5}, + {0b10111010000000, 5}, {0b10111010001011, 4}, + {0b10111010111000, 4}, {0b10111010111111, 5}, + {0b10111011010001, 4}, {0b10111011011111, 5}, + {0b10111011100010, 4}, {0b10111011101111, 5}, + {0b10111011110111, 5}, {0b10111011111011, 5}, + {0b10111011111101, 5}, {0b10111011111110, 5}, + {0b10111011111111, 4}, {0b10111100011111, 3}, + {0b10111100101111, 3}, {0b10111101001111, 3}, + {0b10111101110111, 5}, {0b10111101111011, 5}, + {0b10111101111101, 5}, {0b10111101111110, 5}, + {0b10111101111111, 4}, {0b10111110001111, 3}, + {0b10111110110111, 5}, {0b10111110111011, 5}, + {0b10111110111101, 5}, {0b10111110111110, 5}, + {0b10111110111111, 4}, {0b10111111010111, 5}, + {0b10111111011011, 5}, {0b10111111011101, 5}, + {0b10111111011110, 5}, {0b10111111011111, 4}, + {0b10111111100111, 5}, {0b10111111101011, 5}, + {0b10111111101101, 5}, {0b10111111101110, 5}, + {0b10111111101111, 4}, {0b10111111110001, 3}, + {0b10111111110010, 3}, {0b10111111110100, 3}, + {0b10111111110111, 4}, {0b10111111111000, 3}, + {0b10111111111011, 4}, {0b10111111111101, 4}, + {0b10111111111110, 4}, {0b10111111111111, 5}, + {0b11000000000000, 3}, {0b11000000000001, 5}, + {0b11000000000010, 5}, {0b11000000000011, 2}, + {0b11000000000100, 5}, {0b11000000000101, 4}, + {0b11000000000110, 4}, {0b11000000001000, 5}, + {0b11000000001001, 4}, {0b11000000001010, 4}, + {0b11000000001100, 2}, {0b11000000001111, 3}, + {0b11000000010000, 5}, {0b11000000010001, 4}, + {0b11000000010010, 4}, {0b11000000010100, 4}, + {0b11000000010101, 5}, {0b11000000010110, 5}, + {0b11000000011000, 4}, {0b11000000011001, 5}, + {0b11000000011010, 5}, {0b11000000100000, 5}, + {0b11000000100001, 4}, {0b11000000100010, 4}, + {0b11000000100100, 4}, {0b11000000100101, 5}, + {0b11000000100110, 5}, {0b11000000101000, 4}, + {0b11000000101001, 5}, {0b11000000101010, 5}, + {0b11000000110000, 2}, {0b11000000110011, 3}, + {0b11000000111100, 3}, {0b11000000111111, 4}, + {0b11000001000000, 5}, {0b11000001000001, 4}, + {0b11000001000010, 4}, {0b11000001000100, 4}, + {0b11000001000101, 5}, {0b11000001000110, 5}, + {0b11000001001000, 4}, {0b11000001001001, 5}, + {0b11000001001010, 5}, {0b11000001010000, 4}, + {0b11000001010001, 5}, {0b11000001010010, 5}, + {0b11000001010100, 5}, {0b11000001011000, 5}, + {0b11000001100000, 4}, {0b11000001100001, 5}, + {0b11000001100010, 5}, {0b11000001100100, 5}, + {0b11000001101000, 5}, {0b11000010000000, 5}, + {0b11000010000001, 4}, {0b11000010000010, 4}, + {0b11000010000100, 4}, {0b11000010000101, 5}, + {0b11000010000110, 5}, {0b11000010001000, 4}, + {0b11000010001001, 5}, {0b11000010001010, 5}, + {0b11000010010000, 4}, {0b11000010010001, 5}, + {0b11000010010010, 5}, {0b11000010010100, 5}, + {0b11000010011000, 5}, {0b11000010100000, 4}, + {0b11000010100001, 5}, {0b11000010100010, 5}, + {0b11000010100100, 5}, {0b11000010101000, 5}, + {0b11000011000000, 2}, {0b11000011000011, 3}, + {0b11000011001100, 3}, {0b11000011001111, 4}, + {0b11000011110000, 3}, {0b11000011110011, 4}, + {0b11000011111100, 4}, {0b11000011111111, 3}, + {0b11000100000000, 5}, {0b11000100000001, 4}, + {0b11000100000010, 4}, {0b11000100000100, 4}, + {0b11000100000101, 5}, {0b11000100000110, 5}, + {0b11000100001000, 4}, {0b11000100001001, 5}, + {0b11000100001010, 5}, {0b11000100010000, 4}, + {0b11000100010011, 3}, {0b11000100010100, 5}, + {0b11000100011000, 5}, {0b11000100100000, 4}, + {0b11000100100011, 3}, {0b11000100100100, 5}, + {0b11000100101000, 5}, {0b11000100110001, 3}, + {0b11000100110010, 3}, {0b11000101000000, 4}, + {0b11000101000001, 5}, {0b11000101000010, 5}, + {0b11000101001100, 3}, {0b11000101010000, 5}, + {0b11000101100000, 5}, {0b11000110000000, 4}, + {0b11000110000001, 5}, {0b11000110000010, 5}, + {0b11000110001100, 3}, {0b11000110010000, 5}, + {0b11000110100000, 5}, {0b11000111000100, 3}, + {0b11000111001000, 3}, {0b11001000000000, 5}, + {0b11001000000001, 4}, {0b11001000000010, 4}, + {0b11001000000100, 4}, {0b11001000000101, 5}, + {0b11001000000110, 5}, {0b11001000001000, 4}, + {0b11001000001001, 5}, {0b11001000001010, 5}, + {0b11001000010000, 4}, {0b11001000010011, 3}, + {0b11001000010100, 5}, {0b11001000011000, 5}, + {0b11001000100000, 4}, {0b11001000100011, 3}, + {0b11001000100100, 5}, {0b11001000101000, 5}, + {0b11001000110001, 3}, {0b11001000110010, 3}, + {0b11001001000000, 4}, {0b11001001000001, 5}, + {0b11001001000010, 5}, {0b11001001001100, 3}, + {0b11001001010000, 5}, {0b11001001100000, 5}, + {0b11001010000000, 4}, {0b11001010000001, 5}, + {0b11001010000010, 5}, {0b11001010001100, 3}, + {0b11001010010000, 5}, {0b11001010100000, 5}, + {0b11001011000100, 3}, {0b11001011001000, 3}, + {0b11001100000000, 2}, {0b11001100000011, 3}, + {0b11001100001100, 3}, {0b11001100001111, 4}, + {0b11001100010001, 3}, {0b11001100010010, 3}, + {0b11001100100001, 3}, {0b11001100100010, 3}, + {0b11001100110000, 3}, {0b11001100110011, 1}, + {0b11001100111100, 4}, {0b11001100111111, 3}, + {0b11001101000100, 3}, {0b11001101001000, 3}, + {0b11001101010101, 4}, {0b11001101011010, 4}, + {0b11001101100110, 4}, {0b11001101101001, 4}, + {0b11001101110111, 3}, {0b11001101111011, 3}, + {0b11001110000100, 3}, {0b11001110001000, 3}, + {0b11001110010110, 4}, {0b11001110011001, 4}, + {0b11001110100101, 4}, {0b11001110101010, 4}, + {0b11001110110111, 3}, {0b11001110111011, 3}, + {0b11001111000000, 3}, {0b11001111000011, 4}, + {0b11001111001100, 1}, {0b11001111001111, 3}, + {0b11001111011101, 3}, {0b11001111011110, 3}, + {0b11001111101101, 3}, {0b11001111101110, 3}, + {0b11001111110000, 4}, {0b11001111110011, 3}, + {0b11001111111100, 3}, {0b11001111111111, 2}, + {0b11010000000000, 5}, {0b11010000000001, 4}, + {0b11010000000010, 4}, {0b11010000000100, 4}, + {0b11010000000101, 5}, {0b11010000000110, 5}, + {0b11010000001000, 4}, {0b11010000001001, 5}, + {0b11010000001010, 5}, {0b11010000010000, 4}, + {0b11010000010001, 5}, {0b11010000010010, 5}, + {0b11010000011100, 3}, {0b11010000100000, 4}, + {0b11010000100001, 5}, {0b11010000100010, 5}, + {0b11010000101100, 3}, {0b11010000110100, 3}, + {0b11010000111000, 3}, {0b11010001000000, 4}, + {0b11010001000011, 3}, {0b11010001000100, 5}, + {0b11010001001000, 5}, {0b11010001010000, 5}, + {0b11010001100000, 5}, {0b11010010000000, 4}, + {0b11010010000011, 3}, {0b11010010000100, 5}, + {0b11010010001000, 5}, {0b11010010010000, 5}, + {0b11010010100000, 5}, {0b11010011000001, 3}, + {0b11010011000010, 3}, {0b11010100000000, 4}, + {0b11010100000001, 5}, {0b11010100000010, 5}, + {0b11010100000100, 5}, {0b11010100001000, 5}, + {0b11010100010000, 5}, {0b11010100100000, 5}, + {0b11010100110101, 4}, {0b11010100111010, 4}, + {0b11010101000000, 5}, {0b11010101010011, 4}, + {0b11010101011100, 4}, {0b11010101111111, 5}, + {0b11010110000000, 5}, {0b11010110100011, 4}, + {0b11010110101100, 4}, {0b11010110111111, 5}, + {0b11010111000101, 4}, {0b11010111001010, 4}, + {0b11010111011111, 5}, {0b11010111101111, 5}, + {0b11010111110111, 5}, {0b11010111111011, 5}, + {0b11010111111101, 5}, {0b11010111111110, 5}, + {0b11010111111111, 4}, {0b11011000000000, 4}, + {0b11011000000001, 5}, {0b11011000000010, 5}, + {0b11011000000100, 5}, {0b11011000001000, 5}, + {0b11011000010000, 5}, {0b11011000100000, 5}, + {0b11011000110110, 4}, {0b11011000111001, 4}, + {0b11011001000000, 5}, {0b11011001100011, 4}, + {0b11011001101100, 4}, {0b11011001111111, 5}, + {0b11011010000000, 5}, {0b11011010010011, 4}, + {0b11011010011100, 4}, {0b11011010111111, 5}, + {0b11011011000110, 4}, {0b11011011001001, 4}, + {0b11011011011111, 5}, {0b11011011101111, 5}, + {0b11011011110111, 5}, {0b11011011111011, 5}, + {0b11011011111101, 5}, {0b11011011111110, 5}, + {0b11011011111111, 4}, {0b11011100110111, 3}, + {0b11011100111011, 3}, {0b11011101011111, 5}, + {0b11011101101111, 5}, {0b11011101110011, 3}, + {0b11011101111101, 5}, {0b11011101111110, 5}, + {0b11011101111111, 4}, {0b11011110011111, 5}, + {0b11011110101111, 5}, {0b11011110110011, 3}, + {0b11011110111101, 5}, {0b11011110111110, 5}, + {0b11011110111111, 4}, {0b11011111001101, 3}, + {0b11011111001110, 3}, {0b11011111010111, 5}, + {0b11011111011011, 5}, {0b11011111011100, 3}, + {0b11011111011111, 4}, {0b11011111100111, 5}, + {0b11011111101011, 5}, {0b11011111101100, 3}, + {0b11011111101111, 4}, {0b11011111110101, 5}, + {0b11011111110110, 5}, {0b11011111110111, 4}, + {0b11011111111001, 5}, {0b11011111111010, 5}, + {0b11011111111011, 4}, {0b11011111111101, 4}, + {0b11011111111110, 4}, {0b11011111111111, 5}, + {0b11100000000000, 5}, {0b11100000000001, 4}, + {0b11100000000010, 4}, {0b11100000000100, 4}, + {0b11100000000101, 5}, {0b11100000000110, 5}, + {0b11100000001000, 4}, {0b11100000001001, 5}, + {0b11100000001010, 5}, {0b11100000010000, 4}, + {0b11100000010001, 5}, {0b11100000010010, 5}, + {0b11100000011100, 3}, {0b11100000100000, 4}, + {0b11100000100001, 5}, {0b11100000100010, 5}, + {0b11100000101100, 3}, {0b11100000110100, 3}, + {0b11100000111000, 3}, {0b11100001000000, 4}, + {0b11100001000011, 3}, {0b11100001000100, 5}, + {0b11100001001000, 5}, {0b11100001010000, 5}, + {0b11100001100000, 5}, {0b11100010000000, 4}, + {0b11100010000011, 3}, {0b11100010000100, 5}, + {0b11100010001000, 5}, {0b11100010010000, 5}, + {0b11100010100000, 5}, {0b11100011000001, 3}, + {0b11100011000010, 3}, {0b11100100000000, 4}, + {0b11100100000001, 5}, {0b11100100000010, 5}, + {0b11100100000100, 5}, {0b11100100001000, 5}, + {0b11100100010000, 5}, {0b11100100100000, 5}, + {0b11100100110110, 4}, {0b11100100111001, 4}, + {0b11100101000000, 5}, {0b11100101100011, 4}, + {0b11100101101100, 4}, {0b11100101111111, 5}, + {0b11100110000000, 5}, {0b11100110010011, 4}, + {0b11100110011100, 4}, {0b11100110111111, 5}, + {0b11100111000110, 4}, {0b11100111001001, 4}, + {0b11100111011111, 5}, {0b11100111101111, 5}, + {0b11100111110111, 5}, {0b11100111111011, 5}, + {0b11100111111101, 5}, {0b11100111111110, 5}, + {0b11100111111111, 4}, {0b11101000000000, 4}, + {0b11101000000001, 5}, {0b11101000000010, 5}, + {0b11101000000100, 5}, {0b11101000001000, 5}, + {0b11101000010000, 5}, {0b11101000100000, 5}, + {0b11101000110101, 4}, {0b11101000111010, 4}, + {0b11101001000000, 5}, {0b11101001010011, 4}, + {0b11101001011100, 4}, {0b11101001111111, 5}, + {0b11101010000000, 5}, {0b11101010100011, 4}, + {0b11101010101100, 4}, {0b11101010111111, 5}, + {0b11101011000101, 4}, {0b11101011001010, 4}, + {0b11101011011111, 5}, {0b11101011101111, 5}, + {0b11101011110111, 5}, {0b11101011111011, 5}, + {0b11101011111101, 5}, {0b11101011111110, 5}, + {0b11101011111111, 4}, {0b11101100110111, 3}, + {0b11101100111011, 3}, {0b11101101011111, 5}, + {0b11101101101111, 5}, {0b11101101110011, 3}, + {0b11101101111101, 5}, {0b11101101111110, 5}, + {0b11101101111111, 4}, {0b11101110011111, 5}, + {0b11101110101111, 5}, {0b11101110110011, 3}, + {0b11101110111101, 5}, {0b11101110111110, 5}, + {0b11101110111111, 4}, {0b11101111001101, 3}, + {0b11101111001110, 3}, {0b11101111010111, 5}, + {0b11101111011011, 5}, {0b11101111011100, 3}, + {0b11101111011111, 4}, {0b11101111100111, 5}, + {0b11101111101011, 5}, {0b11101111101100, 3}, + {0b11101111101111, 4}, {0b11101111110101, 5}, + {0b11101111110110, 5}, {0b11101111110111, 4}, + {0b11101111111001, 5}, {0b11101111111010, 5}, + {0b11101111111011, 4}, {0b11101111111101, 4}, + {0b11101111111110, 4}, {0b11101111111111, 5}, + {0b11110000000000, 2}, {0b11110000000011, 3}, + {0b11110000001100, 3}, {0b11110000001111, 4}, + {0b11110000010100, 3}, {0b11110000011000, 3}, + {0b11110000100100, 3}, {0b11110000101000, 3}, + {0b11110000110000, 3}, {0b11110000110011, 4}, + {0b11110000111100, 1}, {0b11110000111111, 3}, + {0b11110001000001, 3}, {0b11110001000010, 3}, + {0b11110001010101, 4}, {0b11110001011010, 4}, + {0b11110001100110, 4}, {0b11110001101001, 4}, + {0b11110001111101, 3}, {0b11110001111110, 3}, + {0b11110010000001, 3}, {0b11110010000010, 3}, + {0b11110010010110, 4}, {0b11110010011001, 4}, + {0b11110010100101, 4}, {0b11110010101010, 4}, + {0b11110010111101, 3}, {0b11110010111110, 3}, + {0b11110011000000, 3}, {0b11110011000011, 1}, + {0b11110011001100, 4}, {0b11110011001111, 3}, + {0b11110011010111, 3}, {0b11110011011011, 3}, + {0b11110011100111, 3}, {0b11110011101011, 3}, + {0b11110011110000, 4}, {0b11110011110011, 3}, + {0b11110011111100, 3}, {0b11110011111111, 2}, + {0b11110100111101, 3}, {0b11110100111110, 3}, + {0b11110101011111, 5}, {0b11110101101111, 5}, + {0b11110101110111, 5}, {0b11110101111011, 5}, + {0b11110101111100, 3}, {0b11110101111111, 4}, + {0b11110110011111, 5}, {0b11110110101111, 5}, + {0b11110110110111, 5}, {0b11110110111011, 5}, + {0b11110110111100, 3}, {0b11110110111111, 4}, + {0b11110111000111, 3}, {0b11110111001011, 3}, + {0b11110111010011, 3}, {0b11110111011101, 5}, + {0b11110111011110, 5}, {0b11110111011111, 4}, + {0b11110111100011, 3}, {0b11110111101101, 5}, + {0b11110111101110, 5}, {0b11110111101111, 4}, + {0b11110111110101, 5}, {0b11110111110110, 5}, + {0b11110111110111, 4}, {0b11110111111001, 5}, + {0b11110111111010, 5}, {0b11110111111011, 4}, + {0b11110111111101, 4}, {0b11110111111110, 4}, + {0b11110111111111, 5}, {0b11111000111101, 3}, + {0b11111000111110, 3}, {0b11111001011111, 5}, + {0b11111001101111, 5}, {0b11111001110111, 5}, + {0b11111001111011, 5}, {0b11111001111100, 3}, + {0b11111001111111, 4}, {0b11111010011111, 5}, + {0b11111010101111, 5}, {0b11111010110111, 5}, + {0b11111010111011, 5}, {0b11111010111100, 3}, + {0b11111010111111, 4}, {0b11111011000111, 3}, + {0b11111011001011, 3}, {0b11111011010011, 3}, + {0b11111011011101, 5}, {0b11111011011110, 5}, + {0b11111011011111, 4}, {0b11111011100011, 3}, + {0b11111011101101, 5}, {0b11111011101110, 5}, + {0b11111011101111, 4}, {0b11111011110101, 5}, + {0b11111011110110, 5}, {0b11111011110111, 4}, + {0b11111011111001, 5}, {0b11111011111010, 5}, + {0b11111011111011, 4}, {0b11111011111101, 4}, + {0b11111011111110, 4}, {0b11111011111111, 5}, + {0b11111100000000, 3}, {0b11111100000011, 4}, + {0b11111100001100, 4}, {0b11111100001111, 3}, + {0b11111100110000, 4}, {0b11111100110011, 3}, + {0b11111100111100, 3}, {0b11111100111111, 2}, + {0b11111101010111, 5}, {0b11111101011011, 5}, + {0b11111101011101, 5}, {0b11111101011110, 5}, + {0b11111101011111, 4}, {0b11111101100111, 5}, + {0b11111101101011, 5}, {0b11111101101101, 5}, + {0b11111101101110, 5}, {0b11111101101111, 4}, + {0b11111101110101, 5}, {0b11111101110110, 5}, + {0b11111101110111, 4}, {0b11111101111001, 5}, + {0b11111101111010, 5}, {0b11111101111011, 4}, + {0b11111101111101, 4}, {0b11111101111110, 4}, + {0b11111101111111, 5}, {0b11111110010111, 5}, + {0b11111110011011, 5}, {0b11111110011101, 5}, + {0b11111110011110, 5}, {0b11111110011111, 4}, + {0b11111110100111, 5}, {0b11111110101011, 5}, + {0b11111110101101, 5}, {0b11111110101110, 5}, + {0b11111110101111, 4}, {0b11111110110101, 5}, + {0b11111110110110, 5}, {0b11111110110111, 4}, + {0b11111110111001, 5}, {0b11111110111010, 5}, + {0b11111110111011, 4}, {0b11111110111101, 4}, + {0b11111110111110, 4}, {0b11111110111111, 5}, + {0b11111111000000, 4}, {0b11111111000011, 3}, + {0b11111111001100, 3}, {0b11111111001111, 2}, + {0b11111111010101, 5}, {0b11111111010110, 5}, + {0b11111111010111, 4}, {0b11111111011001, 5}, + {0b11111111011010, 5}, {0b11111111011011, 4}, + {0b11111111011101, 4}, {0b11111111011110, 4}, + {0b11111111011111, 5}, {0b11111111100101, 5}, + {0b11111111100110, 5}, {0b11111111100111, 4}, + {0b11111111101001, 5}, {0b11111111101010, 5}, + {0b11111111101011, 4}, {0b11111111101101, 4}, + {0b11111111101110, 4}, {0b11111111101111, 5}, + {0b11111111110000, 3}, {0b11111111110011, 2}, + {0b11111111110101, 4}, {0b11111111110110, 4}, + {0b11111111110111, 5}, {0b11111111111001, 4}, + {0b11111111111010, 4}, {0b11111111111011, 5}, + {0b11111111111100, 2}, {0b11111111111101, 5}, + {0b11111111111110, 5}, {0b11111111111111, 3}, + {0b100000000000000, 4}, {0b100000000000001, 3}, + {0b100000000000010, 3}, {0b100000000000011, 5}, + {0b100000000000100, 3}, {0b100000000000101, 5}, + {0b100000000000110, 5}, {0b100000000000111, 4}, + {0b100000000001000, 3}, {0b100000000001001, 5}, + {0b100000000001010, 5}, {0b100000000001011, 4}, + {0b100000000001100, 5}, {0b100000000001101, 4}, + {0b100000000001110, 4}, {0b100000000010000, 3}, + {0b100000000010001, 5}, {0b100000000010010, 5}, + {0b100000000010011, 4}, {0b100000000010100, 5}, + {0b100000000010101, 4}, {0b100000000010110, 4}, + {0b100000000010111, 5}, {0b100000000011000, 5}, + {0b100000000011001, 4}, {0b100000000011010, 4}, + {0b100000000011011, 5}, {0b100000000011100, 4}, + {0b100000000011101, 5}, {0b100000000011110, 5}, + {0b100000000100000, 3}, {0b100000000100001, 5}, + {0b100000000100010, 5}, {0b100000000100011, 4}, + {0b100000000100100, 5}, {0b100000000100101, 4}, + {0b100000000100110, 4}, {0b100000000100111, 5}, + {0b100000000101000, 5}, {0b100000000101001, 4}, + {0b100000000101010, 4}, {0b100000000101011, 5}, + {0b100000000101100, 4}, {0b100000000101101, 5}, + {0b100000000101110, 5}, {0b100000000110000, 5}, + {0b100000000110001, 4}, {0b100000000110010, 4}, + {0b100000000110100, 4}, {0b100000000110101, 5}, + {0b100000000110110, 5}, {0b100000000111000, 4}, + {0b100000000111001, 5}, {0b100000000111010, 5}, + {0b100000001000000, 3}, {0b100000001000001, 5}, + {0b100000001000010, 5}, {0b100000001000011, 4}, + {0b100000001000100, 5}, {0b100000001000101, 4}, + {0b100000001000110, 4}, {0b100000001000111, 5}, + {0b100000001001000, 5}, {0b100000001001001, 4}, + {0b100000001001010, 4}, {0b100000001001011, 5}, + {0b100000001001100, 4}, {0b100000001001101, 5}, + {0b100000001001110, 5}, {0b100000001010000, 5}, + {0b100000001010001, 4}, {0b100000001010010, 4}, + {0b100000001010011, 5}, {0b100000001010100, 4}, + {0b100000001010110, 5}, {0b100000001011000, 4}, + {0b100000001011001, 5}, {0b100000001011100, 5}, + {0b100000001100000, 5}, {0b100000001100001, 4}, + {0b100000001100010, 4}, {0b100000001100011, 5}, + {0b100000001100100, 4}, {0b100000001100101, 5}, + {0b100000001101000, 4}, {0b100000001101010, 5}, + {0b100000001101100, 5}, {0b100000001110000, 4}, + {0b100000001110001, 5}, {0b100000001110010, 5}, + {0b100000001110100, 5}, {0b100000001111000, 5}, + {0b100000010000000, 3}, {0b100000010000001, 5}, + {0b100000010000010, 5}, {0b100000010000011, 4}, + {0b100000010000100, 5}, {0b100000010000101, 4}, + {0b100000010000110, 4}, {0b100000010000111, 5}, + {0b100000010001000, 5}, {0b100000010001001, 4}, + {0b100000010001010, 4}, {0b100000010001011, 5}, + {0b100000010001100, 4}, {0b100000010001101, 5}, + {0b100000010001110, 5}, {0b100000010010000, 5}, + {0b100000010010001, 4}, {0b100000010010010, 4}, + {0b100000010010011, 5}, {0b100000010010100, 4}, + {0b100000010010101, 5}, {0b100000010011000, 4}, + {0b100000010011010, 5}, {0b100000010011100, 5}, + {0b100000010100000, 5}, {0b100000010100001, 4}, + {0b100000010100010, 4}, {0b100000010100011, 5}, + {0b100000010100100, 4}, {0b100000010100110, 5}, + {0b100000010101000, 4}, {0b100000010101001, 5}, + {0b100000010101100, 5}, {0b100000010110000, 4}, + {0b100000010110001, 5}, {0b100000010110010, 5}, + {0b100000010110100, 5}, {0b100000010111000, 5}, + {0b100000011000000, 5}, {0b100000011000001, 4}, + {0b100000011000010, 4}, {0b100000011000100, 4}, + {0b100000011000101, 5}, {0b100000011000110, 5}, + {0b100000011001000, 4}, {0b100000011001001, 5}, + {0b100000011001010, 5}, {0b100000011010000, 4}, + {0b100000011010001, 5}, {0b100000011010010, 5}, + {0b100000011010100, 5}, {0b100000011011000, 5}, + {0b100000011100000, 4}, {0b100000011100001, 5}, + {0b100000011100010, 5}, {0b100000011100100, 5}, + {0b100000011101000, 5}, {0b100000100000000, 3}, + {0b100000100000001, 5}, {0b100000100000010, 5}, + {0b100000100000011, 4}, {0b100000100000100, 5}, + {0b100000100000101, 4}, {0b100000100000110, 4}, + {0b100000100000111, 5}, {0b100000100001000, 5}, + {0b100000100001001, 4}, {0b100000100001010, 4}, + {0b100000100001011, 5}, {0b100000100001100, 4}, + {0b100000100001101, 5}, {0b100000100001110, 5}, + {0b100000100010000, 5}, {0b100000100010001, 4}, + {0b100000100010010, 4}, {0b100000100010011, 5}, + {0b100000100010100, 2}, {0b100000100011000, 4}, + {0b100000100011001, 5}, {0b100000100011010, 5}, + {0b100000100100000, 5}, {0b100000100100001, 4}, + {0b100000100100010, 4}, {0b100000100100011, 5}, + {0b100000100100100, 4}, {0b100000100100101, 5}, + {0b100000100100110, 5}, {0b100000100101000, 2}, + {0b100000100110000, 4}, {0b100000100110001, 5}, + {0b100000100110010, 5}, {0b100000100111100, 3}, + {0b100000101000000, 5}, {0b100000101000001, 2}, + {0b100000101000010, 4}, {0b100000101000100, 4}, + {0b100000101000110, 5}, {0b100000101001000, 4}, + {0b100000101001010, 5}, {0b100000101001100, 5}, + {0b100000101010000, 4}, {0b100000101010010, 5}, + {0b100000101010101, 3}, {0b100000101011000, 5}, + {0b100000101100000, 4}, {0b100000101100010, 5}, + {0b100000101100100, 5}, {0b100000101101001, 3}, + {0b100000101110000, 5}, {0b100000101111101, 4}, + {0b100000110000000, 5}, {0b100000110000001, 4}, + {0b100000110000010, 2}, {0b100000110000100, 4}, + {0b100000110000101, 5}, {0b100000110001000, 4}, + {0b100000110001001, 5}, {0b100000110001100, 5}, + {0b100000110010000, 4}, {0b100000110010001, 5}, + {0b100000110010110, 3}, {0b100000110011000, 5}, + {0b100000110100000, 4}, {0b100000110100001, 5}, + {0b100000110100100, 5}, {0b100000110101010, 3}, + {0b100000110110000, 5}, {0b100000110111110, 4}, + {0b100000111000000, 4}, {0b100000111000011, 3}, + {0b100000111000100, 5}, {0b100000111001000, 5}, + {0b100000111010000, 5}, {0b100000111010111, 4}, + {0b100000111100000, 5}, {0b100000111101011, 4}, + {0b100000111111111, 3}, {0b100001000000000, 3}, + {0b100001000000001, 5}, {0b100001000000010, 5}, + {0b100001000000011, 4}, {0b100001000000100, 5}, + {0b100001000000101, 4}, {0b100001000000110, 4}, + {0b100001000000111, 5}, {0b100001000001000, 5}, + {0b100001000001001, 4}, {0b100001000001010, 4}, + {0b100001000001011, 5}, {0b100001000001100, 4}, + {0b100001000001101, 5}, {0b100001000001110, 5}, + {0b100001000010000, 5}, {0b100001000010001, 4}, + {0b100001000010010, 4}, {0b100001000010011, 5}, + {0b100001000010100, 4}, {0b100001000010101, 5}, + {0b100001000010110, 5}, {0b100001000011000, 2}, + {0b100001000100000, 5}, {0b100001000100001, 4}, + {0b100001000100010, 4}, {0b100001000100011, 5}, + {0b100001000100100, 2}, {0b100001000101000, 4}, + {0b100001000101001, 5}, {0b100001000101010, 5}, + {0b100001000110000, 4}, {0b100001000110001, 5}, + {0b100001000110010, 5}, {0b100001000111100, 3}, + {0b100001001000000, 5}, {0b100001001000001, 4}, + {0b100001001000010, 2}, {0b100001001000100, 4}, + {0b100001001000101, 5}, {0b100001001001000, 4}, + {0b100001001001001, 5}, {0b100001001001100, 5}, + {0b100001001010000, 4}, {0b100001001010001, 5}, + {0b100001001010100, 5}, {0b100001001011010, 3}, + {0b100001001100000, 4}, {0b100001001100001, 5}, + {0b100001001100110, 3}, {0b100001001101000, 5}, + {0b100001001110000, 5}, {0b100001001111110, 4}, + {0b100001010000000, 5}, {0b100001010000001, 2}, + {0b100001010000010, 4}, {0b100001010000100, 4}, + {0b100001010000110, 5}, {0b100001010001000, 4}, + {0b100001010001010, 5}, {0b100001010001100, 5}, + {0b100001010010000, 4}, {0b100001010010010, 5}, + {0b100001010010100, 5}, {0b100001010011001, 3}, + {0b100001010100000, 4}, {0b100001010100010, 5}, + {0b100001010100101, 3}, {0b100001010101000, 5}, + {0b100001010110000, 5}, {0b100001010111101, 4}, + {0b100001011000000, 4}, {0b100001011000011, 3}, + {0b100001011000100, 5}, {0b100001011001000, 5}, + {0b100001011010000, 5}, {0b100001011011011, 4}, + {0b100001011100000, 5}, {0b100001011100111, 4}, + {0b100001011111111, 3}, {0b100001100000000, 5}, + {0b100001100000001, 4}, {0b100001100000010, 4}, + {0b100001100000100, 4}, {0b100001100000101, 5}, + {0b100001100000110, 5}, {0b100001100001000, 4}, + {0b100001100001001, 5}, {0b100001100001010, 5}, + {0b100001100010000, 4}, {0b100001100010001, 5}, + {0b100001100010010, 5}, {0b100001100011100, 3}, + {0b100001100100000, 4}, {0b100001100100001, 5}, + {0b100001100100010, 5}, {0b100001100101100, 3}, + {0b100001100110100, 3}, {0b100001100111000, 3}, + {0b100001101000000, 4}, {0b100001101000011, 3}, + {0b100001101000100, 5}, {0b100001101001000, 5}, + {0b100001101010000, 5}, {0b100001101100000, 5}, + {0b100001110000000, 4}, {0b100001110000011, 3}, + {0b100001110000100, 5}, {0b100001110001000, 5}, + {0b100001110010000, 5}, {0b100001110100000, 5}, + {0b100001111000001, 3}, {0b100001111000010, 3}, + {0b100010000000000, 3}, {0b100010000000001, 5}, + {0b100010000000010, 5}, {0b100010000000011, 4}, + {0b100010000000100, 5}, {0b100010000000101, 4}, + {0b100010000000110, 4}, {0b100010000000111, 5}, + {0b100010000001000, 5}, {0b100010000001001, 4}, + {0b100010000001010, 4}, {0b100010000001011, 5}, + {0b100010000001100, 4}, {0b100010000001101, 5}, + {0b100010000001110, 5}, {0b100010000010000, 5}, + {0b100010000010001, 2}, {0b100010000010010, 4}, + {0b100010000010100, 4}, {0b100010000010110, 5}, + {0b100010000011000, 4}, {0b100010000011010, 5}, + {0b100010000011100, 5}, {0b100010000100000, 5}, + {0b100010000100001, 4}, {0b100010000100010, 2}, + {0b100010000100100, 4}, {0b100010000100101, 5}, + {0b100010000101000, 4}, {0b100010000101001, 5}, + {0b100010000101100, 5}, {0b100010000110000, 4}, + {0b100010000110011, 3}, {0b100010000110100, 5}, + {0b100010000111000, 5}, {0b100010001000000, 5}, + {0b100010001000001, 4}, {0b100010001000010, 4}, + {0b100010001000011, 5}, {0b100010001000100, 2}, + {0b100010001001000, 4}, {0b100010001001001, 5}, + {0b100010001001010, 5}, {0b100010001010000, 4}, + {0b100010001010010, 5}, {0b100010001010101, 3}, + {0b100010001011000, 5}, {0b100010001100000, 4}, + {0b100010001100001, 5}, {0b100010001100110, 3}, + {0b100010001101000, 5}, {0b100010001110000, 5}, + {0b100010001110111, 4}, {0b100010010000000, 5}, + {0b100010010000001, 4}, {0b100010010000010, 4}, + {0b100010010000011, 5}, {0b100010010000100, 4}, + {0b100010010000101, 5}, {0b100010010000110, 5}, + {0b100010010001000, 2}, {0b100010010010000, 4}, + {0b100010010010010, 5}, {0b100010010010100, 5}, + {0b100010010011001, 3}, {0b100010010100000, 4}, + {0b100010010100001, 5}, {0b100010010100100, 5}, + {0b100010010101010, 3}, {0b100010010110000, 5}, + {0b100010010111011, 4}, {0b100010011000000, 4}, + {0b100010011000001, 5}, {0b100010011000010, 5}, + {0b100010011001100, 3}, {0b100010011010000, 5}, + {0b100010011011101, 4}, {0b100010011100000, 5}, + {0b100010011101110, 4}, {0b100010011111111, 3}, + {0b100010100000000, 5}, {0b100010100000001, 4}, + {0b100010100000010, 4}, {0b100010100000011, 5}, + {0b100010100000100, 4}, {0b100010100000110, 5}, + {0b100010100001000, 4}, {0b100010100001001, 5}, + {0b100010100001100, 5}, {0b100010100010000, 4}, + {0b100010100010010, 5}, {0b100010100010101, 3}, + {0b100010100011000, 5}, {0b100010100100000, 4}, + {0b100010100100001, 5}, {0b100010100100100, 5}, + {0b100010100101010, 3}, {0b100010100110000, 5}, + {0b100010101000000, 4}, {0b100010101000010, 5}, + {0b100010101000101, 3}, {0b100010101001000, 5}, + {0b100010101010001, 3}, {0b100010101010100, 3}, + {0b100010101100000, 5}, {0b100010110000000, 4}, + {0b100010110000001, 5}, {0b100010110000100, 5}, + {0b100010110001010, 3}, {0b100010110010000, 5}, + {0b100010110100010, 3}, {0b100010110101000, 3}, + {0b100010111000000, 5}, {0b100011000000000, 5}, + {0b100011000000001, 4}, {0b100011000000010, 4}, + {0b100011000000011, 5}, {0b100011000000100, 4}, + {0b100011000000101, 5}, {0b100011000001000, 4}, + {0b100011000001010, 5}, {0b100011000001100, 5}, + {0b100011000010000, 4}, {0b100011000010010, 5}, + {0b100011000010100, 5}, {0b100011000011001, 3}, + {0b100011000100000, 4}, {0b100011000100001, 5}, + {0b100011000100110, 3}, {0b100011000101000, 5}, + {0b100011000110000, 5}, {0b100011001000000, 4}, + {0b100011001000001, 5}, {0b100011001000110, 3}, + {0b100011001001000, 5}, {0b100011001010000, 5}, + {0b100011001100010, 3}, {0b100011001100100, 3}, + {0b100011010000000, 4}, {0b100011010000010, 5}, + {0b100011010000100, 5}, {0b100011010001001, 3}, + {0b100011010010001, 3}, {0b100011010011000, 3}, + {0b100011010100000, 5}, {0b100011011000000, 5}, + {0b100011100000000, 4}, {0b100011100000001, 5}, + {0b100011100000010, 5}, {0b100011100000100, 5}, + {0b100011100001000, 5}, {0b100011100010000, 5}, + {0b100011100011101, 4}, {0b100011100100000, 5}, + {0b100011100101110, 4}, {0b100011101000000, 5}, + {0b100011101000111, 4}, {0b100011101110100, 4}, + {0b100011101111111, 5}, {0b100011110000000, 5}, + {0b100011110001011, 4}, {0b100011110111000, 4}, + {0b100011110111111, 5}, {0b100011111010001, 4}, + {0b100011111011111, 5}, {0b100011111100010, 4}, + {0b100011111101111, 5}, {0b100011111110111, 5}, + {0b100011111111011, 5}, {0b100011111111101, 5}, + {0b100011111111110, 5}, {0b100011111111111, 4}, + {0b100100000000000, 3}, {0b100100000000001, 5}, + {0b100100000000010, 5}, {0b100100000000011, 4}, + {0b100100000000100, 5}, {0b100100000000101, 4}, + {0b100100000000110, 4}, {0b100100000000111, 5}, + {0b100100000001000, 5}, {0b100100000001001, 4}, + {0b100100000001010, 4}, {0b100100000001011, 5}, + {0b100100000001100, 4}, {0b100100000001101, 5}, + {0b100100000001110, 5}, {0b100100000010000, 5}, + {0b100100000010001, 4}, {0b100100000010010, 2}, + {0b100100000010100, 4}, {0b100100000010101, 5}, + {0b100100000011000, 4}, {0b100100000011001, 5}, + {0b100100000011100, 5}, {0b100100000100000, 5}, + {0b100100000100001, 2}, {0b100100000100010, 4}, + {0b100100000100100, 4}, {0b100100000100110, 5}, + {0b100100000101000, 4}, {0b100100000101010, 5}, + {0b100100000101100, 5}, {0b100100000110000, 4}, + {0b100100000110011, 3}, {0b100100000110100, 5}, + {0b100100000111000, 5}, {0b100100001000000, 5}, + {0b100100001000001, 4}, {0b100100001000010, 4}, + {0b100100001000011, 5}, {0b100100001000100, 4}, + {0b100100001000101, 5}, {0b100100001000110, 5}, + {0b100100001001000, 2}, {0b100100001010000, 4}, + {0b100100001010001, 5}, {0b100100001010100, 5}, + {0b100100001011010, 3}, {0b100100001100000, 4}, + {0b100100001100010, 5}, {0b100100001100100, 5}, + {0b100100001101001, 3}, {0b100100001110000, 5}, + {0b100100001111011, 4}, {0b100100010000000, 5}, + {0b100100010000001, 4}, {0b100100010000010, 4}, + {0b100100010000011, 5}, {0b100100010000100, 2}, + {0b100100010001000, 4}, {0b100100010001001, 5}, + {0b100100010001010, 5}, {0b100100010010000, 4}, + {0b100100010010001, 5}, {0b100100010010110, 3}, + {0b100100010011000, 5}, {0b100100010100000, 4}, + {0b100100010100010, 5}, {0b100100010100101, 3}, + {0b100100010101000, 5}, {0b100100010110000, 5}, + {0b100100010110111, 4}, {0b100100011000000, 4}, + {0b100100011000001, 5}, {0b100100011000010, 5}, + {0b100100011001100, 3}, {0b100100011010000, 5}, + {0b100100011011110, 4}, {0b100100011100000, 5}, + {0b100100011101101, 4}, {0b100100011111111, 3}, + {0b100100100000000, 5}, {0b100100100000001, 4}, + {0b100100100000010, 4}, {0b100100100000011, 5}, + {0b100100100000100, 4}, {0b100100100000101, 5}, + {0b100100100001000, 4}, {0b100100100001010, 5}, + {0b100100100001100, 5}, {0b100100100010000, 4}, + {0b100100100010001, 5}, {0b100100100010110, 3}, + {0b100100100011000, 5}, {0b100100100100000, 4}, + {0b100100100100010, 5}, {0b100100100100100, 5}, + {0b100100100101001, 3}, {0b100100100110000, 5}, + {0b100100101000000, 4}, {0b100100101000010, 5}, + {0b100100101000100, 5}, {0b100100101001001, 3}, + {0b100100101010000, 5}, {0b100100101100001, 3}, + {0b100100101101000, 3}, {0b100100110000000, 4}, + {0b100100110000001, 5}, {0b100100110000110, 3}, + {0b100100110001000, 5}, {0b100100110010010, 3}, + {0b100100110010100, 3}, {0b100100110100000, 5}, + {0b100100111000000, 5}, {0b100101000000000, 5}, + {0b100101000000001, 4}, {0b100101000000010, 4}, + {0b100101000000011, 5}, {0b100101000000100, 4}, + {0b100101000000110, 5}, {0b100101000001000, 4}, + {0b100101000001001, 5}, {0b100101000001100, 5}, + {0b100101000010000, 4}, {0b100101000010001, 5}, + {0b100101000010100, 5}, {0b100101000011010, 3}, + {0b100101000100000, 4}, {0b100101000100010, 5}, + {0b100101000100101, 3}, {0b100101000101000, 5}, + {0b100101000110000, 5}, {0b100101001000000, 4}, + {0b100101001000001, 5}, {0b100101001000100, 5}, + {0b100101001001010, 3}, {0b100101001010010, 3}, + {0b100101001011000, 3}, {0b100101001100000, 5}, + {0b100101010000000, 4}, {0b100101010000010, 5}, + {0b100101010000101, 3}, {0b100101010001000, 5}, + {0b100101010010000, 5}, {0b100101010100001, 3}, + {0b100101010100100, 3}, {0b100101011000000, 5}, + {0b100101100000000, 4}, {0b100101100000001, 5}, + {0b100101100000010, 5}, {0b100101100000100, 5}, + {0b100101100001000, 5}, {0b100101100010000, 5}, + {0b100101100011110, 4}, {0b100101100100000, 5}, + {0b100101100101101, 4}, {0b100101101000000, 5}, + {0b100101101001011, 4}, {0b100101101111000, 4}, + {0b100101101111111, 5}, {0b100101110000000, 5}, + {0b100101110000111, 4}, {0b100101110110100, 4}, + {0b100101110111111, 5}, {0b100101111010010, 4}, + {0b100101111011111, 5}, {0b100101111100001, 4}, + {0b100101111101111, 5}, {0b100101111110111, 5}, + {0b100101111111011, 5}, {0b100101111111101, 5}, + {0b100101111111110, 5}, {0b100101111111111, 4}, + {0b100110000000000, 5}, {0b100110000000001, 4}, + {0b100110000000010, 4}, {0b100110000000100, 4}, + {0b100110000000101, 5}, {0b100110000000110, 5}, + {0b100110000001000, 4}, {0b100110000001001, 5}, + {0b100110000001010, 5}, {0b100110000010000, 4}, + {0b100110000010011, 3}, {0b100110000010100, 5}, + {0b100110000011000, 5}, {0b100110000100000, 4}, + {0b100110000100011, 3}, {0b100110000100100, 5}, + {0b100110000101000, 5}, {0b100110000110001, 3}, + {0b100110000110010, 3}, {0b100110001000000, 4}, + {0b100110001000001, 5}, {0b100110001000010, 5}, + {0b100110001001100, 3}, {0b100110001010000, 5}, + {0b100110001100000, 5}, {0b100110010000000, 4}, + {0b100110010000001, 5}, {0b100110010000010, 5}, + {0b100110010001100, 3}, {0b100110010010000, 5}, + {0b100110010100000, 5}, {0b100110011000100, 3}, + {0b100110011001000, 3}, {0b100110100000000, 4}, + {0b100110100000001, 5}, {0b100110100000010, 5}, + {0b100110100000100, 5}, {0b100110100001000, 5}, + {0b100110100010000, 5}, {0b100110100010111, 4}, + {0b100110100100000, 5}, {0b100110100101011, 4}, + {0b100110101000000, 5}, {0b100110101001101, 4}, + {0b100110101110001, 4}, {0b100110101111111, 5}, + {0b100110110000000, 5}, {0b100110110001110, 4}, + {0b100110110110010, 4}, {0b100110110111111, 5}, + {0b100110111010100, 4}, {0b100110111011111, 5}, + {0b100110111101000, 4}, {0b100110111101111, 5}, + {0b100110111110111, 5}, {0b100110111111011, 5}, + {0b100110111111101, 5}, {0b100110111111110, 5}, + {0b100110111111111, 4}, {0b100111000000000, 4}, + {0b100111000000001, 5}, {0b100111000000010, 5}, + {0b100111000000100, 5}, {0b100111000001000, 5}, + {0b100111000010000, 5}, {0b100111000011011, 4}, + {0b100111000100000, 5}, {0b100111000100111, 4}, + {0b100111001000000, 5}, {0b100111001001110, 4}, + {0b100111001110010, 4}, {0b100111001111111, 5}, + {0b100111010000000, 5}, {0b100111010001101, 4}, + {0b100111010110001, 4}, {0b100111010111111, 5}, + {0b100111011011000, 4}, {0b100111011011111, 5}, + {0b100111011100100, 4}, {0b100111011101111, 5}, + {0b100111011110111, 5}, {0b100111011111011, 5}, + {0b100111011111101, 5}, {0b100111011111110, 5}, + {0b100111011111111, 4}, {0b100111100011111, 3}, + {0b100111100101111, 3}, {0b100111101001111, 3}, + {0b100111101110111, 5}, {0b100111101111011, 5}, + {0b100111101111101, 5}, {0b100111101111110, 5}, + {0b100111101111111, 4}, {0b100111110001111, 3}, + {0b100111110110111, 5}, {0b100111110111011, 5}, + {0b100111110111101, 5}, {0b100111110111110, 5}, + {0b100111110111111, 4}, {0b100111111010111, 5}, + {0b100111111011011, 5}, {0b100111111011101, 5}, + {0b100111111011110, 5}, {0b100111111011111, 4}, + {0b100111111100111, 5}, {0b100111111101011, 5}, + {0b100111111101101, 5}, {0b100111111101110, 5}, + {0b100111111101111, 4}, {0b100111111110001, 3}, + {0b100111111110010, 3}, {0b100111111110100, 3}, + {0b100111111110111, 4}, {0b100111111111000, 3}, + {0b100111111111011, 4}, {0b100111111111101, 4}, + {0b100111111111110, 4}, {0b100111111111111, 5}, + {0b101000000000000, 3}, {0b101000000000001, 5}, + {0b101000000000010, 5}, {0b101000000000011, 4}, + {0b101000000000100, 5}, {0b101000000000101, 2}, + {0b101000000000110, 4}, {0b101000000001000, 5}, + {0b101000000001001, 4}, {0b101000000001010, 2}, + {0b101000000001100, 4}, {0b101000000001111, 3}, + {0b101000000010000, 5}, {0b101000000010001, 4}, + {0b101000000010010, 4}, {0b101000000010011, 5}, + {0b101000000010100, 4}, {0b101000000010110, 5}, + {0b101000000011000, 4}, {0b101000000011001, 5}, + {0b101000000011100, 5}, {0b101000000100000, 5}, + {0b101000000100001, 4}, {0b101000000100010, 4}, + {0b101000000100011, 5}, {0b101000000100100, 4}, + {0b101000000100110, 5}, {0b101000000101000, 4}, + {0b101000000101001, 5}, {0b101000000101100, 5}, + {0b101000000110000, 4}, {0b101000000110001, 5}, + {0b101000000110010, 5}, {0b101000000110100, 5}, + {0b101000000111000, 5}, {0b101000001000000, 5}, + {0b101000001000001, 4}, {0b101000001000010, 4}, + {0b101000001000011, 5}, {0b101000001000100, 4}, + {0b101000001000110, 5}, {0b101000001001000, 4}, + {0b101000001001001, 5}, {0b101000001001100, 5}, + {0b101000001010000, 2}, {0b101000001010101, 3}, + {0b101000001011010, 3}, {0b101000001011111, 4}, + {0b101000001100000, 4}, {0b101000001100001, 5}, + {0b101000001100010, 5}, {0b101000001100100, 5}, + {0b101000001101000, 5}, {0b101000010000000, 5}, + {0b101000010000001, 4}, {0b101000010000010, 4}, + {0b101000010000011, 5}, {0b101000010000100, 4}, + {0b101000010000110, 5}, {0b101000010001000, 4}, + {0b101000010001001, 5}, {0b101000010001100, 5}, + {0b101000010010000, 4}, {0b101000010010001, 5}, + {0b101000010010010, 5}, {0b101000010010100, 5}, + {0b101000010011000, 5}, {0b101000010100000, 2}, + {0b101000010100101, 3}, {0b101000010101010, 3}, + {0b101000010101111, 4}, {0b101000011000000, 4}, + {0b101000011000001, 5}, {0b101000011000010, 5}, + {0b101000011000100, 5}, {0b101000011001000, 5}, + {0b101000011110000, 3}, {0b101000011110101, 4}, + {0b101000011111010, 4}, {0b101000011111111, 3}, + {0b101000100000000, 5}, {0b101000100000001, 4}, + {0b101000100000010, 4}, {0b101000100000011, 5}, + {0b101000100000100, 4}, {0b101000100000110, 5}, + {0b101000100001000, 4}, {0b101000100001001, 5}, + {0b101000100001100, 5}, {0b101000100010000, 4}, + {0b101000100010010, 5}, {0b101000100010101, 3}, + {0b101000100011000, 5}, {0b101000100100000, 4}, + {0b101000100100001, 5}, {0b101000100100100, 5}, + {0b101000100101010, 3}, {0b101000100110000, 5}, + {0b101000101000000, 4}, {0b101000101000010, 5}, + {0b101000101000101, 3}, {0b101000101001000, 5}, + {0b101000101010001, 3}, {0b101000101010100, 3}, + {0b101000101100000, 5}, {0b101000110000000, 4}, + {0b101000110000001, 5}, {0b101000110000100, 5}, + {0b101000110001010, 3}, {0b101000110010000, 5}, + {0b101000110100010, 3}, {0b101000110101000, 3}, + {0b101000111000000, 5}, {0b101001000000000, 5}, + {0b101001000000001, 4}, {0b101001000000010, 4}, + {0b101001000000011, 5}, {0b101001000000100, 4}, + {0b101001000000110, 5}, {0b101001000001000, 4}, + {0b101001000001001, 5}, {0b101001000001100, 5}, + {0b101001000010000, 4}, {0b101001000010001, 5}, + {0b101001000010100, 5}, {0b101001000011010, 3}, + {0b101001000100000, 4}, {0b101001000100010, 5}, + {0b101001000100101, 3}, {0b101001000101000, 5}, + {0b101001000110000, 5}, {0b101001001000000, 4}, + {0b101001001000001, 5}, {0b101001001000100, 5}, + {0b101001001001010, 3}, {0b101001001010010, 3}, + {0b101001001011000, 3}, {0b101001001100000, 5}, + {0b101001010000000, 4}, {0b101001010000010, 5}, + {0b101001010000101, 3}, {0b101001010001000, 5}, + {0b101001010010000, 5}, {0b101001010100001, 3}, + {0b101001010100100, 3}, {0b101001011000000, 5}, + {0b101001100000000, 4}, {0b101001100000001, 5}, + {0b101001100000010, 5}, {0b101001100000100, 5}, + {0b101001100001000, 5}, {0b101001100010000, 5}, + {0b101001100100000, 5}, {0b101001100110101, 4}, + {0b101001100111010, 4}, {0b101001101000000, 5}, + {0b101001101010011, 4}, {0b101001101011100, 4}, + {0b101001101111111, 5}, {0b101001110000000, 5}, + {0b101001110100011, 4}, {0b101001110101100, 4}, + {0b101001110111111, 5}, {0b101001111000101, 4}, + {0b101001111001010, 4}, {0b101001111011111, 5}, + {0b101001111101111, 5}, {0b101001111110111, 5}, + {0b101001111111011, 5}, {0b101001111111101, 5}, + {0b101001111111110, 5}, {0b101001111111111, 4}, + {0b101010000000000, 5}, {0b101010000000001, 4}, + {0b101010000000010, 4}, {0b101010000000011, 5}, + {0b101010000000100, 4}, {0b101010000000110, 5}, + {0b101010000001000, 4}, {0b101010000001001, 5}, + {0b101010000001100, 5}, {0b101010000010000, 4}, + {0b101010000010010, 5}, {0b101010000010101, 3}, + {0b101010000011000, 5}, {0b101010000100000, 4}, + {0b101010000100001, 5}, {0b101010000100100, 5}, + {0b101010000101010, 3}, {0b101010000110000, 5}, + {0b101010001000000, 4}, {0b101010001000010, 5}, + {0b101010001000101, 3}, {0b101010001001000, 5}, + {0b101010001010001, 3}, {0b101010001010100, 3}, + {0b101010001100000, 5}, {0b101010010000000, 4}, + {0b101010010000001, 5}, {0b101010010000100, 5}, + {0b101010010001010, 3}, {0b101010010010000, 5}, + {0b101010010100010, 3}, {0b101010010101000, 3}, + {0b101010011000000, 5}, {0b101010100000000, 2}, + {0b101010100000101, 3}, {0b101010100001010, 3}, + {0b101010100001111, 4}, {0b101010100010001, 3}, + {0b101010100010100, 3}, {0b101010100100010, 3}, + {0b101010100101000, 3}, {0b101010100110011, 4}, + {0b101010100111100, 4}, {0b101010101000001, 3}, + {0b101010101000100, 3}, {0b101010101010000, 3}, + {0b101010101010101, 1}, {0b101010101011010, 4}, + {0b101010101011111, 3}, {0b101010101100110, 4}, + {0b101010101101001, 4}, {0b101010101110111, 3}, + {0b101010101111101, 3}, {0b101010110000010, 3}, + {0b101010110001000, 3}, {0b101010110010110, 4}, + {0b101010110011001, 4}, {0b101010110100000, 3}, + {0b101010110100101, 4}, {0b101010110101010, 1}, + {0b101010110101111, 3}, {0b101010110111011, 3}, + {0b101010110111110, 3}, {0b101010111000011, 4}, + {0b101010111001100, 4}, {0b101010111010111, 3}, + {0b101010111011101, 3}, {0b101010111101011, 3}, + {0b101010111101110, 3}, {0b101010111110000, 4}, + {0b101010111110101, 3}, {0b101010111111010, 3}, + {0b101010111111111, 2}, {0b101011000000000, 4}, + {0b101011000000001, 5}, {0b101011000000010, 5}, + {0b101011000000100, 5}, {0b101011000001000, 5}, + {0b101011000010000, 5}, {0b101011000100000, 5}, + {0b101011001000000, 5}, {0b101011001010110, 4}, + {0b101011001011001, 4}, {0b101011001100101, 4}, + {0b101011001101010, 4}, {0b101011001111111, 5}, + {0b101011010000000, 5}, {0b101011010010101, 4}, + {0b101011010011010, 4}, {0b101011010100110, 4}, + {0b101011010101001, 4}, {0b101011010111111, 5}, + {0b101011011011111, 5}, {0b101011011101111, 5}, + {0b101011011110111, 5}, {0b101011011111011, 5}, + {0b101011011111101, 5}, {0b101011011111110, 5}, + {0b101011011111111, 4}, {0b101011100111111, 5}, + {0b101011101010111, 3}, {0b101011101011101, 3}, + {0b101011101101111, 5}, {0b101011101110101, 3}, + {0b101011101111011, 5}, {0b101011101111110, 5}, + {0b101011101111111, 4}, {0b101011110011111, 5}, + {0b101011110101011, 3}, {0b101011110101110, 3}, + {0b101011110110111, 5}, {0b101011110111010, 3}, + {0b101011110111101, 5}, {0b101011110111111, 4}, + {0b101011111001111, 5}, {0b101011111010101, 3}, + {0b101011111011011, 5}, {0b101011111011110, 5}, + {0b101011111011111, 4}, {0b101011111100111, 5}, + {0b101011111101010, 3}, {0b101011111101101, 5}, + {0b101011111101111, 4}, {0b101011111110011, 5}, + {0b101011111110110, 5}, {0b101011111110111, 4}, + {0b101011111111001, 5}, {0b101011111111011, 4}, + {0b101011111111100, 5}, {0b101011111111101, 4}, + {0b101011111111110, 4}, {0b101011111111111, 5}, + {0b101100000000000, 5}, {0b101100000000001, 4}, + {0b101100000000010, 4}, {0b101100000000011, 5}, + {0b101100000000100, 4}, {0b101100000000110, 5}, + {0b101100000001000, 4}, {0b101100000001001, 5}, + {0b101100000001100, 5}, {0b101100000010000, 4}, + {0b101100000010001, 5}, {0b101100000010100, 5}, + {0b101100000011010, 3}, {0b101100000100000, 4}, + {0b101100000100010, 5}, {0b101100000100101, 3}, + {0b101100000101000, 5}, {0b101100000110000, 5}, + {0b101100001000000, 4}, {0b101100001000001, 5}, + {0b101100001000100, 5}, {0b101100001001010, 3}, + {0b101100001010010, 3}, {0b101100001011000, 3}, + {0b101100001100000, 5}, {0b101100010000000, 4}, + {0b101100010000010, 5}, {0b101100010000101, 3}, + {0b101100010001000, 5}, {0b101100010010000, 5}, + {0b101100010100001, 3}, {0b101100010100100, 3}, + {0b101100011000000, 5}, {0b101100100000000, 4}, + {0b101100100000001, 5}, {0b101100100000010, 5}, + {0b101100100000100, 5}, {0b101100100001000, 5}, + {0b101100100010000, 5}, {0b101100100100000, 5}, + {0b101100101000000, 5}, {0b101100101010110, 4}, + {0b101100101011001, 4}, {0b101100101100101, 4}, + {0b101100101101010, 4}, {0b101100101111111, 5}, + {0b101100110000000, 5}, {0b101100110010101, 4}, + {0b101100110011010, 4}, {0b101100110100110, 4}, + {0b101100110101001, 4}, {0b101100110111111, 5}, + {0b101100111011111, 5}, {0b101100111101111, 5}, + {0b101100111110111, 5}, {0b101100111111011, 5}, + {0b101100111111101, 5}, {0b101100111111110, 5}, + {0b101100111111111, 4}, {0b101101000000000, 2}, + {0b101101000000101, 3}, {0b101101000001010, 3}, + {0b101101000001111, 4}, {0b101101000010010, 3}, + {0b101101000011000, 3}, {0b101101000100001, 3}, + {0b101101000100100, 3}, {0b101101000110011, 4}, + {0b101101000111100, 4}, {0b101101001000010, 3}, + {0b101101001001000, 3}, {0b101101001010000, 3}, + {0b101101001010101, 4}, {0b101101001011010, 1}, + {0b101101001011111, 3}, {0b101101001100110, 4}, + {0b101101001101001, 4}, {0b101101001111011, 3}, + {0b101101001111110, 3}, {0b101101010000001, 3}, + {0b101101010000100, 3}, {0b101101010010110, 4}, + {0b101101010011001, 4}, {0b101101010100000, 3}, + {0b101101010100101, 1}, {0b101101010101010, 4}, + {0b101101010101111, 3}, {0b101101010110111, 3}, + {0b101101010111101, 3}, {0b101101011000011, 4}, + {0b101101011001100, 4}, {0b101101011011011, 3}, + {0b101101011011110, 3}, {0b101101011100111, 3}, + {0b101101011101101, 3}, {0b101101011110000, 4}, + {0b101101011110101, 3}, {0b101101011111010, 3}, + {0b101101011111111, 2}, {0b101101100111111, 5}, + {0b101101101011011, 3}, {0b101101101011110, 3}, + {0b101101101101111, 5}, {0b101101101110111, 5}, + {0b101101101111010, 3}, {0b101101101111101, 5}, + {0b101101101111111, 4}, {0b101101110011111, 5}, + {0b101101110100111, 3}, {0b101101110101101, 3}, + {0b101101110110101, 3}, {0b101101110111011, 5}, + {0b101101110111110, 5}, {0b101101110111111, 4}, + {0b101101111001111, 5}, {0b101101111010111, 5}, + {0b101101111011010, 3}, {0b101101111011101, 5}, + {0b101101111011111, 4}, {0b101101111100101, 3}, + {0b101101111101011, 5}, {0b101101111101110, 5}, + {0b101101111101111, 4}, {0b101101111110011, 5}, + {0b101101111110110, 5}, {0b101101111110111, 4}, + {0b101101111111001, 5}, {0b101101111111011, 4}, + {0b101101111111100, 5}, {0b101101111111101, 4}, + {0b101101111111110, 4}, {0b101101111111111, 5}, + {0b101110000000000, 4}, {0b101110000000001, 5}, + {0b101110000000010, 5}, {0b101110000000100, 5}, + {0b101110000001000, 5}, {0b101110000010000, 5}, + {0b101110000100000, 5}, {0b101110000110101, 4}, + {0b101110000111010, 4}, {0b101110001000000, 5}, + {0b101110001010011, 4}, {0b101110001011100, 4}, + {0b101110001111111, 5}, {0b101110010000000, 5}, + {0b101110010100011, 4}, {0b101110010101100, 4}, + {0b101110010111111, 5}, {0b101110011000101, 4}, + {0b101110011001010, 4}, {0b101110011011111, 5}, + {0b101110011101111, 5}, {0b101110011110111, 5}, + {0b101110011111011, 5}, {0b101110011111101, 5}, + {0b101110011111110, 5}, {0b101110011111111, 4}, + {0b101110100111111, 5}, {0b101110101010111, 3}, + {0b101110101011101, 3}, {0b101110101101111, 5}, + {0b101110101110101, 3}, {0b101110101111011, 5}, + {0b101110101111110, 5}, {0b101110101111111, 4}, + {0b101110110011111, 5}, {0b101110110101011, 3}, + {0b101110110101110, 3}, {0b101110110110111, 5}, + {0b101110110111010, 3}, {0b101110110111101, 5}, + {0b101110110111111, 4}, {0b101110111001111, 5}, + {0b101110111010101, 3}, {0b101110111011011, 5}, + {0b101110111011110, 5}, {0b101110111011111, 4}, + {0b101110111100111, 5}, {0b101110111101010, 3}, + {0b101110111101101, 5}, {0b101110111101111, 4}, + {0b101110111110011, 5}, {0b101110111110110, 5}, + {0b101110111110111, 4}, {0b101110111111001, 5}, + {0b101110111111011, 4}, {0b101110111111100, 5}, + {0b101110111111101, 4}, {0b101110111111110, 4}, + {0b101110111111111, 5}, {0b101111000111111, 5}, + {0b101111001011011, 3}, {0b101111001011110, 3}, + {0b101111001101111, 5}, {0b101111001110111, 5}, + {0b101111001111010, 3}, {0b101111001111101, 5}, + {0b101111001111111, 4}, {0b101111010011111, 5}, + {0b101111010100111, 3}, {0b101111010101101, 3}, + {0b101111010110101, 3}, {0b101111010111011, 5}, + {0b101111010111110, 5}, {0b101111010111111, 4}, + {0b101111011001111, 5}, {0b101111011010111, 5}, + {0b101111011011010, 3}, {0b101111011011101, 5}, + {0b101111011011111, 4}, {0b101111011100101, 3}, + {0b101111011101011, 5}, {0b101111011101110, 5}, + {0b101111011101111, 4}, {0b101111011110011, 5}, + {0b101111011110110, 5}, {0b101111011110111, 4}, + {0b101111011111001, 5}, {0b101111011111011, 4}, + {0b101111011111100, 5}, {0b101111011111101, 4}, + {0b101111011111110, 4}, {0b101111011111111, 5}, + {0b101111100000000, 3}, {0b101111100000101, 4}, + {0b101111100001010, 4}, {0b101111100001111, 3}, + {0b101111100110111, 5}, {0b101111100111011, 5}, + {0b101111100111101, 5}, {0b101111100111110, 5}, + {0b101111100111111, 4}, {0b101111101010000, 4}, + {0b101111101010101, 3}, {0b101111101011010, 3}, + {0b101111101011111, 2}, {0b101111101100111, 5}, + {0b101111101101011, 5}, {0b101111101101101, 5}, + {0b101111101101110, 5}, {0b101111101101111, 4}, + {0b101111101110011, 5}, {0b101111101110110, 5}, + {0b101111101110111, 4}, {0b101111101111001, 5}, + {0b101111101111011, 4}, {0b101111101111100, 5}, + {0b101111101111101, 4}, {0b101111101111110, 4}, + {0b101111101111111, 5}, {0b101111110010111, 5}, + {0b101111110011011, 5}, {0b101111110011101, 5}, + {0b101111110011110, 5}, {0b101111110011111, 4}, + {0b101111110100000, 4}, {0b101111110100101, 3}, + {0b101111110101010, 3}, {0b101111110101111, 2}, + {0b101111110110011, 5}, {0b101111110110110, 5}, + {0b101111110110111, 4}, {0b101111110111001, 5}, + {0b101111110111011, 4}, {0b101111110111100, 5}, + {0b101111110111101, 4}, {0b101111110111110, 4}, + {0b101111110111111, 5}, {0b101111111000111, 5}, + {0b101111111001011, 5}, {0b101111111001101, 5}, + {0b101111111001110, 5}, {0b101111111001111, 4}, + {0b101111111010011, 5}, {0b101111111010110, 5}, + {0b101111111010111, 4}, {0b101111111011001, 5}, + {0b101111111011011, 4}, {0b101111111011100, 5}, + {0b101111111011101, 4}, {0b101111111011110, 4}, + {0b101111111011111, 5}, {0b101111111100011, 5}, + {0b101111111100110, 5}, {0b101111111100111, 4}, + {0b101111111101001, 5}, {0b101111111101011, 4}, + {0b101111111101100, 5}, {0b101111111101101, 4}, + {0b101111111101110, 4}, {0b101111111101111, 5}, + {0b101111111110000, 3}, {0b101111111110011, 4}, + {0b101111111110101, 2}, {0b101111111110110, 4}, + {0b101111111110111, 5}, {0b101111111111001, 4}, + {0b101111111111010, 2}, {0b101111111111011, 5}, + {0b101111111111100, 4}, {0b101111111111101, 5}, + {0b101111111111110, 5}, {0b101111111111111, 3}, + {0b110000000000000, 3}, {0b110000000000001, 5}, + {0b110000000000010, 5}, {0b110000000000011, 4}, + {0b110000000000100, 5}, {0b110000000000101, 4}, + {0b110000000000110, 2}, {0b110000000001000, 5}, + {0b110000000001001, 2}, {0b110000000001010, 4}, + {0b110000000001100, 4}, {0b110000000001111, 3}, + {0b110000000010000, 5}, {0b110000000010001, 4}, + {0b110000000010010, 4}, {0b110000000010011, 5}, + {0b110000000010100, 4}, {0b110000000010101, 5}, + {0b110000000011000, 4}, {0b110000000011010, 5}, + {0b110000000011100, 5}, {0b110000000100000, 5}, + {0b110000000100001, 4}, {0b110000000100010, 4}, + {0b110000000100011, 5}, {0b110000000100100, 4}, + {0b110000000100101, 5}, {0b110000000101000, 4}, + {0b110000000101010, 5}, {0b110000000101100, 5}, + {0b110000000110000, 4}, {0b110000000110001, 5}, + {0b110000000110010, 5}, {0b110000000110100, 5}, + {0b110000000111000, 5}, {0b110000001000000, 5}, + {0b110000001000001, 4}, {0b110000001000010, 4}, + {0b110000001000011, 5}, {0b110000001000100, 4}, + {0b110000001000101, 5}, {0b110000001001000, 4}, + {0b110000001001010, 5}, {0b110000001001100, 5}, + {0b110000001010000, 4}, {0b110000001010001, 5}, + {0b110000001010010, 5}, {0b110000001010100, 5}, + {0b110000001011000, 5}, {0b110000001100000, 2}, + {0b110000001100110, 3}, {0b110000001101001, 3}, + {0b110000001101111, 4}, {0b110000010000000, 5}, + {0b110000010000001, 4}, {0b110000010000010, 4}, + {0b110000010000011, 5}, {0b110000010000100, 4}, + {0b110000010000101, 5}, {0b110000010001000, 4}, + {0b110000010001010, 5}, {0b110000010001100, 5}, + {0b110000010010000, 2}, {0b110000010010110, 3}, + {0b110000010011001, 3}, {0b110000010011111, 4}, + {0b110000010100000, 4}, {0b110000010100001, 5}, + {0b110000010100010, 5}, {0b110000010100100, 5}, + {0b110000010101000, 5}, {0b110000011000000, 4}, + {0b110000011000001, 5}, {0b110000011000010, 5}, + {0b110000011000100, 5}, {0b110000011001000, 5}, + {0b110000011110000, 3}, {0b110000011110110, 4}, + {0b110000011111001, 4}, {0b110000011111111, 3}, + {0b110000100000000, 5}, {0b110000100000001, 4}, + {0b110000100000010, 4}, {0b110000100000011, 5}, + {0b110000100000100, 4}, {0b110000100000101, 5}, + {0b110000100001000, 4}, {0b110000100001010, 5}, + {0b110000100001100, 5}, {0b110000100010000, 4}, + {0b110000100010001, 5}, {0b110000100010110, 3}, + {0b110000100011000, 5}, {0b110000100100000, 4}, + {0b110000100100010, 5}, {0b110000100100100, 5}, + {0b110000100101001, 3}, {0b110000100110000, 5}, + {0b110000101000000, 4}, {0b110000101000010, 5}, + {0b110000101000100, 5}, {0b110000101001001, 3}, + {0b110000101010000, 5}, {0b110000101100001, 3}, + {0b110000101101000, 3}, {0b110000110000000, 4}, + {0b110000110000001, 5}, {0b110000110000110, 3}, + {0b110000110001000, 5}, {0b110000110010010, 3}, + {0b110000110010100, 3}, {0b110000110100000, 5}, + {0b110000111000000, 5}, {0b110001000000000, 5}, + {0b110001000000001, 4}, {0b110001000000010, 4}, + {0b110001000000011, 5}, {0b110001000000100, 4}, + {0b110001000000101, 5}, {0b110001000001000, 4}, + {0b110001000001010, 5}, {0b110001000001100, 5}, + {0b110001000010000, 4}, {0b110001000010010, 5}, + {0b110001000010100, 5}, {0b110001000011001, 3}, + {0b110001000100000, 4}, {0b110001000100001, 5}, + {0b110001000100110, 3}, {0b110001000101000, 5}, + {0b110001000110000, 5}, {0b110001001000000, 4}, + {0b110001001000001, 5}, {0b110001001000110, 3}, + {0b110001001001000, 5}, {0b110001001010000, 5}, + {0b110001001100010, 3}, {0b110001001100100, 3}, + {0b110001010000000, 4}, {0b110001010000010, 5}, + {0b110001010000100, 5}, {0b110001010001001, 3}, + {0b110001010010001, 3}, {0b110001010011000, 3}, + {0b110001010100000, 5}, {0b110001011000000, 5}, + {0b110001100000000, 4}, {0b110001100000001, 5}, + {0b110001100000010, 5}, {0b110001100000100, 5}, + {0b110001100001000, 5}, {0b110001100010000, 5}, + {0b110001100100000, 5}, {0b110001100110110, 4}, + {0b110001100111001, 4}, {0b110001101000000, 5}, + {0b110001101100011, 4}, {0b110001101101100, 4}, + {0b110001101111111, 5}, {0b110001110000000, 5}, + {0b110001110010011, 4}, {0b110001110011100, 4}, + {0b110001110111111, 5}, {0b110001111000110, 4}, + {0b110001111001001, 4}, {0b110001111011111, 5}, + {0b110001111101111, 5}, {0b110001111110111, 5}, + {0b110001111111011, 5}, {0b110001111111101, 5}, + {0b110001111111110, 5}, {0b110001111111111, 4}, + {0b110010000000000, 5}, {0b110010000000001, 4}, + {0b110010000000010, 4}, {0b110010000000011, 5}, + {0b110010000000100, 4}, {0b110010000000101, 5}, + {0b110010000001000, 4}, {0b110010000001010, 5}, + {0b110010000001100, 5}, {0b110010000010000, 4}, + {0b110010000010010, 5}, {0b110010000010100, 5}, + {0b110010000011001, 3}, {0b110010000100000, 4}, + {0b110010000100001, 5}, {0b110010000100110, 3}, + {0b110010000101000, 5}, {0b110010000110000, 5}, + {0b110010001000000, 4}, {0b110010001000001, 5}, + {0b110010001000110, 3}, {0b110010001001000, 5}, + {0b110010001010000, 5}, {0b110010001100010, 3}, + {0b110010001100100, 3}, {0b110010010000000, 4}, + {0b110010010000010, 5}, {0b110010010000100, 5}, + {0b110010010001001, 3}, {0b110010010010001, 3}, + {0b110010010011000, 3}, {0b110010010100000, 5}, + {0b110010011000000, 5}, {0b110010100000000, 4}, + {0b110010100000001, 5}, {0b110010100000010, 5}, + {0b110010100000100, 5}, {0b110010100001000, 5}, + {0b110010100010000, 5}, {0b110010100100000, 5}, + {0b110010101000000, 5}, {0b110010101010110, 4}, + {0b110010101011001, 4}, {0b110010101100101, 4}, + {0b110010101101010, 4}, {0b110010101111111, 5}, + {0b110010110000000, 5}, {0b110010110010101, 4}, + {0b110010110011010, 4}, {0b110010110100110, 4}, + {0b110010110101001, 4}, {0b110010110111111, 5}, + {0b110010111011111, 5}, {0b110010111101111, 5}, + {0b110010111110111, 5}, {0b110010111111011, 5}, + {0b110010111111101, 5}, {0b110010111111110, 5}, + {0b110010111111111, 4}, {0b110011000000000, 2}, + {0b110011000000110, 3}, {0b110011000001001, 3}, + {0b110011000001111, 4}, {0b110011000010001, 3}, + {0b110011000011000, 3}, {0b110011000100010, 3}, + {0b110011000100100, 3}, {0b110011000110011, 4}, + {0b110011000111100, 4}, {0b110011001000010, 3}, + {0b110011001000100, 3}, {0b110011001010101, 4}, + {0b110011001011010, 4}, {0b110011001100000, 3}, + {0b110011001100110, 1}, {0b110011001101001, 4}, + {0b110011001101111, 3}, {0b110011001110111, 3}, + {0b110011001111110, 3}, {0b110011010000001, 3}, + {0b110011010001000, 3}, {0b110011010010000, 3}, + {0b110011010010110, 4}, {0b110011010011001, 1}, + {0b110011010011111, 3}, {0b110011010100101, 4}, + {0b110011010101010, 4}, {0b110011010111011, 3}, + {0b110011010111101, 3}, {0b110011011000011, 4}, + {0b110011011001100, 4}, {0b110011011011011, 3}, + {0b110011011011101, 3}, {0b110011011100111, 3}, + {0b110011011101110, 3}, {0b110011011110000, 4}, + {0b110011011110110, 3}, {0b110011011111001, 3}, + {0b110011011111111, 2}, {0b110011100111111, 5}, + {0b110011101011111, 5}, {0b110011101100111, 3}, + {0b110011101101110, 3}, {0b110011101110110, 3}, + {0b110011101111011, 5}, {0b110011101111101, 5}, + {0b110011101111111, 4}, {0b110011110011011, 3}, + {0b110011110011101, 3}, {0b110011110101111, 5}, + {0b110011110110111, 5}, {0b110011110111001, 3}, + {0b110011110111110, 5}, {0b110011110111111, 4}, + {0b110011111001111, 5}, {0b110011111010111, 5}, + {0b110011111011001, 3}, {0b110011111011110, 5}, + {0b110011111011111, 4}, {0b110011111100110, 3}, + {0b110011111101011, 5}, {0b110011111101101, 5}, + {0b110011111101111, 4}, {0b110011111110011, 5}, + {0b110011111110101, 5}, {0b110011111110111, 4}, + {0b110011111111010, 5}, {0b110011111111011, 4}, + {0b110011111111100, 5}, {0b110011111111101, 4}, + {0b110011111111110, 4}, {0b110011111111111, 5}, + {0b110100000000000, 5}, {0b110100000000001, 4}, + {0b110100000000010, 4}, {0b110100000000011, 5}, + {0b110100000000100, 4}, {0b110100000000101, 5}, + {0b110100000001000, 4}, {0b110100000001010, 5}, + {0b110100000001100, 5}, {0b110100000010000, 4}, + {0b110100000010001, 5}, {0b110100000010110, 3}, + {0b110100000011000, 5}, {0b110100000100000, 4}, + {0b110100000100010, 5}, {0b110100000100100, 5}, + {0b110100000101001, 3}, {0b110100000110000, 5}, + {0b110100001000000, 4}, {0b110100001000010, 5}, + {0b110100001000100, 5}, {0b110100001001001, 3}, + {0b110100001010000, 5}, {0b110100001100001, 3}, + {0b110100001101000, 3}, {0b110100010000000, 4}, + {0b110100010000001, 5}, {0b110100010000110, 3}, + {0b110100010001000, 5}, {0b110100010010010, 3}, + {0b110100010010100, 3}, {0b110100010100000, 5}, + {0b110100011000000, 5}, {0b110100100000000, 2}, + {0b110100100000110, 3}, {0b110100100001001, 3}, + {0b110100100001111, 4}, {0b110100100010010, 3}, + {0b110100100010100, 3}, {0b110100100100001, 3}, + {0b110100100101000, 3}, {0b110100100110011, 4}, + {0b110100100111100, 4}, {0b110100101000001, 3}, + {0b110100101001000, 3}, {0b110100101010101, 4}, + {0b110100101011010, 4}, {0b110100101100000, 3}, + {0b110100101100110, 4}, {0b110100101101001, 1}, + {0b110100101101111, 3}, {0b110100101111011, 3}, + {0b110100101111101, 3}, {0b110100110000010, 3}, + {0b110100110000100, 3}, {0b110100110010000, 3}, + {0b110100110010110, 1}, {0b110100110011001, 4}, + {0b110100110011111, 3}, {0b110100110100101, 4}, + {0b110100110101010, 4}, {0b110100110110111, 3}, + {0b110100110111110, 3}, {0b110100111000011, 4}, + {0b110100111001100, 4}, {0b110100111010111, 3}, + {0b110100111011110, 3}, {0b110100111101011, 3}, + {0b110100111101101, 3}, {0b110100111110000, 4}, + {0b110100111110110, 3}, {0b110100111111001, 3}, + {0b110100111111111, 2}, {0b110101000000000, 4}, + {0b110101000000001, 5}, {0b110101000000010, 5}, + {0b110101000000100, 5}, {0b110101000001000, 5}, + {0b110101000010000, 5}, {0b110101000100000, 5}, + {0b110101001000000, 5}, {0b110101001010110, 4}, + {0b110101001011001, 4}, {0b110101001100101, 4}, + {0b110101001101010, 4}, {0b110101001111111, 5}, + {0b110101010000000, 5}, {0b110101010010101, 4}, + {0b110101010011010, 4}, {0b110101010100110, 4}, + {0b110101010101001, 4}, {0b110101010111111, 5}, + {0b110101011011111, 5}, {0b110101011101111, 5}, + {0b110101011110111, 5}, {0b110101011111011, 5}, + {0b110101011111101, 5}, {0b110101011111110, 5}, + {0b110101011111111, 4}, {0b110101100111111, 5}, + {0b110101101011111, 5}, {0b110101101101011, 3}, + {0b110101101101101, 3}, {0b110101101110111, 5}, + {0b110101101111001, 3}, {0b110101101111110, 5}, + {0b110101101111111, 4}, {0b110101110010111, 3}, + {0b110101110011110, 3}, {0b110101110101111, 5}, + {0b110101110110110, 3}, {0b110101110111011, 5}, + {0b110101110111101, 5}, {0b110101110111111, 4}, + {0b110101111001111, 5}, {0b110101111010110, 3}, + {0b110101111011011, 5}, {0b110101111011101, 5}, + {0b110101111011111, 4}, {0b110101111100111, 5}, + {0b110101111101001, 3}, {0b110101111101110, 5}, + {0b110101111101111, 4}, {0b110101111110011, 5}, + {0b110101111110101, 5}, {0b110101111110111, 4}, + {0b110101111111010, 5}, {0b110101111111011, 4}, + {0b110101111111100, 5}, {0b110101111111101, 4}, + {0b110101111111110, 4}, {0b110101111111111, 5}, + {0b110110000000000, 4}, {0b110110000000001, 5}, + {0b110110000000010, 5}, {0b110110000000100, 5}, + {0b110110000001000, 5}, {0b110110000010000, 5}, + {0b110110000100000, 5}, {0b110110000110110, 4}, + {0b110110000111001, 4}, {0b110110001000000, 5}, + {0b110110001100011, 4}, {0b110110001101100, 4}, + {0b110110001111111, 5}, {0b110110010000000, 5}, + {0b110110010010011, 4}, {0b110110010011100, 4}, + {0b110110010111111, 5}, {0b110110011000110, 4}, + {0b110110011001001, 4}, {0b110110011011111, 5}, + {0b110110011101111, 5}, {0b110110011110111, 5}, + {0b110110011111011, 5}, {0b110110011111101, 5}, + {0b110110011111110, 5}, {0b110110011111111, 4}, + {0b110110100111111, 5}, {0b110110101011111, 5}, + {0b110110101101011, 3}, {0b110110101101101, 3}, + {0b110110101110111, 5}, {0b110110101111001, 3}, + {0b110110101111110, 5}, {0b110110101111111, 4}, + {0b110110110010111, 3}, {0b110110110011110, 3}, + {0b110110110101111, 5}, {0b110110110110110, 3}, + {0b110110110111011, 5}, {0b110110110111101, 5}, + {0b110110110111111, 4}, {0b110110111001111, 5}, + {0b110110111010110, 3}, {0b110110111011011, 5}, + {0b110110111011101, 5}, {0b110110111011111, 4}, + {0b110110111100111, 5}, {0b110110111101001, 3}, + {0b110110111101110, 5}, {0b110110111101111, 4}, + {0b110110111110011, 5}, {0b110110111110101, 5}, + {0b110110111110111, 4}, {0b110110111111010, 5}, + {0b110110111111011, 4}, {0b110110111111100, 5}, + {0b110110111111101, 4}, {0b110110111111110, 4}, + {0b110110111111111, 5}, {0b110111000111111, 5}, + {0b110111001011111, 5}, {0b110111001100111, 3}, + {0b110111001101110, 3}, {0b110111001110110, 3}, + {0b110111001111011, 5}, {0b110111001111101, 5}, + {0b110111001111111, 4}, {0b110111010011011, 3}, + {0b110111010011101, 3}, {0b110111010101111, 5}, + {0b110111010110111, 5}, {0b110111010111001, 3}, + {0b110111010111110, 5}, {0b110111010111111, 4}, + {0b110111011001111, 5}, {0b110111011010111, 5}, + {0b110111011011001, 3}, {0b110111011011110, 5}, + {0b110111011011111, 4}, {0b110111011100110, 3}, + {0b110111011101011, 5}, {0b110111011101101, 5}, + {0b110111011101111, 4}, {0b110111011110011, 5}, + {0b110111011110101, 5}, {0b110111011110111, 4}, + {0b110111011111010, 5}, {0b110111011111011, 4}, + {0b110111011111100, 5}, {0b110111011111101, 4}, + {0b110111011111110, 4}, {0b110111011111111, 5}, + {0b110111100000000, 3}, {0b110111100000110, 4}, + {0b110111100001001, 4}, {0b110111100001111, 3}, + {0b110111100110111, 5}, {0b110111100111011, 5}, + {0b110111100111101, 5}, {0b110111100111110, 5}, + {0b110111100111111, 4}, {0b110111101010111, 5}, + {0b110111101011011, 5}, {0b110111101011101, 5}, + {0b110111101011110, 5}, {0b110111101011111, 4}, + {0b110111101100000, 4}, {0b110111101100110, 3}, + {0b110111101101001, 3}, {0b110111101101111, 2}, + {0b110111101110011, 5}, {0b110111101110101, 5}, + {0b110111101110111, 4}, {0b110111101111010, 5}, + {0b110111101111011, 4}, {0b110111101111100, 5}, + {0b110111101111101, 4}, {0b110111101111110, 4}, + {0b110111101111111, 5}, {0b110111110010000, 4}, + {0b110111110010110, 3}, {0b110111110011001, 3}, + {0b110111110011111, 2}, {0b110111110100111, 5}, + {0b110111110101011, 5}, {0b110111110101101, 5}, + {0b110111110101110, 5}, {0b110111110101111, 4}, + {0b110111110110011, 5}, {0b110111110110101, 5}, + {0b110111110110111, 4}, {0b110111110111010, 5}, + {0b110111110111011, 4}, {0b110111110111100, 5}, + {0b110111110111101, 4}, {0b110111110111110, 4}, + {0b110111110111111, 5}, {0b110111111000111, 5}, + {0b110111111001011, 5}, {0b110111111001101, 5}, + {0b110111111001110, 5}, {0b110111111001111, 4}, + {0b110111111010011, 5}, {0b110111111010101, 5}, + {0b110111111010111, 4}, {0b110111111011010, 5}, + {0b110111111011011, 4}, {0b110111111011100, 5}, + {0b110111111011101, 4}, {0b110111111011110, 4}, + {0b110111111011111, 5}, {0b110111111100011, 5}, + {0b110111111100101, 5}, {0b110111111100111, 4}, + {0b110111111101010, 5}, {0b110111111101011, 4}, + {0b110111111101100, 5}, {0b110111111101101, 4}, + {0b110111111101110, 4}, {0b110111111101111, 5}, + {0b110111111110000, 3}, {0b110111111110011, 4}, + {0b110111111110101, 4}, {0b110111111110110, 2}, + {0b110111111110111, 5}, {0b110111111111001, 2}, + {0b110111111111010, 4}, {0b110111111111011, 5}, + {0b110111111111100, 4}, {0b110111111111101, 5}, + {0b110111111111110, 5}, {0b110111111111111, 3}, + {0b111000000000000, 5}, {0b111000000000001, 4}, + {0b111000000000010, 4}, {0b111000000000100, 4}, + {0b111000000000111, 3}, {0b111000000001000, 4}, + {0b111000000001011, 3}, {0b111000000001101, 3}, + {0b111000000001110, 3}, {0b111000000010000, 4}, + {0b111000000010001, 5}, {0b111000000010010, 5}, + {0b111000000010100, 5}, {0b111000000011000, 5}, + {0b111000000100000, 4}, {0b111000000100001, 5}, + {0b111000000100010, 5}, {0b111000000100100, 5}, + {0b111000000101000, 5}, {0b111000001000000, 4}, + {0b111000001000001, 5}, {0b111000001000010, 5}, + {0b111000001000100, 5}, {0b111000001001000, 5}, + {0b111000001110000, 3}, {0b111000010000000, 4}, + {0b111000010000001, 5}, {0b111000010000010, 5}, + {0b111000010000100, 5}, {0b111000010001000, 5}, + {0b111000010110000, 3}, {0b111000011010000, 3}, + {0b111000011100000, 3}, {0b111000100000000, 4}, + {0b111000100000001, 5}, {0b111000100000010, 5}, + {0b111000100000100, 5}, {0b111000100001000, 5}, + {0b111000100010000, 5}, {0b111000100010111, 4}, + {0b111000100100000, 5}, {0b111000100101011, 4}, + {0b111000101000000, 5}, {0b111000101001101, 4}, + {0b111000101110001, 4}, {0b111000101111111, 5}, + {0b111000110000000, 5}, {0b111000110001110, 4}, + {0b111000110110010, 4}, {0b111000110111111, 5}, + {0b111000111010100, 4}, {0b111000111011111, 5}, + {0b111000111101000, 4}, {0b111000111101111, 5}, + {0b111000111110111, 5}, {0b111000111111011, 5}, + {0b111000111111101, 5}, {0b111000111111110, 5}, + {0b111000111111111, 4}, {0b111001000000000, 4}, + {0b111001000000001, 5}, {0b111001000000010, 5}, + {0b111001000000100, 5}, {0b111001000001000, 5}, + {0b111001000010000, 5}, {0b111001000011011, 4}, + {0b111001000100000, 5}, {0b111001000100111, 4}, + {0b111001001000000, 5}, {0b111001001001110, 4}, + {0b111001001110010, 4}, {0b111001001111111, 5}, + {0b111001010000000, 5}, {0b111001010001101, 4}, + {0b111001010110001, 4}, {0b111001010111111, 5}, + {0b111001011011000, 4}, {0b111001011011111, 5}, + {0b111001011100100, 4}, {0b111001011101111, 5}, + {0b111001011110111, 5}, {0b111001011111011, 5}, + {0b111001011111101, 5}, {0b111001011111110, 5}, + {0b111001011111111, 4}, {0b111001100110111, 3}, + {0b111001100111011, 3}, {0b111001101011111, 5}, + {0b111001101101111, 5}, {0b111001101110011, 3}, + {0b111001101111101, 5}, {0b111001101111110, 5}, + {0b111001101111111, 4}, {0b111001110011111, 5}, + {0b111001110101111, 5}, {0b111001110110011, 3}, + {0b111001110111101, 5}, {0b111001110111110, 5}, + {0b111001110111111, 4}, {0b111001111001101, 3}, + {0b111001111001110, 3}, {0b111001111010111, 5}, + {0b111001111011011, 5}, {0b111001111011100, 3}, + {0b111001111011111, 4}, {0b111001111100111, 5}, + {0b111001111101011, 5}, {0b111001111101100, 3}, + {0b111001111101111, 4}, {0b111001111110101, 5}, + {0b111001111110110, 5}, {0b111001111110111, 4}, + {0b111001111111001, 5}, {0b111001111111010, 5}, + {0b111001111111011, 4}, {0b111001111111101, 4}, + {0b111001111111110, 4}, {0b111001111111111, 5}, + {0b111010000000000, 4}, {0b111010000000001, 5}, + {0b111010000000010, 5}, {0b111010000000100, 5}, + {0b111010000001000, 5}, {0b111010000010000, 5}, + {0b111010000011101, 4}, {0b111010000100000, 5}, + {0b111010000101110, 4}, {0b111010001000000, 5}, + {0b111010001000111, 4}, {0b111010001110100, 4}, + {0b111010001111111, 5}, {0b111010010000000, 5}, + {0b111010010001011, 4}, {0b111010010111000, 4}, + {0b111010010111111, 5}, {0b111010011010001, 4}, + {0b111010011011111, 5}, {0b111010011100010, 4}, + {0b111010011101111, 5}, {0b111010011110111, 5}, + {0b111010011111011, 5}, {0b111010011111101, 5}, + {0b111010011111110, 5}, {0b111010011111111, 4}, + {0b111010100111111, 5}, {0b111010101010111, 3}, + {0b111010101011101, 3}, {0b111010101101111, 5}, + {0b111010101110101, 3}, {0b111010101111011, 5}, + {0b111010101111110, 5}, {0b111010101111111, 4}, + {0b111010110011111, 5}, {0b111010110101011, 3}, + {0b111010110101110, 3}, {0b111010110110111, 5}, + {0b111010110111010, 3}, {0b111010110111101, 5}, + {0b111010110111111, 4}, {0b111010111001111, 5}, + {0b111010111010101, 3}, {0b111010111011011, 5}, + {0b111010111011110, 5}, {0b111010111011111, 4}, + {0b111010111100111, 5}, {0b111010111101010, 3}, + {0b111010111101101, 5}, {0b111010111101111, 4}, + {0b111010111110011, 5}, {0b111010111110110, 5}, + {0b111010111110111, 4}, {0b111010111111001, 5}, + {0b111010111111011, 4}, {0b111010111111100, 5}, + {0b111010111111101, 4}, {0b111010111111110, 4}, + {0b111010111111111, 5}, {0b111011000111111, 5}, + {0b111011001011111, 5}, {0b111011001100111, 3}, + {0b111011001101110, 3}, {0b111011001110110, 3}, + {0b111011001111011, 5}, {0b111011001111101, 5}, + {0b111011001111111, 4}, {0b111011010011011, 3}, + {0b111011010011101, 3}, {0b111011010101111, 5}, + {0b111011010110111, 5}, {0b111011010111001, 3}, + {0b111011010111110, 5}, {0b111011010111111, 4}, + {0b111011011001111, 5}, {0b111011011010111, 5}, + {0b111011011011001, 3}, {0b111011011011110, 5}, + {0b111011011011111, 4}, {0b111011011100110, 3}, + {0b111011011101011, 5}, {0b111011011101101, 5}, + {0b111011011101111, 4}, {0b111011011110011, 5}, + {0b111011011110101, 5}, {0b111011011110111, 4}, + {0b111011011111010, 5}, {0b111011011111011, 4}, + {0b111011011111100, 5}, {0b111011011111101, 4}, + {0b111011011111110, 4}, {0b111011011111111, 5}, + {0b111011100000000, 3}, {0b111011100010001, 4}, + {0b111011100011111, 5}, {0b111011100100010, 4}, + {0b111011100101111, 5}, {0b111011100110011, 3}, + {0b111011100111101, 5}, {0b111011100111110, 5}, + {0b111011100111111, 4}, {0b111011101000100, 4}, + {0b111011101001111, 5}, {0b111011101010101, 3}, + {0b111011101011011, 5}, {0b111011101011110, 5}, + {0b111011101011111, 4}, {0b111011101100110, 3}, + {0b111011101101011, 5}, {0b111011101101101, 5}, + {0b111011101101111, 4}, {0b111011101110111, 2}, + {0b111011101111001, 5}, {0b111011101111010, 5}, + {0b111011101111011, 4}, {0b111011101111100, 5}, + {0b111011101111101, 4}, {0b111011101111110, 4}, + {0b111011101111111, 5}, {0b111011110001000, 4}, + {0b111011110001111, 5}, {0b111011110010111, 5}, + {0b111011110011001, 3}, {0b111011110011110, 5}, + {0b111011110011111, 4}, {0b111011110100111, 5}, + {0b111011110101010, 3}, {0b111011110101101, 5}, + {0b111011110101111, 4}, {0b111011110110101, 5}, + {0b111011110110110, 5}, {0b111011110110111, 4}, + {0b111011110111011, 2}, {0b111011110111100, 5}, + {0b111011110111101, 4}, {0b111011110111110, 4}, + {0b111011110111111, 5}, {0b111011111000111, 5}, + {0b111011111001011, 5}, {0b111011111001100, 3}, + {0b111011111001111, 4}, {0b111011111010011, 5}, + {0b111011111010110, 5}, {0b111011111010111, 4}, + {0b111011111011010, 5}, {0b111011111011011, 4}, + {0b111011111011101, 2}, {0b111011111011110, 4}, + {0b111011111011111, 5}, {0b111011111100011, 5}, + {0b111011111100101, 5}, {0b111011111100111, 4}, + {0b111011111101001, 5}, {0b111011111101011, 4}, + {0b111011111101101, 4}, {0b111011111101110, 2}, + {0b111011111101111, 5}, {0b111011111110001, 5}, + {0b111011111110010, 5}, {0b111011111110011, 4}, + {0b111011111110100, 5}, {0b111011111110101, 4}, + {0b111011111110110, 4}, {0b111011111110111, 5}, + {0b111011111111000, 5}, {0b111011111111001, 4}, + {0b111011111111010, 4}, {0b111011111111011, 5}, + {0b111011111111100, 4}, {0b111011111111101, 5}, + {0b111011111111110, 5}, {0b111011111111111, 3}, + {0b111100000000000, 4}, {0b111100000000001, 5}, + {0b111100000000010, 5}, {0b111100000000100, 5}, + {0b111100000001000, 5}, {0b111100000010000, 5}, + {0b111100000011110, 4}, {0b111100000100000, 5}, + {0b111100000101101, 4}, {0b111100001000000, 5}, + {0b111100001001011, 4}, {0b111100001111000, 4}, + {0b111100001111111, 5}, {0b111100010000000, 5}, + {0b111100010000111, 4}, {0b111100010110100, 4}, + {0b111100010111111, 5}, {0b111100011010010, 4}, + {0b111100011011111, 5}, {0b111100011100001, 4}, + {0b111100011101111, 5}, {0b111100011110111, 5}, + {0b111100011111011, 5}, {0b111100011111101, 5}, + {0b111100011111110, 5}, {0b111100011111111, 4}, + {0b111100100111111, 5}, {0b111100101011111, 5}, + {0b111100101101011, 3}, {0b111100101101101, 3}, + {0b111100101110111, 5}, {0b111100101111001, 3}, + {0b111100101111110, 5}, {0b111100101111111, 4}, + {0b111100110010111, 3}, {0b111100110011110, 3}, + {0b111100110101111, 5}, {0b111100110110110, 3}, + {0b111100110111011, 5}, {0b111100110111101, 5}, + {0b111100110111111, 4}, {0b111100111001111, 5}, + {0b111100111010110, 3}, {0b111100111011011, 5}, + {0b111100111011101, 5}, {0b111100111011111, 4}, + {0b111100111100111, 5}, {0b111100111101001, 3}, + {0b111100111101110, 5}, {0b111100111101111, 4}, + {0b111100111110011, 5}, {0b111100111110101, 5}, + {0b111100111110111, 4}, {0b111100111111010, 5}, + {0b111100111111011, 4}, {0b111100111111100, 5}, + {0b111100111111101, 4}, {0b111100111111110, 4}, + {0b111100111111111, 5}, {0b111101000111111, 5}, + {0b111101001011011, 3}, {0b111101001011110, 3}, + {0b111101001101111, 5}, {0b111101001110111, 5}, + {0b111101001111010, 3}, {0b111101001111101, 5}, + {0b111101001111111, 4}, {0b111101010011111, 5}, + {0b111101010100111, 3}, {0b111101010101101, 3}, + {0b111101010110101, 3}, {0b111101010111011, 5}, + {0b111101010111110, 5}, {0b111101010111111, 4}, + {0b111101011001111, 5}, {0b111101011010111, 5}, + {0b111101011011010, 3}, {0b111101011011101, 5}, + {0b111101011011111, 4}, {0b111101011100101, 3}, + {0b111101011101011, 5}, {0b111101011101110, 5}, + {0b111101011101111, 4}, {0b111101011110011, 5}, + {0b111101011110110, 5}, {0b111101011110111, 4}, + {0b111101011111001, 5}, {0b111101011111011, 4}, + {0b111101011111100, 5}, {0b111101011111101, 4}, + {0b111101011111110, 4}, {0b111101011111111, 5}, + {0b111101100000000, 3}, {0b111101100010010, 4}, + {0b111101100011111, 5}, {0b111101100100001, 4}, + {0b111101100101111, 5}, {0b111101100110011, 3}, + {0b111101100111101, 5}, {0b111101100111110, 5}, + {0b111101100111111, 4}, {0b111101101001000, 4}, + {0b111101101001111, 5}, {0b111101101010111, 5}, + {0b111101101011010, 3}, {0b111101101011101, 5}, + {0b111101101011111, 4}, {0b111101101100111, 5}, + {0b111101101101001, 3}, {0b111101101101110, 5}, + {0b111101101101111, 4}, {0b111101101110101, 5}, + {0b111101101110110, 5}, {0b111101101110111, 4}, + {0b111101101111011, 2}, {0b111101101111100, 5}, + {0b111101101111101, 4}, {0b111101101111110, 4}, + {0b111101101111111, 5}, {0b111101110000100, 4}, + {0b111101110001111, 5}, {0b111101110010110, 3}, + {0b111101110011011, 5}, {0b111101110011101, 5}, + {0b111101110011111, 4}, {0b111101110100101, 3}, + {0b111101110101011, 5}, {0b111101110101110, 5}, + {0b111101110101111, 4}, {0b111101110110111, 2}, + {0b111101110111001, 5}, {0b111101110111010, 5}, + {0b111101110111011, 4}, {0b111101110111100, 5}, + {0b111101110111101, 4}, {0b111101110111110, 4}, + {0b111101110111111, 5}, {0b111101111000111, 5}, + {0b111101111001011, 5}, {0b111101111001100, 3}, + {0b111101111001111, 4}, {0b111101111010011, 5}, + {0b111101111010101, 5}, {0b111101111010111, 4}, + {0b111101111011001, 5}, {0b111101111011011, 4}, + {0b111101111011101, 4}, {0b111101111011110, 2}, + {0b111101111011111, 5}, {0b111101111100011, 5}, + {0b111101111100110, 5}, {0b111101111100111, 4}, + {0b111101111101010, 5}, {0b111101111101011, 4}, + {0b111101111101101, 2}, {0b111101111101110, 4}, + {0b111101111101111, 5}, {0b111101111110001, 5}, + {0b111101111110010, 5}, {0b111101111110011, 4}, + {0b111101111110100, 5}, {0b111101111110101, 4}, + {0b111101111110110, 4}, {0b111101111110111, 5}, + {0b111101111111000, 5}, {0b111101111111001, 4}, + {0b111101111111010, 4}, {0b111101111111011, 5}, + {0b111101111111100, 4}, {0b111101111111101, 5}, + {0b111101111111110, 5}, {0b111101111111111, 3}, + {0b111110000111101, 3}, {0b111110000111110, 3}, + {0b111110001011111, 5}, {0b111110001101111, 5}, + {0b111110001110111, 5}, {0b111110001111011, 5}, + {0b111110001111100, 3}, {0b111110001111111, 4}, + {0b111110010011111, 5}, {0b111110010101111, 5}, + {0b111110010110111, 5}, {0b111110010111011, 5}, + {0b111110010111100, 3}, {0b111110010111111, 4}, + {0b111110011000111, 3}, {0b111110011001011, 3}, + {0b111110011010011, 3}, {0b111110011011101, 5}, + {0b111110011011110, 5}, {0b111110011011111, 4}, + {0b111110011100011, 3}, {0b111110011101101, 5}, + {0b111110011101110, 5}, {0b111110011101111, 4}, + {0b111110011110101, 5}, {0b111110011110110, 5}, + {0b111110011110111, 4}, {0b111110011111001, 5}, + {0b111110011111010, 5}, {0b111110011111011, 4}, + {0b111110011111101, 4}, {0b111110011111110, 4}, + {0b111110011111111, 5}, {0b111110100000000, 3}, + {0b111110100010100, 4}, {0b111110100011111, 5}, + {0b111110100101000, 4}, {0b111110100101111, 5}, + {0b111110100110111, 5}, {0b111110100111011, 5}, + {0b111110100111100, 3}, {0b111110100111111, 4}, + {0b111110101000001, 4}, {0b111110101001111, 5}, + {0b111110101010101, 3}, {0b111110101011011, 5}, + {0b111110101011110, 5}, {0b111110101011111, 4}, + {0b111110101100111, 5}, {0b111110101101001, 3}, + {0b111110101101110, 5}, {0b111110101101111, 4}, + {0b111110101110011, 5}, {0b111110101110110, 5}, + {0b111110101110111, 4}, {0b111110101111010, 5}, + {0b111110101111011, 4}, {0b111110101111101, 2}, + {0b111110101111110, 4}, {0b111110101111111, 5}, + {0b111110110000010, 4}, {0b111110110001111, 5}, + {0b111110110010110, 3}, {0b111110110011011, 5}, + {0b111110110011101, 5}, {0b111110110011111, 4}, + {0b111110110100111, 5}, {0b111110110101010, 3}, + {0b111110110101101, 5}, {0b111110110101111, 4}, + {0b111110110110011, 5}, {0b111110110110101, 5}, + {0b111110110110111, 4}, {0b111110110111001, 5}, + {0b111110110111011, 4}, {0b111110110111101, 4}, + {0b111110110111110, 2}, {0b111110110111111, 5}, + {0b111110111000011, 3}, {0b111110111001101, 5}, + {0b111110111001110, 5}, {0b111110111001111, 4}, + {0b111110111010111, 2}, {0b111110111011001, 5}, + {0b111110111011010, 5}, {0b111110111011011, 4}, + {0b111110111011100, 5}, {0b111110111011101, 4}, + {0b111110111011110, 4}, {0b111110111011111, 5}, + {0b111110111100101, 5}, {0b111110111100110, 5}, + {0b111110111100111, 4}, {0b111110111101011, 2}, + {0b111110111101100, 5}, {0b111110111101101, 4}, + {0b111110111101110, 4}, {0b111110111101111, 5}, + {0b111110111110001, 5}, {0b111110111110010, 5}, + {0b111110111110011, 4}, {0b111110111110100, 5}, + {0b111110111110101, 4}, {0b111110111110110, 4}, + {0b111110111110111, 5}, {0b111110111111000, 5}, + {0b111110111111001, 4}, {0b111110111111010, 4}, + {0b111110111111011, 5}, {0b111110111111100, 4}, + {0b111110111111101, 5}, {0b111110111111110, 5}, + {0b111110111111111, 3}, {0b111111000000000, 3}, + {0b111111000011000, 4}, {0b111111000011111, 5}, + {0b111111000100100, 4}, {0b111111000101111, 5}, + {0b111111000110111, 5}, {0b111111000111011, 5}, + {0b111111000111100, 3}, {0b111111000111111, 4}, + {0b111111001000010, 4}, {0b111111001001111, 5}, + {0b111111001010111, 5}, {0b111111001011010, 3}, + {0b111111001011101, 5}, {0b111111001011111, 4}, + {0b111111001100110, 3}, {0b111111001101011, 5}, + {0b111111001101101, 5}, {0b111111001101111, 4}, + {0b111111001110011, 5}, {0b111111001110101, 5}, + {0b111111001110111, 4}, {0b111111001111001, 5}, + {0b111111001111011, 4}, {0b111111001111101, 4}, + {0b111111001111110, 2}, {0b111111001111111, 5}, + {0b111111010000001, 4}, {0b111111010001111, 5}, + {0b111111010010111, 5}, {0b111111010011001, 3}, + {0b111111010011110, 5}, {0b111111010011111, 4}, + {0b111111010100101, 3}, {0b111111010101011, 5}, + {0b111111010101110, 5}, {0b111111010101111, 4}, + {0b111111010110011, 5}, {0b111111010110110, 5}, + {0b111111010110111, 4}, {0b111111010111010, 5}, + {0b111111010111011, 4}, {0b111111010111101, 2}, + {0b111111010111110, 4}, {0b111111010111111, 5}, + {0b111111011000011, 3}, {0b111111011001101, 5}, + {0b111111011001110, 5}, {0b111111011001111, 4}, + {0b111111011010101, 5}, {0b111111011010110, 5}, + {0b111111011010111, 4}, {0b111111011011011, 2}, + {0b111111011011100, 5}, {0b111111011011101, 4}, + {0b111111011011110, 4}, {0b111111011011111, 5}, + {0b111111011100111, 2}, {0b111111011101001, 5}, + {0b111111011101010, 5}, {0b111111011101011, 4}, + {0b111111011101100, 5}, {0b111111011101101, 4}, + {0b111111011101110, 4}, {0b111111011101111, 5}, + {0b111111011110001, 5}, {0b111111011110010, 5}, + {0b111111011110011, 4}, {0b111111011110100, 5}, + {0b111111011110101, 4}, {0b111111011110110, 4}, + {0b111111011110111, 5}, {0b111111011111000, 5}, + {0b111111011111001, 4}, {0b111111011111010, 4}, + {0b111111011111011, 5}, {0b111111011111100, 4}, + {0b111111011111101, 5}, {0b111111011111110, 5}, + {0b111111011111111, 3}, {0b111111100010111, 5}, + {0b111111100011011, 5}, {0b111111100011101, 5}, + {0b111111100011110, 5}, {0b111111100011111, 4}, + {0b111111100100111, 5}, {0b111111100101011, 5}, + {0b111111100101101, 5}, {0b111111100101110, 5}, + {0b111111100101111, 4}, {0b111111100110101, 5}, + {0b111111100110110, 5}, {0b111111100110111, 4}, + {0b111111100111001, 5}, {0b111111100111010, 5}, + {0b111111100111011, 4}, {0b111111100111101, 4}, + {0b111111100111110, 4}, {0b111111100111111, 5}, + {0b111111101000111, 5}, {0b111111101001011, 5}, + {0b111111101001101, 5}, {0b111111101001110, 5}, + {0b111111101001111, 4}, {0b111111101010011, 5}, + {0b111111101010110, 5}, {0b111111101010111, 4}, + {0b111111101011001, 5}, {0b111111101011011, 4}, + {0b111111101011100, 5}, {0b111111101011101, 4}, + {0b111111101011110, 4}, {0b111111101011111, 5}, + {0b111111101100011, 5}, {0b111111101100101, 5}, + {0b111111101100111, 4}, {0b111111101101010, 5}, + {0b111111101101011, 4}, {0b111111101101100, 5}, + {0b111111101101101, 4}, {0b111111101101110, 4}, + {0b111111101101111, 5}, {0b111111101110001, 5}, + {0b111111101110010, 5}, {0b111111101110011, 4}, + {0b111111101110100, 5}, {0b111111101110101, 4}, + {0b111111101110110, 4}, {0b111111101110111, 5}, + {0b111111101111000, 5}, {0b111111101111001, 4}, + {0b111111101111010, 4}, {0b111111101111011, 5}, + {0b111111101111100, 4}, {0b111111101111101, 5}, + {0b111111101111110, 5}, {0b111111101111111, 3}, + {0b111111110000111, 5}, {0b111111110001011, 5}, + {0b111111110001101, 5}, {0b111111110001110, 5}, + {0b111111110001111, 4}, {0b111111110010011, 5}, + {0b111111110010101, 5}, {0b111111110010111, 4}, + {0b111111110011010, 5}, {0b111111110011011, 4}, + {0b111111110011100, 5}, {0b111111110011101, 4}, + {0b111111110011110, 4}, {0b111111110011111, 5}, + {0b111111110100011, 5}, {0b111111110100110, 5}, + {0b111111110100111, 4}, {0b111111110101001, 5}, + {0b111111110101011, 4}, {0b111111110101100, 5}, + {0b111111110101101, 4}, {0b111111110101110, 4}, + {0b111111110101111, 5}, {0b111111110110001, 5}, + {0b111111110110010, 5}, {0b111111110110011, 4}, + {0b111111110110100, 5}, {0b111111110110101, 4}, + {0b111111110110110, 4}, {0b111111110110111, 5}, + {0b111111110111000, 5}, {0b111111110111001, 4}, + {0b111111110111010, 4}, {0b111111110111011, 5}, + {0b111111110111100, 4}, {0b111111110111101, 5}, + {0b111111110111110, 5}, {0b111111110111111, 3}, + {0b111111111000101, 5}, {0b111111111000110, 5}, + {0b111111111000111, 4}, {0b111111111001001, 5}, + {0b111111111001010, 5}, {0b111111111001011, 4}, + {0b111111111001101, 4}, {0b111111111001110, 4}, + {0b111111111001111, 5}, {0b111111111010001, 5}, + {0b111111111010010, 5}, {0b111111111010011, 4}, + {0b111111111010100, 5}, {0b111111111010101, 4}, + {0b111111111010110, 4}, {0b111111111010111, 5}, + {0b111111111011000, 5}, {0b111111111011001, 4}, + {0b111111111011010, 4}, {0b111111111011011, 5}, + {0b111111111011100, 4}, {0b111111111011101, 5}, + {0b111111111011110, 5}, {0b111111111011111, 3}, + {0b111111111100001, 5}, {0b111111111100010, 5}, + {0b111111111100011, 4}, {0b111111111100100, 5}, + {0b111111111100101, 4}, {0b111111111100110, 4}, + {0b111111111100111, 5}, {0b111111111101000, 5}, + {0b111111111101001, 4}, {0b111111111101010, 4}, + {0b111111111101011, 5}, {0b111111111101100, 4}, + {0b111111111101101, 5}, {0b111111111101110, 5}, + {0b111111111101111, 3}, {0b111111111110001, 4}, + {0b111111111110010, 4}, {0b111111111110011, 5}, + {0b111111111110100, 4}, {0b111111111110101, 5}, + {0b111111111110110, 5}, {0b111111111110111, 3}, + {0b111111111111000, 4}, {0b111111111111001, 5}, + {0b111111111111010, 5}, {0b111111111111011, 3}, + {0b111111111111100, 5}, {0b111111111111101, 3}, + {0b111111111111110, 3}, {0b111111111111111, 4}, + {0b1000000000000000, 4}, {0b1000000000000001, 3}, + {0b1000000000000010, 3}, {0b1000000000000011, 5}, + {0b1000000000000100, 3}, {0b1000000000000101, 5}, + {0b1000000000000110, 5}, {0b1000000000000111, 4}, + {0b1000000000001000, 3}, {0b1000000000001001, 5}, + {0b1000000000001010, 5}, {0b1000000000001011, 4}, + {0b1000000000001100, 5}, {0b1000000000001101, 4}, + {0b1000000000001110, 4}, {0b1000000000010000, 3}, + {0b1000000000010001, 5}, {0b1000000000010010, 5}, + {0b1000000000010011, 4}, {0b1000000000010100, 5}, + {0b1000000000010101, 4}, {0b1000000000010110, 4}, + {0b1000000000010111, 5}, {0b1000000000011000, 5}, + {0b1000000000011001, 4}, {0b1000000000011010, 4}, + {0b1000000000011011, 5}, {0b1000000000011100, 4}, + {0b1000000000011101, 5}, {0b1000000000011110, 5}, + {0b1000000000100000, 3}, {0b1000000000100001, 5}, + {0b1000000000100010, 5}, {0b1000000000100011, 4}, + {0b1000000000100100, 5}, {0b1000000000100101, 4}, + {0b1000000000100110, 4}, {0b1000000000100111, 5}, + {0b1000000000101000, 5}, {0b1000000000101001, 4}, + {0b1000000000101010, 4}, {0b1000000000101011, 5}, + {0b1000000000101100, 4}, {0b1000000000101101, 5}, + {0b1000000000101110, 5}, {0b1000000000110000, 5}, + {0b1000000000110001, 4}, {0b1000000000110010, 4}, + {0b1000000000110100, 4}, {0b1000000000110101, 5}, + {0b1000000000110110, 5}, {0b1000000000111000, 4}, + {0b1000000000111001, 5}, {0b1000000000111010, 5}, + {0b1000000001000000, 3}, {0b1000000001000001, 5}, + {0b1000000001000010, 5}, {0b1000000001000011, 4}, + {0b1000000001000100, 5}, {0b1000000001000101, 4}, + {0b1000000001000110, 4}, {0b1000000001000111, 5}, + {0b1000000001001000, 5}, {0b1000000001001001, 4}, + {0b1000000001001010, 4}, {0b1000000001001011, 5}, + {0b1000000001001100, 4}, {0b1000000001001101, 5}, + {0b1000000001001110, 5}, {0b1000000001010000, 5}, + {0b1000000001010001, 4}, {0b1000000001010010, 4}, + {0b1000000001010011, 5}, {0b1000000001010100, 4}, + {0b1000000001010110, 5}, {0b1000000001011000, 4}, + {0b1000000001011001, 5}, {0b1000000001011100, 5}, + {0b1000000001100000, 5}, {0b1000000001100001, 4}, + {0b1000000001100010, 4}, {0b1000000001100011, 5}, + {0b1000000001100100, 4}, {0b1000000001100101, 5}, + {0b1000000001101000, 4}, {0b1000000001101010, 5}, + {0b1000000001101100, 5}, {0b1000000001110000, 4}, + {0b1000000001110001, 5}, {0b1000000001110010, 5}, + {0b1000000001110100, 5}, {0b1000000001111000, 5}, + {0b1000000010000000, 3}, {0b1000000010000001, 5}, + {0b1000000010000010, 5}, {0b1000000010000011, 4}, + {0b1000000010000100, 5}, {0b1000000010000101, 4}, + {0b1000000010000110, 4}, {0b1000000010000111, 5}, + {0b1000000010001000, 5}, {0b1000000010001001, 4}, + {0b1000000010001010, 4}, {0b1000000010001011, 5}, + {0b1000000010001100, 4}, {0b1000000010001101, 5}, + {0b1000000010001110, 5}, {0b1000000010010000, 5}, + {0b1000000010010001, 4}, {0b1000000010010010, 4}, + {0b1000000010010011, 5}, {0b1000000010010100, 4}, + {0b1000000010010101, 5}, {0b1000000010011000, 4}, + {0b1000000010011010, 5}, {0b1000000010011100, 5}, + {0b1000000010100000, 5}, {0b1000000010100001, 4}, + {0b1000000010100010, 4}, {0b1000000010100011, 5}, + {0b1000000010100100, 4}, {0b1000000010100110, 5}, + {0b1000000010101000, 4}, {0b1000000010101001, 5}, + {0b1000000010101100, 5}, {0b1000000010110000, 4}, + {0b1000000010110001, 5}, {0b1000000010110010, 5}, + {0b1000000010110100, 5}, {0b1000000010111000, 5}, + {0b1000000011000000, 5}, {0b1000000011000001, 4}, + {0b1000000011000010, 4}, {0b1000000011000100, 4}, + {0b1000000011000101, 5}, {0b1000000011000110, 5}, + {0b1000000011001000, 4}, {0b1000000011001001, 5}, + {0b1000000011001010, 5}, {0b1000000011010000, 4}, + {0b1000000011010001, 5}, {0b1000000011010010, 5}, + {0b1000000011010100, 5}, {0b1000000011011000, 5}, + {0b1000000011100000, 4}, {0b1000000011100001, 5}, + {0b1000000011100010, 5}, {0b1000000011100100, 5}, + {0b1000000011101000, 5}, {0b1000000100000000, 3}, + {0b1000000100000001, 5}, {0b1000000100000010, 5}, + {0b1000000100000011, 4}, {0b1000000100000100, 5}, + {0b1000000100000101, 4}, {0b1000000100000110, 4}, + {0b1000000100000111, 5}, {0b1000000100001000, 5}, + {0b1000000100001001, 4}, {0b1000000100001010, 4}, + {0b1000000100001011, 5}, {0b1000000100001100, 4}, + {0b1000000100001101, 5}, {0b1000000100001110, 5}, + {0b1000000100010000, 5}, {0b1000000100010001, 4}, + {0b1000000100010010, 4}, {0b1000000100010011, 5}, + {0b1000000100010100, 4}, {0b1000000100010101, 5}, + {0b1000000100010110, 5}, {0b1000000100011000, 2}, + {0b1000000100100000, 5}, {0b1000000100100001, 4}, + {0b1000000100100010, 4}, {0b1000000100100011, 5}, + {0b1000000100100100, 2}, {0b1000000100101000, 4}, + {0b1000000100101001, 5}, {0b1000000100101010, 5}, + {0b1000000100110000, 4}, {0b1000000100110001, 5}, + {0b1000000100110010, 5}, {0b1000000100111100, 3}, + {0b1000000101000000, 5}, {0b1000000101000001, 4}, + {0b1000000101000010, 2}, {0b1000000101000100, 4}, + {0b1000000101000101, 5}, {0b1000000101001000, 4}, + {0b1000000101001001, 5}, {0b1000000101001100, 5}, + {0b1000000101010000, 4}, {0b1000000101010001, 5}, + {0b1000000101010100, 5}, {0b1000000101011010, 3}, + {0b1000000101100000, 4}, {0b1000000101100001, 5}, + {0b1000000101100110, 3}, {0b1000000101101000, 5}, + {0b1000000101110000, 5}, {0b1000000101111110, 4}, + {0b1000000110000000, 5}, {0b1000000110000001, 2}, + {0b1000000110000010, 4}, {0b1000000110000100, 4}, + {0b1000000110000110, 5}, {0b1000000110001000, 4}, + {0b1000000110001010, 5}, {0b1000000110001100, 5}, + {0b1000000110010000, 4}, {0b1000000110010010, 5}, + {0b1000000110010100, 5}, {0b1000000110011001, 3}, + {0b1000000110100000, 4}, {0b1000000110100010, 5}, + {0b1000000110100101, 3}, {0b1000000110101000, 5}, + {0b1000000110110000, 5}, {0b1000000110111101, 4}, + {0b1000000111000000, 4}, {0b1000000111000011, 3}, + {0b1000000111000100, 5}, {0b1000000111001000, 5}, + {0b1000000111010000, 5}, {0b1000000111011011, 4}, + {0b1000000111100000, 5}, {0b1000000111100111, 4}, + {0b1000000111111111, 3}, {0b1000001000000000, 3}, + {0b1000001000000001, 5}, {0b1000001000000010, 5}, + {0b1000001000000011, 4}, {0b1000001000000100, 5}, + {0b1000001000000101, 4}, {0b1000001000000110, 4}, + {0b1000001000000111, 5}, {0b1000001000001000, 5}, + {0b1000001000001001, 4}, {0b1000001000001010, 4}, + {0b1000001000001011, 5}, {0b1000001000001100, 4}, + {0b1000001000001101, 5}, {0b1000001000001110, 5}, + {0b1000001000010000, 5}, {0b1000001000010001, 4}, + {0b1000001000010010, 4}, {0b1000001000010011, 5}, + {0b1000001000010100, 2}, {0b1000001000011000, 4}, + {0b1000001000011001, 5}, {0b1000001000011010, 5}, + {0b1000001000100000, 5}, {0b1000001000100001, 4}, + {0b1000001000100010, 4}, {0b1000001000100011, 5}, + {0b1000001000100100, 4}, {0b1000001000100101, 5}, + {0b1000001000100110, 5}, {0b1000001000101000, 2}, + {0b1000001000110000, 4}, {0b1000001000110001, 5}, + {0b1000001000110010, 5}, {0b1000001000111100, 3}, + {0b1000001001000000, 5}, {0b1000001001000001, 2}, + {0b1000001001000010, 4}, {0b1000001001000100, 4}, + {0b1000001001000110, 5}, {0b1000001001001000, 4}, + {0b1000001001001010, 5}, {0b1000001001001100, 5}, + {0b1000001001010000, 4}, {0b1000001001010010, 5}, + {0b1000001001010101, 3}, {0b1000001001011000, 5}, + {0b1000001001100000, 4}, {0b1000001001100010, 5}, + {0b1000001001100100, 5}, {0b1000001001101001, 3}, + {0b1000001001110000, 5}, {0b1000001001111101, 4}, + {0b1000001010000000, 5}, {0b1000001010000001, 4}, + {0b1000001010000010, 2}, {0b1000001010000100, 4}, + {0b1000001010000101, 5}, {0b1000001010001000, 4}, + {0b1000001010001001, 5}, {0b1000001010001100, 5}, + {0b1000001010010000, 4}, {0b1000001010010001, 5}, + {0b1000001010010110, 3}, {0b1000001010011000, 5}, + {0b1000001010100000, 4}, {0b1000001010100001, 5}, + {0b1000001010100100, 5}, {0b1000001010101010, 3}, + {0b1000001010110000, 5}, {0b1000001010111110, 4}, + {0b1000001011000000, 4}, {0b1000001011000011, 3}, + {0b1000001011000100, 5}, {0b1000001011001000, 5}, + {0b1000001011010000, 5}, {0b1000001011010111, 4}, + {0b1000001011100000, 5}, {0b1000001011101011, 4}, + {0b1000001011111111, 3}, {0b1000001100000000, 5}, + {0b1000001100000001, 4}, {0b1000001100000010, 4}, + {0b1000001100000100, 4}, {0b1000001100000101, 5}, + {0b1000001100000110, 5}, {0b1000001100001000, 4}, + {0b1000001100001001, 5}, {0b1000001100001010, 5}, + {0b1000001100010000, 4}, {0b1000001100010001, 5}, + {0b1000001100010010, 5}, {0b1000001100011100, 3}, + {0b1000001100100000, 4}, {0b1000001100100001, 5}, + {0b1000001100100010, 5}, {0b1000001100101100, 3}, + {0b1000001100110100, 3}, {0b1000001100111000, 3}, + {0b1000001101000000, 4}, {0b1000001101000011, 3}, + {0b1000001101000100, 5}, {0b1000001101001000, 5}, + {0b1000001101010000, 5}, {0b1000001101100000, 5}, + {0b1000001110000000, 4}, {0b1000001110000011, 3}, + {0b1000001110000100, 5}, {0b1000001110001000, 5}, + {0b1000001110010000, 5}, {0b1000001110100000, 5}, + {0b1000001111000001, 3}, {0b1000001111000010, 3}, + {0b1000010000000000, 3}, {0b1000010000000001, 5}, + {0b1000010000000010, 5}, {0b1000010000000011, 4}, + {0b1000010000000100, 5}, {0b1000010000000101, 4}, + {0b1000010000000110, 4}, {0b1000010000000111, 5}, + {0b1000010000001000, 5}, {0b1000010000001001, 4}, + {0b1000010000001010, 4}, {0b1000010000001011, 5}, + {0b1000010000001100, 4}, {0b1000010000001101, 5}, + {0b1000010000001110, 5}, {0b1000010000010000, 5}, + {0b1000010000010001, 4}, {0b1000010000010010, 2}, + {0b1000010000010100, 4}, {0b1000010000010101, 5}, + {0b1000010000011000, 4}, {0b1000010000011001, 5}, + {0b1000010000011100, 5}, {0b1000010000100000, 5}, + {0b1000010000100001, 2}, {0b1000010000100010, 4}, + {0b1000010000100100, 4}, {0b1000010000100110, 5}, + {0b1000010000101000, 4}, {0b1000010000101010, 5}, + {0b1000010000101100, 5}, {0b1000010000110000, 4}, + {0b1000010000110011, 3}, {0b1000010000110100, 5}, + {0b1000010000111000, 5}, {0b1000010001000000, 5}, + {0b1000010001000001, 4}, {0b1000010001000010, 4}, + {0b1000010001000011, 5}, {0b1000010001000100, 4}, + {0b1000010001000101, 5}, {0b1000010001000110, 5}, + {0b1000010001001000, 2}, {0b1000010001010000, 4}, + {0b1000010001010001, 5}, {0b1000010001010100, 5}, + {0b1000010001011010, 3}, {0b1000010001100000, 4}, + {0b1000010001100010, 5}, {0b1000010001100100, 5}, + {0b1000010001101001, 3}, {0b1000010001110000, 5}, + {0b1000010001111011, 4}, {0b1000010010000000, 5}, + {0b1000010010000001, 4}, {0b1000010010000010, 4}, + {0b1000010010000011, 5}, {0b1000010010000100, 2}, + {0b1000010010001000, 4}, {0b1000010010001001, 5}, + {0b1000010010001010, 5}, {0b1000010010010000, 4}, + {0b1000010010010001, 5}, {0b1000010010010110, 3}, + {0b1000010010011000, 5}, {0b1000010010100000, 4}, + {0b1000010010100010, 5}, {0b1000010010100101, 3}, + {0b1000010010101000, 5}, {0b1000010010110000, 5}, + {0b1000010010110111, 4}, {0b1000010011000000, 4}, + {0b1000010011000001, 5}, {0b1000010011000010, 5}, + {0b1000010011001100, 3}, {0b1000010011010000, 5}, + {0b1000010011011110, 4}, {0b1000010011100000, 5}, + {0b1000010011101101, 4}, {0b1000010011111111, 3}, + {0b1000010100000000, 5}, {0b1000010100000001, 4}, + {0b1000010100000010, 4}, {0b1000010100000011, 5}, + {0b1000010100000100, 4}, {0b1000010100000110, 5}, + {0b1000010100001000, 4}, {0b1000010100001001, 5}, + {0b1000010100001100, 5}, {0b1000010100010000, 4}, + {0b1000010100010001, 5}, {0b1000010100010100, 5}, + {0b1000010100011010, 3}, {0b1000010100100000, 4}, + {0b1000010100100010, 5}, {0b1000010100100101, 3}, + {0b1000010100101000, 5}, {0b1000010100110000, 5}, + {0b1000010101000000, 4}, {0b1000010101000001, 5}, + {0b1000010101000100, 5}, {0b1000010101001010, 3}, + {0b1000010101010010, 3}, {0b1000010101011000, 3}, + {0b1000010101100000, 5}, {0b1000010110000000, 4}, + {0b1000010110000010, 5}, {0b1000010110000101, 3}, + {0b1000010110001000, 5}, {0b1000010110010000, 5}, + {0b1000010110100001, 3}, {0b1000010110100100, 3}, + {0b1000010111000000, 5}, {0b1000011000000000, 5}, + {0b1000011000000001, 4}, {0b1000011000000010, 4}, + {0b1000011000000011, 5}, {0b1000011000000100, 4}, + {0b1000011000000101, 5}, {0b1000011000001000, 4}, + {0b1000011000001010, 5}, {0b1000011000001100, 5}, + {0b1000011000010000, 4}, {0b1000011000010001, 5}, + {0b1000011000010110, 3}, {0b1000011000011000, 5}, + {0b1000011000100000, 4}, {0b1000011000100010, 5}, + {0b1000011000100100, 5}, {0b1000011000101001, 3}, + {0b1000011000110000, 5}, {0b1000011001000000, 4}, + {0b1000011001000010, 5}, {0b1000011001000100, 5}, + {0b1000011001001001, 3}, {0b1000011001010000, 5}, + {0b1000011001100001, 3}, {0b1000011001101000, 3}, + {0b1000011010000000, 4}, {0b1000011010000001, 5}, + {0b1000011010000110, 3}, {0b1000011010001000, 5}, + {0b1000011010010010, 3}, {0b1000011010010100, 3}, + {0b1000011010100000, 5}, {0b1000011011000000, 5}, + {0b1000011100000000, 4}, {0b1000011100000001, 5}, + {0b1000011100000010, 5}, {0b1000011100000100, 5}, + {0b1000011100001000, 5}, {0b1000011100010000, 5}, + {0b1000011100011110, 4}, {0b1000011100100000, 5}, + {0b1000011100101101, 4}, {0b1000011101000000, 5}, + {0b1000011101001011, 4}, {0b1000011101111000, 4}, + {0b1000011101111111, 5}, {0b1000011110000000, 5}, + {0b1000011110000111, 4}, {0b1000011110110100, 4}, + {0b1000011110111111, 5}, {0b1000011111010010, 4}, + {0b1000011111011111, 5}, {0b1000011111100001, 4}, + {0b1000011111101111, 5}, {0b1000011111110111, 5}, + {0b1000011111111011, 5}, {0b1000011111111101, 5}, + {0b1000011111111110, 5}, {0b1000011111111111, 4}, + {0b1000100000000000, 3}, {0b1000100000000001, 5}, + {0b1000100000000010, 5}, {0b1000100000000011, 4}, + {0b1000100000000100, 5}, {0b1000100000000101, 4}, + {0b1000100000000110, 4}, {0b1000100000000111, 5}, + {0b1000100000001000, 5}, {0b1000100000001001, 4}, + {0b1000100000001010, 4}, {0b1000100000001011, 5}, + {0b1000100000001100, 4}, {0b1000100000001101, 5}, + {0b1000100000001110, 5}, {0b1000100000010000, 5}, + {0b1000100000010001, 2}, {0b1000100000010010, 4}, + {0b1000100000010100, 4}, {0b1000100000010110, 5}, + {0b1000100000011000, 4}, {0b1000100000011010, 5}, + {0b1000100000011100, 5}, {0b1000100000100000, 5}, + {0b1000100000100001, 4}, {0b1000100000100010, 2}, + {0b1000100000100100, 4}, {0b1000100000100101, 5}, + {0b1000100000101000, 4}, {0b1000100000101001, 5}, + {0b1000100000101100, 5}, {0b1000100000110000, 4}, + {0b1000100000110011, 3}, {0b1000100000110100, 5}, + {0b1000100000111000, 5}, {0b1000100001000000, 5}, + {0b1000100001000001, 4}, {0b1000100001000010, 4}, + {0b1000100001000011, 5}, {0b1000100001000100, 2}, + {0b1000100001001000, 4}, {0b1000100001001001, 5}, + {0b1000100001001010, 5}, {0b1000100001010000, 4}, + {0b1000100001010010, 5}, {0b1000100001010101, 3}, + {0b1000100001011000, 5}, {0b1000100001100000, 4}, + {0b1000100001100001, 5}, {0b1000100001100110, 3}, + {0b1000100001101000, 5}, {0b1000100001110000, 5}, + {0b1000100001110111, 4}, {0b1000100010000000, 5}, + {0b1000100010000001, 4}, {0b1000100010000010, 4}, + {0b1000100010000011, 5}, {0b1000100010000100, 4}, + {0b1000100010000101, 5}, {0b1000100010000110, 5}, + {0b1000100010001000, 2}, {0b1000100010010000, 4}, + {0b1000100010010010, 5}, {0b1000100010010100, 5}, + {0b1000100010011001, 3}, {0b1000100010100000, 4}, + {0b1000100010100001, 5}, {0b1000100010100100, 5}, + {0b1000100010101010, 3}, {0b1000100010110000, 5}, + {0b1000100010111011, 4}, {0b1000100011000000, 4}, + {0b1000100011000001, 5}, {0b1000100011000010, 5}, + {0b1000100011001100, 3}, {0b1000100011010000, 5}, + {0b1000100011011101, 4}, {0b1000100011100000, 5}, + {0b1000100011101110, 4}, {0b1000100011111111, 3}, + {0b1000100100000000, 5}, {0b1000100100000001, 4}, + {0b1000100100000010, 4}, {0b1000100100000011, 5}, + {0b1000100100000100, 4}, {0b1000100100000101, 5}, + {0b1000100100001000, 4}, {0b1000100100001010, 5}, + {0b1000100100001100, 5}, {0b1000100100010000, 4}, + {0b1000100100010010, 5}, {0b1000100100010100, 5}, + {0b1000100100011001, 3}, {0b1000100100100000, 4}, + {0b1000100100100001, 5}, {0b1000100100100110, 3}, + {0b1000100100101000, 5}, {0b1000100100110000, 5}, + {0b1000100101000000, 4}, {0b1000100101000001, 5}, + {0b1000100101000110, 3}, {0b1000100101001000, 5}, + {0b1000100101010000, 5}, {0b1000100101100010, 3}, + {0b1000100101100100, 3}, {0b1000100110000000, 4}, + {0b1000100110000010, 5}, {0b1000100110000100, 5}, + {0b1000100110001001, 3}, {0b1000100110010001, 3}, + {0b1000100110011000, 3}, {0b1000100110100000, 5}, + {0b1000100111000000, 5}, {0b1000101000000000, 5}, + {0b1000101000000001, 4}, {0b1000101000000010, 4}, + {0b1000101000000011, 5}, {0b1000101000000100, 4}, + {0b1000101000000110, 5}, {0b1000101000001000, 4}, + {0b1000101000001001, 5}, {0b1000101000001100, 5}, + {0b1000101000010000, 4}, {0b1000101000010010, 5}, + {0b1000101000010101, 3}, {0b1000101000011000, 5}, + {0b1000101000100000, 4}, {0b1000101000100001, 5}, + {0b1000101000100100, 5}, {0b1000101000101010, 3}, + {0b1000101000110000, 5}, {0b1000101001000000, 4}, + {0b1000101001000010, 5}, {0b1000101001000101, 3}, + {0b1000101001001000, 5}, {0b1000101001010001, 3}, + {0b1000101001010100, 3}, {0b1000101001100000, 5}, + {0b1000101010000000, 4}, {0b1000101010000001, 5}, + {0b1000101010000100, 5}, {0b1000101010001010, 3}, + {0b1000101010010000, 5}, {0b1000101010100010, 3}, + {0b1000101010101000, 3}, {0b1000101011000000, 5}, + {0b1000101100000000, 4}, {0b1000101100000001, 5}, + {0b1000101100000010, 5}, {0b1000101100000100, 5}, + {0b1000101100001000, 5}, {0b1000101100010000, 5}, + {0b1000101100011101, 4}, {0b1000101100100000, 5}, + {0b1000101100101110, 4}, {0b1000101101000000, 5}, + {0b1000101101000111, 4}, {0b1000101101110100, 4}, + {0b1000101101111111, 5}, {0b1000101110000000, 5}, + {0b1000101110001011, 4}, {0b1000101110111000, 4}, + {0b1000101110111111, 5}, {0b1000101111010001, 4}, + {0b1000101111011111, 5}, {0b1000101111100010, 4}, + {0b1000101111101111, 5}, {0b1000101111110111, 5}, + {0b1000101111111011, 5}, {0b1000101111111101, 5}, + {0b1000101111111110, 5}, {0b1000101111111111, 4}, + {0b1000110000000000, 5}, {0b1000110000000001, 4}, + {0b1000110000000010, 4}, {0b1000110000000100, 4}, + {0b1000110000000101, 5}, {0b1000110000000110, 5}, + {0b1000110000001000, 4}, {0b1000110000001001, 5}, + {0b1000110000001010, 5}, {0b1000110000010000, 4}, + {0b1000110000010011, 3}, {0b1000110000010100, 5}, + {0b1000110000011000, 5}, {0b1000110000100000, 4}, + {0b1000110000100011, 3}, {0b1000110000100100, 5}, + {0b1000110000101000, 5}, {0b1000110000110001, 3}, + {0b1000110000110010, 3}, {0b1000110001000000, 4}, + {0b1000110001000001, 5}, {0b1000110001000010, 5}, + {0b1000110001001100, 3}, {0b1000110001010000, 5}, + {0b1000110001100000, 5}, {0b1000110010000000, 4}, + {0b1000110010000001, 5}, {0b1000110010000010, 5}, + {0b1000110010001100, 3}, {0b1000110010010000, 5}, + {0b1000110010100000, 5}, {0b1000110011000100, 3}, + {0b1000110011001000, 3}, {0b1000110100000000, 4}, + {0b1000110100000001, 5}, {0b1000110100000010, 5}, + {0b1000110100000100, 5}, {0b1000110100001000, 5}, + {0b1000110100010000, 5}, {0b1000110100011011, 4}, + {0b1000110100100000, 5}, {0b1000110100100111, 4}, + {0b1000110101000000, 5}, {0b1000110101001110, 4}, + {0b1000110101110010, 4}, {0b1000110101111111, 5}, + {0b1000110110000000, 5}, {0b1000110110001101, 4}, + {0b1000110110110001, 4}, {0b1000110110111111, 5}, + {0b1000110111011000, 4}, {0b1000110111011111, 5}, + {0b1000110111100100, 4}, {0b1000110111101111, 5}, + {0b1000110111110111, 5}, {0b1000110111111011, 5}, + {0b1000110111111101, 5}, {0b1000110111111110, 5}, + {0b1000110111111111, 4}, {0b1000111000000000, 4}, + {0b1000111000000001, 5}, {0b1000111000000010, 5}, + {0b1000111000000100, 5}, {0b1000111000001000, 5}, + {0b1000111000010000, 5}, {0b1000111000010111, 4}, + {0b1000111000100000, 5}, {0b1000111000101011, 4}, + {0b1000111001000000, 5}, {0b1000111001001101, 4}, + {0b1000111001110001, 4}, {0b1000111001111111, 5}, + {0b1000111010000000, 5}, {0b1000111010001110, 4}, + {0b1000111010110010, 4}, {0b1000111010111111, 5}, + {0b1000111011010100, 4}, {0b1000111011011111, 5}, + {0b1000111011101000, 4}, {0b1000111011101111, 5}, + {0b1000111011110111, 5}, {0b1000111011111011, 5}, + {0b1000111011111101, 5}, {0b1000111011111110, 5}, + {0b1000111011111111, 4}, {0b1000111100011111, 3}, + {0b1000111100101111, 3}, {0b1000111101001111, 3}, + {0b1000111101110111, 5}, {0b1000111101111011, 5}, + {0b1000111101111101, 5}, {0b1000111101111110, 5}, + {0b1000111101111111, 4}, {0b1000111110001111, 3}, + {0b1000111110110111, 5}, {0b1000111110111011, 5}, + {0b1000111110111101, 5}, {0b1000111110111110, 5}, + {0b1000111110111111, 4}, {0b1000111111010111, 5}, + {0b1000111111011011, 5}, {0b1000111111011101, 5}, + {0b1000111111011110, 5}, {0b1000111111011111, 4}, + {0b1000111111100111, 5}, {0b1000111111101011, 5}, + {0b1000111111101101, 5}, {0b1000111111101110, 5}, + {0b1000111111101111, 4}, {0b1000111111110001, 3}, + {0b1000111111110010, 3}, {0b1000111111110100, 3}, + {0b1000111111110111, 4}, {0b1000111111111000, 3}, + {0b1000111111111011, 4}, {0b1000111111111101, 4}, + {0b1000111111111110, 4}, {0b1000111111111111, 5}, + {0b1001000000000000, 3}, {0b1001000000000001, 5}, + {0b1001000000000010, 5}, {0b1001000000000011, 4}, + {0b1001000000000100, 5}, {0b1001000000000101, 4}, + {0b1001000000000110, 2}, {0b1001000000001000, 5}, + {0b1001000000001001, 2}, {0b1001000000001010, 4}, + {0b1001000000001100, 4}, {0b1001000000001111, 3}, + {0b1001000000010000, 5}, {0b1001000000010001, 4}, + {0b1001000000010010, 4}, {0b1001000000010011, 5}, + {0b1001000000010100, 4}, {0b1001000000010101, 5}, + {0b1001000000011000, 4}, {0b1001000000011010, 5}, + {0b1001000000011100, 5}, {0b1001000000100000, 5}, + {0b1001000000100001, 4}, {0b1001000000100010, 4}, + {0b1001000000100011, 5}, {0b1001000000100100, 4}, + {0b1001000000100101, 5}, {0b1001000000101000, 4}, + {0b1001000000101010, 5}, {0b1001000000101100, 5}, + {0b1001000000110000, 4}, {0b1001000000110001, 5}, + {0b1001000000110010, 5}, {0b1001000000110100, 5}, + {0b1001000000111000, 5}, {0b1001000001000000, 5}, + {0b1001000001000001, 4}, {0b1001000001000010, 4}, + {0b1001000001000011, 5}, {0b1001000001000100, 4}, + {0b1001000001000101, 5}, {0b1001000001001000, 4}, + {0b1001000001001010, 5}, {0b1001000001001100, 5}, + {0b1001000001010000, 4}, {0b1001000001010001, 5}, + {0b1001000001010010, 5}, {0b1001000001010100, 5}, + {0b1001000001011000, 5}, {0b1001000001100000, 2}, + {0b1001000001100110, 3}, {0b1001000001101001, 3}, + {0b1001000001101111, 4}, {0b1001000010000000, 5}, + {0b1001000010000001, 4}, {0b1001000010000010, 4}, + {0b1001000010000011, 5}, {0b1001000010000100, 4}, + {0b1001000010000101, 5}, {0b1001000010001000, 4}, + {0b1001000010001010, 5}, {0b1001000010001100, 5}, + {0b1001000010010000, 2}, {0b1001000010010110, 3}, + {0b1001000010011001, 3}, {0b1001000010011111, 4}, + {0b1001000010100000, 4}, {0b1001000010100001, 5}, + {0b1001000010100010, 5}, {0b1001000010100100, 5}, + {0b1001000010101000, 5}, {0b1001000011000000, 4}, + {0b1001000011000001, 5}, {0b1001000011000010, 5}, + {0b1001000011000100, 5}, {0b1001000011001000, 5}, + {0b1001000011110000, 3}, {0b1001000011110110, 4}, + {0b1001000011111001, 4}, {0b1001000011111111, 3}, + {0b1001000100000000, 5}, {0b1001000100000001, 4}, + {0b1001000100000010, 4}, {0b1001000100000011, 5}, + {0b1001000100000100, 4}, {0b1001000100000101, 5}, + {0b1001000100001000, 4}, {0b1001000100001010, 5}, + {0b1001000100001100, 5}, {0b1001000100010000, 4}, + {0b1001000100010010, 5}, {0b1001000100010100, 5}, + {0b1001000100011001, 3}, {0b1001000100100000, 4}, + {0b1001000100100001, 5}, {0b1001000100100110, 3}, + {0b1001000100101000, 5}, {0b1001000100110000, 5}, + {0b1001000101000000, 4}, {0b1001000101000001, 5}, + {0b1001000101000110, 3}, {0b1001000101001000, 5}, + {0b1001000101010000, 5}, {0b1001000101100010, 3}, + {0b1001000101100100, 3}, {0b1001000110000000, 4}, + {0b1001000110000010, 5}, {0b1001000110000100, 5}, + {0b1001000110001001, 3}, {0b1001000110010001, 3}, + {0b1001000110011000, 3}, {0b1001000110100000, 5}, + {0b1001000111000000, 5}, {0b1001001000000000, 5}, + {0b1001001000000001, 4}, {0b1001001000000010, 4}, + {0b1001001000000011, 5}, {0b1001001000000100, 4}, + {0b1001001000000101, 5}, {0b1001001000001000, 4}, + {0b1001001000001010, 5}, {0b1001001000001100, 5}, + {0b1001001000010000, 4}, {0b1001001000010001, 5}, + {0b1001001000010110, 3}, {0b1001001000011000, 5}, + {0b1001001000100000, 4}, {0b1001001000100010, 5}, + {0b1001001000100100, 5}, {0b1001001000101001, 3}, + {0b1001001000110000, 5}, {0b1001001001000000, 4}, + {0b1001001001000010, 5}, {0b1001001001000100, 5}, + {0b1001001001001001, 3}, {0b1001001001010000, 5}, + {0b1001001001100001, 3}, {0b1001001001101000, 3}, + {0b1001001010000000, 4}, {0b1001001010000001, 5}, + {0b1001001010000110, 3}, {0b1001001010001000, 5}, + {0b1001001010010010, 3}, {0b1001001010010100, 3}, + {0b1001001010100000, 5}, {0b1001001011000000, 5}, + {0b1001001100000000, 4}, {0b1001001100000001, 5}, + {0b1001001100000010, 5}, {0b1001001100000100, 5}, + {0b1001001100001000, 5}, {0b1001001100010000, 5}, + {0b1001001100100000, 5}, {0b1001001100110110, 4}, + {0b1001001100111001, 4}, {0b1001001101000000, 5}, + {0b1001001101100011, 4}, {0b1001001101101100, 4}, + {0b1001001101111111, 5}, {0b1001001110000000, 5}, + {0b1001001110010011, 4}, {0b1001001110011100, 4}, + {0b1001001110111111, 5}, {0b1001001111000110, 4}, + {0b1001001111001001, 4}, {0b1001001111011111, 5}, + {0b1001001111101111, 5}, {0b1001001111110111, 5}, + {0b1001001111111011, 5}, {0b1001001111111101, 5}, + {0b1001001111111110, 5}, {0b1001001111111111, 4}, + {0b1001010000000000, 5}, {0b1001010000000001, 4}, + {0b1001010000000010, 4}, {0b1001010000000011, 5}, + {0b1001010000000100, 4}, {0b1001010000000101, 5}, + {0b1001010000001000, 4}, {0b1001010000001010, 5}, + {0b1001010000001100, 5}, {0b1001010000010000, 4}, + {0b1001010000010001, 5}, {0b1001010000010110, 3}, + {0b1001010000011000, 5}, {0b1001010000100000, 4}, + {0b1001010000100010, 5}, {0b1001010000100100, 5}, + {0b1001010000101001, 3}, {0b1001010000110000, 5}, + {0b1001010001000000, 4}, {0b1001010001000010, 5}, + {0b1001010001000100, 5}, {0b1001010001001001, 3}, + {0b1001010001010000, 5}, {0b1001010001100001, 3}, + {0b1001010001101000, 3}, {0b1001010010000000, 4}, + {0b1001010010000001, 5}, {0b1001010010000110, 3}, + {0b1001010010001000, 5}, {0b1001010010010010, 3}, + {0b1001010010010100, 3}, {0b1001010010100000, 5}, + {0b1001010011000000, 5}, {0b1001010100000000, 4}, + {0b1001010100000001, 5}, {0b1001010100000010, 5}, + {0b1001010100000100, 5}, {0b1001010100001000, 5}, + {0b1001010100010000, 5}, {0b1001010100100000, 5}, + {0b1001010101000000, 5}, {0b1001010101010110, 4}, + {0b1001010101011001, 4}, {0b1001010101100101, 4}, + {0b1001010101101010, 4}, {0b1001010101111111, 5}, + {0b1001010110000000, 5}, {0b1001010110010101, 4}, + {0b1001010110011010, 4}, {0b1001010110100110, 4}, + {0b1001010110101001, 4}, {0b1001010110111111, 5}, + {0b1001010111011111, 5}, {0b1001010111101111, 5}, + {0b1001010111110111, 5}, {0b1001010111111011, 5}, + {0b1001010111111101, 5}, {0b1001010111111110, 5}, + {0b1001010111111111, 4}, {0b1001011000000000, 2}, + {0b1001011000000110, 3}, {0b1001011000001001, 3}, + {0b1001011000001111, 4}, {0b1001011000010010, 3}, + {0b1001011000010100, 3}, {0b1001011000100001, 3}, + {0b1001011000101000, 3}, {0b1001011000110011, 4}, + {0b1001011000111100, 4}, {0b1001011001000001, 3}, + {0b1001011001001000, 3}, {0b1001011001010101, 4}, + {0b1001011001011010, 4}, {0b1001011001100000, 3}, + {0b1001011001100110, 4}, {0b1001011001101001, 1}, + {0b1001011001101111, 3}, {0b1001011001111011, 3}, + {0b1001011001111101, 3}, {0b1001011010000010, 3}, + {0b1001011010000100, 3}, {0b1001011010010000, 3}, + {0b1001011010010110, 1}, {0b1001011010011001, 4}, + {0b1001011010011111, 3}, {0b1001011010100101, 4}, + {0b1001011010101010, 4}, {0b1001011010110111, 3}, + {0b1001011010111110, 3}, {0b1001011011000011, 4}, + {0b1001011011001100, 4}, {0b1001011011010111, 3}, + {0b1001011011011110, 3}, {0b1001011011101011, 3}, + {0b1001011011101101, 3}, {0b1001011011110000, 4}, + {0b1001011011110110, 3}, {0b1001011011111001, 3}, + {0b1001011011111111, 2}, {0b1001011100111111, 5}, + {0b1001011101011111, 5}, {0b1001011101101011, 3}, + {0b1001011101101101, 3}, {0b1001011101110111, 5}, + {0b1001011101111001, 3}, {0b1001011101111110, 5}, + {0b1001011101111111, 4}, {0b1001011110010111, 3}, + {0b1001011110011110, 3}, {0b1001011110101111, 5}, + {0b1001011110110110, 3}, {0b1001011110111011, 5}, + {0b1001011110111101, 5}, {0b1001011110111111, 4}, + {0b1001011111001111, 5}, {0b1001011111010110, 3}, + {0b1001011111011011, 5}, {0b1001011111011101, 5}, + {0b1001011111011111, 4}, {0b1001011111100111, 5}, + {0b1001011111101001, 3}, {0b1001011111101110, 5}, + {0b1001011111101111, 4}, {0b1001011111110011, 5}, + {0b1001011111110101, 5}, {0b1001011111110111, 4}, + {0b1001011111111010, 5}, {0b1001011111111011, 4}, + {0b1001011111111100, 5}, {0b1001011111111101, 4}, + {0b1001011111111110, 4}, {0b1001011111111111, 5}, + {0b1001100000000000, 5}, {0b1001100000000001, 4}, + {0b1001100000000010, 4}, {0b1001100000000011, 5}, + {0b1001100000000100, 4}, {0b1001100000000101, 5}, + {0b1001100000001000, 4}, {0b1001100000001010, 5}, + {0b1001100000001100, 5}, {0b1001100000010000, 4}, + {0b1001100000010010, 5}, {0b1001100000010100, 5}, + {0b1001100000011001, 3}, {0b1001100000100000, 4}, + {0b1001100000100001, 5}, {0b1001100000100110, 3}, + {0b1001100000101000, 5}, {0b1001100000110000, 5}, + {0b1001100001000000, 4}, {0b1001100001000001, 5}, + {0b1001100001000110, 3}, {0b1001100001001000, 5}, + {0b1001100001010000, 5}, {0b1001100001100010, 3}, + {0b1001100001100100, 3}, {0b1001100010000000, 4}, + {0b1001100010000010, 5}, {0b1001100010000100, 5}, + {0b1001100010001001, 3}, {0b1001100010010001, 3}, + {0b1001100010011000, 3}, {0b1001100010100000, 5}, + {0b1001100011000000, 5}, {0b1001100100000000, 2}, + {0b1001100100000110, 3}, {0b1001100100001001, 3}, + {0b1001100100001111, 4}, {0b1001100100010001, 3}, + {0b1001100100011000, 3}, {0b1001100100100010, 3}, + {0b1001100100100100, 3}, {0b1001100100110011, 4}, + {0b1001100100111100, 4}, {0b1001100101000010, 3}, + {0b1001100101000100, 3}, {0b1001100101010101, 4}, + {0b1001100101011010, 4}, {0b1001100101100000, 3}, + {0b1001100101100110, 1}, {0b1001100101101001, 4}, + {0b1001100101101111, 3}, {0b1001100101110111, 3}, + {0b1001100101111110, 3}, {0b1001100110000001, 3}, + {0b1001100110001000, 3}, {0b1001100110010000, 3}, + {0b1001100110010110, 4}, {0b1001100110011001, 1}, + {0b1001100110011111, 3}, {0b1001100110100101, 4}, + {0b1001100110101010, 4}, {0b1001100110111011, 3}, + {0b1001100110111101, 3}, {0b1001100111000011, 4}, + {0b1001100111001100, 4}, {0b1001100111011011, 3}, + {0b1001100111011101, 3}, {0b1001100111100111, 3}, + {0b1001100111101110, 3}, {0b1001100111110000, 4}, + {0b1001100111110110, 3}, {0b1001100111111001, 3}, + {0b1001100111111111, 2}, {0b1001101000000000, 4}, + {0b1001101000000001, 5}, {0b1001101000000010, 5}, + {0b1001101000000100, 5}, {0b1001101000001000, 5}, + {0b1001101000010000, 5}, {0b1001101000100000, 5}, + {0b1001101001000000, 5}, {0b1001101001010110, 4}, + {0b1001101001011001, 4}, {0b1001101001100101, 4}, + {0b1001101001101010, 4}, {0b1001101001111111, 5}, + {0b1001101010000000, 5}, {0b1001101010010101, 4}, + {0b1001101010011010, 4}, {0b1001101010100110, 4}, + {0b1001101010101001, 4}, {0b1001101010111111, 5}, + {0b1001101011011111, 5}, {0b1001101011101111, 5}, + {0b1001101011110111, 5}, {0b1001101011111011, 5}, + {0b1001101011111101, 5}, {0b1001101011111110, 5}, + {0b1001101011111111, 4}, {0b1001101100111111, 5}, + {0b1001101101011111, 5}, {0b1001101101100111, 3}, + {0b1001101101101110, 3}, {0b1001101101110110, 3}, + {0b1001101101111011, 5}, {0b1001101101111101, 5}, + {0b1001101101111111, 4}, {0b1001101110011011, 3}, + {0b1001101110011101, 3}, {0b1001101110101111, 5}, + {0b1001101110110111, 5}, {0b1001101110111001, 3}, + {0b1001101110111110, 5}, {0b1001101110111111, 4}, + {0b1001101111001111, 5}, {0b1001101111010111, 5}, + {0b1001101111011001, 3}, {0b1001101111011110, 5}, + {0b1001101111011111, 4}, {0b1001101111100110, 3}, + {0b1001101111101011, 5}, {0b1001101111101101, 5}, + {0b1001101111101111, 4}, {0b1001101111110011, 5}, + {0b1001101111110101, 5}, {0b1001101111110111, 4}, + {0b1001101111111010, 5}, {0b1001101111111011, 4}, + {0b1001101111111100, 5}, {0b1001101111111101, 4}, + {0b1001101111111110, 4}, {0b1001101111111111, 5}, + {0b1001110000000000, 4}, {0b1001110000000001, 5}, + {0b1001110000000010, 5}, {0b1001110000000100, 5}, + {0b1001110000001000, 5}, {0b1001110000010000, 5}, + {0b1001110000100000, 5}, {0b1001110000110110, 4}, + {0b1001110000111001, 4}, {0b1001110001000000, 5}, + {0b1001110001100011, 4}, {0b1001110001101100, 4}, + {0b1001110001111111, 5}, {0b1001110010000000, 5}, + {0b1001110010010011, 4}, {0b1001110010011100, 4}, + {0b1001110010111111, 5}, {0b1001110011000110, 4}, + {0b1001110011001001, 4}, {0b1001110011011111, 5}, + {0b1001110011101111, 5}, {0b1001110011110111, 5}, + {0b1001110011111011, 5}, {0b1001110011111101, 5}, + {0b1001110011111110, 5}, {0b1001110011111111, 4}, + {0b1001110100111111, 5}, {0b1001110101011111, 5}, + {0b1001110101100111, 3}, {0b1001110101101110, 3}, + {0b1001110101110110, 3}, {0b1001110101111011, 5}, + {0b1001110101111101, 5}, {0b1001110101111111, 4}, + {0b1001110110011011, 3}, {0b1001110110011101, 3}, + {0b1001110110101111, 5}, {0b1001110110110111, 5}, + {0b1001110110111001, 3}, {0b1001110110111110, 5}, + {0b1001110110111111, 4}, {0b1001110111001111, 5}, + {0b1001110111010111, 5}, {0b1001110111011001, 3}, + {0b1001110111011110, 5}, {0b1001110111011111, 4}, + {0b1001110111100110, 3}, {0b1001110111101011, 5}, + {0b1001110111101101, 5}, {0b1001110111101111, 4}, + {0b1001110111110011, 5}, {0b1001110111110101, 5}, + {0b1001110111110111, 4}, {0b1001110111111010, 5}, + {0b1001110111111011, 4}, {0b1001110111111100, 5}, + {0b1001110111111101, 4}, {0b1001110111111110, 4}, + {0b1001110111111111, 5}, {0b1001111000111111, 5}, + {0b1001111001011111, 5}, {0b1001111001101011, 3}, + {0b1001111001101101, 3}, {0b1001111001110111, 5}, + {0b1001111001111001, 3}, {0b1001111001111110, 5}, + {0b1001111001111111, 4}, {0b1001111010010111, 3}, + {0b1001111010011110, 3}, {0b1001111010101111, 5}, + {0b1001111010110110, 3}, {0b1001111010111011, 5}, + {0b1001111010111101, 5}, {0b1001111010111111, 4}, + {0b1001111011001111, 5}, {0b1001111011010110, 3}, + {0b1001111011011011, 5}, {0b1001111011011101, 5}, + {0b1001111011011111, 4}, {0b1001111011100111, 5}, + {0b1001111011101001, 3}, {0b1001111011101110, 5}, + {0b1001111011101111, 4}, {0b1001111011110011, 5}, + {0b1001111011110101, 5}, {0b1001111011110111, 4}, + {0b1001111011111010, 5}, {0b1001111011111011, 4}, + {0b1001111011111100, 5}, {0b1001111011111101, 4}, + {0b1001111011111110, 4}, {0b1001111011111111, 5}, + {0b1001111100000000, 3}, {0b1001111100000110, 4}, + {0b1001111100001001, 4}, {0b1001111100001111, 3}, + {0b1001111100110111, 5}, {0b1001111100111011, 5}, + {0b1001111100111101, 5}, {0b1001111100111110, 5}, + {0b1001111100111111, 4}, {0b1001111101010111, 5}, + {0b1001111101011011, 5}, {0b1001111101011101, 5}, + {0b1001111101011110, 5}, {0b1001111101011111, 4}, + {0b1001111101100000, 4}, {0b1001111101100110, 3}, + {0b1001111101101001, 3}, {0b1001111101101111, 2}, + {0b1001111101110011, 5}, {0b1001111101110101, 5}, + {0b1001111101110111, 4}, {0b1001111101111010, 5}, + {0b1001111101111011, 4}, {0b1001111101111100, 5}, + {0b1001111101111101, 4}, {0b1001111101111110, 4}, + {0b1001111101111111, 5}, {0b1001111110010000, 4}, + {0b1001111110010110, 3}, {0b1001111110011001, 3}, + {0b1001111110011111, 2}, {0b1001111110100111, 5}, + {0b1001111110101011, 5}, {0b1001111110101101, 5}, + {0b1001111110101110, 5}, {0b1001111110101111, 4}, + {0b1001111110110011, 5}, {0b1001111110110101, 5}, + {0b1001111110110111, 4}, {0b1001111110111010, 5}, + {0b1001111110111011, 4}, {0b1001111110111100, 5}, + {0b1001111110111101, 4}, {0b1001111110111110, 4}, + {0b1001111110111111, 5}, {0b1001111111000111, 5}, + {0b1001111111001011, 5}, {0b1001111111001101, 5}, + {0b1001111111001110, 5}, {0b1001111111001111, 4}, + {0b1001111111010011, 5}, {0b1001111111010101, 5}, + {0b1001111111010111, 4}, {0b1001111111011010, 5}, + {0b1001111111011011, 4}, {0b1001111111011100, 5}, + {0b1001111111011101, 4}, {0b1001111111011110, 4}, + {0b1001111111011111, 5}, {0b1001111111100011, 5}, + {0b1001111111100101, 5}, {0b1001111111100111, 4}, + {0b1001111111101010, 5}, {0b1001111111101011, 4}, + {0b1001111111101100, 5}, {0b1001111111101101, 4}, + {0b1001111111101110, 4}, {0b1001111111101111, 5}, + {0b1001111111110000, 3}, {0b1001111111110011, 4}, + {0b1001111111110101, 4}, {0b1001111111110110, 2}, + {0b1001111111110111, 5}, {0b1001111111111001, 2}, + {0b1001111111111010, 4}, {0b1001111111111011, 5}, + {0b1001111111111100, 4}, {0b1001111111111101, 5}, + {0b1001111111111110, 5}, {0b1001111111111111, 3}, + {0b1010000000000000, 3}, {0b1010000000000001, 5}, + {0b1010000000000010, 5}, {0b1010000000000011, 4}, + {0b1010000000000100, 5}, {0b1010000000000101, 2}, + {0b1010000000000110, 4}, {0b1010000000001000, 5}, + {0b1010000000001001, 4}, {0b1010000000001010, 2}, + {0b1010000000001100, 4}, {0b1010000000001111, 3}, + {0b1010000000010000, 5}, {0b1010000000010001, 4}, + {0b1010000000010010, 4}, {0b1010000000010011, 5}, + {0b1010000000010100, 4}, {0b1010000000010110, 5}, + {0b1010000000011000, 4}, {0b1010000000011001, 5}, + {0b1010000000011100, 5}, {0b1010000000100000, 5}, + {0b1010000000100001, 4}, {0b1010000000100010, 4}, + {0b1010000000100011, 5}, {0b1010000000100100, 4}, + {0b1010000000100110, 5}, {0b1010000000101000, 4}, + {0b1010000000101001, 5}, {0b1010000000101100, 5}, + {0b1010000000110000, 4}, {0b1010000000110001, 5}, + {0b1010000000110010, 5}, {0b1010000000110100, 5}, + {0b1010000000111000, 5}, {0b1010000001000000, 5}, + {0b1010000001000001, 4}, {0b1010000001000010, 4}, + {0b1010000001000011, 5}, {0b1010000001000100, 4}, + {0b1010000001000110, 5}, {0b1010000001001000, 4}, + {0b1010000001001001, 5}, {0b1010000001001100, 5}, + {0b1010000001010000, 2}, {0b1010000001010101, 3}, + {0b1010000001011010, 3}, {0b1010000001011111, 4}, + {0b1010000001100000, 4}, {0b1010000001100001, 5}, + {0b1010000001100010, 5}, {0b1010000001100100, 5}, + {0b1010000001101000, 5}, {0b1010000010000000, 5}, + {0b1010000010000001, 4}, {0b1010000010000010, 4}, + {0b1010000010000011, 5}, {0b1010000010000100, 4}, + {0b1010000010000110, 5}, {0b1010000010001000, 4}, + {0b1010000010001001, 5}, {0b1010000010001100, 5}, + {0b1010000010010000, 4}, {0b1010000010010001, 5}, + {0b1010000010010010, 5}, {0b1010000010010100, 5}, + {0b1010000010011000, 5}, {0b1010000010100000, 2}, + {0b1010000010100101, 3}, {0b1010000010101010, 3}, + {0b1010000010101111, 4}, {0b1010000011000000, 4}, + {0b1010000011000001, 5}, {0b1010000011000010, 5}, + {0b1010000011000100, 5}, {0b1010000011001000, 5}, + {0b1010000011110000, 3}, {0b1010000011110101, 4}, + {0b1010000011111010, 4}, {0b1010000011111111, 3}, + {0b1010000100000000, 5}, {0b1010000100000001, 4}, + {0b1010000100000010, 4}, {0b1010000100000011, 5}, + {0b1010000100000100, 4}, {0b1010000100000110, 5}, + {0b1010000100001000, 4}, {0b1010000100001001, 5}, + {0b1010000100001100, 5}, {0b1010000100010000, 4}, + {0b1010000100010001, 5}, {0b1010000100010100, 5}, + {0b1010000100011010, 3}, {0b1010000100100000, 4}, + {0b1010000100100010, 5}, {0b1010000100100101, 3}, + {0b1010000100101000, 5}, {0b1010000100110000, 5}, + {0b1010000101000000, 4}, {0b1010000101000001, 5}, + {0b1010000101000100, 5}, {0b1010000101001010, 3}, + {0b1010000101010010, 3}, {0b1010000101011000, 3}, + {0b1010000101100000, 5}, {0b1010000110000000, 4}, + {0b1010000110000010, 5}, {0b1010000110000101, 3}, + {0b1010000110001000, 5}, {0b1010000110010000, 5}, + {0b1010000110100001, 3}, {0b1010000110100100, 3}, + {0b1010000111000000, 5}, {0b1010001000000000, 5}, + {0b1010001000000001, 4}, {0b1010001000000010, 4}, + {0b1010001000000011, 5}, {0b1010001000000100, 4}, + {0b1010001000000110, 5}, {0b1010001000001000, 4}, + {0b1010001000001001, 5}, {0b1010001000001100, 5}, + {0b1010001000010000, 4}, {0b1010001000010010, 5}, + {0b1010001000010101, 3}, {0b1010001000011000, 5}, + {0b1010001000100000, 4}, {0b1010001000100001, 5}, + {0b1010001000100100, 5}, {0b1010001000101010, 3}, + {0b1010001000110000, 5}, {0b1010001001000000, 4}, + {0b1010001001000010, 5}, {0b1010001001000101, 3}, + {0b1010001001001000, 5}, {0b1010001001010001, 3}, + {0b1010001001010100, 3}, {0b1010001001100000, 5}, + {0b1010001010000000, 4}, {0b1010001010000001, 5}, + {0b1010001010000100, 5}, {0b1010001010001010, 3}, + {0b1010001010010000, 5}, {0b1010001010100010, 3}, + {0b1010001010101000, 3}, {0b1010001011000000, 5}, + {0b1010001100000000, 4}, {0b1010001100000001, 5}, + {0b1010001100000010, 5}, {0b1010001100000100, 5}, + {0b1010001100001000, 5}, {0b1010001100010000, 5}, + {0b1010001100100000, 5}, {0b1010001100110101, 4}, + {0b1010001100111010, 4}, {0b1010001101000000, 5}, + {0b1010001101010011, 4}, {0b1010001101011100, 4}, + {0b1010001101111111, 5}, {0b1010001110000000, 5}, + {0b1010001110100011, 4}, {0b1010001110101100, 4}, + {0b1010001110111111, 5}, {0b1010001111000101, 4}, + {0b1010001111001010, 4}, {0b1010001111011111, 5}, + {0b1010001111101111, 5}, {0b1010001111110111, 5}, + {0b1010001111111011, 5}, {0b1010001111111101, 5}, + {0b1010001111111110, 5}, {0b1010001111111111, 4}, + {0b1010010000000000, 5}, {0b1010010000000001, 4}, + {0b1010010000000010, 4}, {0b1010010000000011, 5}, + {0b1010010000000100, 4}, {0b1010010000000110, 5}, + {0b1010010000001000, 4}, {0b1010010000001001, 5}, + {0b1010010000001100, 5}, {0b1010010000010000, 4}, + {0b1010010000010001, 5}, {0b1010010000010100, 5}, + {0b1010010000011010, 3}, {0b1010010000100000, 4}, + {0b1010010000100010, 5}, {0b1010010000100101, 3}, + {0b1010010000101000, 5}, {0b1010010000110000, 5}, + {0b1010010001000000, 4}, {0b1010010001000001, 5}, + {0b1010010001000100, 5}, {0b1010010001001010, 3}, + {0b1010010001010010, 3}, {0b1010010001011000, 3}, + {0b1010010001100000, 5}, {0b1010010010000000, 4}, + {0b1010010010000010, 5}, {0b1010010010000101, 3}, + {0b1010010010001000, 5}, {0b1010010010010000, 5}, + {0b1010010010100001, 3}, {0b1010010010100100, 3}, + {0b1010010011000000, 5}, {0b1010010100000000, 2}, + {0b1010010100000101, 3}, {0b1010010100001010, 3}, + {0b1010010100001111, 4}, {0b1010010100010010, 3}, + {0b1010010100011000, 3}, {0b1010010100100001, 3}, + {0b1010010100100100, 3}, {0b1010010100110011, 4}, + {0b1010010100111100, 4}, {0b1010010101000010, 3}, + {0b1010010101001000, 3}, {0b1010010101010000, 3}, + {0b1010010101010101, 4}, {0b1010010101011010, 1}, + {0b1010010101011111, 3}, {0b1010010101100110, 4}, + {0b1010010101101001, 4}, {0b1010010101111011, 3}, + {0b1010010101111110, 3}, {0b1010010110000001, 3}, + {0b1010010110000100, 3}, {0b1010010110010110, 4}, + {0b1010010110011001, 4}, {0b1010010110100000, 3}, + {0b1010010110100101, 1}, {0b1010010110101010, 4}, + {0b1010010110101111, 3}, {0b1010010110110111, 3}, + {0b1010010110111101, 3}, {0b1010010111000011, 4}, + {0b1010010111001100, 4}, {0b1010010111011011, 3}, + {0b1010010111011110, 3}, {0b1010010111100111, 3}, + {0b1010010111101101, 3}, {0b1010010111110000, 4}, + {0b1010010111110101, 3}, {0b1010010111111010, 3}, + {0b1010010111111111, 2}, {0b1010011000000000, 4}, + {0b1010011000000001, 5}, {0b1010011000000010, 5}, + {0b1010011000000100, 5}, {0b1010011000001000, 5}, + {0b1010011000010000, 5}, {0b1010011000100000, 5}, + {0b1010011001000000, 5}, {0b1010011001010110, 4}, + {0b1010011001011001, 4}, {0b1010011001100101, 4}, + {0b1010011001101010, 4}, {0b1010011001111111, 5}, + {0b1010011010000000, 5}, {0b1010011010010101, 4}, + {0b1010011010011010, 4}, {0b1010011010100110, 4}, + {0b1010011010101001, 4}, {0b1010011010111111, 5}, + {0b1010011011011111, 5}, {0b1010011011101111, 5}, + {0b1010011011110111, 5}, {0b1010011011111011, 5}, + {0b1010011011111101, 5}, {0b1010011011111110, 5}, + {0b1010011011111111, 4}, {0b1010011100111111, 5}, + {0b1010011101011011, 3}, {0b1010011101011110, 3}, + {0b1010011101101111, 5}, {0b1010011101110111, 5}, + {0b1010011101111010, 3}, {0b1010011101111101, 5}, + {0b1010011101111111, 4}, {0b1010011110011111, 5}, + {0b1010011110100111, 3}, {0b1010011110101101, 3}, + {0b1010011110110101, 3}, {0b1010011110111011, 5}, + {0b1010011110111110, 5}, {0b1010011110111111, 4}, + {0b1010011111001111, 5}, {0b1010011111010111, 5}, + {0b1010011111011010, 3}, {0b1010011111011101, 5}, + {0b1010011111011111, 4}, {0b1010011111100101, 3}, + {0b1010011111101011, 5}, {0b1010011111101110, 5}, + {0b1010011111101111, 4}, {0b1010011111110011, 5}, + {0b1010011111110110, 5}, {0b1010011111110111, 4}, + {0b1010011111111001, 5}, {0b1010011111111011, 4}, + {0b1010011111111100, 5}, {0b1010011111111101, 4}, + {0b1010011111111110, 4}, {0b1010011111111111, 5}, + {0b1010100000000000, 5}, {0b1010100000000001, 4}, + {0b1010100000000010, 4}, {0b1010100000000011, 5}, + {0b1010100000000100, 4}, {0b1010100000000110, 5}, + {0b1010100000001000, 4}, {0b1010100000001001, 5}, + {0b1010100000001100, 5}, {0b1010100000010000, 4}, + {0b1010100000010010, 5}, {0b1010100000010101, 3}, + {0b1010100000011000, 5}, {0b1010100000100000, 4}, + {0b1010100000100001, 5}, {0b1010100000100100, 5}, + {0b1010100000101010, 3}, {0b1010100000110000, 5}, + {0b1010100001000000, 4}, {0b1010100001000010, 5}, + {0b1010100001000101, 3}, {0b1010100001001000, 5}, + {0b1010100001010001, 3}, {0b1010100001010100, 3}, + {0b1010100001100000, 5}, {0b1010100010000000, 4}, + {0b1010100010000001, 5}, {0b1010100010000100, 5}, + {0b1010100010001010, 3}, {0b1010100010010000, 5}, + {0b1010100010100010, 3}, {0b1010100010101000, 3}, + {0b1010100011000000, 5}, {0b1010100100000000, 4}, + {0b1010100100000001, 5}, {0b1010100100000010, 5}, + {0b1010100100000100, 5}, {0b1010100100001000, 5}, + {0b1010100100010000, 5}, {0b1010100100100000, 5}, + {0b1010100101000000, 5}, {0b1010100101010110, 4}, + {0b1010100101011001, 4}, {0b1010100101100101, 4}, + {0b1010100101101010, 4}, {0b1010100101111111, 5}, + {0b1010100110000000, 5}, {0b1010100110010101, 4}, + {0b1010100110011010, 4}, {0b1010100110100110, 4}, + {0b1010100110101001, 4}, {0b1010100110111111, 5}, + {0b1010100111011111, 5}, {0b1010100111101111, 5}, + {0b1010100111110111, 5}, {0b1010100111111011, 5}, + {0b1010100111111101, 5}, {0b1010100111111110, 5}, + {0b1010100111111111, 4}, {0b1010101000000000, 2}, + {0b1010101000000101, 3}, {0b1010101000001010, 3}, + {0b1010101000001111, 4}, {0b1010101000010001, 3}, + {0b1010101000010100, 3}, {0b1010101000100010, 3}, + {0b1010101000101000, 3}, {0b1010101000110011, 4}, + {0b1010101000111100, 4}, {0b1010101001000001, 3}, + {0b1010101001000100, 3}, {0b1010101001010000, 3}, + {0b1010101001010101, 1}, {0b1010101001011010, 4}, + {0b1010101001011111, 3}, {0b1010101001100110, 4}, + {0b1010101001101001, 4}, {0b1010101001110111, 3}, + {0b1010101001111101, 3}, {0b1010101010000010, 3}, + {0b1010101010001000, 3}, {0b1010101010010110, 4}, + {0b1010101010011001, 4}, {0b1010101010100000, 3}, + {0b1010101010100101, 4}, {0b1010101010101010, 1}, + {0b1010101010101111, 3}, {0b1010101010111011, 3}, + {0b1010101010111110, 3}, {0b1010101011000011, 4}, + {0b1010101011001100, 4}, {0b1010101011010111, 3}, + {0b1010101011011101, 3}, {0b1010101011101011, 3}, + {0b1010101011101110, 3}, {0b1010101011110000, 4}, + {0b1010101011110101, 3}, {0b1010101011111010, 3}, + {0b1010101011111111, 2}, {0b1010101100111111, 5}, + {0b1010101101010111, 3}, {0b1010101101011101, 3}, + {0b1010101101101111, 5}, {0b1010101101110101, 3}, + {0b1010101101111011, 5}, {0b1010101101111110, 5}, + {0b1010101101111111, 4}, {0b1010101110011111, 5}, + {0b1010101110101011, 3}, {0b1010101110101110, 3}, + {0b1010101110110111, 5}, {0b1010101110111010, 3}, + {0b1010101110111101, 5}, {0b1010101110111111, 4}, + {0b1010101111001111, 5}, {0b1010101111010101, 3}, + {0b1010101111011011, 5}, {0b1010101111011110, 5}, + {0b1010101111011111, 4}, {0b1010101111100111, 5}, + {0b1010101111101010, 3}, {0b1010101111101101, 5}, + {0b1010101111101111, 4}, {0b1010101111110011, 5}, + {0b1010101111110110, 5}, {0b1010101111110111, 4}, + {0b1010101111111001, 5}, {0b1010101111111011, 4}, + {0b1010101111111100, 5}, {0b1010101111111101, 4}, + {0b1010101111111110, 4}, {0b1010101111111111, 5}, + {0b1010110000000000, 4}, {0b1010110000000001, 5}, + {0b1010110000000010, 5}, {0b1010110000000100, 5}, + {0b1010110000001000, 5}, {0b1010110000010000, 5}, + {0b1010110000100000, 5}, {0b1010110000110101, 4}, + {0b1010110000111010, 4}, {0b1010110001000000, 5}, + {0b1010110001010011, 4}, {0b1010110001011100, 4}, + {0b1010110001111111, 5}, {0b1010110010000000, 5}, + {0b1010110010100011, 4}, {0b1010110010101100, 4}, + {0b1010110010111111, 5}, {0b1010110011000101, 4}, + {0b1010110011001010, 4}, {0b1010110011011111, 5}, + {0b1010110011101111, 5}, {0b1010110011110111, 5}, + {0b1010110011111011, 5}, {0b1010110011111101, 5}, + {0b1010110011111110, 5}, {0b1010110011111111, 4}, + {0b1010110100111111, 5}, {0b1010110101011011, 3}, + {0b1010110101011110, 3}, {0b1010110101101111, 5}, + {0b1010110101110111, 5}, {0b1010110101111010, 3}, + {0b1010110101111101, 5}, {0b1010110101111111, 4}, + {0b1010110110011111, 5}, {0b1010110110100111, 3}, + {0b1010110110101101, 3}, {0b1010110110110101, 3}, + {0b1010110110111011, 5}, {0b1010110110111110, 5}, + {0b1010110110111111, 4}, {0b1010110111001111, 5}, + {0b1010110111010111, 5}, {0b1010110111011010, 3}, + {0b1010110111011101, 5}, {0b1010110111011111, 4}, + {0b1010110111100101, 3}, {0b1010110111101011, 5}, + {0b1010110111101110, 5}, {0b1010110111101111, 4}, + {0b1010110111110011, 5}, {0b1010110111110110, 5}, + {0b1010110111110111, 4}, {0b1010110111111001, 5}, + {0b1010110111111011, 4}, {0b1010110111111100, 5}, + {0b1010110111111101, 4}, {0b1010110111111110, 4}, + {0b1010110111111111, 5}, {0b1010111000111111, 5}, + {0b1010111001010111, 3}, {0b1010111001011101, 3}, + {0b1010111001101111, 5}, {0b1010111001110101, 3}, + {0b1010111001111011, 5}, {0b1010111001111110, 5}, + {0b1010111001111111, 4}, {0b1010111010011111, 5}, + {0b1010111010101011, 3}, {0b1010111010101110, 3}, + {0b1010111010110111, 5}, {0b1010111010111010, 3}, + {0b1010111010111101, 5}, {0b1010111010111111, 4}, + {0b1010111011001111, 5}, {0b1010111011010101, 3}, + {0b1010111011011011, 5}, {0b1010111011011110, 5}, + {0b1010111011011111, 4}, {0b1010111011100111, 5}, + {0b1010111011101010, 3}, {0b1010111011101101, 5}, + {0b1010111011101111, 4}, {0b1010111011110011, 5}, + {0b1010111011110110, 5}, {0b1010111011110111, 4}, + {0b1010111011111001, 5}, {0b1010111011111011, 4}, + {0b1010111011111100, 5}, {0b1010111011111101, 4}, + {0b1010111011111110, 4}, {0b1010111011111111, 5}, + {0b1010111100000000, 3}, {0b1010111100000101, 4}, + {0b1010111100001010, 4}, {0b1010111100001111, 3}, + {0b1010111100110111, 5}, {0b1010111100111011, 5}, + {0b1010111100111101, 5}, {0b1010111100111110, 5}, + {0b1010111100111111, 4}, {0b1010111101010000, 4}, + {0b1010111101010101, 3}, {0b1010111101011010, 3}, + {0b1010111101011111, 2}, {0b1010111101100111, 5}, + {0b1010111101101011, 5}, {0b1010111101101101, 5}, + {0b1010111101101110, 5}, {0b1010111101101111, 4}, + {0b1010111101110011, 5}, {0b1010111101110110, 5}, + {0b1010111101110111, 4}, {0b1010111101111001, 5}, + {0b1010111101111011, 4}, {0b1010111101111100, 5}, + {0b1010111101111101, 4}, {0b1010111101111110, 4}, + {0b1010111101111111, 5}, {0b1010111110010111, 5}, + {0b1010111110011011, 5}, {0b1010111110011101, 5}, + {0b1010111110011110, 5}, {0b1010111110011111, 4}, + {0b1010111110100000, 4}, {0b1010111110100101, 3}, + {0b1010111110101010, 3}, {0b1010111110101111, 2}, + {0b1010111110110011, 5}, {0b1010111110110110, 5}, + {0b1010111110110111, 4}, {0b1010111110111001, 5}, + {0b1010111110111011, 4}, {0b1010111110111100, 5}, + {0b1010111110111101, 4}, {0b1010111110111110, 4}, + {0b1010111110111111, 5}, {0b1010111111000111, 5}, + {0b1010111111001011, 5}, {0b1010111111001101, 5}, + {0b1010111111001110, 5}, {0b1010111111001111, 4}, + {0b1010111111010011, 5}, {0b1010111111010110, 5}, + {0b1010111111010111, 4}, {0b1010111111011001, 5}, + {0b1010111111011011, 4}, {0b1010111111011100, 5}, + {0b1010111111011101, 4}, {0b1010111111011110, 4}, + {0b1010111111011111, 5}, {0b1010111111100011, 5}, + {0b1010111111100110, 5}, {0b1010111111100111, 4}, + {0b1010111111101001, 5}, {0b1010111111101011, 4}, + {0b1010111111101100, 5}, {0b1010111111101101, 4}, + {0b1010111111101110, 4}, {0b1010111111101111, 5}, + {0b1010111111110000, 3}, {0b1010111111110011, 4}, + {0b1010111111110101, 2}, {0b1010111111110110, 4}, + {0b1010111111110111, 5}, {0b1010111111111001, 4}, + {0b1010111111111010, 2}, {0b1010111111111011, 5}, + {0b1010111111111100, 4}, {0b1010111111111101, 5}, + {0b1010111111111110, 5}, {0b1010111111111111, 3}, + {0b1011000000000000, 5}, {0b1011000000000001, 4}, + {0b1011000000000010, 4}, {0b1011000000000100, 4}, + {0b1011000000000111, 3}, {0b1011000000001000, 4}, + {0b1011000000001011, 3}, {0b1011000000001101, 3}, + {0b1011000000001110, 3}, {0b1011000000010000, 4}, + {0b1011000000010001, 5}, {0b1011000000010010, 5}, + {0b1011000000010100, 5}, {0b1011000000011000, 5}, + {0b1011000000100000, 4}, {0b1011000000100001, 5}, + {0b1011000000100010, 5}, {0b1011000000100100, 5}, + {0b1011000000101000, 5}, {0b1011000001000000, 4}, + {0b1011000001000001, 5}, {0b1011000001000010, 5}, + {0b1011000001000100, 5}, {0b1011000001001000, 5}, + {0b1011000001110000, 3}, {0b1011000010000000, 4}, + {0b1011000010000001, 5}, {0b1011000010000010, 5}, + {0b1011000010000100, 5}, {0b1011000010001000, 5}, + {0b1011000010110000, 3}, {0b1011000011010000, 3}, + {0b1011000011100000, 3}, {0b1011000100000000, 4}, + {0b1011000100000001, 5}, {0b1011000100000010, 5}, + {0b1011000100000100, 5}, {0b1011000100001000, 5}, + {0b1011000100010000, 5}, {0b1011000100011011, 4}, + {0b1011000100100000, 5}, {0b1011000100100111, 4}, + {0b1011000101000000, 5}, {0b1011000101001110, 4}, + {0b1011000101110010, 4}, {0b1011000101111111, 5}, + {0b1011000110000000, 5}, {0b1011000110001101, 4}, + {0b1011000110110001, 4}, {0b1011000110111111, 5}, + {0b1011000111011000, 4}, {0b1011000111011111, 5}, + {0b1011000111100100, 4}, {0b1011000111101111, 5}, + {0b1011000111110111, 5}, {0b1011000111111011, 5}, + {0b1011000111111101, 5}, {0b1011000111111110, 5}, + {0b1011000111111111, 4}, {0b1011001000000000, 4}, + {0b1011001000000001, 5}, {0b1011001000000010, 5}, + {0b1011001000000100, 5}, {0b1011001000001000, 5}, + {0b1011001000010000, 5}, {0b1011001000010111, 4}, + {0b1011001000100000, 5}, {0b1011001000101011, 4}, + {0b1011001001000000, 5}, {0b1011001001001101, 4}, + {0b1011001001110001, 4}, {0b1011001001111111, 5}, + {0b1011001010000000, 5}, {0b1011001010001110, 4}, + {0b1011001010110010, 4}, {0b1011001010111111, 5}, + {0b1011001011010100, 4}, {0b1011001011011111, 5}, + {0b1011001011101000, 4}, {0b1011001011101111, 5}, + {0b1011001011110111, 5}, {0b1011001011111011, 5}, + {0b1011001011111101, 5}, {0b1011001011111110, 5}, + {0b1011001011111111, 4}, {0b1011001100110111, 3}, + {0b1011001100111011, 3}, {0b1011001101011111, 5}, + {0b1011001101101111, 5}, {0b1011001101110011, 3}, + {0b1011001101111101, 5}, {0b1011001101111110, 5}, + {0b1011001101111111, 4}, {0b1011001110011111, 5}, + {0b1011001110101111, 5}, {0b1011001110110011, 3}, + {0b1011001110111101, 5}, {0b1011001110111110, 5}, + {0b1011001110111111, 4}, {0b1011001111001101, 3}, + {0b1011001111001110, 3}, {0b1011001111010111, 5}, + {0b1011001111011011, 5}, {0b1011001111011100, 3}, + {0b1011001111011111, 4}, {0b1011001111100111, 5}, + {0b1011001111101011, 5}, {0b1011001111101100, 3}, + {0b1011001111101111, 4}, {0b1011001111110101, 5}, + {0b1011001111110110, 5}, {0b1011001111110111, 4}, + {0b1011001111111001, 5}, {0b1011001111111010, 5}, + {0b1011001111111011, 4}, {0b1011001111111101, 4}, + {0b1011001111111110, 4}, {0b1011001111111111, 5}, + {0b1011010000000000, 4}, {0b1011010000000001, 5}, + {0b1011010000000010, 5}, {0b1011010000000100, 5}, + {0b1011010000001000, 5}, {0b1011010000010000, 5}, + {0b1011010000011110, 4}, {0b1011010000100000, 5}, + {0b1011010000101101, 4}, {0b1011010001000000, 5}, + {0b1011010001001011, 4}, {0b1011010001111000, 4}, + {0b1011010001111111, 5}, {0b1011010010000000, 5}, + {0b1011010010000111, 4}, {0b1011010010110100, 4}, + {0b1011010010111111, 5}, {0b1011010011010010, 4}, + {0b1011010011011111, 5}, {0b1011010011100001, 4}, + {0b1011010011101111, 5}, {0b1011010011110111, 5}, + {0b1011010011111011, 5}, {0b1011010011111101, 5}, + {0b1011010011111110, 5}, {0b1011010011111111, 4}, + {0b1011010100111111, 5}, {0b1011010101011011, 3}, + {0b1011010101011110, 3}, {0b1011010101101111, 5}, + {0b1011010101110111, 5}, {0b1011010101111010, 3}, + {0b1011010101111101, 5}, {0b1011010101111111, 4}, + {0b1011010110011111, 5}, {0b1011010110100111, 3}, + {0b1011010110101101, 3}, {0b1011010110110101, 3}, + {0b1011010110111011, 5}, {0b1011010110111110, 5}, + {0b1011010110111111, 4}, {0b1011010111001111, 5}, + {0b1011010111010111, 5}, {0b1011010111011010, 3}, + {0b1011010111011101, 5}, {0b1011010111011111, 4}, + {0b1011010111100101, 3}, {0b1011010111101011, 5}, + {0b1011010111101110, 5}, {0b1011010111101111, 4}, + {0b1011010111110011, 5}, {0b1011010111110110, 5}, + {0b1011010111110111, 4}, {0b1011010111111001, 5}, + {0b1011010111111011, 4}, {0b1011010111111100, 5}, + {0b1011010111111101, 4}, {0b1011010111111110, 4}, + {0b1011010111111111, 5}, {0b1011011000111111, 5}, + {0b1011011001011111, 5}, {0b1011011001101011, 3}, + {0b1011011001101101, 3}, {0b1011011001110111, 5}, + {0b1011011001111001, 3}, {0b1011011001111110, 5}, + {0b1011011001111111, 4}, {0b1011011010010111, 3}, + {0b1011011010011110, 3}, {0b1011011010101111, 5}, + {0b1011011010110110, 3}, {0b1011011010111011, 5}, + {0b1011011010111101, 5}, {0b1011011010111111, 4}, + {0b1011011011001111, 5}, {0b1011011011010110, 3}, + {0b1011011011011011, 5}, {0b1011011011011101, 5}, + {0b1011011011011111, 4}, {0b1011011011100111, 5}, + {0b1011011011101001, 3}, {0b1011011011101110, 5}, + {0b1011011011101111, 4}, {0b1011011011110011, 5}, + {0b1011011011110101, 5}, {0b1011011011110111, 4}, + {0b1011011011111010, 5}, {0b1011011011111011, 4}, + {0b1011011011111100, 5}, {0b1011011011111101, 4}, + {0b1011011011111110, 4}, {0b1011011011111111, 5}, + {0b1011011100000000, 3}, {0b1011011100010010, 4}, + {0b1011011100011111, 5}, {0b1011011100100001, 4}, + {0b1011011100101111, 5}, {0b1011011100110011, 3}, + {0b1011011100111101, 5}, {0b1011011100111110, 5}, + {0b1011011100111111, 4}, {0b1011011101001000, 4}, + {0b1011011101001111, 5}, {0b1011011101010111, 5}, + {0b1011011101011010, 3}, {0b1011011101011101, 5}, + {0b1011011101011111, 4}, {0b1011011101100111, 5}, + {0b1011011101101001, 3}, {0b1011011101101110, 5}, + {0b1011011101101111, 4}, {0b1011011101110101, 5}, + {0b1011011101110110, 5}, {0b1011011101110111, 4}, + {0b1011011101111011, 2}, {0b1011011101111100, 5}, + {0b1011011101111101, 4}, {0b1011011101111110, 4}, + {0b1011011101111111, 5}, {0b1011011110000100, 4}, + {0b1011011110001111, 5}, {0b1011011110010110, 3}, + {0b1011011110011011, 5}, {0b1011011110011101, 5}, + {0b1011011110011111, 4}, {0b1011011110100101, 3}, + {0b1011011110101011, 5}, {0b1011011110101110, 5}, + {0b1011011110101111, 4}, {0b1011011110110111, 2}, + {0b1011011110111001, 5}, {0b1011011110111010, 5}, + {0b1011011110111011, 4}, {0b1011011110111100, 5}, + {0b1011011110111101, 4}, {0b1011011110111110, 4}, + {0b1011011110111111, 5}, {0b1011011111000111, 5}, + {0b1011011111001011, 5}, {0b1011011111001100, 3}, + {0b1011011111001111, 4}, {0b1011011111010011, 5}, + {0b1011011111010101, 5}, {0b1011011111010111, 4}, + {0b1011011111011001, 5}, {0b1011011111011011, 4}, + {0b1011011111011101, 4}, {0b1011011111011110, 2}, + {0b1011011111011111, 5}, {0b1011011111100011, 5}, + {0b1011011111100110, 5}, {0b1011011111100111, 4}, + {0b1011011111101010, 5}, {0b1011011111101011, 4}, + {0b1011011111101101, 2}, {0b1011011111101110, 4}, + {0b1011011111101111, 5}, {0b1011011111110001, 5}, + {0b1011011111110010, 5}, {0b1011011111110011, 4}, + {0b1011011111110100, 5}, {0b1011011111110101, 4}, + {0b1011011111110110, 4}, {0b1011011111110111, 5}, + {0b1011011111111000, 5}, {0b1011011111111001, 4}, + {0b1011011111111010, 4}, {0b1011011111111011, 5}, + {0b1011011111111100, 4}, {0b1011011111111101, 5}, + {0b1011011111111110, 5}, {0b1011011111111111, 3}, + {0b1011100000000000, 4}, {0b1011100000000001, 5}, + {0b1011100000000010, 5}, {0b1011100000000100, 5}, + {0b1011100000001000, 5}, {0b1011100000010000, 5}, + {0b1011100000011101, 4}, {0b1011100000100000, 5}, + {0b1011100000101110, 4}, {0b1011100001000000, 5}, + {0b1011100001000111, 4}, {0b1011100001110100, 4}, + {0b1011100001111111, 5}, {0b1011100010000000, 5}, + {0b1011100010001011, 4}, {0b1011100010111000, 4}, + {0b1011100010111111, 5}, {0b1011100011010001, 4}, + {0b1011100011011111, 5}, {0b1011100011100010, 4}, + {0b1011100011101111, 5}, {0b1011100011110111, 5}, + {0b1011100011111011, 5}, {0b1011100011111101, 5}, + {0b1011100011111110, 5}, {0b1011100011111111, 4}, + {0b1011100100111111, 5}, {0b1011100101011111, 5}, + {0b1011100101100111, 3}, {0b1011100101101110, 3}, + {0b1011100101110110, 3}, {0b1011100101111011, 5}, + {0b1011100101111101, 5}, {0b1011100101111111, 4}, + {0b1011100110011011, 3}, {0b1011100110011101, 3}, + {0b1011100110101111, 5}, {0b1011100110110111, 5}, + {0b1011100110111001, 3}, {0b1011100110111110, 5}, + {0b1011100110111111, 4}, {0b1011100111001111, 5}, + {0b1011100111010111, 5}, {0b1011100111011001, 3}, + {0b1011100111011110, 5}, {0b1011100111011111, 4}, + {0b1011100111100110, 3}, {0b1011100111101011, 5}, + {0b1011100111101101, 5}, {0b1011100111101111, 4}, + {0b1011100111110011, 5}, {0b1011100111110101, 5}, + {0b1011100111110111, 4}, {0b1011100111111010, 5}, + {0b1011100111111011, 4}, {0b1011100111111100, 5}, + {0b1011100111111101, 4}, {0b1011100111111110, 4}, + {0b1011100111111111, 5}, {0b1011101000111111, 5}, + {0b1011101001010111, 3}, {0b1011101001011101, 3}, + {0b1011101001101111, 5}, {0b1011101001110101, 3}, + {0b1011101001111011, 5}, {0b1011101001111110, 5}, + {0b1011101001111111, 4}, {0b1011101010011111, 5}, + {0b1011101010101011, 3}, {0b1011101010101110, 3}, + {0b1011101010110111, 5}, {0b1011101010111010, 3}, + {0b1011101010111101, 5}, {0b1011101010111111, 4}, + {0b1011101011001111, 5}, {0b1011101011010101, 3}, + {0b1011101011011011, 5}, {0b1011101011011110, 5}, + {0b1011101011011111, 4}, {0b1011101011100111, 5}, + {0b1011101011101010, 3}, {0b1011101011101101, 5}, + {0b1011101011101111, 4}, {0b1011101011110011, 5}, + {0b1011101011110110, 5}, {0b1011101011110111, 4}, + {0b1011101011111001, 5}, {0b1011101011111011, 4}, + {0b1011101011111100, 5}, {0b1011101011111101, 4}, + {0b1011101011111110, 4}, {0b1011101011111111, 5}, + {0b1011101100000000, 3}, {0b1011101100010001, 4}, + {0b1011101100011111, 5}, {0b1011101100100010, 4}, + {0b1011101100101111, 5}, {0b1011101100110011, 3}, + {0b1011101100111101, 5}, {0b1011101100111110, 5}, + {0b1011101100111111, 4}, {0b1011101101000100, 4}, + {0b1011101101001111, 5}, {0b1011101101010101, 3}, + {0b1011101101011011, 5}, {0b1011101101011110, 5}, + {0b1011101101011111, 4}, {0b1011101101100110, 3}, + {0b1011101101101011, 5}, {0b1011101101101101, 5}, + {0b1011101101101111, 4}, {0b1011101101110111, 2}, + {0b1011101101111001, 5}, {0b1011101101111010, 5}, + {0b1011101101111011, 4}, {0b1011101101111100, 5}, + {0b1011101101111101, 4}, {0b1011101101111110, 4}, + {0b1011101101111111, 5}, {0b1011101110001000, 4}, + {0b1011101110001111, 5}, {0b1011101110010111, 5}, + {0b1011101110011001, 3}, {0b1011101110011110, 5}, + {0b1011101110011111, 4}, {0b1011101110100111, 5}, + {0b1011101110101010, 3}, {0b1011101110101101, 5}, + {0b1011101110101111, 4}, {0b1011101110110101, 5}, + {0b1011101110110110, 5}, {0b1011101110110111, 4}, + {0b1011101110111011, 2}, {0b1011101110111100, 5}, + {0b1011101110111101, 4}, {0b1011101110111110, 4}, + {0b1011101110111111, 5}, {0b1011101111000111, 5}, + {0b1011101111001011, 5}, {0b1011101111001100, 3}, + {0b1011101111001111, 4}, {0b1011101111010011, 5}, + {0b1011101111010110, 5}, {0b1011101111010111, 4}, + {0b1011101111011010, 5}, {0b1011101111011011, 4}, + {0b1011101111011101, 2}, {0b1011101111011110, 4}, + {0b1011101111011111, 5}, {0b1011101111100011, 5}, + {0b1011101111100101, 5}, {0b1011101111100111, 4}, + {0b1011101111101001, 5}, {0b1011101111101011, 4}, + {0b1011101111101101, 4}, {0b1011101111101110, 2}, + {0b1011101111101111, 5}, {0b1011101111110001, 5}, + {0b1011101111110010, 5}, {0b1011101111110011, 4}, + {0b1011101111110100, 5}, {0b1011101111110101, 4}, + {0b1011101111110110, 4}, {0b1011101111110111, 5}, + {0b1011101111111000, 5}, {0b1011101111111001, 4}, + {0b1011101111111010, 4}, {0b1011101111111011, 5}, + {0b1011101111111100, 4}, {0b1011101111111101, 5}, + {0b1011101111111110, 5}, {0b1011101111111111, 3}, + {0b1011110000111101, 3}, {0b1011110000111110, 3}, + {0b1011110001011111, 5}, {0b1011110001101111, 5}, + {0b1011110001110111, 5}, {0b1011110001111011, 5}, + {0b1011110001111100, 3}, {0b1011110001111111, 4}, + {0b1011110010011111, 5}, {0b1011110010101111, 5}, + {0b1011110010110111, 5}, {0b1011110010111011, 5}, + {0b1011110010111100, 3}, {0b1011110010111111, 4}, + {0b1011110011000111, 3}, {0b1011110011001011, 3}, + {0b1011110011010011, 3}, {0b1011110011011101, 5}, + {0b1011110011011110, 5}, {0b1011110011011111, 4}, + {0b1011110011100011, 3}, {0b1011110011101101, 5}, + {0b1011110011101110, 5}, {0b1011110011101111, 4}, + {0b1011110011110101, 5}, {0b1011110011110110, 5}, + {0b1011110011110111, 4}, {0b1011110011111001, 5}, + {0b1011110011111010, 5}, {0b1011110011111011, 4}, + {0b1011110011111101, 4}, {0b1011110011111110, 4}, + {0b1011110011111111, 5}, {0b1011110100000000, 3}, + {0b1011110100011000, 4}, {0b1011110100011111, 5}, + {0b1011110100100100, 4}, {0b1011110100101111, 5}, + {0b1011110100110111, 5}, {0b1011110100111011, 5}, + {0b1011110100111100, 3}, {0b1011110100111111, 4}, + {0b1011110101000010, 4}, {0b1011110101001111, 5}, + {0b1011110101010111, 5}, {0b1011110101011010, 3}, + {0b1011110101011101, 5}, {0b1011110101011111, 4}, + {0b1011110101100110, 3}, {0b1011110101101011, 5}, + {0b1011110101101101, 5}, {0b1011110101101111, 4}, + {0b1011110101110011, 5}, {0b1011110101110101, 5}, + {0b1011110101110111, 4}, {0b1011110101111001, 5}, + {0b1011110101111011, 4}, {0b1011110101111101, 4}, + {0b1011110101111110, 2}, {0b1011110101111111, 5}, + {0b1011110110000001, 4}, {0b1011110110001111, 5}, + {0b1011110110010111, 5}, {0b1011110110011001, 3}, + {0b1011110110011110, 5}, {0b1011110110011111, 4}, + {0b1011110110100101, 3}, {0b1011110110101011, 5}, + {0b1011110110101110, 5}, {0b1011110110101111, 4}, + {0b1011110110110011, 5}, {0b1011110110110110, 5}, + {0b1011110110110111, 4}, {0b1011110110111010, 5}, + {0b1011110110111011, 4}, {0b1011110110111101, 2}, + {0b1011110110111110, 4}, {0b1011110110111111, 5}, + {0b1011110111000011, 3}, {0b1011110111001101, 5}, + {0b1011110111001110, 5}, {0b1011110111001111, 4}, + {0b1011110111010101, 5}, {0b1011110111010110, 5}, + {0b1011110111010111, 4}, {0b1011110111011011, 2}, + {0b1011110111011100, 5}, {0b1011110111011101, 4}, + {0b1011110111011110, 4}, {0b1011110111011111, 5}, + {0b1011110111100111, 2}, {0b1011110111101001, 5}, + {0b1011110111101010, 5}, {0b1011110111101011, 4}, + {0b1011110111101100, 5}, {0b1011110111101101, 4}, + {0b1011110111101110, 4}, {0b1011110111101111, 5}, + {0b1011110111110001, 5}, {0b1011110111110010, 5}, + {0b1011110111110011, 4}, {0b1011110111110100, 5}, + {0b1011110111110101, 4}, {0b1011110111110110, 4}, + {0b1011110111110111, 5}, {0b1011110111111000, 5}, + {0b1011110111111001, 4}, {0b1011110111111010, 4}, + {0b1011110111111011, 5}, {0b1011110111111100, 4}, + {0b1011110111111101, 5}, {0b1011110111111110, 5}, + {0b1011110111111111, 3}, {0b1011111000000000, 3}, + {0b1011111000010100, 4}, {0b1011111000011111, 5}, + {0b1011111000101000, 4}, {0b1011111000101111, 5}, + {0b1011111000110111, 5}, {0b1011111000111011, 5}, + {0b1011111000111100, 3}, {0b1011111000111111, 4}, + {0b1011111001000001, 4}, {0b1011111001001111, 5}, + {0b1011111001010101, 3}, {0b1011111001011011, 5}, + {0b1011111001011110, 5}, {0b1011111001011111, 4}, + {0b1011111001100111, 5}, {0b1011111001101001, 3}, + {0b1011111001101110, 5}, {0b1011111001101111, 4}, + {0b1011111001110011, 5}, {0b1011111001110110, 5}, + {0b1011111001110111, 4}, {0b1011111001111010, 5}, + {0b1011111001111011, 4}, {0b1011111001111101, 2}, + {0b1011111001111110, 4}, {0b1011111001111111, 5}, + {0b1011111010000010, 4}, {0b1011111010001111, 5}, + {0b1011111010010110, 3}, {0b1011111010011011, 5}, + {0b1011111010011101, 5}, {0b1011111010011111, 4}, + {0b1011111010100111, 5}, {0b1011111010101010, 3}, + {0b1011111010101101, 5}, {0b1011111010101111, 4}, + {0b1011111010110011, 5}, {0b1011111010110101, 5}, + {0b1011111010110111, 4}, {0b1011111010111001, 5}, + {0b1011111010111011, 4}, {0b1011111010111101, 4}, + {0b1011111010111110, 2}, {0b1011111010111111, 5}, + {0b1011111011000011, 3}, {0b1011111011001101, 5}, + {0b1011111011001110, 5}, {0b1011111011001111, 4}, + {0b1011111011010111, 2}, {0b1011111011011001, 5}, + {0b1011111011011010, 5}, {0b1011111011011011, 4}, + {0b1011111011011100, 5}, {0b1011111011011101, 4}, + {0b1011111011011110, 4}, {0b1011111011011111, 5}, + {0b1011111011100101, 5}, {0b1011111011100110, 5}, + {0b1011111011100111, 4}, {0b1011111011101011, 2}, + {0b1011111011101100, 5}, {0b1011111011101101, 4}, + {0b1011111011101110, 4}, {0b1011111011101111, 5}, + {0b1011111011110001, 5}, {0b1011111011110010, 5}, + {0b1011111011110011, 4}, {0b1011111011110100, 5}, + {0b1011111011110101, 4}, {0b1011111011110110, 4}, + {0b1011111011110111, 5}, {0b1011111011111000, 5}, + {0b1011111011111001, 4}, {0b1011111011111010, 4}, + {0b1011111011111011, 5}, {0b1011111011111100, 4}, + {0b1011111011111101, 5}, {0b1011111011111110, 5}, + {0b1011111011111111, 3}, {0b1011111100010111, 5}, + {0b1011111100011011, 5}, {0b1011111100011101, 5}, + {0b1011111100011110, 5}, {0b1011111100011111, 4}, + {0b1011111100100111, 5}, {0b1011111100101011, 5}, + {0b1011111100101101, 5}, {0b1011111100101110, 5}, + {0b1011111100101111, 4}, {0b1011111100110101, 5}, + {0b1011111100110110, 5}, {0b1011111100110111, 4}, + {0b1011111100111001, 5}, {0b1011111100111010, 5}, + {0b1011111100111011, 4}, {0b1011111100111101, 4}, + {0b1011111100111110, 4}, {0b1011111100111111, 5}, + {0b1011111101000111, 5}, {0b1011111101001011, 5}, + {0b1011111101001101, 5}, {0b1011111101001110, 5}, + {0b1011111101001111, 4}, {0b1011111101010011, 5}, + {0b1011111101010110, 5}, {0b1011111101010111, 4}, + {0b1011111101011001, 5}, {0b1011111101011011, 4}, + {0b1011111101011100, 5}, {0b1011111101011101, 4}, + {0b1011111101011110, 4}, {0b1011111101011111, 5}, + {0b1011111101100011, 5}, {0b1011111101100101, 5}, + {0b1011111101100111, 4}, {0b1011111101101010, 5}, + {0b1011111101101011, 4}, {0b1011111101101100, 5}, + {0b1011111101101101, 4}, {0b1011111101101110, 4}, + {0b1011111101101111, 5}, {0b1011111101110001, 5}, + {0b1011111101110010, 5}, {0b1011111101110011, 4}, + {0b1011111101110100, 5}, {0b1011111101110101, 4}, + {0b1011111101110110, 4}, {0b1011111101110111, 5}, + {0b1011111101111000, 5}, {0b1011111101111001, 4}, + {0b1011111101111010, 4}, {0b1011111101111011, 5}, + {0b1011111101111100, 4}, {0b1011111101111101, 5}, + {0b1011111101111110, 5}, {0b1011111101111111, 3}, + {0b1011111110000111, 5}, {0b1011111110001011, 5}, + {0b1011111110001101, 5}, {0b1011111110001110, 5}, + {0b1011111110001111, 4}, {0b1011111110010011, 5}, + {0b1011111110010101, 5}, {0b1011111110010111, 4}, + {0b1011111110011010, 5}, {0b1011111110011011, 4}, + {0b1011111110011100, 5}, {0b1011111110011101, 4}, + {0b1011111110011110, 4}, {0b1011111110011111, 5}, + {0b1011111110100011, 5}, {0b1011111110100110, 5}, + {0b1011111110100111, 4}, {0b1011111110101001, 5}, + {0b1011111110101011, 4}, {0b1011111110101100, 5}, + {0b1011111110101101, 4}, {0b1011111110101110, 4}, + {0b1011111110101111, 5}, {0b1011111110110001, 5}, + {0b1011111110110010, 5}, {0b1011111110110011, 4}, + {0b1011111110110100, 5}, {0b1011111110110101, 4}, + {0b1011111110110110, 4}, {0b1011111110110111, 5}, + {0b1011111110111000, 5}, {0b1011111110111001, 4}, + {0b1011111110111010, 4}, {0b1011111110111011, 5}, + {0b1011111110111100, 4}, {0b1011111110111101, 5}, + {0b1011111110111110, 5}, {0b1011111110111111, 3}, + {0b1011111111000101, 5}, {0b1011111111000110, 5}, + {0b1011111111000111, 4}, {0b1011111111001001, 5}, + {0b1011111111001010, 5}, {0b1011111111001011, 4}, + {0b1011111111001101, 4}, {0b1011111111001110, 4}, + {0b1011111111001111, 5}, {0b1011111111010001, 5}, + {0b1011111111010010, 5}, {0b1011111111010011, 4}, + {0b1011111111010100, 5}, {0b1011111111010101, 4}, + {0b1011111111010110, 4}, {0b1011111111010111, 5}, + {0b1011111111011000, 5}, {0b1011111111011001, 4}, + {0b1011111111011010, 4}, {0b1011111111011011, 5}, + {0b1011111111011100, 4}, {0b1011111111011101, 5}, + {0b1011111111011110, 5}, {0b1011111111011111, 3}, + {0b1011111111100001, 5}, {0b1011111111100010, 5}, + {0b1011111111100011, 4}, {0b1011111111100100, 5}, + {0b1011111111100101, 4}, {0b1011111111100110, 4}, + {0b1011111111100111, 5}, {0b1011111111101000, 5}, + {0b1011111111101001, 4}, {0b1011111111101010, 4}, + {0b1011111111101011, 5}, {0b1011111111101100, 4}, + {0b1011111111101101, 5}, {0b1011111111101110, 5}, + {0b1011111111101111, 3}, {0b1011111111110001, 4}, + {0b1011111111110010, 4}, {0b1011111111110011, 5}, + {0b1011111111110100, 4}, {0b1011111111110101, 5}, + {0b1011111111110110, 5}, {0b1011111111110111, 3}, + {0b1011111111111000, 4}, {0b1011111111111001, 5}, + {0b1011111111111010, 5}, {0b1011111111111011, 3}, + {0b1011111111111100, 5}, {0b1011111111111101, 3}, + {0b1011111111111110, 3}, {0b1011111111111111, 4}, + {0b1100000000000000, 3}, {0b1100000000000001, 5}, + {0b1100000000000010, 5}, {0b1100000000000011, 2}, + {0b1100000000000100, 5}, {0b1100000000000101, 4}, + {0b1100000000000110, 4}, {0b1100000000001000, 5}, + {0b1100000000001001, 4}, {0b1100000000001010, 4}, + {0b1100000000001100, 2}, {0b1100000000001111, 3}, + {0b1100000000010000, 5}, {0b1100000000010001, 4}, + {0b1100000000010010, 4}, {0b1100000000010100, 4}, + {0b1100000000010101, 5}, {0b1100000000010110, 5}, + {0b1100000000011000, 4}, {0b1100000000011001, 5}, + {0b1100000000011010, 5}, {0b1100000000100000, 5}, + {0b1100000000100001, 4}, {0b1100000000100010, 4}, + {0b1100000000100100, 4}, {0b1100000000100101, 5}, + {0b1100000000100110, 5}, {0b1100000000101000, 4}, + {0b1100000000101001, 5}, {0b1100000000101010, 5}, + {0b1100000000110000, 2}, {0b1100000000110011, 3}, + {0b1100000000111100, 3}, {0b1100000000111111, 4}, + {0b1100000001000000, 5}, {0b1100000001000001, 4}, + {0b1100000001000010, 4}, {0b1100000001000100, 4}, + {0b1100000001000101, 5}, {0b1100000001000110, 5}, + {0b1100000001001000, 4}, {0b1100000001001001, 5}, + {0b1100000001001010, 5}, {0b1100000001010000, 4}, + {0b1100000001010001, 5}, {0b1100000001010010, 5}, + {0b1100000001010100, 5}, {0b1100000001011000, 5}, + {0b1100000001100000, 4}, {0b1100000001100001, 5}, + {0b1100000001100010, 5}, {0b1100000001100100, 5}, + {0b1100000001101000, 5}, {0b1100000010000000, 5}, + {0b1100000010000001, 4}, {0b1100000010000010, 4}, + {0b1100000010000100, 4}, {0b1100000010000101, 5}, + {0b1100000010000110, 5}, {0b1100000010001000, 4}, + {0b1100000010001001, 5}, {0b1100000010001010, 5}, + {0b1100000010010000, 4}, {0b1100000010010001, 5}, + {0b1100000010010010, 5}, {0b1100000010010100, 5}, + {0b1100000010011000, 5}, {0b1100000010100000, 4}, + {0b1100000010100001, 5}, {0b1100000010100010, 5}, + {0b1100000010100100, 5}, {0b1100000010101000, 5}, + {0b1100000011000000, 2}, {0b1100000011000011, 3}, + {0b1100000011001100, 3}, {0b1100000011001111, 4}, + {0b1100000011110000, 3}, {0b1100000011110011, 4}, + {0b1100000011111100, 4}, {0b1100000011111111, 3}, + {0b1100000100000000, 5}, {0b1100000100000001, 4}, + {0b1100000100000010, 4}, {0b1100000100000100, 4}, + {0b1100000100000101, 5}, {0b1100000100000110, 5}, + {0b1100000100001000, 4}, {0b1100000100001001, 5}, + {0b1100000100001010, 5}, {0b1100000100010000, 4}, + {0b1100000100010001, 5}, {0b1100000100010010, 5}, + {0b1100000100011100, 3}, {0b1100000100100000, 4}, + {0b1100000100100001, 5}, {0b1100000100100010, 5}, + {0b1100000100101100, 3}, {0b1100000100110100, 3}, + {0b1100000100111000, 3}, {0b1100000101000000, 4}, + {0b1100000101000011, 3}, {0b1100000101000100, 5}, + {0b1100000101001000, 5}, {0b1100000101010000, 5}, + {0b1100000101100000, 5}, {0b1100000110000000, 4}, + {0b1100000110000011, 3}, {0b1100000110000100, 5}, + {0b1100000110001000, 5}, {0b1100000110010000, 5}, + {0b1100000110100000, 5}, {0b1100000111000001, 3}, + {0b1100000111000010, 3}, {0b1100001000000000, 5}, + {0b1100001000000001, 4}, {0b1100001000000010, 4}, + {0b1100001000000100, 4}, {0b1100001000000101, 5}, + {0b1100001000000110, 5}, {0b1100001000001000, 4}, + {0b1100001000001001, 5}, {0b1100001000001010, 5}, + {0b1100001000010000, 4}, {0b1100001000010001, 5}, + {0b1100001000010010, 5}, {0b1100001000011100, 3}, + {0b1100001000100000, 4}, {0b1100001000100001, 5}, + {0b1100001000100010, 5}, {0b1100001000101100, 3}, + {0b1100001000110100, 3}, {0b1100001000111000, 3}, + {0b1100001001000000, 4}, {0b1100001001000011, 3}, + {0b1100001001000100, 5}, {0b1100001001001000, 5}, + {0b1100001001010000, 5}, {0b1100001001100000, 5}, + {0b1100001010000000, 4}, {0b1100001010000011, 3}, + {0b1100001010000100, 5}, {0b1100001010001000, 5}, + {0b1100001010010000, 5}, {0b1100001010100000, 5}, + {0b1100001011000001, 3}, {0b1100001011000010, 3}, + {0b1100001100000000, 2}, {0b1100001100000011, 3}, + {0b1100001100001100, 3}, {0b1100001100001111, 4}, + {0b1100001100010100, 3}, {0b1100001100011000, 3}, + {0b1100001100100100, 3}, {0b1100001100101000, 3}, + {0b1100001100110000, 3}, {0b1100001100110011, 4}, + {0b1100001100111100, 1}, {0b1100001100111111, 3}, + {0b1100001101000001, 3}, {0b1100001101000010, 3}, + {0b1100001101010101, 4}, {0b1100001101011010, 4}, + {0b1100001101100110, 4}, {0b1100001101101001, 4}, + {0b1100001101111101, 3}, {0b1100001101111110, 3}, + {0b1100001110000001, 3}, {0b1100001110000010, 3}, + {0b1100001110010110, 4}, {0b1100001110011001, 4}, + {0b1100001110100101, 4}, {0b1100001110101010, 4}, + {0b1100001110111101, 3}, {0b1100001110111110, 3}, + {0b1100001111000000, 3}, {0b1100001111000011, 1}, + {0b1100001111001100, 4}, {0b1100001111001111, 3}, + {0b1100001111010111, 3}, {0b1100001111011011, 3}, + {0b1100001111100111, 3}, {0b1100001111101011, 3}, + {0b1100001111110000, 4}, {0b1100001111110011, 3}, + {0b1100001111111100, 3}, {0b1100001111111111, 2}, + {0b1100010000000000, 5}, {0b1100010000000001, 4}, + {0b1100010000000010, 4}, {0b1100010000000100, 4}, + {0b1100010000000101, 5}, {0b1100010000000110, 5}, + {0b1100010000001000, 4}, {0b1100010000001001, 5}, + {0b1100010000001010, 5}, {0b1100010000010000, 4}, + {0b1100010000010011, 3}, {0b1100010000010100, 5}, + {0b1100010000011000, 5}, {0b1100010000100000, 4}, + {0b1100010000100011, 3}, {0b1100010000100100, 5}, + {0b1100010000101000, 5}, {0b1100010000110001, 3}, + {0b1100010000110010, 3}, {0b1100010001000000, 4}, + {0b1100010001000001, 5}, {0b1100010001000010, 5}, + {0b1100010001001100, 3}, {0b1100010001010000, 5}, + {0b1100010001100000, 5}, {0b1100010010000000, 4}, + {0b1100010010000001, 5}, {0b1100010010000010, 5}, + {0b1100010010001100, 3}, {0b1100010010010000, 5}, + {0b1100010010100000, 5}, {0b1100010011000100, 3}, + {0b1100010011001000, 3}, {0b1100010100000000, 4}, + {0b1100010100000001, 5}, {0b1100010100000010, 5}, + {0b1100010100000100, 5}, {0b1100010100001000, 5}, + {0b1100010100010000, 5}, {0b1100010100100000, 5}, + {0b1100010100110101, 4}, {0b1100010100111010, 4}, + {0b1100010101000000, 5}, {0b1100010101010011, 4}, + {0b1100010101011100, 4}, {0b1100010101111111, 5}, + {0b1100010110000000, 5}, {0b1100010110100011, 4}, + {0b1100010110101100, 4}, {0b1100010110111111, 5}, + {0b1100010111000101, 4}, {0b1100010111001010, 4}, + {0b1100010111011111, 5}, {0b1100010111101111, 5}, + {0b1100010111110111, 5}, {0b1100010111111011, 5}, + {0b1100010111111101, 5}, {0b1100010111111110, 5}, + {0b1100010111111111, 4}, {0b1100011000000000, 4}, + {0b1100011000000001, 5}, {0b1100011000000010, 5}, + {0b1100011000000100, 5}, {0b1100011000001000, 5}, + {0b1100011000010000, 5}, {0b1100011000100000, 5}, + {0b1100011000110110, 4}, {0b1100011000111001, 4}, + {0b1100011001000000, 5}, {0b1100011001100011, 4}, + {0b1100011001101100, 4}, {0b1100011001111111, 5}, + {0b1100011010000000, 5}, {0b1100011010010011, 4}, + {0b1100011010011100, 4}, {0b1100011010111111, 5}, + {0b1100011011000110, 4}, {0b1100011011001001, 4}, + {0b1100011011011111, 5}, {0b1100011011101111, 5}, + {0b1100011011110111, 5}, {0b1100011011111011, 5}, + {0b1100011011111101, 5}, {0b1100011011111110, 5}, + {0b1100011011111111, 4}, {0b1100011100111101, 3}, + {0b1100011100111110, 3}, {0b1100011101011111, 5}, + {0b1100011101101111, 5}, {0b1100011101110111, 5}, + {0b1100011101111011, 5}, {0b1100011101111100, 3}, + {0b1100011101111111, 4}, {0b1100011110011111, 5}, + {0b1100011110101111, 5}, {0b1100011110110111, 5}, + {0b1100011110111011, 5}, {0b1100011110111100, 3}, + {0b1100011110111111, 4}, {0b1100011111000111, 3}, + {0b1100011111001011, 3}, {0b1100011111010011, 3}, + {0b1100011111011101, 5}, {0b1100011111011110, 5}, + {0b1100011111011111, 4}, {0b1100011111100011, 3}, + {0b1100011111101101, 5}, {0b1100011111101110, 5}, + {0b1100011111101111, 4}, {0b1100011111110101, 5}, + {0b1100011111110110, 5}, {0b1100011111110111, 4}, + {0b1100011111111001, 5}, {0b1100011111111010, 5}, + {0b1100011111111011, 4}, {0b1100011111111101, 4}, + {0b1100011111111110, 4}, {0b1100011111111111, 5}, + {0b1100100000000000, 5}, {0b1100100000000001, 4}, + {0b1100100000000010, 4}, {0b1100100000000100, 4}, + {0b1100100000000101, 5}, {0b1100100000000110, 5}, + {0b1100100000001000, 4}, {0b1100100000001001, 5}, + {0b1100100000001010, 5}, {0b1100100000010000, 4}, + {0b1100100000010011, 3}, {0b1100100000010100, 5}, + {0b1100100000011000, 5}, {0b1100100000100000, 4}, + {0b1100100000100011, 3}, {0b1100100000100100, 5}, + {0b1100100000101000, 5}, {0b1100100000110001, 3}, + {0b1100100000110010, 3}, {0b1100100001000000, 4}, + {0b1100100001000001, 5}, {0b1100100001000010, 5}, + {0b1100100001001100, 3}, {0b1100100001010000, 5}, + {0b1100100001100000, 5}, {0b1100100010000000, 4}, + {0b1100100010000001, 5}, {0b1100100010000010, 5}, + {0b1100100010001100, 3}, {0b1100100010010000, 5}, + {0b1100100010100000, 5}, {0b1100100011000100, 3}, + {0b1100100011001000, 3}, {0b1100100100000000, 4}, + {0b1100100100000001, 5}, {0b1100100100000010, 5}, + {0b1100100100000100, 5}, {0b1100100100001000, 5}, + {0b1100100100010000, 5}, {0b1100100100100000, 5}, + {0b1100100100110110, 4}, {0b1100100100111001, 4}, + {0b1100100101000000, 5}, {0b1100100101100011, 4}, + {0b1100100101101100, 4}, {0b1100100101111111, 5}, + {0b1100100110000000, 5}, {0b1100100110010011, 4}, + {0b1100100110011100, 4}, {0b1100100110111111, 5}, + {0b1100100111000110, 4}, {0b1100100111001001, 4}, + {0b1100100111011111, 5}, {0b1100100111101111, 5}, + {0b1100100111110111, 5}, {0b1100100111111011, 5}, + {0b1100100111111101, 5}, {0b1100100111111110, 5}, + {0b1100100111111111, 4}, {0b1100101000000000, 4}, + {0b1100101000000001, 5}, {0b1100101000000010, 5}, + {0b1100101000000100, 5}, {0b1100101000001000, 5}, + {0b1100101000010000, 5}, {0b1100101000100000, 5}, + {0b1100101000110101, 4}, {0b1100101000111010, 4}, + {0b1100101001000000, 5}, {0b1100101001010011, 4}, + {0b1100101001011100, 4}, {0b1100101001111111, 5}, + {0b1100101010000000, 5}, {0b1100101010100011, 4}, + {0b1100101010101100, 4}, {0b1100101010111111, 5}, + {0b1100101011000101, 4}, {0b1100101011001010, 4}, + {0b1100101011011111, 5}, {0b1100101011101111, 5}, + {0b1100101011110111, 5}, {0b1100101011111011, 5}, + {0b1100101011111101, 5}, {0b1100101011111110, 5}, + {0b1100101011111111, 4}, {0b1100101100111101, 3}, + {0b1100101100111110, 3}, {0b1100101101011111, 5}, + {0b1100101101101111, 5}, {0b1100101101110111, 5}, + {0b1100101101111011, 5}, {0b1100101101111100, 3}, + {0b1100101101111111, 4}, {0b1100101110011111, 5}, + {0b1100101110101111, 5}, {0b1100101110110111, 5}, + {0b1100101110111011, 5}, {0b1100101110111100, 3}, + {0b1100101110111111, 4}, {0b1100101111000111, 3}, + {0b1100101111001011, 3}, {0b1100101111010011, 3}, + {0b1100101111011101, 5}, {0b1100101111011110, 5}, + {0b1100101111011111, 4}, {0b1100101111100011, 3}, + {0b1100101111101101, 5}, {0b1100101111101110, 5}, + {0b1100101111101111, 4}, {0b1100101111110101, 5}, + {0b1100101111110110, 5}, {0b1100101111110111, 4}, + {0b1100101111111001, 5}, {0b1100101111111010, 5}, + {0b1100101111111011, 4}, {0b1100101111111101, 4}, + {0b1100101111111110, 4}, {0b1100101111111111, 5}, + {0b1100110000000000, 2}, {0b1100110000000011, 3}, + {0b1100110000001100, 3}, {0b1100110000001111, 4}, + {0b1100110000010001, 3}, {0b1100110000010010, 3}, + {0b1100110000100001, 3}, {0b1100110000100010, 3}, + {0b1100110000110000, 3}, {0b1100110000110011, 1}, + {0b1100110000111100, 4}, {0b1100110000111111, 3}, + {0b1100110001000100, 3}, {0b1100110001001000, 3}, + {0b1100110001010101, 4}, {0b1100110001011010, 4}, + {0b1100110001100110, 4}, {0b1100110001101001, 4}, + {0b1100110001110111, 3}, {0b1100110001111011, 3}, + {0b1100110010000100, 3}, {0b1100110010001000, 3}, + {0b1100110010010110, 4}, {0b1100110010011001, 4}, + {0b1100110010100101, 4}, {0b1100110010101010, 4}, + {0b1100110010110111, 3}, {0b1100110010111011, 3}, + {0b1100110011000000, 3}, {0b1100110011000011, 4}, + {0b1100110011001100, 1}, {0b1100110011001111, 3}, + {0b1100110011011101, 3}, {0b1100110011011110, 3}, + {0b1100110011101101, 3}, {0b1100110011101110, 3}, + {0b1100110011110000, 4}, {0b1100110011110011, 3}, + {0b1100110011111100, 3}, {0b1100110011111111, 2}, + {0b1100110100110111, 3}, {0b1100110100111011, 3}, + {0b1100110101011111, 5}, {0b1100110101101111, 5}, + {0b1100110101110011, 3}, {0b1100110101111101, 5}, + {0b1100110101111110, 5}, {0b1100110101111111, 4}, + {0b1100110110011111, 5}, {0b1100110110101111, 5}, + {0b1100110110110011, 3}, {0b1100110110111101, 5}, + {0b1100110110111110, 5}, {0b1100110110111111, 4}, + {0b1100110111001101, 3}, {0b1100110111001110, 3}, + {0b1100110111010111, 5}, {0b1100110111011011, 5}, + {0b1100110111011100, 3}, {0b1100110111011111, 4}, + {0b1100110111100111, 5}, {0b1100110111101011, 5}, + {0b1100110111101100, 3}, {0b1100110111101111, 4}, + {0b1100110111110101, 5}, {0b1100110111110110, 5}, + {0b1100110111110111, 4}, {0b1100110111111001, 5}, + {0b1100110111111010, 5}, {0b1100110111111011, 4}, + {0b1100110111111101, 4}, {0b1100110111111110, 4}, + {0b1100110111111111, 5}, {0b1100111000110111, 3}, + {0b1100111000111011, 3}, {0b1100111001011111, 5}, + {0b1100111001101111, 5}, {0b1100111001110011, 3}, + {0b1100111001111101, 5}, {0b1100111001111110, 5}, + {0b1100111001111111, 4}, {0b1100111010011111, 5}, + {0b1100111010101111, 5}, {0b1100111010110011, 3}, + {0b1100111010111101, 5}, {0b1100111010111110, 5}, + {0b1100111010111111, 4}, {0b1100111011001101, 3}, + {0b1100111011001110, 3}, {0b1100111011010111, 5}, + {0b1100111011011011, 5}, {0b1100111011011100, 3}, + {0b1100111011011111, 4}, {0b1100111011100111, 5}, + {0b1100111011101011, 5}, {0b1100111011101100, 3}, + {0b1100111011101111, 4}, {0b1100111011110101, 5}, + {0b1100111011110110, 5}, {0b1100111011110111, 4}, + {0b1100111011111001, 5}, {0b1100111011111010, 5}, + {0b1100111011111011, 4}, {0b1100111011111101, 4}, + {0b1100111011111110, 4}, {0b1100111011111111, 5}, + {0b1100111100000000, 3}, {0b1100111100000011, 4}, + {0b1100111100001100, 4}, {0b1100111100001111, 3}, + {0b1100111100110000, 4}, {0b1100111100110011, 3}, + {0b1100111100111100, 3}, {0b1100111100111111, 2}, + {0b1100111101010111, 5}, {0b1100111101011011, 5}, + {0b1100111101011101, 5}, {0b1100111101011110, 5}, + {0b1100111101011111, 4}, {0b1100111101100111, 5}, + {0b1100111101101011, 5}, {0b1100111101101101, 5}, + {0b1100111101101110, 5}, {0b1100111101101111, 4}, + {0b1100111101110101, 5}, {0b1100111101110110, 5}, + {0b1100111101110111, 4}, {0b1100111101111001, 5}, + {0b1100111101111010, 5}, {0b1100111101111011, 4}, + {0b1100111101111101, 4}, {0b1100111101111110, 4}, + {0b1100111101111111, 5}, {0b1100111110010111, 5}, + {0b1100111110011011, 5}, {0b1100111110011101, 5}, + {0b1100111110011110, 5}, {0b1100111110011111, 4}, + {0b1100111110100111, 5}, {0b1100111110101011, 5}, + {0b1100111110101101, 5}, {0b1100111110101110, 5}, + {0b1100111110101111, 4}, {0b1100111110110101, 5}, + {0b1100111110110110, 5}, {0b1100111110110111, 4}, + {0b1100111110111001, 5}, {0b1100111110111010, 5}, + {0b1100111110111011, 4}, {0b1100111110111101, 4}, + {0b1100111110111110, 4}, {0b1100111110111111, 5}, + {0b1100111111000000, 4}, {0b1100111111000011, 3}, + {0b1100111111001100, 3}, {0b1100111111001111, 2}, + {0b1100111111010101, 5}, {0b1100111111010110, 5}, + {0b1100111111010111, 4}, {0b1100111111011001, 5}, + {0b1100111111011010, 5}, {0b1100111111011011, 4}, + {0b1100111111011101, 4}, {0b1100111111011110, 4}, + {0b1100111111011111, 5}, {0b1100111111100101, 5}, + {0b1100111111100110, 5}, {0b1100111111100111, 4}, + {0b1100111111101001, 5}, {0b1100111111101010, 5}, + {0b1100111111101011, 4}, {0b1100111111101101, 4}, + {0b1100111111101110, 4}, {0b1100111111101111, 5}, + {0b1100111111110000, 3}, {0b1100111111110011, 2}, + {0b1100111111110101, 4}, {0b1100111111110110, 4}, + {0b1100111111110111, 5}, {0b1100111111111001, 4}, + {0b1100111111111010, 4}, {0b1100111111111011, 5}, + {0b1100111111111100, 2}, {0b1100111111111101, 5}, + {0b1100111111111110, 5}, {0b1100111111111111, 3}, + {0b1101000000000000, 5}, {0b1101000000000001, 4}, + {0b1101000000000010, 4}, {0b1101000000000100, 4}, + {0b1101000000000111, 3}, {0b1101000000001000, 4}, + {0b1101000000001011, 3}, {0b1101000000001101, 3}, + {0b1101000000001110, 3}, {0b1101000000010000, 4}, + {0b1101000000010001, 5}, {0b1101000000010010, 5}, + {0b1101000000010100, 5}, {0b1101000000011000, 5}, + {0b1101000000100000, 4}, {0b1101000000100001, 5}, + {0b1101000000100010, 5}, {0b1101000000100100, 5}, + {0b1101000000101000, 5}, {0b1101000001000000, 4}, + {0b1101000001000001, 5}, {0b1101000001000010, 5}, + {0b1101000001000100, 5}, {0b1101000001001000, 5}, + {0b1101000001110000, 3}, {0b1101000010000000, 4}, + {0b1101000010000001, 5}, {0b1101000010000010, 5}, + {0b1101000010000100, 5}, {0b1101000010001000, 5}, + {0b1101000010110000, 3}, {0b1101000011010000, 3}, + {0b1101000011100000, 3}, {0b1101000100000000, 4}, + {0b1101000100000001, 5}, {0b1101000100000010, 5}, + {0b1101000100000100, 5}, {0b1101000100001000, 5}, + {0b1101000100010000, 5}, {0b1101000100011101, 4}, + {0b1101000100100000, 5}, {0b1101000100101110, 4}, + {0b1101000101000000, 5}, {0b1101000101000111, 4}, + {0b1101000101110100, 4}, {0b1101000101111111, 5}, + {0b1101000110000000, 5}, {0b1101000110001011, 4}, + {0b1101000110111000, 4}, {0b1101000110111111, 5}, + {0b1101000111010001, 4}, {0b1101000111011111, 5}, + {0b1101000111100010, 4}, {0b1101000111101111, 5}, + {0b1101000111110111, 5}, {0b1101000111111011, 5}, + {0b1101000111111101, 5}, {0b1101000111111110, 5}, + {0b1101000111111111, 4}, {0b1101001000000000, 4}, + {0b1101001000000001, 5}, {0b1101001000000010, 5}, + {0b1101001000000100, 5}, {0b1101001000001000, 5}, + {0b1101001000010000, 5}, {0b1101001000011110, 4}, + {0b1101001000100000, 5}, {0b1101001000101101, 4}, + {0b1101001001000000, 5}, {0b1101001001001011, 4}, + {0b1101001001111000, 4}, {0b1101001001111111, 5}, + {0b1101001010000000, 5}, {0b1101001010000111, 4}, + {0b1101001010110100, 4}, {0b1101001010111111, 5}, + {0b1101001011010010, 4}, {0b1101001011011111, 5}, + {0b1101001011100001, 4}, {0b1101001011101111, 5}, + {0b1101001011110111, 5}, {0b1101001011111011, 5}, + {0b1101001011111101, 5}, {0b1101001011111110, 5}, + {0b1101001011111111, 4}, {0b1101001100111101, 3}, + {0b1101001100111110, 3}, {0b1101001101011111, 5}, + {0b1101001101101111, 5}, {0b1101001101110111, 5}, + {0b1101001101111011, 5}, {0b1101001101111100, 3}, + {0b1101001101111111, 4}, {0b1101001110011111, 5}, + {0b1101001110101111, 5}, {0b1101001110110111, 5}, + {0b1101001110111011, 5}, {0b1101001110111100, 3}, + {0b1101001110111111, 4}, {0b1101001111000111, 3}, + {0b1101001111001011, 3}, {0b1101001111010011, 3}, + {0b1101001111011101, 5}, {0b1101001111011110, 5}, + {0b1101001111011111, 4}, {0b1101001111100011, 3}, + {0b1101001111101101, 5}, {0b1101001111101110, 5}, + {0b1101001111101111, 4}, {0b1101001111110101, 5}, + {0b1101001111110110, 5}, {0b1101001111110111, 4}, + {0b1101001111111001, 5}, {0b1101001111111010, 5}, + {0b1101001111111011, 4}, {0b1101001111111101, 4}, + {0b1101001111111110, 4}, {0b1101001111111111, 5}, + {0b1101010000000000, 4}, {0b1101010000000001, 5}, + {0b1101010000000010, 5}, {0b1101010000000100, 5}, + {0b1101010000001000, 5}, {0b1101010000010000, 5}, + {0b1101010000010111, 4}, {0b1101010000100000, 5}, + {0b1101010000101011, 4}, {0b1101010001000000, 5}, + {0b1101010001001101, 4}, {0b1101010001110001, 4}, + {0b1101010001111111, 5}, {0b1101010010000000, 5}, + {0b1101010010001110, 4}, {0b1101010010110010, 4}, + {0b1101010010111111, 5}, {0b1101010011010100, 4}, + {0b1101010011011111, 5}, {0b1101010011101000, 4}, + {0b1101010011101111, 5}, {0b1101010011110111, 5}, + {0b1101010011111011, 5}, {0b1101010011111101, 5}, + {0b1101010011111110, 5}, {0b1101010011111111, 4}, + {0b1101010100111111, 5}, {0b1101010101010111, 3}, + {0b1101010101011101, 3}, {0b1101010101101111, 5}, + {0b1101010101110101, 3}, {0b1101010101111011, 5}, + {0b1101010101111110, 5}, {0b1101010101111111, 4}, + {0b1101010110011111, 5}, {0b1101010110101011, 3}, + {0b1101010110101110, 3}, {0b1101010110110111, 5}, + {0b1101010110111010, 3}, {0b1101010110111101, 5}, + {0b1101010110111111, 4}, {0b1101010111001111, 5}, + {0b1101010111010101, 3}, {0b1101010111011011, 5}, + {0b1101010111011110, 5}, {0b1101010111011111, 4}, + {0b1101010111100111, 5}, {0b1101010111101010, 3}, + {0b1101010111101101, 5}, {0b1101010111101111, 4}, + {0b1101010111110011, 5}, {0b1101010111110110, 5}, + {0b1101010111110111, 4}, {0b1101010111111001, 5}, + {0b1101010111111011, 4}, {0b1101010111111100, 5}, + {0b1101010111111101, 4}, {0b1101010111111110, 4}, + {0b1101010111111111, 5}, {0b1101011000111111, 5}, + {0b1101011001011111, 5}, {0b1101011001101011, 3}, + {0b1101011001101101, 3}, {0b1101011001110111, 5}, + {0b1101011001111001, 3}, {0b1101011001111110, 5}, + {0b1101011001111111, 4}, {0b1101011010010111, 3}, + {0b1101011010011110, 3}, {0b1101011010101111, 5}, + {0b1101011010110110, 3}, {0b1101011010111011, 5}, + {0b1101011010111101, 5}, {0b1101011010111111, 4}, + {0b1101011011001111, 5}, {0b1101011011010110, 3}, + {0b1101011011011011, 5}, {0b1101011011011101, 5}, + {0b1101011011011111, 4}, {0b1101011011100111, 5}, + {0b1101011011101001, 3}, {0b1101011011101110, 5}, + {0b1101011011101111, 4}, {0b1101011011110011, 5}, + {0b1101011011110101, 5}, {0b1101011011110111, 4}, + {0b1101011011111010, 5}, {0b1101011011111011, 4}, + {0b1101011011111100, 5}, {0b1101011011111101, 4}, + {0b1101011011111110, 4}, {0b1101011011111111, 5}, + {0b1101011100000000, 3}, {0b1101011100010100, 4}, + {0b1101011100011111, 5}, {0b1101011100101000, 4}, + {0b1101011100101111, 5}, {0b1101011100110111, 5}, + {0b1101011100111011, 5}, {0b1101011100111100, 3}, + {0b1101011100111111, 4}, {0b1101011101000001, 4}, + {0b1101011101001111, 5}, {0b1101011101010101, 3}, + {0b1101011101011011, 5}, {0b1101011101011110, 5}, + {0b1101011101011111, 4}, {0b1101011101100111, 5}, + {0b1101011101101001, 3}, {0b1101011101101110, 5}, + {0b1101011101101111, 4}, {0b1101011101110011, 5}, + {0b1101011101110110, 5}, {0b1101011101110111, 4}, + {0b1101011101111010, 5}, {0b1101011101111011, 4}, + {0b1101011101111101, 2}, {0b1101011101111110, 4}, + {0b1101011101111111, 5}, {0b1101011110000010, 4}, + {0b1101011110001111, 5}, {0b1101011110010110, 3}, + {0b1101011110011011, 5}, {0b1101011110011101, 5}, + {0b1101011110011111, 4}, {0b1101011110100111, 5}, + {0b1101011110101010, 3}, {0b1101011110101101, 5}, + {0b1101011110101111, 4}, {0b1101011110110011, 5}, + {0b1101011110110101, 5}, {0b1101011110110111, 4}, + {0b1101011110111001, 5}, {0b1101011110111011, 4}, + {0b1101011110111101, 4}, {0b1101011110111110, 2}, + {0b1101011110111111, 5}, {0b1101011111000011, 3}, + {0b1101011111001101, 5}, {0b1101011111001110, 5}, + {0b1101011111001111, 4}, {0b1101011111010111, 2}, + {0b1101011111011001, 5}, {0b1101011111011010, 5}, + {0b1101011111011011, 4}, {0b1101011111011100, 5}, + {0b1101011111011101, 4}, {0b1101011111011110, 4}, + {0b1101011111011111, 5}, {0b1101011111100101, 5}, + {0b1101011111100110, 5}, {0b1101011111100111, 4}, + {0b1101011111101011, 2}, {0b1101011111101100, 5}, + {0b1101011111101101, 4}, {0b1101011111101110, 4}, + {0b1101011111101111, 5}, {0b1101011111110001, 5}, + {0b1101011111110010, 5}, {0b1101011111110011, 4}, + {0b1101011111110100, 5}, {0b1101011111110101, 4}, + {0b1101011111110110, 4}, {0b1101011111110111, 5}, + {0b1101011111111000, 5}, {0b1101011111111001, 4}, + {0b1101011111111010, 4}, {0b1101011111111011, 5}, + {0b1101011111111100, 4}, {0b1101011111111101, 5}, + {0b1101011111111110, 5}, {0b1101011111111111, 3}, + {0b1101100000000000, 4}, {0b1101100000000001, 5}, + {0b1101100000000010, 5}, {0b1101100000000100, 5}, + {0b1101100000001000, 5}, {0b1101100000010000, 5}, + {0b1101100000011011, 4}, {0b1101100000100000, 5}, + {0b1101100000100111, 4}, {0b1101100001000000, 5}, + {0b1101100001001110, 4}, {0b1101100001110010, 4}, + {0b1101100001111111, 5}, {0b1101100010000000, 5}, + {0b1101100010001101, 4}, {0b1101100010110001, 4}, + {0b1101100010111111, 5}, {0b1101100011011000, 4}, + {0b1101100011011111, 5}, {0b1101100011100100, 4}, + {0b1101100011101111, 5}, {0b1101100011110111, 5}, + {0b1101100011111011, 5}, {0b1101100011111101, 5}, + {0b1101100011111110, 5}, {0b1101100011111111, 4}, + {0b1101100100111111, 5}, {0b1101100101011111, 5}, + {0b1101100101100111, 3}, {0b1101100101101110, 3}, + {0b1101100101110110, 3}, {0b1101100101111011, 5}, + {0b1101100101111101, 5}, {0b1101100101111111, 4}, + {0b1101100110011011, 3}, {0b1101100110011101, 3}, + {0b1101100110101111, 5}, {0b1101100110110111, 5}, + {0b1101100110111001, 3}, {0b1101100110111110, 5}, + {0b1101100110111111, 4}, {0b1101100111001111, 5}, + {0b1101100111010111, 5}, {0b1101100111011001, 3}, + {0b1101100111011110, 5}, {0b1101100111011111, 4}, + {0b1101100111100110, 3}, {0b1101100111101011, 5}, + {0b1101100111101101, 5}, {0b1101100111101111, 4}, + {0b1101100111110011, 5}, {0b1101100111110101, 5}, + {0b1101100111110111, 4}, {0b1101100111111010, 5}, + {0b1101100111111011, 4}, {0b1101100111111100, 5}, + {0b1101100111111101, 4}, {0b1101100111111110, 4}, + {0b1101100111111111, 5}, {0b1101101000111111, 5}, + {0b1101101001011011, 3}, {0b1101101001011110, 3}, + {0b1101101001101111, 5}, {0b1101101001110111, 5}, + {0b1101101001111010, 3}, {0b1101101001111101, 5}, + {0b1101101001111111, 4}, {0b1101101010011111, 5}, + {0b1101101010100111, 3}, {0b1101101010101101, 3}, + {0b1101101010110101, 3}, {0b1101101010111011, 5}, + {0b1101101010111110, 5}, {0b1101101010111111, 4}, + {0b1101101011001111, 5}, {0b1101101011010111, 5}, + {0b1101101011011010, 3}, {0b1101101011011101, 5}, + {0b1101101011011111, 4}, {0b1101101011100101, 3}, + {0b1101101011101011, 5}, {0b1101101011101110, 5}, + {0b1101101011101111, 4}, {0b1101101011110011, 5}, + {0b1101101011110110, 5}, {0b1101101011110111, 4}, + {0b1101101011111001, 5}, {0b1101101011111011, 4}, + {0b1101101011111100, 5}, {0b1101101011111101, 4}, + {0b1101101011111110, 4}, {0b1101101011111111, 5}, + {0b1101101100000000, 3}, {0b1101101100011000, 4}, + {0b1101101100011111, 5}, {0b1101101100100100, 4}, + {0b1101101100101111, 5}, {0b1101101100110111, 5}, + {0b1101101100111011, 5}, {0b1101101100111100, 3}, + {0b1101101100111111, 4}, {0b1101101101000010, 4}, + {0b1101101101001111, 5}, {0b1101101101010111, 5}, + {0b1101101101011010, 3}, {0b1101101101011101, 5}, + {0b1101101101011111, 4}, {0b1101101101100110, 3}, + {0b1101101101101011, 5}, {0b1101101101101101, 5}, + {0b1101101101101111, 4}, {0b1101101101110011, 5}, + {0b1101101101110101, 5}, {0b1101101101110111, 4}, + {0b1101101101111001, 5}, {0b1101101101111011, 4}, + {0b1101101101111101, 4}, {0b1101101101111110, 2}, + {0b1101101101111111, 5}, {0b1101101110000001, 4}, + {0b1101101110001111, 5}, {0b1101101110010111, 5}, + {0b1101101110011001, 3}, {0b1101101110011110, 5}, + {0b1101101110011111, 4}, {0b1101101110100101, 3}, + {0b1101101110101011, 5}, {0b1101101110101110, 5}, + {0b1101101110101111, 4}, {0b1101101110110011, 5}, + {0b1101101110110110, 5}, {0b1101101110110111, 4}, + {0b1101101110111010, 5}, {0b1101101110111011, 4}, + {0b1101101110111101, 2}, {0b1101101110111110, 4}, + {0b1101101110111111, 5}, {0b1101101111000011, 3}, + {0b1101101111001101, 5}, {0b1101101111001110, 5}, + {0b1101101111001111, 4}, {0b1101101111010101, 5}, + {0b1101101111010110, 5}, {0b1101101111010111, 4}, + {0b1101101111011011, 2}, {0b1101101111011100, 5}, + {0b1101101111011101, 4}, {0b1101101111011110, 4}, + {0b1101101111011111, 5}, {0b1101101111100111, 2}, + {0b1101101111101001, 5}, {0b1101101111101010, 5}, + {0b1101101111101011, 4}, {0b1101101111101100, 5}, + {0b1101101111101101, 4}, {0b1101101111101110, 4}, + {0b1101101111101111, 5}, {0b1101101111110001, 5}, + {0b1101101111110010, 5}, {0b1101101111110011, 4}, + {0b1101101111110100, 5}, {0b1101101111110101, 4}, + {0b1101101111110110, 4}, {0b1101101111110111, 5}, + {0b1101101111111000, 5}, {0b1101101111111001, 4}, + {0b1101101111111010, 4}, {0b1101101111111011, 5}, + {0b1101101111111100, 4}, {0b1101101111111101, 5}, + {0b1101101111111110, 5}, {0b1101101111111111, 3}, + {0b1101110000110111, 3}, {0b1101110000111011, 3}, + {0b1101110001011111, 5}, {0b1101110001101111, 5}, + {0b1101110001110011, 3}, {0b1101110001111101, 5}, + {0b1101110001111110, 5}, {0b1101110001111111, 4}, + {0b1101110010011111, 5}, {0b1101110010101111, 5}, + {0b1101110010110011, 3}, {0b1101110010111101, 5}, + {0b1101110010111110, 5}, {0b1101110010111111, 4}, + {0b1101110011001101, 3}, {0b1101110011001110, 3}, + {0b1101110011010111, 5}, {0b1101110011011011, 5}, + {0b1101110011011100, 3}, {0b1101110011011111, 4}, + {0b1101110011100111, 5}, {0b1101110011101011, 5}, + {0b1101110011101100, 3}, {0b1101110011101111, 4}, + {0b1101110011110101, 5}, {0b1101110011110110, 5}, + {0b1101110011110111, 4}, {0b1101110011111001, 5}, + {0b1101110011111010, 5}, {0b1101110011111011, 4}, + {0b1101110011111101, 4}, {0b1101110011111110, 4}, + {0b1101110011111111, 5}, {0b1101110100000000, 3}, + {0b1101110100010001, 4}, {0b1101110100011111, 5}, + {0b1101110100100010, 4}, {0b1101110100101111, 5}, + {0b1101110100110011, 3}, {0b1101110100111101, 5}, + {0b1101110100111110, 5}, {0b1101110100111111, 4}, + {0b1101110101000100, 4}, {0b1101110101001111, 5}, + {0b1101110101010101, 3}, {0b1101110101011011, 5}, + {0b1101110101011110, 5}, {0b1101110101011111, 4}, + {0b1101110101100110, 3}, {0b1101110101101011, 5}, + {0b1101110101101101, 5}, {0b1101110101101111, 4}, + {0b1101110101110111, 2}, {0b1101110101111001, 5}, + {0b1101110101111010, 5}, {0b1101110101111011, 4}, + {0b1101110101111100, 5}, {0b1101110101111101, 4}, + {0b1101110101111110, 4}, {0b1101110101111111, 5}, + {0b1101110110001000, 4}, {0b1101110110001111, 5}, + {0b1101110110010111, 5}, {0b1101110110011001, 3}, + {0b1101110110011110, 5}, {0b1101110110011111, 4}, + {0b1101110110100111, 5}, {0b1101110110101010, 3}, + {0b1101110110101101, 5}, {0b1101110110101111, 4}, + {0b1101110110110101, 5}, {0b1101110110110110, 5}, + {0b1101110110110111, 4}, {0b1101110110111011, 2}, + {0b1101110110111100, 5}, {0b1101110110111101, 4}, + {0b1101110110111110, 4}, {0b1101110110111111, 5}, + {0b1101110111000111, 5}, {0b1101110111001011, 5}, + {0b1101110111001100, 3}, {0b1101110111001111, 4}, + {0b1101110111010011, 5}, {0b1101110111010110, 5}, + {0b1101110111010111, 4}, {0b1101110111011010, 5}, + {0b1101110111011011, 4}, {0b1101110111011101, 2}, + {0b1101110111011110, 4}, {0b1101110111011111, 5}, + {0b1101110111100011, 5}, {0b1101110111100101, 5}, + {0b1101110111100111, 4}, {0b1101110111101001, 5}, + {0b1101110111101011, 4}, {0b1101110111101101, 4}, + {0b1101110111101110, 2}, {0b1101110111101111, 5}, + {0b1101110111110001, 5}, {0b1101110111110010, 5}, + {0b1101110111110011, 4}, {0b1101110111110100, 5}, + {0b1101110111110101, 4}, {0b1101110111110110, 4}, + {0b1101110111110111, 5}, {0b1101110111111000, 5}, + {0b1101110111111001, 4}, {0b1101110111111010, 4}, + {0b1101110111111011, 5}, {0b1101110111111100, 4}, + {0b1101110111111101, 5}, {0b1101110111111110, 5}, + {0b1101110111111111, 3}, {0b1101111000000000, 3}, + {0b1101111000010010, 4}, {0b1101111000011111, 5}, + {0b1101111000100001, 4}, {0b1101111000101111, 5}, + {0b1101111000110011, 3}, {0b1101111000111101, 5}, + {0b1101111000111110, 5}, {0b1101111000111111, 4}, + {0b1101111001001000, 4}, {0b1101111001001111, 5}, + {0b1101111001010111, 5}, {0b1101111001011010, 3}, + {0b1101111001011101, 5}, {0b1101111001011111, 4}, + {0b1101111001100111, 5}, {0b1101111001101001, 3}, + {0b1101111001101110, 5}, {0b1101111001101111, 4}, + {0b1101111001110101, 5}, {0b1101111001110110, 5}, + {0b1101111001110111, 4}, {0b1101111001111011, 2}, + {0b1101111001111100, 5}, {0b1101111001111101, 4}, + {0b1101111001111110, 4}, {0b1101111001111111, 5}, + {0b1101111010000100, 4}, {0b1101111010001111, 5}, + {0b1101111010010110, 3}, {0b1101111010011011, 5}, + {0b1101111010011101, 5}, {0b1101111010011111, 4}, + {0b1101111010100101, 3}, {0b1101111010101011, 5}, + {0b1101111010101110, 5}, {0b1101111010101111, 4}, + {0b1101111010110111, 2}, {0b1101111010111001, 5}, + {0b1101111010111010, 5}, {0b1101111010111011, 4}, + {0b1101111010111100, 5}, {0b1101111010111101, 4}, + {0b1101111010111110, 4}, {0b1101111010111111, 5}, + {0b1101111011000111, 5}, {0b1101111011001011, 5}, + {0b1101111011001100, 3}, {0b1101111011001111, 4}, + {0b1101111011010011, 5}, {0b1101111011010101, 5}, + {0b1101111011010111, 4}, {0b1101111011011001, 5}, + {0b1101111011011011, 4}, {0b1101111011011101, 4}, + {0b1101111011011110, 2}, {0b1101111011011111, 5}, + {0b1101111011100011, 5}, {0b1101111011100110, 5}, + {0b1101111011100111, 4}, {0b1101111011101010, 5}, + {0b1101111011101011, 4}, {0b1101111011101101, 2}, + {0b1101111011101110, 4}, {0b1101111011101111, 5}, + {0b1101111011110001, 5}, {0b1101111011110010, 5}, + {0b1101111011110011, 4}, {0b1101111011110100, 5}, + {0b1101111011110101, 4}, {0b1101111011110110, 4}, + {0b1101111011110111, 5}, {0b1101111011111000, 5}, + {0b1101111011111001, 4}, {0b1101111011111010, 4}, + {0b1101111011111011, 5}, {0b1101111011111100, 4}, + {0b1101111011111101, 5}, {0b1101111011111110, 5}, + {0b1101111011111111, 3}, {0b1101111100010111, 5}, + {0b1101111100011011, 5}, {0b1101111100011101, 5}, + {0b1101111100011110, 5}, {0b1101111100011111, 4}, + {0b1101111100100111, 5}, {0b1101111100101011, 5}, + {0b1101111100101101, 5}, {0b1101111100101110, 5}, + {0b1101111100101111, 4}, {0b1101111100110101, 5}, + {0b1101111100110110, 5}, {0b1101111100110111, 4}, + {0b1101111100111001, 5}, {0b1101111100111010, 5}, + {0b1101111100111011, 4}, {0b1101111100111101, 4}, + {0b1101111100111110, 4}, {0b1101111100111111, 5}, + {0b1101111101000111, 5}, {0b1101111101001011, 5}, + {0b1101111101001101, 5}, {0b1101111101001110, 5}, + {0b1101111101001111, 4}, {0b1101111101010011, 5}, + {0b1101111101010110, 5}, {0b1101111101010111, 4}, + {0b1101111101011001, 5}, {0b1101111101011011, 4}, + {0b1101111101011100, 5}, {0b1101111101011101, 4}, + {0b1101111101011110, 4}, {0b1101111101011111, 5}, + {0b1101111101100011, 5}, {0b1101111101100101, 5}, + {0b1101111101100111, 4}, {0b1101111101101010, 5}, + {0b1101111101101011, 4}, {0b1101111101101100, 5}, + {0b1101111101101101, 4}, {0b1101111101101110, 4}, + {0b1101111101101111, 5}, {0b1101111101110001, 5}, + {0b1101111101110010, 5}, {0b1101111101110011, 4}, + {0b1101111101110100, 5}, {0b1101111101110101, 4}, + {0b1101111101110110, 4}, {0b1101111101110111, 5}, + {0b1101111101111000, 5}, {0b1101111101111001, 4}, + {0b1101111101111010, 4}, {0b1101111101111011, 5}, + {0b1101111101111100, 4}, {0b1101111101111101, 5}, + {0b1101111101111110, 5}, {0b1101111101111111, 3}, + {0b1101111110000111, 5}, {0b1101111110001011, 5}, + {0b1101111110001101, 5}, {0b1101111110001110, 5}, + {0b1101111110001111, 4}, {0b1101111110010011, 5}, + {0b1101111110010101, 5}, {0b1101111110010111, 4}, + {0b1101111110011010, 5}, {0b1101111110011011, 4}, + {0b1101111110011100, 5}, {0b1101111110011101, 4}, + {0b1101111110011110, 4}, {0b1101111110011111, 5}, + {0b1101111110100011, 5}, {0b1101111110100110, 5}, + {0b1101111110100111, 4}, {0b1101111110101001, 5}, + {0b1101111110101011, 4}, {0b1101111110101100, 5}, + {0b1101111110101101, 4}, {0b1101111110101110, 4}, + {0b1101111110101111, 5}, {0b1101111110110001, 5}, + {0b1101111110110010, 5}, {0b1101111110110011, 4}, + {0b1101111110110100, 5}, {0b1101111110110101, 4}, + {0b1101111110110110, 4}, {0b1101111110110111, 5}, + {0b1101111110111000, 5}, {0b1101111110111001, 4}, + {0b1101111110111010, 4}, {0b1101111110111011, 5}, + {0b1101111110111100, 4}, {0b1101111110111101, 5}, + {0b1101111110111110, 5}, {0b1101111110111111, 3}, + {0b1101111111000101, 5}, {0b1101111111000110, 5}, + {0b1101111111000111, 4}, {0b1101111111001001, 5}, + {0b1101111111001010, 5}, {0b1101111111001011, 4}, + {0b1101111111001101, 4}, {0b1101111111001110, 4}, + {0b1101111111001111, 5}, {0b1101111111010001, 5}, + {0b1101111111010010, 5}, {0b1101111111010011, 4}, + {0b1101111111010100, 5}, {0b1101111111010101, 4}, + {0b1101111111010110, 4}, {0b1101111111010111, 5}, + {0b1101111111011000, 5}, {0b1101111111011001, 4}, + {0b1101111111011010, 4}, {0b1101111111011011, 5}, + {0b1101111111011100, 4}, {0b1101111111011101, 5}, + {0b1101111111011110, 5}, {0b1101111111011111, 3}, + {0b1101111111100001, 5}, {0b1101111111100010, 5}, + {0b1101111111100011, 4}, {0b1101111111100100, 5}, + {0b1101111111100101, 4}, {0b1101111111100110, 4}, + {0b1101111111100111, 5}, {0b1101111111101000, 5}, + {0b1101111111101001, 4}, {0b1101111111101010, 4}, + {0b1101111111101011, 5}, {0b1101111111101100, 4}, + {0b1101111111101101, 5}, {0b1101111111101110, 5}, + {0b1101111111101111, 3}, {0b1101111111110001, 4}, + {0b1101111111110010, 4}, {0b1101111111110011, 5}, + {0b1101111111110100, 4}, {0b1101111111110101, 5}, + {0b1101111111110110, 5}, {0b1101111111110111, 3}, + {0b1101111111111000, 4}, {0b1101111111111001, 5}, + {0b1101111111111010, 5}, {0b1101111111111011, 3}, + {0b1101111111111100, 5}, {0b1101111111111101, 3}, + {0b1101111111111110, 3}, {0b1101111111111111, 4}, + {0b1110000000000000, 5}, {0b1110000000000001, 4}, + {0b1110000000000010, 4}, {0b1110000000000100, 4}, + {0b1110000000000111, 3}, {0b1110000000001000, 4}, + {0b1110000000001011, 3}, {0b1110000000001101, 3}, + {0b1110000000001110, 3}, {0b1110000000010000, 4}, + {0b1110000000010001, 5}, {0b1110000000010010, 5}, + {0b1110000000010100, 5}, {0b1110000000011000, 5}, + {0b1110000000100000, 4}, {0b1110000000100001, 5}, + {0b1110000000100010, 5}, {0b1110000000100100, 5}, + {0b1110000000101000, 5}, {0b1110000001000000, 4}, + {0b1110000001000001, 5}, {0b1110000001000010, 5}, + {0b1110000001000100, 5}, {0b1110000001001000, 5}, + {0b1110000001110000, 3}, {0b1110000010000000, 4}, + {0b1110000010000001, 5}, {0b1110000010000010, 5}, + {0b1110000010000100, 5}, {0b1110000010001000, 5}, + {0b1110000010110000, 3}, {0b1110000011010000, 3}, + {0b1110000011100000, 3}, {0b1110000100000000, 4}, + {0b1110000100000001, 5}, {0b1110000100000010, 5}, + {0b1110000100000100, 5}, {0b1110000100001000, 5}, + {0b1110000100010000, 5}, {0b1110000100011110, 4}, + {0b1110000100100000, 5}, {0b1110000100101101, 4}, + {0b1110000101000000, 5}, {0b1110000101001011, 4}, + {0b1110000101111000, 4}, {0b1110000101111111, 5}, + {0b1110000110000000, 5}, {0b1110000110000111, 4}, + {0b1110000110110100, 4}, {0b1110000110111111, 5}, + {0b1110000111010010, 4}, {0b1110000111011111, 5}, + {0b1110000111100001, 4}, {0b1110000111101111, 5}, + {0b1110000111110111, 5}, {0b1110000111111011, 5}, + {0b1110000111111101, 5}, {0b1110000111111110, 5}, + {0b1110000111111111, 4}, {0b1110001000000000, 4}, + {0b1110001000000001, 5}, {0b1110001000000010, 5}, + {0b1110001000000100, 5}, {0b1110001000001000, 5}, + {0b1110001000010000, 5}, {0b1110001000011101, 4}, + {0b1110001000100000, 5}, {0b1110001000101110, 4}, + {0b1110001001000000, 5}, {0b1110001001000111, 4}, + {0b1110001001110100, 4}, {0b1110001001111111, 5}, + {0b1110001010000000, 5}, {0b1110001010001011, 4}, + {0b1110001010111000, 4}, {0b1110001010111111, 5}, + {0b1110001011010001, 4}, {0b1110001011011111, 5}, + {0b1110001011100010, 4}, {0b1110001011101111, 5}, + {0b1110001011110111, 5}, {0b1110001011111011, 5}, + {0b1110001011111101, 5}, {0b1110001011111110, 5}, + {0b1110001011111111, 4}, {0b1110001100111101, 3}, + {0b1110001100111110, 3}, {0b1110001101011111, 5}, + {0b1110001101101111, 5}, {0b1110001101110111, 5}, + {0b1110001101111011, 5}, {0b1110001101111100, 3}, + {0b1110001101111111, 4}, {0b1110001110011111, 5}, + {0b1110001110101111, 5}, {0b1110001110110111, 5}, + {0b1110001110111011, 5}, {0b1110001110111100, 3}, + {0b1110001110111111, 4}, {0b1110001111000111, 3}, + {0b1110001111001011, 3}, {0b1110001111010011, 3}, + {0b1110001111011101, 5}, {0b1110001111011110, 5}, + {0b1110001111011111, 4}, {0b1110001111100011, 3}, + {0b1110001111101101, 5}, {0b1110001111101110, 5}, + {0b1110001111101111, 4}, {0b1110001111110101, 5}, + {0b1110001111110110, 5}, {0b1110001111110111, 4}, + {0b1110001111111001, 5}, {0b1110001111111010, 5}, + {0b1110001111111011, 4}, {0b1110001111111101, 4}, + {0b1110001111111110, 4}, {0b1110001111111111, 5}, + {0b1110010000000000, 4}, {0b1110010000000001, 5}, + {0b1110010000000010, 5}, {0b1110010000000100, 5}, + {0b1110010000001000, 5}, {0b1110010000010000, 5}, + {0b1110010000011011, 4}, {0b1110010000100000, 5}, + {0b1110010000100111, 4}, {0b1110010001000000, 5}, + {0b1110010001001110, 4}, {0b1110010001110010, 4}, + {0b1110010001111111, 5}, {0b1110010010000000, 5}, + {0b1110010010001101, 4}, {0b1110010010110001, 4}, + {0b1110010010111111, 5}, {0b1110010011011000, 4}, + {0b1110010011011111, 5}, {0b1110010011100100, 4}, + {0b1110010011101111, 5}, {0b1110010011110111, 5}, + {0b1110010011111011, 5}, {0b1110010011111101, 5}, + {0b1110010011111110, 5}, {0b1110010011111111, 4}, + {0b1110010100111111, 5}, {0b1110010101011011, 3}, + {0b1110010101011110, 3}, {0b1110010101101111, 5}, + {0b1110010101110111, 5}, {0b1110010101111010, 3}, + {0b1110010101111101, 5}, {0b1110010101111111, 4}, + {0b1110010110011111, 5}, {0b1110010110100111, 3}, + {0b1110010110101101, 3}, {0b1110010110110101, 3}, + {0b1110010110111011, 5}, {0b1110010110111110, 5}, + {0b1110010110111111, 4}, {0b1110010111001111, 5}, + {0b1110010111010111, 5}, {0b1110010111011010, 3}, + {0b1110010111011101, 5}, {0b1110010111011111, 4}, + {0b1110010111100101, 3}, {0b1110010111101011, 5}, + {0b1110010111101110, 5}, {0b1110010111101111, 4}, + {0b1110010111110011, 5}, {0b1110010111110110, 5}, + {0b1110010111110111, 4}, {0b1110010111111001, 5}, + {0b1110010111111011, 4}, {0b1110010111111100, 5}, + {0b1110010111111101, 4}, {0b1110010111111110, 4}, + {0b1110010111111111, 5}, {0b1110011000111111, 5}, + {0b1110011001011111, 5}, {0b1110011001100111, 3}, + {0b1110011001101110, 3}, {0b1110011001110110, 3}, + {0b1110011001111011, 5}, {0b1110011001111101, 5}, + {0b1110011001111111, 4}, {0b1110011010011011, 3}, + {0b1110011010011101, 3}, {0b1110011010101111, 5}, + {0b1110011010110111, 5}, {0b1110011010111001, 3}, + {0b1110011010111110, 5}, {0b1110011010111111, 4}, + {0b1110011011001111, 5}, {0b1110011011010111, 5}, + {0b1110011011011001, 3}, {0b1110011011011110, 5}, + {0b1110011011011111, 4}, {0b1110011011100110, 3}, + {0b1110011011101011, 5}, {0b1110011011101101, 5}, + {0b1110011011101111, 4}, {0b1110011011110011, 5}, + {0b1110011011110101, 5}, {0b1110011011110111, 4}, + {0b1110011011111010, 5}, {0b1110011011111011, 4}, + {0b1110011011111100, 5}, {0b1110011011111101, 4}, + {0b1110011011111110, 4}, {0b1110011011111111, 5}, + {0b1110011100000000, 3}, {0b1110011100011000, 4}, + {0b1110011100011111, 5}, {0b1110011100100100, 4}, + {0b1110011100101111, 5}, {0b1110011100110111, 5}, + {0b1110011100111011, 5}, {0b1110011100111100, 3}, + {0b1110011100111111, 4}, {0b1110011101000010, 4}, + {0b1110011101001111, 5}, {0b1110011101010111, 5}, + {0b1110011101011010, 3}, {0b1110011101011101, 5}, + {0b1110011101011111, 4}, {0b1110011101100110, 3}, + {0b1110011101101011, 5}, {0b1110011101101101, 5}, + {0b1110011101101111, 4}, {0b1110011101110011, 5}, + {0b1110011101110101, 5}, {0b1110011101110111, 4}, + {0b1110011101111001, 5}, {0b1110011101111011, 4}, + {0b1110011101111101, 4}, {0b1110011101111110, 2}, + {0b1110011101111111, 5}, {0b1110011110000001, 4}, + {0b1110011110001111, 5}, {0b1110011110010111, 5}, + {0b1110011110011001, 3}, {0b1110011110011110, 5}, + {0b1110011110011111, 4}, {0b1110011110100101, 3}, + {0b1110011110101011, 5}, {0b1110011110101110, 5}, + {0b1110011110101111, 4}, {0b1110011110110011, 5}, + {0b1110011110110110, 5}, {0b1110011110110111, 4}, + {0b1110011110111010, 5}, {0b1110011110111011, 4}, + {0b1110011110111101, 2}, {0b1110011110111110, 4}, + {0b1110011110111111, 5}, {0b1110011111000011, 3}, + {0b1110011111001101, 5}, {0b1110011111001110, 5}, + {0b1110011111001111, 4}, {0b1110011111010101, 5}, + {0b1110011111010110, 5}, {0b1110011111010111, 4}, + {0b1110011111011011, 2}, {0b1110011111011100, 5}, + {0b1110011111011101, 4}, {0b1110011111011110, 4}, + {0b1110011111011111, 5}, {0b1110011111100111, 2}, + {0b1110011111101001, 5}, {0b1110011111101010, 5}, + {0b1110011111101011, 4}, {0b1110011111101100, 5}, + {0b1110011111101101, 4}, {0b1110011111101110, 4}, + {0b1110011111101111, 5}, {0b1110011111110001, 5}, + {0b1110011111110010, 5}, {0b1110011111110011, 4}, + {0b1110011111110100, 5}, {0b1110011111110101, 4}, + {0b1110011111110110, 4}, {0b1110011111110111, 5}, + {0b1110011111111000, 5}, {0b1110011111111001, 4}, + {0b1110011111111010, 4}, {0b1110011111111011, 5}, + {0b1110011111111100, 4}, {0b1110011111111101, 5}, + {0b1110011111111110, 5}, {0b1110011111111111, 3}, + {0b1110100000000000, 4}, {0b1110100000000001, 5}, + {0b1110100000000010, 5}, {0b1110100000000100, 5}, + {0b1110100000001000, 5}, {0b1110100000010000, 5}, + {0b1110100000010111, 4}, {0b1110100000100000, 5}, + {0b1110100000101011, 4}, {0b1110100001000000, 5}, + {0b1110100001001101, 4}, {0b1110100001110001, 4}, + {0b1110100001111111, 5}, {0b1110100010000000, 5}, + {0b1110100010001110, 4}, {0b1110100010110010, 4}, + {0b1110100010111111, 5}, {0b1110100011010100, 4}, + {0b1110100011011111, 5}, {0b1110100011101000, 4}, + {0b1110100011101111, 5}, {0b1110100011110111, 5}, + {0b1110100011111011, 5}, {0b1110100011111101, 5}, + {0b1110100011111110, 5}, {0b1110100011111111, 4}, + {0b1110100100111111, 5}, {0b1110100101011111, 5}, + {0b1110100101101011, 3}, {0b1110100101101101, 3}, + {0b1110100101110111, 5}, {0b1110100101111001, 3}, + {0b1110100101111110, 5}, {0b1110100101111111, 4}, + {0b1110100110010111, 3}, {0b1110100110011110, 3}, + {0b1110100110101111, 5}, {0b1110100110110110, 3}, + {0b1110100110111011, 5}, {0b1110100110111101, 5}, + {0b1110100110111111, 4}, {0b1110100111001111, 5}, + {0b1110100111010110, 3}, {0b1110100111011011, 5}, + {0b1110100111011101, 5}, {0b1110100111011111, 4}, + {0b1110100111100111, 5}, {0b1110100111101001, 3}, + {0b1110100111101110, 5}, {0b1110100111101111, 4}, + {0b1110100111110011, 5}, {0b1110100111110101, 5}, + {0b1110100111110111, 4}, {0b1110100111111010, 5}, + {0b1110100111111011, 4}, {0b1110100111111100, 5}, + {0b1110100111111101, 4}, {0b1110100111111110, 4}, + {0b1110100111111111, 5}, {0b1110101000111111, 5}, + {0b1110101001010111, 3}, {0b1110101001011101, 3}, + {0b1110101001101111, 5}, {0b1110101001110101, 3}, + {0b1110101001111011, 5}, {0b1110101001111110, 5}, + {0b1110101001111111, 4}, {0b1110101010011111, 5}, + {0b1110101010101011, 3}, {0b1110101010101110, 3}, + {0b1110101010110111, 5}, {0b1110101010111010, 3}, + {0b1110101010111101, 5}, {0b1110101010111111, 4}, + {0b1110101011001111, 5}, {0b1110101011010101, 3}, + {0b1110101011011011, 5}, {0b1110101011011110, 5}, + {0b1110101011011111, 4}, {0b1110101011100111, 5}, + {0b1110101011101010, 3}, {0b1110101011101101, 5}, + {0b1110101011101111, 4}, {0b1110101011110011, 5}, + {0b1110101011110110, 5}, {0b1110101011110111, 4}, + {0b1110101011111001, 5}, {0b1110101011111011, 4}, + {0b1110101011111100, 5}, {0b1110101011111101, 4}, + {0b1110101011111110, 4}, {0b1110101011111111, 5}, + {0b1110101100000000, 3}, {0b1110101100010100, 4}, + {0b1110101100011111, 5}, {0b1110101100101000, 4}, + {0b1110101100101111, 5}, {0b1110101100110111, 5}, + {0b1110101100111011, 5}, {0b1110101100111100, 3}, + {0b1110101100111111, 4}, {0b1110101101000001, 4}, + {0b1110101101001111, 5}, {0b1110101101010101, 3}, + {0b1110101101011011, 5}, {0b1110101101011110, 5}, + {0b1110101101011111, 4}, {0b1110101101100111, 5}, + {0b1110101101101001, 3}, {0b1110101101101110, 5}, + {0b1110101101101111, 4}, {0b1110101101110011, 5}, + {0b1110101101110110, 5}, {0b1110101101110111, 4}, + {0b1110101101111010, 5}, {0b1110101101111011, 4}, + {0b1110101101111101, 2}, {0b1110101101111110, 4}, + {0b1110101101111111, 5}, {0b1110101110000010, 4}, + {0b1110101110001111, 5}, {0b1110101110010110, 3}, + {0b1110101110011011, 5}, {0b1110101110011101, 5}, + {0b1110101110011111, 4}, {0b1110101110100111, 5}, + {0b1110101110101010, 3}, {0b1110101110101101, 5}, + {0b1110101110101111, 4}, {0b1110101110110011, 5}, + {0b1110101110110101, 5}, {0b1110101110110111, 4}, + {0b1110101110111001, 5}, {0b1110101110111011, 4}, + {0b1110101110111101, 4}, {0b1110101110111110, 2}, + {0b1110101110111111, 5}, {0b1110101111000011, 3}, + {0b1110101111001101, 5}, {0b1110101111001110, 5}, + {0b1110101111001111, 4}, {0b1110101111010111, 2}, + {0b1110101111011001, 5}, {0b1110101111011010, 5}, + {0b1110101111011011, 4}, {0b1110101111011100, 5}, + {0b1110101111011101, 4}, {0b1110101111011110, 4}, + {0b1110101111011111, 5}, {0b1110101111100101, 5}, + {0b1110101111100110, 5}, {0b1110101111100111, 4}, + {0b1110101111101011, 2}, {0b1110101111101100, 5}, + {0b1110101111101101, 4}, {0b1110101111101110, 4}, + {0b1110101111101111, 5}, {0b1110101111110001, 5}, + {0b1110101111110010, 5}, {0b1110101111110011, 4}, + {0b1110101111110100, 5}, {0b1110101111110101, 4}, + {0b1110101111110110, 4}, {0b1110101111110111, 5}, + {0b1110101111111000, 5}, {0b1110101111111001, 4}, + {0b1110101111111010, 4}, {0b1110101111111011, 5}, + {0b1110101111111100, 4}, {0b1110101111111101, 5}, + {0b1110101111111110, 5}, {0b1110101111111111, 3}, + {0b1110110000110111, 3}, {0b1110110000111011, 3}, + {0b1110110001011111, 5}, {0b1110110001101111, 5}, + {0b1110110001110011, 3}, {0b1110110001111101, 5}, + {0b1110110001111110, 5}, {0b1110110001111111, 4}, + {0b1110110010011111, 5}, {0b1110110010101111, 5}, + {0b1110110010110011, 3}, {0b1110110010111101, 5}, + {0b1110110010111110, 5}, {0b1110110010111111, 4}, + {0b1110110011001101, 3}, {0b1110110011001110, 3}, + {0b1110110011010111, 5}, {0b1110110011011011, 5}, + {0b1110110011011100, 3}, {0b1110110011011111, 4}, + {0b1110110011100111, 5}, {0b1110110011101011, 5}, + {0b1110110011101100, 3}, {0b1110110011101111, 4}, + {0b1110110011110101, 5}, {0b1110110011110110, 5}, + {0b1110110011110111, 4}, {0b1110110011111001, 5}, + {0b1110110011111010, 5}, {0b1110110011111011, 4}, + {0b1110110011111101, 4}, {0b1110110011111110, 4}, + {0b1110110011111111, 5}, {0b1110110100000000, 3}, + {0b1110110100010010, 4}, {0b1110110100011111, 5}, + {0b1110110100100001, 4}, {0b1110110100101111, 5}, + {0b1110110100110011, 3}, {0b1110110100111101, 5}, + {0b1110110100111110, 5}, {0b1110110100111111, 4}, + {0b1110110101001000, 4}, {0b1110110101001111, 5}, + {0b1110110101010111, 5}, {0b1110110101011010, 3}, + {0b1110110101011101, 5}, {0b1110110101011111, 4}, + {0b1110110101100111, 5}, {0b1110110101101001, 3}, + {0b1110110101101110, 5}, {0b1110110101101111, 4}, + {0b1110110101110101, 5}, {0b1110110101110110, 5}, + {0b1110110101110111, 4}, {0b1110110101111011, 2}, + {0b1110110101111100, 5}, {0b1110110101111101, 4}, + {0b1110110101111110, 4}, {0b1110110101111111, 5}, + {0b1110110110000100, 4}, {0b1110110110001111, 5}, + {0b1110110110010110, 3}, {0b1110110110011011, 5}, + {0b1110110110011101, 5}, {0b1110110110011111, 4}, + {0b1110110110100101, 3}, {0b1110110110101011, 5}, + {0b1110110110101110, 5}, {0b1110110110101111, 4}, + {0b1110110110110111, 2}, {0b1110110110111001, 5}, + {0b1110110110111010, 5}, {0b1110110110111011, 4}, + {0b1110110110111100, 5}, {0b1110110110111101, 4}, + {0b1110110110111110, 4}, {0b1110110110111111, 5}, + {0b1110110111000111, 5}, {0b1110110111001011, 5}, + {0b1110110111001100, 3}, {0b1110110111001111, 4}, + {0b1110110111010011, 5}, {0b1110110111010101, 5}, + {0b1110110111010111, 4}, {0b1110110111011001, 5}, + {0b1110110111011011, 4}, {0b1110110111011101, 4}, + {0b1110110111011110, 2}, {0b1110110111011111, 5}, + {0b1110110111100011, 5}, {0b1110110111100110, 5}, + {0b1110110111100111, 4}, {0b1110110111101010, 5}, + {0b1110110111101011, 4}, {0b1110110111101101, 2}, + {0b1110110111101110, 4}, {0b1110110111101111, 5}, + {0b1110110111110001, 5}, {0b1110110111110010, 5}, + {0b1110110111110011, 4}, {0b1110110111110100, 5}, + {0b1110110111110101, 4}, {0b1110110111110110, 4}, + {0b1110110111110111, 5}, {0b1110110111111000, 5}, + {0b1110110111111001, 4}, {0b1110110111111010, 4}, + {0b1110110111111011, 5}, {0b1110110111111100, 4}, + {0b1110110111111101, 5}, {0b1110110111111110, 5}, + {0b1110110111111111, 3}, {0b1110111000000000, 3}, + {0b1110111000010001, 4}, {0b1110111000011111, 5}, + {0b1110111000100010, 4}, {0b1110111000101111, 5}, + {0b1110111000110011, 3}, {0b1110111000111101, 5}, + {0b1110111000111110, 5}, {0b1110111000111111, 4}, + {0b1110111001000100, 4}, {0b1110111001001111, 5}, + {0b1110111001010101, 3}, {0b1110111001011011, 5}, + {0b1110111001011110, 5}, {0b1110111001011111, 4}, + {0b1110111001100110, 3}, {0b1110111001101011, 5}, + {0b1110111001101101, 5}, {0b1110111001101111, 4}, + {0b1110111001110111, 2}, {0b1110111001111001, 5}, + {0b1110111001111010, 5}, {0b1110111001111011, 4}, + {0b1110111001111100, 5}, {0b1110111001111101, 4}, + {0b1110111001111110, 4}, {0b1110111001111111, 5}, + {0b1110111010001000, 4}, {0b1110111010001111, 5}, + {0b1110111010010111, 5}, {0b1110111010011001, 3}, + {0b1110111010011110, 5}, {0b1110111010011111, 4}, + {0b1110111010100111, 5}, {0b1110111010101010, 3}, + {0b1110111010101101, 5}, {0b1110111010101111, 4}, + {0b1110111010110101, 5}, {0b1110111010110110, 5}, + {0b1110111010110111, 4}, {0b1110111010111011, 2}, + {0b1110111010111100, 5}, {0b1110111010111101, 4}, + {0b1110111010111110, 4}, {0b1110111010111111, 5}, + {0b1110111011000111, 5}, {0b1110111011001011, 5}, + {0b1110111011001100, 3}, {0b1110111011001111, 4}, + {0b1110111011010011, 5}, {0b1110111011010110, 5}, + {0b1110111011010111, 4}, {0b1110111011011010, 5}, + {0b1110111011011011, 4}, {0b1110111011011101, 2}, + {0b1110111011011110, 4}, {0b1110111011011111, 5}, + {0b1110111011100011, 5}, {0b1110111011100101, 5}, + {0b1110111011100111, 4}, {0b1110111011101001, 5}, + {0b1110111011101011, 4}, {0b1110111011101101, 4}, + {0b1110111011101110, 2}, {0b1110111011101111, 5}, + {0b1110111011110001, 5}, {0b1110111011110010, 5}, + {0b1110111011110011, 4}, {0b1110111011110100, 5}, + {0b1110111011110101, 4}, {0b1110111011110110, 4}, + {0b1110111011110111, 5}, {0b1110111011111000, 5}, + {0b1110111011111001, 4}, {0b1110111011111010, 4}, + {0b1110111011111011, 5}, {0b1110111011111100, 4}, + {0b1110111011111101, 5}, {0b1110111011111110, 5}, + {0b1110111011111111, 3}, {0b1110111100010111, 5}, + {0b1110111100011011, 5}, {0b1110111100011101, 5}, + {0b1110111100011110, 5}, {0b1110111100011111, 4}, + {0b1110111100100111, 5}, {0b1110111100101011, 5}, + {0b1110111100101101, 5}, {0b1110111100101110, 5}, + {0b1110111100101111, 4}, {0b1110111100110101, 5}, + {0b1110111100110110, 5}, {0b1110111100110111, 4}, + {0b1110111100111001, 5}, {0b1110111100111010, 5}, + {0b1110111100111011, 4}, {0b1110111100111101, 4}, + {0b1110111100111110, 4}, {0b1110111100111111, 5}, + {0b1110111101000111, 5}, {0b1110111101001011, 5}, + {0b1110111101001101, 5}, {0b1110111101001110, 5}, + {0b1110111101001111, 4}, {0b1110111101010011, 5}, + {0b1110111101010110, 5}, {0b1110111101010111, 4}, + {0b1110111101011001, 5}, {0b1110111101011011, 4}, + {0b1110111101011100, 5}, {0b1110111101011101, 4}, + {0b1110111101011110, 4}, {0b1110111101011111, 5}, + {0b1110111101100011, 5}, {0b1110111101100101, 5}, + {0b1110111101100111, 4}, {0b1110111101101010, 5}, + {0b1110111101101011, 4}, {0b1110111101101100, 5}, + {0b1110111101101101, 4}, {0b1110111101101110, 4}, + {0b1110111101101111, 5}, {0b1110111101110001, 5}, + {0b1110111101110010, 5}, {0b1110111101110011, 4}, + {0b1110111101110100, 5}, {0b1110111101110101, 4}, + {0b1110111101110110, 4}, {0b1110111101110111, 5}, + {0b1110111101111000, 5}, {0b1110111101111001, 4}, + {0b1110111101111010, 4}, {0b1110111101111011, 5}, + {0b1110111101111100, 4}, {0b1110111101111101, 5}, + {0b1110111101111110, 5}, {0b1110111101111111, 3}, + {0b1110111110000111, 5}, {0b1110111110001011, 5}, + {0b1110111110001101, 5}, {0b1110111110001110, 5}, + {0b1110111110001111, 4}, {0b1110111110010011, 5}, + {0b1110111110010101, 5}, {0b1110111110010111, 4}, + {0b1110111110011010, 5}, {0b1110111110011011, 4}, + {0b1110111110011100, 5}, {0b1110111110011101, 4}, + {0b1110111110011110, 4}, {0b1110111110011111, 5}, + {0b1110111110100011, 5}, {0b1110111110100110, 5}, + {0b1110111110100111, 4}, {0b1110111110101001, 5}, + {0b1110111110101011, 4}, {0b1110111110101100, 5}, + {0b1110111110101101, 4}, {0b1110111110101110, 4}, + {0b1110111110101111, 5}, {0b1110111110110001, 5}, + {0b1110111110110010, 5}, {0b1110111110110011, 4}, + {0b1110111110110100, 5}, {0b1110111110110101, 4}, + {0b1110111110110110, 4}, {0b1110111110110111, 5}, + {0b1110111110111000, 5}, {0b1110111110111001, 4}, + {0b1110111110111010, 4}, {0b1110111110111011, 5}, + {0b1110111110111100, 4}, {0b1110111110111101, 5}, + {0b1110111110111110, 5}, {0b1110111110111111, 3}, + {0b1110111111000101, 5}, {0b1110111111000110, 5}, + {0b1110111111000111, 4}, {0b1110111111001001, 5}, + {0b1110111111001010, 5}, {0b1110111111001011, 4}, + {0b1110111111001101, 4}, {0b1110111111001110, 4}, + {0b1110111111001111, 5}, {0b1110111111010001, 5}, + {0b1110111111010010, 5}, {0b1110111111010011, 4}, + {0b1110111111010100, 5}, {0b1110111111010101, 4}, + {0b1110111111010110, 4}, {0b1110111111010111, 5}, + {0b1110111111011000, 5}, {0b1110111111011001, 4}, + {0b1110111111011010, 4}, {0b1110111111011011, 5}, + {0b1110111111011100, 4}, {0b1110111111011101, 5}, + {0b1110111111011110, 5}, {0b1110111111011111, 3}, + {0b1110111111100001, 5}, {0b1110111111100010, 5}, + {0b1110111111100011, 4}, {0b1110111111100100, 5}, + {0b1110111111100101, 4}, {0b1110111111100110, 4}, + {0b1110111111100111, 5}, {0b1110111111101000, 5}, + {0b1110111111101001, 4}, {0b1110111111101010, 4}, + {0b1110111111101011, 5}, {0b1110111111101100, 4}, + {0b1110111111101101, 5}, {0b1110111111101110, 5}, + {0b1110111111101111, 3}, {0b1110111111110001, 4}, + {0b1110111111110010, 4}, {0b1110111111110011, 5}, + {0b1110111111110100, 4}, {0b1110111111110101, 5}, + {0b1110111111110110, 5}, {0b1110111111110111, 3}, + {0b1110111111111000, 4}, {0b1110111111111001, 5}, + {0b1110111111111010, 5}, {0b1110111111111011, 3}, + {0b1110111111111100, 5}, {0b1110111111111101, 3}, + {0b1110111111111110, 3}, {0b1110111111111111, 4}, + {0b1111000000000000, 2}, {0b1111000000000011, 3}, + {0b1111000000000101, 3}, {0b1111000000000110, 3}, + {0b1111000000001001, 3}, {0b1111000000001010, 3}, + {0b1111000000001100, 3}, {0b1111000000001111, 1}, + {0b1111000000110000, 3}, {0b1111000000110011, 4}, + {0b1111000000111100, 4}, {0b1111000000111111, 3}, + {0b1111000001010000, 3}, {0b1111000001010101, 4}, + {0b1111000001011010, 4}, {0b1111000001011111, 3}, + {0b1111000001100000, 3}, {0b1111000001100110, 4}, + {0b1111000001101001, 4}, {0b1111000001101111, 3}, + {0b1111000010010000, 3}, {0b1111000010010110, 4}, + {0b1111000010011001, 4}, {0b1111000010011111, 3}, + {0b1111000010100000, 3}, {0b1111000010100101, 4}, + {0b1111000010101010, 4}, {0b1111000010101111, 3}, + {0b1111000011000000, 3}, {0b1111000011000011, 4}, + {0b1111000011001100, 4}, {0b1111000011001111, 3}, + {0b1111000011110000, 1}, {0b1111000011110011, 3}, + {0b1111000011110101, 3}, {0b1111000011110110, 3}, + {0b1111000011111001, 3}, {0b1111000011111010, 3}, + {0b1111000011111100, 3}, {0b1111000011111111, 2}, + {0b1111000100011111, 3}, {0b1111000100101111, 3}, + {0b1111000101001111, 3}, {0b1111000101110111, 5}, + {0b1111000101111011, 5}, {0b1111000101111101, 5}, + {0b1111000101111110, 5}, {0b1111000101111111, 4}, + {0b1111000110001111, 3}, {0b1111000110110111, 5}, + {0b1111000110111011, 5}, {0b1111000110111101, 5}, + {0b1111000110111110, 5}, {0b1111000110111111, 4}, + {0b1111000111010111, 5}, {0b1111000111011011, 5}, + {0b1111000111011101, 5}, {0b1111000111011110, 5}, + {0b1111000111011111, 4}, {0b1111000111100111, 5}, + {0b1111000111101011, 5}, {0b1111000111101101, 5}, + {0b1111000111101110, 5}, {0b1111000111101111, 4}, + {0b1111000111110001, 3}, {0b1111000111110010, 3}, + {0b1111000111110100, 3}, {0b1111000111110111, 4}, + {0b1111000111111000, 3}, {0b1111000111111011, 4}, + {0b1111000111111101, 4}, {0b1111000111111110, 4}, + {0b1111000111111111, 5}, {0b1111001000011111, 3}, + {0b1111001000101111, 3}, {0b1111001001001111, 3}, + {0b1111001001110111, 5}, {0b1111001001111011, 5}, + {0b1111001001111101, 5}, {0b1111001001111110, 5}, + {0b1111001001111111, 4}, {0b1111001010001111, 3}, + {0b1111001010110111, 5}, {0b1111001010111011, 5}, + {0b1111001010111101, 5}, {0b1111001010111110, 5}, + {0b1111001010111111, 4}, {0b1111001011010111, 5}, + {0b1111001011011011, 5}, {0b1111001011011101, 5}, + {0b1111001011011110, 5}, {0b1111001011011111, 4}, + {0b1111001011100111, 5}, {0b1111001011101011, 5}, + {0b1111001011101101, 5}, {0b1111001011101110, 5}, + {0b1111001011101111, 4}, {0b1111001011110001, 3}, + {0b1111001011110010, 3}, {0b1111001011110100, 3}, + {0b1111001011110111, 4}, {0b1111001011111000, 3}, + {0b1111001011111011, 4}, {0b1111001011111101, 4}, + {0b1111001011111110, 4}, {0b1111001011111111, 5}, + {0b1111001100000000, 3}, {0b1111001100000011, 4}, + {0b1111001100001100, 4}, {0b1111001100001111, 3}, + {0b1111001100110000, 4}, {0b1111001100110011, 3}, + {0b1111001100111100, 3}, {0b1111001100111111, 2}, + {0b1111001101010111, 5}, {0b1111001101011011, 5}, + {0b1111001101011101, 5}, {0b1111001101011110, 5}, + {0b1111001101011111, 4}, {0b1111001101100111, 5}, + {0b1111001101101011, 5}, {0b1111001101101101, 5}, + {0b1111001101101110, 5}, {0b1111001101101111, 4}, + {0b1111001101110101, 5}, {0b1111001101110110, 5}, + {0b1111001101110111, 4}, {0b1111001101111001, 5}, + {0b1111001101111010, 5}, {0b1111001101111011, 4}, + {0b1111001101111101, 4}, {0b1111001101111110, 4}, + {0b1111001101111111, 5}, {0b1111001110010111, 5}, + {0b1111001110011011, 5}, {0b1111001110011101, 5}, + {0b1111001110011110, 5}, {0b1111001110011111, 4}, + {0b1111001110100111, 5}, {0b1111001110101011, 5}, + {0b1111001110101101, 5}, {0b1111001110101110, 5}, + {0b1111001110101111, 4}, {0b1111001110110101, 5}, + {0b1111001110110110, 5}, {0b1111001110110111, 4}, + {0b1111001110111001, 5}, {0b1111001110111010, 5}, + {0b1111001110111011, 4}, {0b1111001110111101, 4}, + {0b1111001110111110, 4}, {0b1111001110111111, 5}, + {0b1111001111000000, 4}, {0b1111001111000011, 3}, + {0b1111001111001100, 3}, {0b1111001111001111, 2}, + {0b1111001111010101, 5}, {0b1111001111010110, 5}, + {0b1111001111010111, 4}, {0b1111001111011001, 5}, + {0b1111001111011010, 5}, {0b1111001111011011, 4}, + {0b1111001111011101, 4}, {0b1111001111011110, 4}, + {0b1111001111011111, 5}, {0b1111001111100101, 5}, + {0b1111001111100110, 5}, {0b1111001111100111, 4}, + {0b1111001111101001, 5}, {0b1111001111101010, 5}, + {0b1111001111101011, 4}, {0b1111001111101101, 4}, + {0b1111001111101110, 4}, {0b1111001111101111, 5}, + {0b1111001111110000, 3}, {0b1111001111110011, 2}, + {0b1111001111110101, 4}, {0b1111001111110110, 4}, + {0b1111001111110111, 5}, {0b1111001111111001, 4}, + {0b1111001111111010, 4}, {0b1111001111111011, 5}, + {0b1111001111111100, 2}, {0b1111001111111101, 5}, + {0b1111001111111110, 5}, {0b1111001111111111, 3}, + {0b1111010000011111, 3}, {0b1111010000101111, 3}, + {0b1111010001001111, 3}, {0b1111010001110111, 5}, + {0b1111010001111011, 5}, {0b1111010001111101, 5}, + {0b1111010001111110, 5}, {0b1111010001111111, 4}, + {0b1111010010001111, 3}, {0b1111010010110111, 5}, + {0b1111010010111011, 5}, {0b1111010010111101, 5}, + {0b1111010010111110, 5}, {0b1111010010111111, 4}, + {0b1111010011010111, 5}, {0b1111010011011011, 5}, + {0b1111010011011101, 5}, {0b1111010011011110, 5}, + {0b1111010011011111, 4}, {0b1111010011100111, 5}, + {0b1111010011101011, 5}, {0b1111010011101101, 5}, + {0b1111010011101110, 5}, {0b1111010011101111, 4}, + {0b1111010011110001, 3}, {0b1111010011110010, 3}, + {0b1111010011110100, 3}, {0b1111010011110111, 4}, + {0b1111010011111000, 3}, {0b1111010011111011, 4}, + {0b1111010011111101, 4}, {0b1111010011111110, 4}, + {0b1111010011111111, 5}, {0b1111010100000000, 3}, + {0b1111010100000101, 4}, {0b1111010100001010, 4}, + {0b1111010100001111, 3}, {0b1111010100110111, 5}, + {0b1111010100111011, 5}, {0b1111010100111101, 5}, + {0b1111010100111110, 5}, {0b1111010100111111, 4}, + {0b1111010101010000, 4}, {0b1111010101010101, 3}, + {0b1111010101011010, 3}, {0b1111010101011111, 2}, + {0b1111010101100111, 5}, {0b1111010101101011, 5}, + {0b1111010101101101, 5}, {0b1111010101101110, 5}, + {0b1111010101101111, 4}, {0b1111010101110011, 5}, + {0b1111010101110110, 5}, {0b1111010101110111, 4}, + {0b1111010101111001, 5}, {0b1111010101111011, 4}, + {0b1111010101111100, 5}, {0b1111010101111101, 4}, + {0b1111010101111110, 4}, {0b1111010101111111, 5}, + {0b1111010110010111, 5}, {0b1111010110011011, 5}, + {0b1111010110011101, 5}, {0b1111010110011110, 5}, + {0b1111010110011111, 4}, {0b1111010110100000, 4}, + {0b1111010110100101, 3}, {0b1111010110101010, 3}, + {0b1111010110101111, 2}, {0b1111010110110011, 5}, + {0b1111010110110110, 5}, {0b1111010110110111, 4}, + {0b1111010110111001, 5}, {0b1111010110111011, 4}, + {0b1111010110111100, 5}, {0b1111010110111101, 4}, + {0b1111010110111110, 4}, {0b1111010110111111, 5}, + {0b1111010111000111, 5}, {0b1111010111001011, 5}, + {0b1111010111001101, 5}, {0b1111010111001110, 5}, + {0b1111010111001111, 4}, {0b1111010111010011, 5}, + {0b1111010111010110, 5}, {0b1111010111010111, 4}, + {0b1111010111011001, 5}, {0b1111010111011011, 4}, + {0b1111010111011100, 5}, {0b1111010111011101, 4}, + {0b1111010111011110, 4}, {0b1111010111011111, 5}, + {0b1111010111100011, 5}, {0b1111010111100110, 5}, + {0b1111010111100111, 4}, {0b1111010111101001, 5}, + {0b1111010111101011, 4}, {0b1111010111101100, 5}, + {0b1111010111101101, 4}, {0b1111010111101110, 4}, + {0b1111010111101111, 5}, {0b1111010111110000, 3}, + {0b1111010111110011, 4}, {0b1111010111110101, 2}, + {0b1111010111110110, 4}, {0b1111010111110111, 5}, + {0b1111010111111001, 4}, {0b1111010111111010, 2}, + {0b1111010111111011, 5}, {0b1111010111111100, 4}, + {0b1111010111111101, 5}, {0b1111010111111110, 5}, + {0b1111010111111111, 3}, {0b1111011000000000, 3}, + {0b1111011000000110, 4}, {0b1111011000001001, 4}, + {0b1111011000001111, 3}, {0b1111011000110111, 5}, + {0b1111011000111011, 5}, {0b1111011000111101, 5}, + {0b1111011000111110, 5}, {0b1111011000111111, 4}, + {0b1111011001010111, 5}, {0b1111011001011011, 5}, + {0b1111011001011101, 5}, {0b1111011001011110, 5}, + {0b1111011001011111, 4}, {0b1111011001100000, 4}, + {0b1111011001100110, 3}, {0b1111011001101001, 3}, + {0b1111011001101111, 2}, {0b1111011001110011, 5}, + {0b1111011001110101, 5}, {0b1111011001110111, 4}, + {0b1111011001111010, 5}, {0b1111011001111011, 4}, + {0b1111011001111100, 5}, {0b1111011001111101, 4}, + {0b1111011001111110, 4}, {0b1111011001111111, 5}, + {0b1111011010010000, 4}, {0b1111011010010110, 3}, + {0b1111011010011001, 3}, {0b1111011010011111, 2}, + {0b1111011010100111, 5}, {0b1111011010101011, 5}, + {0b1111011010101101, 5}, {0b1111011010101110, 5}, + {0b1111011010101111, 4}, {0b1111011010110011, 5}, + {0b1111011010110101, 5}, {0b1111011010110111, 4}, + {0b1111011010111010, 5}, {0b1111011010111011, 4}, + {0b1111011010111100, 5}, {0b1111011010111101, 4}, + {0b1111011010111110, 4}, {0b1111011010111111, 5}, + {0b1111011011000111, 5}, {0b1111011011001011, 5}, + {0b1111011011001101, 5}, {0b1111011011001110, 5}, + {0b1111011011001111, 4}, {0b1111011011010011, 5}, + {0b1111011011010101, 5}, {0b1111011011010111, 4}, + {0b1111011011011010, 5}, {0b1111011011011011, 4}, + {0b1111011011011100, 5}, {0b1111011011011101, 4}, + {0b1111011011011110, 4}, {0b1111011011011111, 5}, + {0b1111011011100011, 5}, {0b1111011011100101, 5}, + {0b1111011011100111, 4}, {0b1111011011101010, 5}, + {0b1111011011101011, 4}, {0b1111011011101100, 5}, + {0b1111011011101101, 4}, {0b1111011011101110, 4}, + {0b1111011011101111, 5}, {0b1111011011110000, 3}, + {0b1111011011110011, 4}, {0b1111011011110101, 4}, + {0b1111011011110110, 2}, {0b1111011011110111, 5}, + {0b1111011011111001, 2}, {0b1111011011111010, 4}, + {0b1111011011111011, 5}, {0b1111011011111100, 4}, + {0b1111011011111101, 5}, {0b1111011011111110, 5}, + {0b1111011011111111, 3}, {0b1111011100010111, 5}, + {0b1111011100011011, 5}, {0b1111011100011101, 5}, + {0b1111011100011110, 5}, {0b1111011100011111, 4}, + {0b1111011100100111, 5}, {0b1111011100101011, 5}, + {0b1111011100101101, 5}, {0b1111011100101110, 5}, + {0b1111011100101111, 4}, {0b1111011100110101, 5}, + {0b1111011100110110, 5}, {0b1111011100110111, 4}, + {0b1111011100111001, 5}, {0b1111011100111010, 5}, + {0b1111011100111011, 4}, {0b1111011100111101, 4}, + {0b1111011100111110, 4}, {0b1111011100111111, 5}, + {0b1111011101000111, 5}, {0b1111011101001011, 5}, + {0b1111011101001101, 5}, {0b1111011101001110, 5}, + {0b1111011101001111, 4}, {0b1111011101010011, 5}, + {0b1111011101010110, 5}, {0b1111011101010111, 4}, + {0b1111011101011001, 5}, {0b1111011101011011, 4}, + {0b1111011101011100, 5}, {0b1111011101011101, 4}, + {0b1111011101011110, 4}, {0b1111011101011111, 5}, + {0b1111011101100011, 5}, {0b1111011101100101, 5}, + {0b1111011101100111, 4}, {0b1111011101101010, 5}, + {0b1111011101101011, 4}, {0b1111011101101100, 5}, + {0b1111011101101101, 4}, {0b1111011101101110, 4}, + {0b1111011101101111, 5}, {0b1111011101110001, 5}, + {0b1111011101110010, 5}, {0b1111011101110011, 4}, + {0b1111011101110100, 5}, {0b1111011101110101, 4}, + {0b1111011101110110, 4}, {0b1111011101110111, 5}, + {0b1111011101111000, 5}, {0b1111011101111001, 4}, + {0b1111011101111010, 4}, {0b1111011101111011, 5}, + {0b1111011101111100, 4}, {0b1111011101111101, 5}, + {0b1111011101111110, 5}, {0b1111011101111111, 3}, + {0b1111011110000111, 5}, {0b1111011110001011, 5}, + {0b1111011110001101, 5}, {0b1111011110001110, 5}, + {0b1111011110001111, 4}, {0b1111011110010011, 5}, + {0b1111011110010101, 5}, {0b1111011110010111, 4}, + {0b1111011110011010, 5}, {0b1111011110011011, 4}, + {0b1111011110011100, 5}, {0b1111011110011101, 4}, + {0b1111011110011110, 4}, {0b1111011110011111, 5}, + {0b1111011110100011, 5}, {0b1111011110100110, 5}, + {0b1111011110100111, 4}, {0b1111011110101001, 5}, + {0b1111011110101011, 4}, {0b1111011110101100, 5}, + {0b1111011110101101, 4}, {0b1111011110101110, 4}, + {0b1111011110101111, 5}, {0b1111011110110001, 5}, + {0b1111011110110010, 5}, {0b1111011110110011, 4}, + {0b1111011110110100, 5}, {0b1111011110110101, 4}, + {0b1111011110110110, 4}, {0b1111011110110111, 5}, + {0b1111011110111000, 5}, {0b1111011110111001, 4}, + {0b1111011110111010, 4}, {0b1111011110111011, 5}, + {0b1111011110111100, 4}, {0b1111011110111101, 5}, + {0b1111011110111110, 5}, {0b1111011110111111, 3}, + {0b1111011111000101, 5}, {0b1111011111000110, 5}, + {0b1111011111000111, 4}, {0b1111011111001001, 5}, + {0b1111011111001010, 5}, {0b1111011111001011, 4}, + {0b1111011111001101, 4}, {0b1111011111001110, 4}, + {0b1111011111001111, 5}, {0b1111011111010001, 5}, + {0b1111011111010010, 5}, {0b1111011111010011, 4}, + {0b1111011111010100, 5}, {0b1111011111010101, 4}, + {0b1111011111010110, 4}, {0b1111011111010111, 5}, + {0b1111011111011000, 5}, {0b1111011111011001, 4}, + {0b1111011111011010, 4}, {0b1111011111011011, 5}, + {0b1111011111011100, 4}, {0b1111011111011101, 5}, + {0b1111011111011110, 5}, {0b1111011111011111, 3}, + {0b1111011111100001, 5}, {0b1111011111100010, 5}, + {0b1111011111100011, 4}, {0b1111011111100100, 5}, + {0b1111011111100101, 4}, {0b1111011111100110, 4}, + {0b1111011111100111, 5}, {0b1111011111101000, 5}, + {0b1111011111101001, 4}, {0b1111011111101010, 4}, + {0b1111011111101011, 5}, {0b1111011111101100, 4}, + {0b1111011111101101, 5}, {0b1111011111101110, 5}, + {0b1111011111101111, 3}, {0b1111011111110001, 4}, + {0b1111011111110010, 4}, {0b1111011111110011, 5}, + {0b1111011111110100, 4}, {0b1111011111110101, 5}, + {0b1111011111110110, 5}, {0b1111011111110111, 3}, + {0b1111011111111000, 4}, {0b1111011111111001, 5}, + {0b1111011111111010, 5}, {0b1111011111111011, 3}, + {0b1111011111111100, 5}, {0b1111011111111101, 3}, + {0b1111011111111110, 3}, {0b1111011111111111, 4}, + {0b1111100000011111, 3}, {0b1111100000101111, 3}, + {0b1111100001001111, 3}, {0b1111100001110111, 5}, + {0b1111100001111011, 5}, {0b1111100001111101, 5}, + {0b1111100001111110, 5}, {0b1111100001111111, 4}, + {0b1111100010001111, 3}, {0b1111100010110111, 5}, + {0b1111100010111011, 5}, {0b1111100010111101, 5}, + {0b1111100010111110, 5}, {0b1111100010111111, 4}, + {0b1111100011010111, 5}, {0b1111100011011011, 5}, + {0b1111100011011101, 5}, {0b1111100011011110, 5}, + {0b1111100011011111, 4}, {0b1111100011100111, 5}, + {0b1111100011101011, 5}, {0b1111100011101101, 5}, + {0b1111100011101110, 5}, {0b1111100011101111, 4}, + {0b1111100011110001, 3}, {0b1111100011110010, 3}, + {0b1111100011110100, 3}, {0b1111100011110111, 4}, + {0b1111100011111000, 3}, {0b1111100011111011, 4}, + {0b1111100011111101, 4}, {0b1111100011111110, 4}, + {0b1111100011111111, 5}, {0b1111100100000000, 3}, + {0b1111100100000110, 4}, {0b1111100100001001, 4}, + {0b1111100100001111, 3}, {0b1111100100110111, 5}, + {0b1111100100111011, 5}, {0b1111100100111101, 5}, + {0b1111100100111110, 5}, {0b1111100100111111, 4}, + {0b1111100101010111, 5}, {0b1111100101011011, 5}, + {0b1111100101011101, 5}, {0b1111100101011110, 5}, + {0b1111100101011111, 4}, {0b1111100101100000, 4}, + {0b1111100101100110, 3}, {0b1111100101101001, 3}, + {0b1111100101101111, 2}, {0b1111100101110011, 5}, + {0b1111100101110101, 5}, {0b1111100101110111, 4}, + {0b1111100101111010, 5}, {0b1111100101111011, 4}, + {0b1111100101111100, 5}, {0b1111100101111101, 4}, + {0b1111100101111110, 4}, {0b1111100101111111, 5}, + {0b1111100110010000, 4}, {0b1111100110010110, 3}, + {0b1111100110011001, 3}, {0b1111100110011111, 2}, + {0b1111100110100111, 5}, {0b1111100110101011, 5}, + {0b1111100110101101, 5}, {0b1111100110101110, 5}, + {0b1111100110101111, 4}, {0b1111100110110011, 5}, + {0b1111100110110101, 5}, {0b1111100110110111, 4}, + {0b1111100110111010, 5}, {0b1111100110111011, 4}, + {0b1111100110111100, 5}, {0b1111100110111101, 4}, + {0b1111100110111110, 4}, {0b1111100110111111, 5}, + {0b1111100111000111, 5}, {0b1111100111001011, 5}, + {0b1111100111001101, 5}, {0b1111100111001110, 5}, + {0b1111100111001111, 4}, {0b1111100111010011, 5}, + {0b1111100111010101, 5}, {0b1111100111010111, 4}, + {0b1111100111011010, 5}, {0b1111100111011011, 4}, + {0b1111100111011100, 5}, {0b1111100111011101, 4}, + {0b1111100111011110, 4}, {0b1111100111011111, 5}, + {0b1111100111100011, 5}, {0b1111100111100101, 5}, + {0b1111100111100111, 4}, {0b1111100111101010, 5}, + {0b1111100111101011, 4}, {0b1111100111101100, 5}, + {0b1111100111101101, 4}, {0b1111100111101110, 4}, + {0b1111100111101111, 5}, {0b1111100111110000, 3}, + {0b1111100111110011, 4}, {0b1111100111110101, 4}, + {0b1111100111110110, 2}, {0b1111100111110111, 5}, + {0b1111100111111001, 2}, {0b1111100111111010, 4}, + {0b1111100111111011, 5}, {0b1111100111111100, 4}, + {0b1111100111111101, 5}, {0b1111100111111110, 5}, + {0b1111100111111111, 3}, {0b1111101000000000, 3}, + {0b1111101000000101, 4}, {0b1111101000001010, 4}, + {0b1111101000001111, 3}, {0b1111101000110111, 5}, + {0b1111101000111011, 5}, {0b1111101000111101, 5}, + {0b1111101000111110, 5}, {0b1111101000111111, 4}, + {0b1111101001010000, 4}, {0b1111101001010101, 3}, + {0b1111101001011010, 3}, {0b1111101001011111, 2}, + {0b1111101001100111, 5}, {0b1111101001101011, 5}, + {0b1111101001101101, 5}, {0b1111101001101110, 5}, + {0b1111101001101111, 4}, {0b1111101001110011, 5}, + {0b1111101001110110, 5}, {0b1111101001110111, 4}, + {0b1111101001111001, 5}, {0b1111101001111011, 4}, + {0b1111101001111100, 5}, {0b1111101001111101, 4}, + {0b1111101001111110, 4}, {0b1111101001111111, 5}, + {0b1111101010010111, 5}, {0b1111101010011011, 5}, + {0b1111101010011101, 5}, {0b1111101010011110, 5}, + {0b1111101010011111, 4}, {0b1111101010100000, 4}, + {0b1111101010100101, 3}, {0b1111101010101010, 3}, + {0b1111101010101111, 2}, {0b1111101010110011, 5}, + {0b1111101010110110, 5}, {0b1111101010110111, 4}, + {0b1111101010111001, 5}, {0b1111101010111011, 4}, + {0b1111101010111100, 5}, {0b1111101010111101, 4}, + {0b1111101010111110, 4}, {0b1111101010111111, 5}, + {0b1111101011000111, 5}, {0b1111101011001011, 5}, + {0b1111101011001101, 5}, {0b1111101011001110, 5}, + {0b1111101011001111, 4}, {0b1111101011010011, 5}, + {0b1111101011010110, 5}, {0b1111101011010111, 4}, + {0b1111101011011001, 5}, {0b1111101011011011, 4}, + {0b1111101011011100, 5}, {0b1111101011011101, 4}, + {0b1111101011011110, 4}, {0b1111101011011111, 5}, + {0b1111101011100011, 5}, {0b1111101011100110, 5}, + {0b1111101011100111, 4}, {0b1111101011101001, 5}, + {0b1111101011101011, 4}, {0b1111101011101100, 5}, + {0b1111101011101101, 4}, {0b1111101011101110, 4}, + {0b1111101011101111, 5}, {0b1111101011110000, 3}, + {0b1111101011110011, 4}, {0b1111101011110101, 2}, + {0b1111101011110110, 4}, {0b1111101011110111, 5}, + {0b1111101011111001, 4}, {0b1111101011111010, 2}, + {0b1111101011111011, 5}, {0b1111101011111100, 4}, + {0b1111101011111101, 5}, {0b1111101011111110, 5}, + {0b1111101011111111, 3}, {0b1111101100010111, 5}, + {0b1111101100011011, 5}, {0b1111101100011101, 5}, + {0b1111101100011110, 5}, {0b1111101100011111, 4}, + {0b1111101100100111, 5}, {0b1111101100101011, 5}, + {0b1111101100101101, 5}, {0b1111101100101110, 5}, + {0b1111101100101111, 4}, {0b1111101100110101, 5}, + {0b1111101100110110, 5}, {0b1111101100110111, 4}, + {0b1111101100111001, 5}, {0b1111101100111010, 5}, + {0b1111101100111011, 4}, {0b1111101100111101, 4}, + {0b1111101100111110, 4}, {0b1111101100111111, 5}, + {0b1111101101000111, 5}, {0b1111101101001011, 5}, + {0b1111101101001101, 5}, {0b1111101101001110, 5}, + {0b1111101101001111, 4}, {0b1111101101010011, 5}, + {0b1111101101010110, 5}, {0b1111101101010111, 4}, + {0b1111101101011001, 5}, {0b1111101101011011, 4}, + {0b1111101101011100, 5}, {0b1111101101011101, 4}, + {0b1111101101011110, 4}, {0b1111101101011111, 5}, + {0b1111101101100011, 5}, {0b1111101101100101, 5}, + {0b1111101101100111, 4}, {0b1111101101101010, 5}, + {0b1111101101101011, 4}, {0b1111101101101100, 5}, + {0b1111101101101101, 4}, {0b1111101101101110, 4}, + {0b1111101101101111, 5}, {0b1111101101110001, 5}, + {0b1111101101110010, 5}, {0b1111101101110011, 4}, + {0b1111101101110100, 5}, {0b1111101101110101, 4}, + {0b1111101101110110, 4}, {0b1111101101110111, 5}, + {0b1111101101111000, 5}, {0b1111101101111001, 4}, + {0b1111101101111010, 4}, {0b1111101101111011, 5}, + {0b1111101101111100, 4}, {0b1111101101111101, 5}, + {0b1111101101111110, 5}, {0b1111101101111111, 3}, + {0b1111101110000111, 5}, {0b1111101110001011, 5}, + {0b1111101110001101, 5}, {0b1111101110001110, 5}, + {0b1111101110001111, 4}, {0b1111101110010011, 5}, + {0b1111101110010101, 5}, {0b1111101110010111, 4}, + {0b1111101110011010, 5}, {0b1111101110011011, 4}, + {0b1111101110011100, 5}, {0b1111101110011101, 4}, + {0b1111101110011110, 4}, {0b1111101110011111, 5}, + {0b1111101110100011, 5}, {0b1111101110100110, 5}, + {0b1111101110100111, 4}, {0b1111101110101001, 5}, + {0b1111101110101011, 4}, {0b1111101110101100, 5}, + {0b1111101110101101, 4}, {0b1111101110101110, 4}, + {0b1111101110101111, 5}, {0b1111101110110001, 5}, + {0b1111101110110010, 5}, {0b1111101110110011, 4}, + {0b1111101110110100, 5}, {0b1111101110110101, 4}, + {0b1111101110110110, 4}, {0b1111101110110111, 5}, + {0b1111101110111000, 5}, {0b1111101110111001, 4}, + {0b1111101110111010, 4}, {0b1111101110111011, 5}, + {0b1111101110111100, 4}, {0b1111101110111101, 5}, + {0b1111101110111110, 5}, {0b1111101110111111, 3}, + {0b1111101111000101, 5}, {0b1111101111000110, 5}, + {0b1111101111000111, 4}, {0b1111101111001001, 5}, + {0b1111101111001010, 5}, {0b1111101111001011, 4}, + {0b1111101111001101, 4}, {0b1111101111001110, 4}, + {0b1111101111001111, 5}, {0b1111101111010001, 5}, + {0b1111101111010010, 5}, {0b1111101111010011, 4}, + {0b1111101111010100, 5}, {0b1111101111010101, 4}, + {0b1111101111010110, 4}, {0b1111101111010111, 5}, + {0b1111101111011000, 5}, {0b1111101111011001, 4}, + {0b1111101111011010, 4}, {0b1111101111011011, 5}, + {0b1111101111011100, 4}, {0b1111101111011101, 5}, + {0b1111101111011110, 5}, {0b1111101111011111, 3}, + {0b1111101111100001, 5}, {0b1111101111100010, 5}, + {0b1111101111100011, 4}, {0b1111101111100100, 5}, + {0b1111101111100101, 4}, {0b1111101111100110, 4}, + {0b1111101111100111, 5}, {0b1111101111101000, 5}, + {0b1111101111101001, 4}, {0b1111101111101010, 4}, + {0b1111101111101011, 5}, {0b1111101111101100, 4}, + {0b1111101111101101, 5}, {0b1111101111101110, 5}, + {0b1111101111101111, 3}, {0b1111101111110001, 4}, + {0b1111101111110010, 4}, {0b1111101111110011, 5}, + {0b1111101111110100, 4}, {0b1111101111110101, 5}, + {0b1111101111110110, 5}, {0b1111101111110111, 3}, + {0b1111101111111000, 4}, {0b1111101111111001, 5}, + {0b1111101111111010, 5}, {0b1111101111111011, 3}, + {0b1111101111111100, 5}, {0b1111101111111101, 3}, + {0b1111101111111110, 3}, {0b1111101111111111, 4}, + {0b1111110000000000, 3}, {0b1111110000000011, 4}, + {0b1111110000001100, 4}, {0b1111110000001111, 3}, + {0b1111110000110000, 4}, {0b1111110000110011, 3}, + {0b1111110000111100, 3}, {0b1111110000111111, 2}, + {0b1111110001010111, 5}, {0b1111110001011011, 5}, + {0b1111110001011101, 5}, {0b1111110001011110, 5}, + {0b1111110001011111, 4}, {0b1111110001100111, 5}, + {0b1111110001101011, 5}, {0b1111110001101101, 5}, + {0b1111110001101110, 5}, {0b1111110001101111, 4}, + {0b1111110001110101, 5}, {0b1111110001110110, 5}, + {0b1111110001110111, 4}, {0b1111110001111001, 5}, + {0b1111110001111010, 5}, {0b1111110001111011, 4}, + {0b1111110001111101, 4}, {0b1111110001111110, 4}, + {0b1111110001111111, 5}, {0b1111110010010111, 5}, + {0b1111110010011011, 5}, {0b1111110010011101, 5}, + {0b1111110010011110, 5}, {0b1111110010011111, 4}, + {0b1111110010100111, 5}, {0b1111110010101011, 5}, + {0b1111110010101101, 5}, {0b1111110010101110, 5}, + {0b1111110010101111, 4}, {0b1111110010110101, 5}, + {0b1111110010110110, 5}, {0b1111110010110111, 4}, + {0b1111110010111001, 5}, {0b1111110010111010, 5}, + {0b1111110010111011, 4}, {0b1111110010111101, 4}, + {0b1111110010111110, 4}, {0b1111110010111111, 5}, + {0b1111110011000000, 4}, {0b1111110011000011, 3}, + {0b1111110011001100, 3}, {0b1111110011001111, 2}, + {0b1111110011010101, 5}, {0b1111110011010110, 5}, + {0b1111110011010111, 4}, {0b1111110011011001, 5}, + {0b1111110011011010, 5}, {0b1111110011011011, 4}, + {0b1111110011011101, 4}, {0b1111110011011110, 4}, + {0b1111110011011111, 5}, {0b1111110011100101, 5}, + {0b1111110011100110, 5}, {0b1111110011100111, 4}, + {0b1111110011101001, 5}, {0b1111110011101010, 5}, + {0b1111110011101011, 4}, {0b1111110011101101, 4}, + {0b1111110011101110, 4}, {0b1111110011101111, 5}, + {0b1111110011110000, 3}, {0b1111110011110011, 2}, + {0b1111110011110101, 4}, {0b1111110011110110, 4}, + {0b1111110011110111, 5}, {0b1111110011111001, 4}, + {0b1111110011111010, 4}, {0b1111110011111011, 5}, + {0b1111110011111100, 2}, {0b1111110011111101, 5}, + {0b1111110011111110, 5}, {0b1111110011111111, 3}, + {0b1111110100010111, 5}, {0b1111110100011011, 5}, + {0b1111110100011101, 5}, {0b1111110100011110, 5}, + {0b1111110100011111, 4}, {0b1111110100100111, 5}, + {0b1111110100101011, 5}, {0b1111110100101101, 5}, + {0b1111110100101110, 5}, {0b1111110100101111, 4}, + {0b1111110100110101, 5}, {0b1111110100110110, 5}, + {0b1111110100110111, 4}, {0b1111110100111001, 5}, + {0b1111110100111010, 5}, {0b1111110100111011, 4}, + {0b1111110100111101, 4}, {0b1111110100111110, 4}, + {0b1111110100111111, 5}, {0b1111110101000111, 5}, + {0b1111110101001011, 5}, {0b1111110101001101, 5}, + {0b1111110101001110, 5}, {0b1111110101001111, 4}, + {0b1111110101010011, 5}, {0b1111110101010110, 5}, + {0b1111110101010111, 4}, {0b1111110101011001, 5}, + {0b1111110101011011, 4}, {0b1111110101011100, 5}, + {0b1111110101011101, 4}, {0b1111110101011110, 4}, + {0b1111110101011111, 5}, {0b1111110101100011, 5}, + {0b1111110101100101, 5}, {0b1111110101100111, 4}, + {0b1111110101101010, 5}, {0b1111110101101011, 4}, + {0b1111110101101100, 5}, {0b1111110101101101, 4}, + {0b1111110101101110, 4}, {0b1111110101101111, 5}, + {0b1111110101110001, 5}, {0b1111110101110010, 5}, + {0b1111110101110011, 4}, {0b1111110101110100, 5}, + {0b1111110101110101, 4}, {0b1111110101110110, 4}, + {0b1111110101110111, 5}, {0b1111110101111000, 5}, + {0b1111110101111001, 4}, {0b1111110101111010, 4}, + {0b1111110101111011, 5}, {0b1111110101111100, 4}, + {0b1111110101111101, 5}, {0b1111110101111110, 5}, + {0b1111110101111111, 3}, {0b1111110110000111, 5}, + {0b1111110110001011, 5}, {0b1111110110001101, 5}, + {0b1111110110001110, 5}, {0b1111110110001111, 4}, + {0b1111110110010011, 5}, {0b1111110110010101, 5}, + {0b1111110110010111, 4}, {0b1111110110011010, 5}, + {0b1111110110011011, 4}, {0b1111110110011100, 5}, + {0b1111110110011101, 4}, {0b1111110110011110, 4}, + {0b1111110110011111, 5}, {0b1111110110100011, 5}, + {0b1111110110100110, 5}, {0b1111110110100111, 4}, + {0b1111110110101001, 5}, {0b1111110110101011, 4}, + {0b1111110110101100, 5}, {0b1111110110101101, 4}, + {0b1111110110101110, 4}, {0b1111110110101111, 5}, + {0b1111110110110001, 5}, {0b1111110110110010, 5}, + {0b1111110110110011, 4}, {0b1111110110110100, 5}, + {0b1111110110110101, 4}, {0b1111110110110110, 4}, + {0b1111110110110111, 5}, {0b1111110110111000, 5}, + {0b1111110110111001, 4}, {0b1111110110111010, 4}, + {0b1111110110111011, 5}, {0b1111110110111100, 4}, + {0b1111110110111101, 5}, {0b1111110110111110, 5}, + {0b1111110110111111, 3}, {0b1111110111000101, 5}, + {0b1111110111000110, 5}, {0b1111110111000111, 4}, + {0b1111110111001001, 5}, {0b1111110111001010, 5}, + {0b1111110111001011, 4}, {0b1111110111001101, 4}, + {0b1111110111001110, 4}, {0b1111110111001111, 5}, + {0b1111110111010001, 5}, {0b1111110111010010, 5}, + {0b1111110111010011, 4}, {0b1111110111010100, 5}, + {0b1111110111010101, 4}, {0b1111110111010110, 4}, + {0b1111110111010111, 5}, {0b1111110111011000, 5}, + {0b1111110111011001, 4}, {0b1111110111011010, 4}, + {0b1111110111011011, 5}, {0b1111110111011100, 4}, + {0b1111110111011101, 5}, {0b1111110111011110, 5}, + {0b1111110111011111, 3}, {0b1111110111100001, 5}, + {0b1111110111100010, 5}, {0b1111110111100011, 4}, + {0b1111110111100100, 5}, {0b1111110111100101, 4}, + {0b1111110111100110, 4}, {0b1111110111100111, 5}, + {0b1111110111101000, 5}, {0b1111110111101001, 4}, + {0b1111110111101010, 4}, {0b1111110111101011, 5}, + {0b1111110111101100, 4}, {0b1111110111101101, 5}, + {0b1111110111101110, 5}, {0b1111110111101111, 3}, + {0b1111110111110001, 4}, {0b1111110111110010, 4}, + {0b1111110111110011, 5}, {0b1111110111110100, 4}, + {0b1111110111110101, 5}, {0b1111110111110110, 5}, + {0b1111110111110111, 3}, {0b1111110111111000, 4}, + {0b1111110111111001, 5}, {0b1111110111111010, 5}, + {0b1111110111111011, 3}, {0b1111110111111100, 5}, + {0b1111110111111101, 3}, {0b1111110111111110, 3}, + {0b1111110111111111, 4}, {0b1111111000010111, 5}, + {0b1111111000011011, 5}, {0b1111111000011101, 5}, + {0b1111111000011110, 5}, {0b1111111000011111, 4}, + {0b1111111000100111, 5}, {0b1111111000101011, 5}, + {0b1111111000101101, 5}, {0b1111111000101110, 5}, + {0b1111111000101111, 4}, {0b1111111000110101, 5}, + {0b1111111000110110, 5}, {0b1111111000110111, 4}, + {0b1111111000111001, 5}, {0b1111111000111010, 5}, + {0b1111111000111011, 4}, {0b1111111000111101, 4}, + {0b1111111000111110, 4}, {0b1111111000111111, 5}, + {0b1111111001000111, 5}, {0b1111111001001011, 5}, + {0b1111111001001101, 5}, {0b1111111001001110, 5}, + {0b1111111001001111, 4}, {0b1111111001010011, 5}, + {0b1111111001010110, 5}, {0b1111111001010111, 4}, + {0b1111111001011001, 5}, {0b1111111001011011, 4}, + {0b1111111001011100, 5}, {0b1111111001011101, 4}, + {0b1111111001011110, 4}, {0b1111111001011111, 5}, + {0b1111111001100011, 5}, {0b1111111001100101, 5}, + {0b1111111001100111, 4}, {0b1111111001101010, 5}, + {0b1111111001101011, 4}, {0b1111111001101100, 5}, + {0b1111111001101101, 4}, {0b1111111001101110, 4}, + {0b1111111001101111, 5}, {0b1111111001110001, 5}, + {0b1111111001110010, 5}, {0b1111111001110011, 4}, + {0b1111111001110100, 5}, {0b1111111001110101, 4}, + {0b1111111001110110, 4}, {0b1111111001110111, 5}, + {0b1111111001111000, 5}, {0b1111111001111001, 4}, + {0b1111111001111010, 4}, {0b1111111001111011, 5}, + {0b1111111001111100, 4}, {0b1111111001111101, 5}, + {0b1111111001111110, 5}, {0b1111111001111111, 3}, + {0b1111111010000111, 5}, {0b1111111010001011, 5}, + {0b1111111010001101, 5}, {0b1111111010001110, 5}, + {0b1111111010001111, 4}, {0b1111111010010011, 5}, + {0b1111111010010101, 5}, {0b1111111010010111, 4}, + {0b1111111010011010, 5}, {0b1111111010011011, 4}, + {0b1111111010011100, 5}, {0b1111111010011101, 4}, + {0b1111111010011110, 4}, {0b1111111010011111, 5}, + {0b1111111010100011, 5}, {0b1111111010100110, 5}, + {0b1111111010100111, 4}, {0b1111111010101001, 5}, + {0b1111111010101011, 4}, {0b1111111010101100, 5}, + {0b1111111010101101, 4}, {0b1111111010101110, 4}, + {0b1111111010101111, 5}, {0b1111111010110001, 5}, + {0b1111111010110010, 5}, {0b1111111010110011, 4}, + {0b1111111010110100, 5}, {0b1111111010110101, 4}, + {0b1111111010110110, 4}, {0b1111111010110111, 5}, + {0b1111111010111000, 5}, {0b1111111010111001, 4}, + {0b1111111010111010, 4}, {0b1111111010111011, 5}, + {0b1111111010111100, 4}, {0b1111111010111101, 5}, + {0b1111111010111110, 5}, {0b1111111010111111, 3}, + {0b1111111011000101, 5}, {0b1111111011000110, 5}, + {0b1111111011000111, 4}, {0b1111111011001001, 5}, + {0b1111111011001010, 5}, {0b1111111011001011, 4}, + {0b1111111011001101, 4}, {0b1111111011001110, 4}, + {0b1111111011001111, 5}, {0b1111111011010001, 5}, + {0b1111111011010010, 5}, {0b1111111011010011, 4}, + {0b1111111011010100, 5}, {0b1111111011010101, 4}, + {0b1111111011010110, 4}, {0b1111111011010111, 5}, + {0b1111111011011000, 5}, {0b1111111011011001, 4}, + {0b1111111011011010, 4}, {0b1111111011011011, 5}, + {0b1111111011011100, 4}, {0b1111111011011101, 5}, + {0b1111111011011110, 5}, {0b1111111011011111, 3}, + {0b1111111011100001, 5}, {0b1111111011100010, 5}, + {0b1111111011100011, 4}, {0b1111111011100100, 5}, + {0b1111111011100101, 4}, {0b1111111011100110, 4}, + {0b1111111011100111, 5}, {0b1111111011101000, 5}, + {0b1111111011101001, 4}, {0b1111111011101010, 4}, + {0b1111111011101011, 5}, {0b1111111011101100, 4}, + {0b1111111011101101, 5}, {0b1111111011101110, 5}, + {0b1111111011101111, 3}, {0b1111111011110001, 4}, + {0b1111111011110010, 4}, {0b1111111011110011, 5}, + {0b1111111011110100, 4}, {0b1111111011110101, 5}, + {0b1111111011110110, 5}, {0b1111111011110111, 3}, + {0b1111111011111000, 4}, {0b1111111011111001, 5}, + {0b1111111011111010, 5}, {0b1111111011111011, 3}, + {0b1111111011111100, 5}, {0b1111111011111101, 3}, + {0b1111111011111110, 3}, {0b1111111011111111, 4}, + {0b1111111100000000, 1}, {0b1111111100000011, 3}, + {0b1111111100000101, 3}, {0b1111111100000110, 3}, + {0b1111111100001001, 3}, {0b1111111100001010, 3}, + {0b1111111100001100, 3}, {0b1111111100001111, 2}, + {0b1111111100010001, 3}, {0b1111111100010010, 3}, + {0b1111111100010100, 3}, {0b1111111100010111, 4}, + {0b1111111100011000, 3}, {0b1111111100011011, 4}, + {0b1111111100011101, 4}, {0b1111111100011110, 4}, + {0b1111111100011111, 5}, {0b1111111100100001, 3}, + {0b1111111100100010, 3}, {0b1111111100100100, 3}, + {0b1111111100100111, 4}, {0b1111111100101000, 3}, + {0b1111111100101011, 4}, {0b1111111100101101, 4}, + {0b1111111100101110, 4}, {0b1111111100101111, 5}, + {0b1111111100110000, 3}, {0b1111111100110011, 2}, + {0b1111111100110101, 4}, {0b1111111100110110, 4}, + {0b1111111100110111, 5}, {0b1111111100111001, 4}, + {0b1111111100111010, 4}, {0b1111111100111011, 5}, + {0b1111111100111100, 2}, {0b1111111100111101, 5}, + {0b1111111100111110, 5}, {0b1111111100111111, 3}, + {0b1111111101000001, 3}, {0b1111111101000010, 3}, + {0b1111111101000100, 3}, {0b1111111101000111, 4}, + {0b1111111101001000, 3}, {0b1111111101001011, 4}, + {0b1111111101001101, 4}, {0b1111111101001110, 4}, + {0b1111111101001111, 5}, {0b1111111101010000, 3}, + {0b1111111101010011, 4}, {0b1111111101010101, 2}, + {0b1111111101010110, 4}, {0b1111111101010111, 5}, + {0b1111111101011001, 4}, {0b1111111101011010, 2}, + {0b1111111101011011, 5}, {0b1111111101011100, 4}, + {0b1111111101011101, 5}, {0b1111111101011110, 5}, + {0b1111111101011111, 3}, {0b1111111101100000, 3}, + {0b1111111101100011, 4}, {0b1111111101100101, 4}, + {0b1111111101100110, 2}, {0b1111111101100111, 5}, + {0b1111111101101001, 2}, {0b1111111101101010, 4}, + {0b1111111101101011, 5}, {0b1111111101101100, 4}, + {0b1111111101101101, 5}, {0b1111111101101110, 5}, + {0b1111111101101111, 3}, {0b1111111101110001, 4}, + {0b1111111101110010, 4}, {0b1111111101110011, 5}, + {0b1111111101110100, 4}, {0b1111111101110101, 5}, + {0b1111111101110110, 5}, {0b1111111101110111, 3}, + {0b1111111101111000, 4}, {0b1111111101111001, 5}, + {0b1111111101111010, 5}, {0b1111111101111011, 3}, + {0b1111111101111100, 5}, {0b1111111101111101, 3}, + {0b1111111101111110, 3}, {0b1111111101111111, 4}, + {0b1111111110000001, 3}, {0b1111111110000010, 3}, + {0b1111111110000100, 3}, {0b1111111110000111, 4}, + {0b1111111110001000, 3}, {0b1111111110001011, 4}, + {0b1111111110001101, 4}, {0b1111111110001110, 4}, + {0b1111111110001111, 5}, {0b1111111110010000, 3}, + {0b1111111110010011, 4}, {0b1111111110010101, 4}, + {0b1111111110010110, 2}, {0b1111111110010111, 5}, + {0b1111111110011001, 2}, {0b1111111110011010, 4}, + {0b1111111110011011, 5}, {0b1111111110011100, 4}, + {0b1111111110011101, 5}, {0b1111111110011110, 5}, + {0b1111111110011111, 3}, {0b1111111110100000, 3}, + {0b1111111110100011, 4}, {0b1111111110100101, 2}, + {0b1111111110100110, 4}, {0b1111111110100111, 5}, + {0b1111111110101001, 4}, {0b1111111110101010, 2}, + {0b1111111110101011, 5}, {0b1111111110101100, 4}, + {0b1111111110101101, 5}, {0b1111111110101110, 5}, + {0b1111111110101111, 3}, {0b1111111110110001, 4}, + {0b1111111110110010, 4}, {0b1111111110110011, 5}, + {0b1111111110110100, 4}, {0b1111111110110101, 5}, + {0b1111111110110110, 5}, {0b1111111110110111, 3}, + {0b1111111110111000, 4}, {0b1111111110111001, 5}, + {0b1111111110111010, 5}, {0b1111111110111011, 3}, + {0b1111111110111100, 5}, {0b1111111110111101, 3}, + {0b1111111110111110, 3}, {0b1111111110111111, 4}, + {0b1111111111000000, 3}, {0b1111111111000011, 2}, + {0b1111111111000101, 4}, {0b1111111111000110, 4}, + {0b1111111111000111, 5}, {0b1111111111001001, 4}, + {0b1111111111001010, 4}, {0b1111111111001011, 5}, + {0b1111111111001100, 2}, {0b1111111111001101, 5}, + {0b1111111111001110, 5}, {0b1111111111001111, 3}, + {0b1111111111010001, 4}, {0b1111111111010010, 4}, + {0b1111111111010011, 5}, {0b1111111111010100, 4}, + {0b1111111111010101, 5}, {0b1111111111010110, 5}, + {0b1111111111010111, 3}, {0b1111111111011000, 4}, + {0b1111111111011001, 5}, {0b1111111111011010, 5}, + {0b1111111111011011, 3}, {0b1111111111011100, 5}, + {0b1111111111011101, 3}, {0b1111111111011110, 3}, + {0b1111111111011111, 4}, {0b1111111111100001, 4}, + {0b1111111111100010, 4}, {0b1111111111100011, 5}, + {0b1111111111100100, 4}, {0b1111111111100101, 5}, + {0b1111111111100110, 5}, {0b1111111111100111, 3}, + {0b1111111111101000, 4}, {0b1111111111101001, 5}, + {0b1111111111101010, 5}, {0b1111111111101011, 3}, + {0b1111111111101100, 5}, {0b1111111111101101, 3}, + {0b1111111111101110, 3}, {0b1111111111101111, 4}, + {0b1111111111110000, 2}, {0b1111111111110001, 5}, + {0b1111111111110010, 5}, {0b1111111111110011, 3}, + {0b1111111111110100, 5}, {0b1111111111110101, 3}, + {0b1111111111110110, 3}, {0b1111111111110111, 4}, + {0b1111111111111000, 5}, {0b1111111111111001, 3}, + {0b1111111111111010, 3}, {0b1111111111111011, 4}, + {0b1111111111111100, 3}, {0b1111111111111101, 4}, + {0b1111111111111110, 4}, {0b1111111111111111, 1}}}; + +/** + * Tests if the matrix is invertible by checking the rows are linearly + * independent in GF(2). + * @param {number[]} rows + * @returns {boolean} + */ + +int total = 0; +__attribute__((noinline)) bool +isInvertible(const std::vector &matrix) { + uint16_t basis[16]{}; + auto curr = matrix.cbegin(); + do { + uint16_t v = *curr; + do { + uint16_t b = 15 - __builtin_clzs(v); + if (!basis[b]) { + basis[b] = v; + break; + } + v ^= basis[b]; + if (!v) + return false; + } while (true); + } while (++curr < matrix.cend()); + return true; +} + +__attribute__((noinline)) bool invertMatrix(const std::vector &matrix, + std::vector &scratch, + std::vector &output) { + for (size_t i = 0; i < matrix.size(); i++) { + scratch[i] = matrix[i] | (1 << (16 + i)); + } + uint32_t mask = 1; + for (auto currI = scratch.begin(); currI < scratch.end(); currI++) { + for (auto currJ = currI; currJ < scratch.end(); currJ++) { + if ((*currJ) & mask) { + std::swap(*currI, *currJ); + break; + } + } + for (auto currJ = currI + 1; currJ < scratch.end(); currJ++) { + if ((*currJ) & mask) { + *currJ ^= *currI; + } + } + mask <<= 1; + } + auto currI = scratch.end(); + while (currI-- != scratch.begin()) { + mask >>= 1; + auto currJ = currI; + while (currJ-- != scratch.begin()) { + if ((*currJ) & mask) { + *currJ ^= *currI; + } + } + } + for (size_t i = 0; i < scratch.size(); i++) { + output[i] = scratch[i] >> 16; + } + return true; +} + +std::vector transition(const std::vector &rows, + const std::vector &terms) { + std::vector new_terms = std::vector(terms.size()); + for (size_t i = 0; i < terms.size(); i++) { + uint16_t bitmask = 1; + for (size_t j = 0; j < terms.size(); j++) { + if (rows[i] & bitmask) { + new_terms[i] ^= terms[j]; + } + bitmask <<= 1; + } + } + return new_terms; +} + +std::vector transpose(const std::vector &matrix) { + std::vector result = std::vector(matrix.size()); + for (size_t i = 0; i < matrix.size(); i++) { + uint16_t beginning = (matrix[0] >> i) & 1; + for (size_t j = 1; j < matrix.size(); j++) { + beginning |= ((matrix[j] >> i) & 1) << j; + } + result[i] = beginning; + } + return result; +} + +/** + * @typedef {Map} TermMap + * @description Transitioned term as key, lamp count as value, ordered by lamp + * count + */ +/** + * @typedef {number[]} viableCombinations + * @description Array of solvable linear combinations, preserving order of + * TermMap + */ +/** + * Generates all viable linear combinations (encodings) of input terms + * @param {number[]} terms + * @param {number} mask + * @returns {[viableCombinations,TermMap]} Viable linear combinations array, and + * pruned map of terms. + */ + +struct Precursor { + uint8_t lampCount; + uint16_t precursor; + uint16_t combination; + Precursor(uint8_t lc, uint16_t p, uint16_t c) + : lampCount(lc), precursor(p), combination(c) {} +}; + +size_t sizes[] = {16, 256, 12960}; + +__attribute__((noinline)) +std::pair, std::unordered_map> +getGoodTerms(size_t varCount, const std::vector &terms, + uint16_t mask) { + const auto &dictionary = Dictionary[varCount - 2]; + size_t size = sizes[varCount - 2]; + std::unordered_map maskedDictionary; + for (size_t i = 0; i < size; i++) { + auto [term, complexity] = dictionary[i]; + auto [it, inserted] = maskedDictionary.try_emplace(term | mask, complexity); + if (!inserted) { + if (complexity < it->second) { + it->second = complexity; + } + } + } + + std::vector precursorTerms; + for (uint16_t combination = 1; combination < 1 << terms.size(); + combination++) { + uint16_t bitmask = 0b1; + uint16_t precursor = 0b0; + for (size_t i = 0; i < terms.size(); i++) { + if ((combination & bitmask)) { + precursor ^= terms[i]; + } + bitmask <<= 1; + } + + auto minIt = maskedDictionary.find(precursor | mask); + if (minIt != maskedDictionary.end()) { + precursorTerms.emplace_back(minIt->second, precursor, combination); + } + } + std::stable_sort(precursorTerms.begin(), precursorTerms.end(), + [](const Precursor &a, const Precursor &b) -> bool { + return a.lampCount < b.lampCount; + }); + + maskedDictionary.clear(); // We can reuse this dictionary. + + std::vector realPrecursorTerms; + for (size_t i = 0; i < precursorTerms.size(); i++) { + const auto &term = precursorTerms[i]; + + auto [it, inserted] = + maskedDictionary.try_emplace(term.precursor, term.lampCount); + if (inserted) { + realPrecursorTerms.emplace_back(term.combination); + } + } + return std::make_pair(std::move(realPrecursorTerms), + std::move(maskedDictionary)); +} + +struct Result { + uint8_t complexity; + std::vector rows; + std::vector transitioned; + uint16_t mask; +}; + +typedef std::vector::const_iterator cit_u16_t; + +__attribute__((noinline)) bool nextCombination(std::vector &arr, + std::vector &view, + cit_u16_t n, size_t m) { + for (size_t i = m; i-- > 0;) { + if (arr[i] < n - (m - i)) { + auto last = ++arr[i]; + view[i] = *last; + for (size_t j = i + 1; j < m; j++) { + arr[j] = ++last; + view[j] = *last; + } + return true; + } + } + return false; +} + +/** + * Generates all transition matrices for a given set of terms + * @param {number[]} terms + * @param {number} mask + * @returns {number[][]} Partially sorted transition matrices + */ +std::vector combinations(size_t varCount, + std::vector terms, uint16_t mask = 0, + size_t hardLimit = 20) { + const size_t terms_size = terms.size(); + + const auto [linCombs, goodTermsMap] = getGoodTerms(varCount, terms, mask); + + std::vector combination(terms_size); + + std::vector lin_combination(terms_size, linCombs[0]); + + std::vector BigRes; + std::vector invert_scratch = std::vector(terms_size); + std::vector invert_output = std::vector(terms_size); + + for (size_t i = 0; i < terms_size; i++) { + combination[i] = linCombs.cbegin() + i; + lin_combination[i] = *combination[i]; + } + + size_t tested = 0; + do { + // We want just... linearly independent matrixes. + bool hasInverse = isInvertible(lin_combination); + if (hasInverse) { + invertMatrix(lin_combination, invert_scratch, invert_output); + const auto transitioned = transition(lin_combination, terms); + const auto &inverse = invert_output; + const auto rows = transpose(inverse); + std::vector new_transitioned; + std::unordered_map transitionedMap; + + for (size_t i = 0; i < transitioned.size(); i++) { + uint16_t itransition = transitioned[i]; + auto itranIt = transitionedMap.find(itransition); + if (itranIt != transitionedMap.end()) { + itranIt->second ^= rows[i]; + } else { + transitionedMap.emplace(itransition, rows[i]); + new_transitioned.emplace_back(itransition); + } + } + + std::vector new_rows; + + uint8_t complexity_sum = 0; + + for (size_t i = 0; i < new_transitioned.size(); i++) { + complexity_sum += goodTermsMap.at(new_transitioned[i]); + new_rows.emplace_back(transitionedMap.at(new_transitioned[i])); + } + + BigRes.emplace_back(Result{complexity_sum, std::move(new_rows), + std::move(new_transitioned), mask}); + } + tested++; + if (BigRes.size() >= hardLimit) { + break; + } + } while (nextCombination(combination, lin_combination, linCombs.cend(), + terms_size)); + std::stable_sort(BigRes.begin(), BigRes.end(), + [](const auto &a, const auto &b) -> bool { + return a.complexity < b.complexity; + }); + return BigRes; +} + +EMSCRIPTEN_BINDINGS(my_module) { + emscripten::function("combinations", &combinations); + emscripten::value_object("_") + .field("complexity", &Result::complexity) + .field("rows", &Result::rows) + .field("transitioned", &Result::transitioned) + .field("mask", &Result::mask); +} + +namespace emscripten { +namespace internal { + +template +struct BindingType> { + using ValBinding = BindingType; + using WireType = ValBinding::WireType; + + static WireType toWireType(const std::vector &vec, + rvp::default_tag) { + return ValBinding::toWireType(val::array(vec), rvp::default_tag{}); + } + + static std::vector fromWireType(WireType value) { + return vecFromJSArray(ValBinding::fromWireType(value)); + } +}; + +template +struct TypeID< + T, + typename std::enable_if_t::type, + std::vector::type::value_type, + typename Canonicalized::type::allocator_type>>::value>> { + static constexpr TYPEID get() { return TypeID::get(); } +}; + +} // namespace internal +} // namespace emscripten diff --git a/js/worker/transmatrix.js b/js/worker/transmatrix.js index 7da286e..687e5c7 100644 --- a/js/worker/transmatrix.js +++ b/js/worker/transmatrix.js @@ -11,6 +11,7 @@ SOLUTION: prune linear combination set (what the getGoodTerms function does) at */ import { Dictionary } from "../data/dictionary.js"; +import Module from "./transmatrix_wasm.mjs" /** * tests if a number is a power of two @@ -61,6 +62,22 @@ function transition(rows, terms) { return newTerms; } +/** + * We are tasked with transposing an array of numbers as if the bits formed a matrix. + * We assume they are square, but that's fine for the uses we have. + */ +function transpose(arrayOfNums) { + let result = []; + for(let i = 0; i < arrayOfNums.length; i++) { + let beginning = (arrayOfNums[0] >> i) & 1; + for(let j = 1; j < arrayOfNums.length; j++) { + beginning |= ((arrayOfNums[j] >> i) & 1) << j; + } + result[i] = beginning; + } + return result; +} + /** * @typedef {Map} TermMap * @description Transitioned term as key, lamp count as value, ordered by lamp count @@ -146,16 +163,32 @@ function combinations({ varCount, terms, mask = 0, hardLimit = 20 }) { // Check the matrix and add it to possible solutions list. if (isInvertible(lin_combinations)) { const transitioned = transition(lin_combinations, terms); - const lampSum = transitioned.reduce( + const inverse = getInverseMatrix(lin_combinations); + let rows = transpose(inverse); + let new_transitioned = []; + let transitionedMap = new Map(); + for(let i = 0; i < transitioned.length; i++) { + let itransition = transitioned[i]; + if(transitionedMap.has(itransition)) { + // We XOR instead of OR here, even though they *should* be identical, but just in case the system decides to use the same term twice for some reason. + transitionedMap.set(itransition, transitionedMap.get(itransition) ^ rows[i]); + } else { + transitionedMap.set(itransition, rows[i]); + new_transitioned.push(itransition); + } + } + let new_rows = []; + for(let i = 0; i < new_transitioned.length; i++) { + new_rows.push(transitionedMap.get(new_transitioned[i])); + } + const lampSum = new_transitioned.reduce( (acc, term) => acc + goodTermsMap.get(term), 0 ); - const inverse = getInverseMatrix(lin_combinations); - BigRes.push({ complexity: lampSum, - rows: inverse, - transitioned: transitioned, + rows: new_rows, + transitioned: new_transitioned, mask: mask, }); } @@ -203,19 +236,23 @@ function getInverseMatrix(lin_combinations) { return inverse; } -onmessage = (e) => { +let module = Module({}); + +async function wasmWorkerWrapper(varCount, terms, mask, hardLimit) { + return (await module).combinations(varCount, terms, mask, hardLimit); +} + +onmessage = async (e) => { switch (e.data.action) { case "generate": - const matrices = combinations({ - varCount: e.data.varCount, - terms: e.data.terms, - mask: e.data.mask, - hardLimit: e.data.hardLimit, - }); - matrices.sort((a, b) => a[0] - b[0]); + const matrices = await wasmWorkerWrapper(e.data.varCount, e.data.terms, e.data.mask, e.data.hardLimit); postMessage({ action: "matrices", - results: matrices, + results: { + varCount: e.data.varCount, + matrices, + outputs: e.data.terms.length + }, }); break; default: diff --git a/js/worker/transmatrix_wasm.mjs b/js/worker/transmatrix_wasm.mjs new file mode 100644 index 0000000..8f49cc5 --- /dev/null +++ b/js/worker/transmatrix_wasm.mjs @@ -0,0 +1,1744 @@ +// This code implements the `-sMODULARIZE` settings by taking the generated +// JS program code (INNER_JS_CODE) and wrapping it in a factory function. + +// When targetting node and ES6 we use `await import ..` in the generated code +// so the outer function needs to be marked as async. +async function Module(moduleArg = {}) { + var moduleRtn; + +// include: shell.js +// The Module object: Our interface to the outside world. We import +// and export values on it. There are various ways Module can be used: +// 1. Not defined. We create it here +// 2. A function parameter, function(moduleArg) => Promise +// 3. pre-run appended it, var Module = {}; ..generated code.. +// 4. External script tag defines var Module. +// We need to check if Module already exists (e.g. case 3 above). +// Substitution will be replaced with actual code on later stage of the build, +// this way Closure Compiler will not mangle it (e.g. case 4. above). +// Note that if you want to run closure, and also to use Module +// after the generated code, you will need to define var Module = {}; +// before the code. Then that object will be used in the code, and you +// can continue to use Module afterwards as well. +var Module = moduleArg; + +// Determine the runtime environment we are in. You can customize this by +// setting the ENVIRONMENT setting at compile time (see settings.js). +// Attempt to auto-detect the environment +var ENVIRONMENT_IS_WEB = typeof window == "object"; + +var ENVIRONMENT_IS_WORKER = typeof WorkerGlobalScope != "undefined"; + +// N.b. Electron.js environment is simultaneously a NODE-environment, but +// also a web environment. +var ENVIRONMENT_IS_NODE = typeof process == "object" && process.versions?.node && process.type != "renderer"; + +if (ENVIRONMENT_IS_NODE) { + // When building an ES module `require` is not normally available. + // We need to use `createRequire()` to construct the require()` function. + const {createRequire} = await import("module"); + /** @suppress{duplicate} */ var require = createRequire(import.meta.url); +} + +// --pre-jses are emitted after the Module integration code, so that they can +// refer to Module (if they choose; they can also define Module) +var arguments_ = []; + +var thisProgram = "./this.program"; + +var quit_ = (status, toThrow) => { + throw toThrow; +}; + +var _scriptName = import.meta.url; + +// `/` should be present at the end if `scriptDirectory` is not empty +var scriptDirectory = ""; + +function locateFile(path) { + if (Module["locateFile"]) { + return Module["locateFile"](path, scriptDirectory); + } + return scriptDirectory + path; +} + +// Hooks that are implemented differently in different runtime environments. +var readAsync, readBinary; + +if (ENVIRONMENT_IS_NODE) { + // These modules will usually be used on Node.js. Load them eagerly to avoid + // the complexity of lazy-loading. + var fs = require("fs"); + if (_scriptName.startsWith("file:")) { + scriptDirectory = require("path").dirname(require("url").fileURLToPath(_scriptName)) + "/"; + } + // include: node_shell_read.js + readBinary = filename => { + // We need to re-wrap `file://` strings to URLs. + filename = isFileURI(filename) ? new URL(filename) : filename; + var ret = fs.readFileSync(filename); + return ret; + }; + readAsync = async (filename, binary = true) => { + // See the comment in the `readBinary` function. + filename = isFileURI(filename) ? new URL(filename) : filename; + var ret = fs.readFileSync(filename, binary ? undefined : "utf8"); + return ret; + }; + // end include: node_shell_read.js + if (process.argv.length > 1) { + thisProgram = process.argv[1].replace(/\\/g, "/"); + } + arguments_ = process.argv.slice(2); + quit_ = (status, toThrow) => { + process.exitCode = status; + throw toThrow; + }; +} else // Note that this includes Node.js workers when relevant (pthreads is enabled). +// Node.js workers are detected as a combination of ENVIRONMENT_IS_WORKER and +// ENVIRONMENT_IS_NODE. +if (ENVIRONMENT_IS_WEB || ENVIRONMENT_IS_WORKER) { + try { + scriptDirectory = new URL(".", _scriptName).href; + } catch {} + { + // include: web_or_worker_shell_read.js + if (ENVIRONMENT_IS_WORKER) { + readBinary = url => { + var xhr = new XMLHttpRequest; + xhr.open("GET", url, false); + xhr.responseType = "arraybuffer"; + xhr.send(null); + return new Uint8Array(/** @type{!ArrayBuffer} */ (xhr.response)); + }; + } + readAsync = async url => { + // Fetch has some additional restrictions over XHR, like it can't be used on a file:// url. + // See https://github.com/github/fetch/pull/92#issuecomment-140665932 + // Cordova or Electron apps are typically loaded from a file:// url. + // So use XHR on webview if URL is a file URL. + if (isFileURI(url)) { + return new Promise((resolve, reject) => { + var xhr = new XMLHttpRequest; + xhr.open("GET", url, true); + xhr.responseType = "arraybuffer"; + xhr.onload = () => { + if (xhr.status == 200 || (xhr.status == 0 && xhr.response)) { + // file URLs can return 0 + resolve(xhr.response); + return; + } + reject(xhr.status); + }; + xhr.onerror = reject; + xhr.send(null); + }); + } + var response = await fetch(url, { + credentials: "same-origin" + }); + if (response.ok) { + return response.arrayBuffer(); + } + throw new Error(response.status + " : " + response.url); + }; + } +} else {} + +var out = console.log.bind(console); + +var err = console.error.bind(console); + +// end include: shell.js +// include: preamble.js +// === Preamble library stuff === +// Documentation for the public APIs defined in this file must be updated in: +// site/source/docs/api_reference/preamble.js.rst +// A prebuilt local version of the documentation is available at: +// site/build/text/docs/api_reference/preamble.js.txt +// You can also build docs locally as HTML or other formats in site/ +// An online HTML version (which may be of a different version of Emscripten) +// is up at http://kripken.github.io/emscripten-site/docs/api_reference/preamble.js.html +var wasmBinary; + +// Wasm globals +//======================================== +// Runtime essentials +//======================================== +// whether we are quitting the application. no code should run after this. +// set in exit() and abort() +var ABORT = false; + +/** + * Indicates whether filename is delivered via file protocol (as opposed to http/https) + * @noinline + */ var isFileURI = filename => filename.startsWith("file://"); + +// include: runtime_common.js +// include: runtime_stack_check.js +// end include: runtime_stack_check.js +// include: runtime_exceptions.js +// end include: runtime_exceptions.js +// include: runtime_debug.js +// end include: runtime_debug.js +var readyPromiseResolve, readyPromiseReject; + +// Memory management +var wasmMemory; + +var /** @type {!Int8Array} */ HEAP8, /** @type {!Uint8Array} */ HEAPU8, /** @type {!Int16Array} */ HEAP16, /** @type {!Uint16Array} */ HEAPU16, /** @type {!Int32Array} */ HEAP32, /** @type {!Uint32Array} */ HEAPU32, /** @type {!Float32Array} */ HEAPF32, /** @type {!Float64Array} */ HEAPF64; + +// BigInt64Array type is not correctly defined in closure +var /** not-@type {!BigInt64Array} */ HEAP64, /* BigUint64Array type is not correctly defined in closure +/** not-@type {!BigUint64Array} */ HEAPU64; + +var runtimeInitialized = false; + +function updateMemoryViews() { + var b = wasmMemory.buffer; + HEAP8 = new Int8Array(b); + HEAP16 = new Int16Array(b); + HEAPU8 = new Uint8Array(b); + HEAPU16 = new Uint16Array(b); + HEAP32 = new Int32Array(b); + HEAPU32 = new Uint32Array(b); + HEAPF32 = new Float32Array(b); + HEAPF64 = new Float64Array(b); + HEAP64 = new BigInt64Array(b); + HEAPU64 = new BigUint64Array(b); +} + +// include: memoryprofiler.js +// end include: memoryprofiler.js +// end include: runtime_common.js +function preRun() { + if (Module["preRun"]) { + if (typeof Module["preRun"] == "function") Module["preRun"] = [ Module["preRun"] ]; + while (Module["preRun"].length) { + addOnPreRun(Module["preRun"].shift()); + } + } + // Begin ATPRERUNS hooks + callRuntimeCallbacks(onPreRuns); +} + +function initRuntime() { + runtimeInitialized = true; + // No ATINITS hooks + wasmExports["A"](); +} + +function postRun() { + // PThreads reuse the runtime from the main thread. + if (Module["postRun"]) { + if (typeof Module["postRun"] == "function") Module["postRun"] = [ Module["postRun"] ]; + while (Module["postRun"].length) { + addOnPostRun(Module["postRun"].shift()); + } + } + // Begin ATPOSTRUNS hooks + callRuntimeCallbacks(onPostRuns); +} + +// A counter of dependencies for calling run(). If we need to +// do asynchronous work before running, increment this and +// decrement it. Incrementing must happen in a place like +// Module.preRun (used by emcc to add file preloading). +// Note that you can add dependencies in preRun, even though +// it happens right before run - run will be postponed until +// the dependencies are met. +var runDependencies = 0; + +var dependenciesFulfilled = null; + +// overridden to take different actions when all run dependencies are fulfilled +function addRunDependency(id) { + runDependencies++; + Module["monitorRunDependencies"]?.(runDependencies); +} + +function removeRunDependency(id) { + runDependencies--; + Module["monitorRunDependencies"]?.(runDependencies); + if (runDependencies == 0) { + if (dependenciesFulfilled) { + var callback = dependenciesFulfilled; + dependenciesFulfilled = null; + callback(); + } + } +} + +/** @param {string|number=} what */ function abort(what) { + Module["onAbort"]?.(what); + what = "Aborted(" + what + ")"; + // TODO(sbc): Should we remove printing and leave it up to whoever + // catches the exception? + err(what); + ABORT = true; + what += ". Build with -sASSERTIONS for more info."; + // Use a wasm runtime error, because a JS error might be seen as a foreign + // exception, which means we'd run destructors on it. We need the error to + // simply make the program stop. + // FIXME This approach does not work in Wasm EH because it currently does not assume + // all RuntimeErrors are from traps; it decides whether a RuntimeError is from + // a trap or not based on a hidden field within the object. So at the moment + // we don't have a way of throwing a wasm trap from JS. TODO Make a JS API that + // allows this in the wasm spec. + // Suppress closure compiler warning here. Closure compiler's builtin extern + // definition for WebAssembly.RuntimeError claims it takes no arguments even + // though it can. + // TODO(https://github.com/google/closure-compiler/pull/3913): Remove if/when upstream closure gets fixed. + /** @suppress {checkTypes} */ var e = new WebAssembly.RuntimeError(what); + readyPromiseReject?.(e); + // Throw the error whether or not MODULARIZE is set because abort is used + // in code paths apart from instantiation where an exception is expected + // to be thrown when abort is called. + throw e; +} + +var wasmBinaryFile; + +function findWasmBinary() { + if (Module["locateFile"]) { + return locateFile("transmatrix_wasm.wasm"); + } + // Use bundler-friendly `new URL(..., import.meta.url)` pattern; works in browsers too. + return new URL("transmatrix_wasm.wasm", import.meta.url).href; +} + +function getBinarySync(file) { + if (file == wasmBinaryFile && wasmBinary) { + return new Uint8Array(wasmBinary); + } + if (readBinary) { + return readBinary(file); + } + throw "both async and sync fetching of the wasm failed"; +} + +async function getWasmBinary(binaryFile) { + // If we don't have the binary yet, load it asynchronously using readAsync. + if (!wasmBinary) { + // Fetch the binary using readAsync + try { + var response = await readAsync(binaryFile); + return new Uint8Array(response); + } catch {} + } + // Otherwise, getBinarySync should be able to get it synchronously + return getBinarySync(binaryFile); +} + +async function instantiateArrayBuffer(binaryFile, imports) { + try { + var binary = await getWasmBinary(binaryFile); + var instance = await WebAssembly.instantiate(binary, imports); + return instance; + } catch (reason) { + err(`failed to asynchronously prepare wasm: ${reason}`); + abort(reason); + } +} + +async function instantiateAsync(binary, binaryFile, imports) { + if (!binary && typeof WebAssembly.instantiateStreaming == "function" && !isFileURI(binaryFile) && !ENVIRONMENT_IS_NODE) { + try { + var response = fetch(binaryFile, { + credentials: "same-origin" + }); + var instantiationResult = await WebAssembly.instantiateStreaming(response, imports); + return instantiationResult; + } catch (reason) { + // We expect the most common failure cause to be a bad MIME type for the binary, + // in which case falling back to ArrayBuffer instantiation should work. + err(`wasm streaming compile failed: ${reason}`); + err("falling back to ArrayBuffer instantiation"); + } + } + return instantiateArrayBuffer(binaryFile, imports); +} + +function getWasmImports() { + // prepare imports + return { + "a": wasmImports + }; +} + +// Create the wasm instance. +// Receives the wasm imports, returns the exports. +async function createWasm() { + // Load the wasm module and create an instance of using native support in the JS engine. + // handle a generated wasm instance, receiving its exports and + // performing other necessary setup + /** @param {WebAssembly.Module=} module*/ function receiveInstance(instance, module) { + wasmExports = instance.exports; + wasmMemory = wasmExports["z"]; + updateMemoryViews(); + wasmTable = wasmExports["B"]; + assignWasmExports(wasmExports); + removeRunDependency("wasm-instantiate"); + return wasmExports; + } + // wait for the pthread pool (if any) + addRunDependency("wasm-instantiate"); + // Prefer streaming instantiation if available. + function receiveInstantiationResult(result) { + // 'result' is a ResultObject object which has both the module and instance. + // receiveInstance() will swap in the exports (to Module.asm) so they can be called + // TODO: Due to Closure regression https://github.com/google/closure-compiler/issues/3193, the above line no longer optimizes out down to the following line. + // When the regression is fixed, can restore the above PTHREADS-enabled path. + return receiveInstance(result["instance"]); + } + var info = getWasmImports(); + // User shell pages can write their own Module.instantiateWasm = function(imports, successCallback) callback + // to manually instantiate the Wasm module themselves. This allows pages to + // run the instantiation parallel to any other async startup actions they are + // performing. + // Also pthreads and wasm workers initialize the wasm instance through this + // path. + if (Module["instantiateWasm"]) { + return new Promise((resolve, reject) => { + Module["instantiateWasm"](info, (mod, inst) => { + resolve(receiveInstance(mod, inst)); + }); + }); + } + wasmBinaryFile ??= findWasmBinary(); + var result = await instantiateAsync(wasmBinary, wasmBinaryFile, info); + var exports = receiveInstantiationResult(result); + return exports; +} + +// end include: preamble.js +// Begin JS library code +class ExitStatus { + name="ExitStatus"; + constructor(status) { + this.message = `Program terminated with exit(${status})`; + this.status = status; + } +} + +var callRuntimeCallbacks = callbacks => { + while (callbacks.length > 0) { + // Pass the module as the first argument. + callbacks.shift()(Module); + } +}; + +var onPostRuns = []; + +var addOnPostRun = cb => onPostRuns.push(cb); + +var onPreRuns = []; + +var addOnPreRun = cb => onPreRuns.push(cb); + +var noExitRuntime = true; + +class ExceptionInfo { + // excPtr - Thrown object pointer to wrap. Metadata pointer is calculated from it. + constructor(excPtr) { + this.excPtr = excPtr; + this.ptr = excPtr - 24; + } + set_type(type) { + HEAPU32[(((this.ptr) + (4)) >> 2)] = type; + } + get_type() { + return HEAPU32[(((this.ptr) + (4)) >> 2)]; + } + set_destructor(destructor) { + HEAPU32[(((this.ptr) + (8)) >> 2)] = destructor; + } + get_destructor() { + return HEAPU32[(((this.ptr) + (8)) >> 2)]; + } + set_caught(caught) { + caught = caught ? 1 : 0; + HEAP8[(this.ptr) + (12)] = caught; + } + get_caught() { + return HEAP8[(this.ptr) + (12)] != 0; + } + set_rethrown(rethrown) { + rethrown = rethrown ? 1 : 0; + HEAP8[(this.ptr) + (13)] = rethrown; + } + get_rethrown() { + return HEAP8[(this.ptr) + (13)] != 0; + } + // Initialize native structure fields. Should be called once after allocated. + init(type, destructor) { + this.set_adjusted_ptr(0); + this.set_type(type); + this.set_destructor(destructor); + } + set_adjusted_ptr(adjustedPtr) { + HEAPU32[(((this.ptr) + (16)) >> 2)] = adjustedPtr; + } + get_adjusted_ptr() { + return HEAPU32[(((this.ptr) + (16)) >> 2)]; + } +} + +var exceptionLast = 0; + +var uncaughtExceptionCount = 0; + +var ___cxa_throw = (ptr, type, destructor) => { + var info = new ExceptionInfo(ptr); + // Initialize ExceptionInfo content after it was allocated in __cxa_allocate_exception. + info.init(type, destructor); + exceptionLast = ptr; + uncaughtExceptionCount++; + throw exceptionLast; +}; + +var __abort_js = () => abort(""); + +var structRegistrations = {}; + +var runDestructors = destructors => { + while (destructors.length) { + var ptr = destructors.pop(); + var del = destructors.pop(); + del(ptr); + } +}; + +/** @suppress {globalThis} */ function readPointer(pointer) { + return this.fromWireType(HEAPU32[((pointer) >> 2)]); +} + +var awaitingDependencies = {}; + +var registeredTypes = {}; + +var typeDependencies = {}; + +var InternalError = class InternalError extends Error { + constructor(message) { + super(message); + this.name = "InternalError"; + } +}; + +var throwInternalError = message => { + throw new InternalError(message); +}; + +var whenDependentTypesAreResolved = (myTypes, dependentTypes, getTypeConverters) => { + myTypes.forEach(type => typeDependencies[type] = dependentTypes); + function onComplete(typeConverters) { + var myTypeConverters = getTypeConverters(typeConverters); + if (myTypeConverters.length !== myTypes.length) { + throwInternalError("Mismatched type converter count"); + } + for (var i = 0; i < myTypes.length; ++i) { + registerType(myTypes[i], myTypeConverters[i]); + } + } + var typeConverters = new Array(dependentTypes.length); + var unregisteredTypes = []; + var registered = 0; + dependentTypes.forEach((dt, i) => { + if (registeredTypes.hasOwnProperty(dt)) { + typeConverters[i] = registeredTypes[dt]; + } else { + unregisteredTypes.push(dt); + if (!awaitingDependencies.hasOwnProperty(dt)) { + awaitingDependencies[dt] = []; + } + awaitingDependencies[dt].push(() => { + typeConverters[i] = registeredTypes[dt]; + ++registered; + if (registered === unregisteredTypes.length) { + onComplete(typeConverters); + } + }); + } + }); + if (0 === unregisteredTypes.length) { + onComplete(typeConverters); + } +}; + +var __embind_finalize_value_object = structType => { + var reg = structRegistrations[structType]; + delete structRegistrations[structType]; + var rawConstructor = reg.rawConstructor; + var rawDestructor = reg.rawDestructor; + var fieldRecords = reg.fields; + var fieldTypes = fieldRecords.map(field => field.getterReturnType).concat(fieldRecords.map(field => field.setterArgumentType)); + whenDependentTypesAreResolved([ structType ], fieldTypes, fieldTypes => { + var fields = {}; + fieldRecords.forEach((field, i) => { + var fieldName = field.fieldName; + var getterReturnType = fieldTypes[i]; + var optional = fieldTypes[i].optional; + var getter = field.getter; + var getterContext = field.getterContext; + var setterArgumentType = fieldTypes[i + fieldRecords.length]; + var setter = field.setter; + var setterContext = field.setterContext; + fields[fieldName] = { + read: ptr => getterReturnType.fromWireType(getter(getterContext, ptr)), + write: (ptr, o) => { + var destructors = []; + setter(setterContext, ptr, setterArgumentType.toWireType(destructors, o)); + runDestructors(destructors); + }, + optional + }; + }); + return [ { + name: reg.name, + fromWireType: ptr => { + var rv = {}; + for (var i in fields) { + rv[i] = fields[i].read(ptr); + } + rawDestructor(ptr); + return rv; + }, + toWireType: (destructors, o) => { + // todo: Here we have an opportunity for -O3 level "unsafe" optimizations: + // assume all fields are present without checking. + for (var fieldName in fields) { + if (!(fieldName in o) && !fields[fieldName].optional) { + throw new TypeError(`Missing field: "${fieldName}"`); + } + } + var ptr = rawConstructor(); + for (fieldName in fields) { + fields[fieldName].write(ptr, o[fieldName]); + } + if (destructors !== null) { + destructors.push(rawDestructor, ptr); + } + return ptr; + }, + readValueFromPointer: readPointer, + destructorFunction: rawDestructor + } ]; + }); +}; + +var AsciiToString = ptr => { + var str = ""; + while (1) { + var ch = HEAPU8[ptr++]; + if (!ch) return str; + str += String.fromCharCode(ch); + } +}; + +var BindingError = class BindingError extends Error { + constructor(message) { + super(message); + this.name = "BindingError"; + } +}; + +var throwBindingError = message => { + throw new BindingError(message); +}; + +/** @param {Object=} options */ function sharedRegisterType(rawType, registeredInstance, options = {}) { + var name = registeredInstance.name; + if (!rawType) { + throwBindingError(`type "${name}" must have a positive integer typeid pointer`); + } + if (registeredTypes.hasOwnProperty(rawType)) { + if (options.ignoreDuplicateRegistrations) { + return; + } else { + throwBindingError(`Cannot register type '${name}' twice`); + } + } + registeredTypes[rawType] = registeredInstance; + delete typeDependencies[rawType]; + if (awaitingDependencies.hasOwnProperty(rawType)) { + var callbacks = awaitingDependencies[rawType]; + delete awaitingDependencies[rawType]; + callbacks.forEach(cb => cb()); + } +} + +/** @param {Object=} options */ function registerType(rawType, registeredInstance, options = {}) { + return sharedRegisterType(rawType, registeredInstance, options); +} + +var integerReadValueFromPointer = (name, width, signed) => { + // integers are quite common, so generate very specialized functions + switch (width) { + case 1: + return signed ? pointer => HEAP8[pointer] : pointer => HEAPU8[pointer]; + + case 2: + return signed ? pointer => HEAP16[((pointer) >> 1)] : pointer => HEAPU16[((pointer) >> 1)]; + + case 4: + return signed ? pointer => HEAP32[((pointer) >> 2)] : pointer => HEAPU32[((pointer) >> 2)]; + + case 8: + return signed ? pointer => HEAP64[((pointer) >> 3)] : pointer => HEAPU64[((pointer) >> 3)]; + + default: + throw new TypeError(`invalid integer width (${width}): ${name}`); + } +}; + +/** @suppress {globalThis} */ var __embind_register_bigint = (primitiveType, name, size, minRange, maxRange) => { + name = AsciiToString(name); + const isUnsignedType = minRange === 0n; + let fromWireType = value => value; + if (isUnsignedType) { + // uint64 get converted to int64 in ABI, fix them up like we do for 32-bit integers. + const bitSize = size * 8; + fromWireType = value => BigInt.asUintN(bitSize, value); + maxRange = fromWireType(maxRange); + } + registerType(primitiveType, { + name, + fromWireType, + toWireType: (destructors, value) => { + if (typeof value == "number") { + value = BigInt(value); + } + return value; + }, + readValueFromPointer: integerReadValueFromPointer(name, size, !isUnsignedType), + destructorFunction: null + }); +}; + +/** @suppress {globalThis} */ var __embind_register_bool = (rawType, name, trueValue, falseValue) => { + name = AsciiToString(name); + registerType(rawType, { + name, + fromWireType: function(wt) { + // ambiguous emscripten ABI: sometimes return values are + // true or false, and sometimes integers (0 or 1) + return !!wt; + }, + toWireType: function(destructors, o) { + return o ? trueValue : falseValue; + }, + readValueFromPointer: function(pointer) { + return this.fromWireType(HEAPU8[pointer]); + }, + destructorFunction: null + }); +}; + +var emval_freelist = []; + +var emval_handles = [ 0, 1, , 1, null, 1, true, 1, false, 1 ]; + +var __emval_decref = handle => { + if (handle > 9 && 0 === --emval_handles[handle + 1]) { + emval_handles[handle] = undefined; + emval_freelist.push(handle); + } +}; + +var Emval = { + toValue: handle => { + if (!handle) { + throwBindingError(`Cannot use deleted val. handle = ${handle}`); + } + return emval_handles[handle]; + }, + toHandle: value => { + switch (value) { + case undefined: + return 2; + + case null: + return 4; + + case true: + return 6; + + case false: + return 8; + + default: + { + const handle = emval_freelist.pop() || emval_handles.length; + emval_handles[handle] = value; + emval_handles[handle + 1] = 1; + return handle; + } + } + } +}; + +var EmValType = { + name: "emscripten::val", + fromWireType: handle => { + var rv = Emval.toValue(handle); + __emval_decref(handle); + return rv; + }, + toWireType: (destructors, value) => Emval.toHandle(value), + readValueFromPointer: readPointer, + destructorFunction: null +}; + +var __embind_register_emval = rawType => registerType(rawType, EmValType); + +var floatReadValueFromPointer = (name, width) => { + switch (width) { + case 4: + return function(pointer) { + return this.fromWireType(HEAPF32[((pointer) >> 2)]); + }; + + case 8: + return function(pointer) { + return this.fromWireType(HEAPF64[((pointer) >> 3)]); + }; + + default: + throw new TypeError(`invalid float width (${width}): ${name}`); + } +}; + +var __embind_register_float = (rawType, name, size) => { + name = AsciiToString(name); + registerType(rawType, { + name, + fromWireType: value => value, + toWireType: (destructors, value) => value, + readValueFromPointer: floatReadValueFromPointer(name, size), + destructorFunction: null + }); +}; + +var createNamedFunction = (name, func) => Object.defineProperty(func, "name", { + value: name +}); + +function usesDestructorStack(argTypes) { + // Skip return value at index 0 - it's not deleted here. + for (var i = 1; i < argTypes.length; ++i) { + // The type does not define a destructor function - must use dynamic stack + if (argTypes[i] !== null && argTypes[i].destructorFunction === undefined) { + return true; + } + } + return false; +} + +function createJsInvoker(argTypes, isClassMethodFunc, returns, isAsync) { + var needsDestructorStack = usesDestructorStack(argTypes); + var argCount = argTypes.length - 2; + var argsList = []; + var argsListWired = [ "fn" ]; + if (isClassMethodFunc) { + argsListWired.push("thisWired"); + } + for (var i = 0; i < argCount; ++i) { + argsList.push(`arg${i}`); + argsListWired.push(`arg${i}Wired`); + } + argsList = argsList.join(","); + argsListWired = argsListWired.join(","); + var invokerFnBody = `return function (${argsList}) {\n`; + if (needsDestructorStack) { + invokerFnBody += "var destructors = [];\n"; + } + var dtorStack = needsDestructorStack ? "destructors" : "null"; + var args1 = [ "humanName", "throwBindingError", "invoker", "fn", "runDestructors", "fromRetWire", "toClassParamWire" ]; + if (isClassMethodFunc) { + invokerFnBody += `var thisWired = toClassParamWire(${dtorStack}, this);\n`; + } + for (var i = 0; i < argCount; ++i) { + var argName = `toArg${i}Wire`; + invokerFnBody += `var arg${i}Wired = ${argName}(${dtorStack}, arg${i});\n`; + args1.push(argName); + } + invokerFnBody += (returns || isAsync ? "var rv = " : "") + `invoker(${argsListWired});\n`; + if (needsDestructorStack) { + invokerFnBody += "runDestructors(destructors);\n"; + } else { + for (var i = isClassMethodFunc ? 1 : 2; i < argTypes.length; ++i) { + // Skip return value at index 0 - it's not deleted here. Also skip class type if not a method. + var paramName = (i === 1 ? "thisWired" : ("arg" + (i - 2) + "Wired")); + if (argTypes[i].destructorFunction !== null) { + invokerFnBody += `${paramName}_dtor(${paramName});\n`; + args1.push(`${paramName}_dtor`); + } + } + } + if (returns) { + invokerFnBody += "var ret = fromRetWire(rv);\n" + "return ret;\n"; + } else {} + invokerFnBody += "}\n"; + return new Function(args1, invokerFnBody); +} + +function craftInvokerFunction(humanName, argTypes, classType, cppInvokerFunc, cppTargetFunc, /** boolean= */ isAsync) { + // humanName: a human-readable string name for the function to be generated. + // argTypes: An array that contains the embind type objects for all types in the function signature. + // argTypes[0] is the type object for the function return value. + // argTypes[1] is the type object for function this object/class type, or null if not crafting an invoker for a class method. + // argTypes[2...] are the actual function parameters. + // classType: The embind type object for the class to be bound, or null if this is not a method of a class. + // cppInvokerFunc: JS Function object to the C++-side function that interops into C++ code. + // cppTargetFunc: Function pointer (an integer to FUNCTION_TABLE) to the target C++ function the cppInvokerFunc will end up calling. + // isAsync: Optional. If true, returns an async function. Async bindings are only supported with JSPI. + var argCount = argTypes.length; + if (argCount < 2) { + throwBindingError("argTypes array size mismatch! Must at least get return value and 'this' types!"); + } + var isClassMethodFunc = (argTypes[1] !== null && classType !== null); + // Free functions with signature "void function()" do not need an invoker that marshalls between wire types. + // TODO: This omits argument count check - enable only at -O3 or similar. + // if (ENABLE_UNSAFE_OPTS && argCount == 2 && argTypes[0].name == "void" && !isClassMethodFunc) { + // return FUNCTION_TABLE[fn]; + // } + // Determine if we need to use a dynamic stack to store the destructors for the function parameters. + // TODO: Remove this completely once all function invokers are being dynamically generated. + var needsDestructorStack = usesDestructorStack(argTypes); + var returns = !argTypes[0].isVoid; + // Builld the arguments that will be passed into the closure around the invoker + // function. + var retType = argTypes[0]; + var instType = argTypes[1]; + var closureArgs = [ humanName, throwBindingError, cppInvokerFunc, cppTargetFunc, runDestructors, retType.fromWireType.bind(retType), instType?.toWireType.bind(instType) ]; + for (var i = 2; i < argCount; ++i) { + var argType = argTypes[i]; + closureArgs.push(argType.toWireType.bind(argType)); + } + if (!needsDestructorStack) { + // Skip return value at index 0 - it's not deleted here. Also skip class type if not a method. + for (var i = isClassMethodFunc ? 1 : 2; i < argTypes.length; ++i) { + if (argTypes[i].destructorFunction !== null) { + closureArgs.push(argTypes[i].destructorFunction); + } + } + } + let invokerFactory = createJsInvoker(argTypes, isClassMethodFunc, returns, isAsync); + var invokerFn = invokerFactory(...closureArgs); + return createNamedFunction(humanName, invokerFn); +} + +var ensureOverloadTable = (proto, methodName, humanName) => { + if (undefined === proto[methodName].overloadTable) { + var prevFunc = proto[methodName]; + // Inject an overload resolver function that routes to the appropriate overload based on the number of arguments. + proto[methodName] = function(...args) { + // TODO This check can be removed in -O3 level "unsafe" optimizations. + if (!proto[methodName].overloadTable.hasOwnProperty(args.length)) { + throwBindingError(`Function '${humanName}' called with an invalid number of arguments (${args.length}) - expects one of (${proto[methodName].overloadTable})!`); + } + return proto[methodName].overloadTable[args.length].apply(this, args); + }; + // Move the previous function into the overload table. + proto[methodName].overloadTable = []; + proto[methodName].overloadTable[prevFunc.argCount] = prevFunc; + } +}; + +/** @param {number=} numArguments */ var exposePublicSymbol = (name, value, numArguments) => { + if (Module.hasOwnProperty(name)) { + if (undefined === numArguments || (undefined !== Module[name].overloadTable && undefined !== Module[name].overloadTable[numArguments])) { + throwBindingError(`Cannot register public name '${name}' twice`); + } + // We are exposing a function with the same name as an existing function. Create an overload table and a function selector + // that routes between the two. + ensureOverloadTable(Module, name, name); + if (Module[name].overloadTable.hasOwnProperty(numArguments)) { + throwBindingError(`Cannot register multiple overloads of a function with the same number of arguments (${numArguments})!`); + } + // Add the new function into the overload table. + Module[name].overloadTable[numArguments] = value; + } else { + Module[name] = value; + Module[name].argCount = numArguments; + } +}; + +var heap32VectorToArray = (count, firstElement) => { + var array = []; + for (var i = 0; i < count; i++) { + // TODO(https://github.com/emscripten-core/emscripten/issues/17310): + // Find a way to hoist the `>> 2` or `>> 3` out of this loop. + array.push(HEAPU32[(((firstElement) + (i * 4)) >> 2)]); + } + return array; +}; + +/** @param {number=} numArguments */ var replacePublicSymbol = (name, value, numArguments) => { + if (!Module.hasOwnProperty(name)) { + throwInternalError("Replacing nonexistent public symbol"); + } + // If there's an overload table for this symbol, replace the symbol in the overload table instead. + if (undefined !== Module[name].overloadTable && undefined !== numArguments) { + Module[name].overloadTable[numArguments] = value; + } else { + Module[name] = value; + Module[name].argCount = numArguments; + } +}; + +var wasmTableMirror = []; + +/** @type {WebAssembly.Table} */ var wasmTable; + +var getWasmTableEntry = funcPtr => { + var func = wasmTableMirror[funcPtr]; + if (!func) { + /** @suppress {checkTypes} */ wasmTableMirror[funcPtr] = func = wasmTable.get(funcPtr); + } + return func; +}; + +var embind__requireFunction = (signature, rawFunction, isAsync = false) => { + signature = AsciiToString(signature); + function makeDynCaller() { + var rtn = getWasmTableEntry(rawFunction); + return rtn; + } + var fp = makeDynCaller(); + if (typeof fp != "function") { + throwBindingError(`unknown function pointer with signature ${signature}: ${rawFunction}`); + } + return fp; +}; + +class UnboundTypeError extends Error {} + +var getTypeName = type => { + var ptr = ___getTypeName(type); + var rv = AsciiToString(ptr); + _free(ptr); + return rv; +}; + +var throwUnboundTypeError = (message, types) => { + var unboundTypes = []; + var seen = {}; + function visit(type) { + if (seen[type]) { + return; + } + if (registeredTypes[type]) { + return; + } + if (typeDependencies[type]) { + typeDependencies[type].forEach(visit); + return; + } + unboundTypes.push(type); + seen[type] = true; + } + types.forEach(visit); + throw new UnboundTypeError(`${message}: ` + unboundTypes.map(getTypeName).join([ ", " ])); +}; + +var getFunctionName = signature => { + signature = signature.trim(); + const argsIndex = signature.indexOf("("); + if (argsIndex === -1) return signature; + return signature.slice(0, argsIndex); +}; + +var __embind_register_function = (name, argCount, rawArgTypesAddr, signature, rawInvoker, fn, isAsync, isNonnullReturn) => { + var argTypes = heap32VectorToArray(argCount, rawArgTypesAddr); + name = AsciiToString(name); + name = getFunctionName(name); + rawInvoker = embind__requireFunction(signature, rawInvoker, isAsync); + exposePublicSymbol(name, function() { + throwUnboundTypeError(`Cannot call ${name} due to unbound types`, argTypes); + }, argCount - 1); + whenDependentTypesAreResolved([], argTypes, argTypes => { + var invokerArgsArray = [ argTypes[0], null ].concat(argTypes.slice(1)); + replacePublicSymbol(name, craftInvokerFunction(name, invokerArgsArray, null, rawInvoker, fn, isAsync), argCount - 1); + return []; + }); +}; + +/** @suppress {globalThis} */ var __embind_register_integer = (primitiveType, name, size, minRange, maxRange) => { + name = AsciiToString(name); + const isUnsignedType = minRange === 0; + let fromWireType = value => value; + if (isUnsignedType) { + var bitshift = 32 - 8 * size; + fromWireType = value => (value << bitshift) >>> bitshift; + maxRange = fromWireType(maxRange); + } + registerType(primitiveType, { + name, + fromWireType, + toWireType: (destructors, value) => value, + readValueFromPointer: integerReadValueFromPointer(name, size, minRange !== 0), + destructorFunction: null + }); +}; + +var __embind_register_memory_view = (rawType, dataTypeIndex, name) => { + var typeMapping = [ Int8Array, Uint8Array, Int16Array, Uint16Array, Int32Array, Uint32Array, Float32Array, Float64Array, BigInt64Array, BigUint64Array ]; + var TA = typeMapping[dataTypeIndex]; + function decodeMemoryView(handle) { + var size = HEAPU32[((handle) >> 2)]; + var data = HEAPU32[(((handle) + (4)) >> 2)]; + return new TA(HEAP8.buffer, data, size); + } + name = AsciiToString(name); + registerType(rawType, { + name, + fromWireType: decodeMemoryView, + readValueFromPointer: decodeMemoryView + }, { + ignoreDuplicateRegistrations: true + }); +}; + +var stringToUTF8Array = (str, heap, outIdx, maxBytesToWrite) => { + // Parameter maxBytesToWrite is not optional. Negative values, 0, null, + // undefined and false each don't write out any bytes. + if (!(maxBytesToWrite > 0)) return 0; + var startIdx = outIdx; + var endIdx = outIdx + maxBytesToWrite - 1; + // -1 for string null terminator. + for (var i = 0; i < str.length; ++i) { + // For UTF8 byte structure, see http://en.wikipedia.org/wiki/UTF-8#Description + // and https://www.ietf.org/rfc/rfc2279.txt + // and https://tools.ietf.org/html/rfc3629 + var u = str.codePointAt(i); + if (u <= 127) { + if (outIdx >= endIdx) break; + heap[outIdx++] = u; + } else if (u <= 2047) { + if (outIdx + 1 >= endIdx) break; + heap[outIdx++] = 192 | (u >> 6); + heap[outIdx++] = 128 | (u & 63); + } else if (u <= 65535) { + if (outIdx + 2 >= endIdx) break; + heap[outIdx++] = 224 | (u >> 12); + heap[outIdx++] = 128 | ((u >> 6) & 63); + heap[outIdx++] = 128 | (u & 63); + } else { + if (outIdx + 3 >= endIdx) break; + heap[outIdx++] = 240 | (u >> 18); + heap[outIdx++] = 128 | ((u >> 12) & 63); + heap[outIdx++] = 128 | ((u >> 6) & 63); + heap[outIdx++] = 128 | (u & 63); + // Gotcha: if codePoint is over 0xFFFF, it is represented as a surrogate pair in UTF-16. + // We need to manually skip over the second code unit for correct iteration. + i++; + } + } + // Null-terminate the pointer to the buffer. + heap[outIdx] = 0; + return outIdx - startIdx; +}; + +var stringToUTF8 = (str, outPtr, maxBytesToWrite) => stringToUTF8Array(str, HEAPU8, outPtr, maxBytesToWrite); + +var lengthBytesUTF8 = str => { + var len = 0; + for (var i = 0; i < str.length; ++i) { + // Gotcha: charCodeAt returns a 16-bit word that is a UTF-16 encoded code + // unit, not a Unicode code point of the character! So decode + // UTF16->UTF32->UTF8. + // See http://unicode.org/faq/utf_bom.html#utf16-3 + var c = str.charCodeAt(i); + // possibly a lead surrogate + if (c <= 127) { + len++; + } else if (c <= 2047) { + len += 2; + } else if (c >= 55296 && c <= 57343) { + len += 4; + ++i; + } else { + len += 3; + } + } + return len; +}; + +var UTF8Decoder = typeof TextDecoder != "undefined" ? new TextDecoder : undefined; + +var findStringEnd = (heapOrArray, idx, maxBytesToRead, ignoreNul) => { + var maxIdx = idx + maxBytesToRead; + if (ignoreNul) return maxIdx; + // TextDecoder needs to know the byte length in advance, it doesn't stop on + // null terminator by itself. + // As a tiny code save trick, compare idx against maxIdx using a negation, + // so that maxBytesToRead=undefined/NaN means Infinity. + while (heapOrArray[idx] && !(idx >= maxIdx)) ++idx; + return idx; +}; + +/** + * Given a pointer 'idx' to a null-terminated UTF8-encoded string in the given + * array that contains uint8 values, returns a copy of that string as a + * Javascript String object. + * heapOrArray is either a regular array, or a JavaScript typed array view. + * @param {number=} idx + * @param {number=} maxBytesToRead + * @param {boolean=} ignoreNul - If true, the function will not stop on a NUL character. + * @return {string} + */ var UTF8ArrayToString = (heapOrArray, idx = 0, maxBytesToRead, ignoreNul) => { + var endPtr = findStringEnd(heapOrArray, idx, maxBytesToRead, ignoreNul); + // When using conditional TextDecoder, skip it for short strings as the overhead of the native call is not worth it. + if (endPtr - idx > 16 && heapOrArray.buffer && UTF8Decoder) { + return UTF8Decoder.decode(heapOrArray.subarray(idx, endPtr)); + } + var str = ""; + // If building with TextDecoder, we have already computed the string length + // above, so test loop end condition against that + while (idx < endPtr) { + // For UTF8 byte structure, see: + // http://en.wikipedia.org/wiki/UTF-8#Description + // https://www.ietf.org/rfc/rfc2279.txt + // https://tools.ietf.org/html/rfc3629 + var u0 = heapOrArray[idx++]; + if (!(u0 & 128)) { + str += String.fromCharCode(u0); + continue; + } + var u1 = heapOrArray[idx++] & 63; + if ((u0 & 224) == 192) { + str += String.fromCharCode(((u0 & 31) << 6) | u1); + continue; + } + var u2 = heapOrArray[idx++] & 63; + if ((u0 & 240) == 224) { + u0 = ((u0 & 15) << 12) | (u1 << 6) | u2; + } else { + u0 = ((u0 & 7) << 18) | (u1 << 12) | (u2 << 6) | (heapOrArray[idx++] & 63); + } + if (u0 < 65536) { + str += String.fromCharCode(u0); + } else { + var ch = u0 - 65536; + str += String.fromCharCode(55296 | (ch >> 10), 56320 | (ch & 1023)); + } + } + return str; +}; + +/** + * Given a pointer 'ptr' to a null-terminated UTF8-encoded string in the + * emscripten HEAP, returns a copy of that string as a Javascript String object. + * + * @param {number} ptr + * @param {number=} maxBytesToRead - An optional length that specifies the + * maximum number of bytes to read. You can omit this parameter to scan the + * string until the first 0 byte. If maxBytesToRead is passed, and the string + * at [ptr, ptr+maxBytesToReadr[ contains a null byte in the middle, then the + * string will cut short at that byte index. + * @param {boolean=} ignoreNul - If true, the function will not stop on a NUL character. + * @return {string} + */ var UTF8ToString = (ptr, maxBytesToRead, ignoreNul) => ptr ? UTF8ArrayToString(HEAPU8, ptr, maxBytesToRead, ignoreNul) : ""; + +var __embind_register_std_string = (rawType, name) => { + name = AsciiToString(name); + var stdStringIsUTF8 = true; + registerType(rawType, { + name, + // For some method names we use string keys here since they are part of + // the public/external API and/or used by the runtime-generated code. + fromWireType(value) { + var length = HEAPU32[((value) >> 2)]; + var payload = value + 4; + var str; + if (stdStringIsUTF8) { + str = UTF8ToString(payload, length, true); + } else { + str = ""; + for (var i = 0; i < length; ++i) { + str += String.fromCharCode(HEAPU8[payload + i]); + } + } + _free(value); + return str; + }, + toWireType(destructors, value) { + if (value instanceof ArrayBuffer) { + value = new Uint8Array(value); + } + var length; + var valueIsOfTypeString = (typeof value == "string"); + // We accept `string` or array views with single byte elements + if (!(valueIsOfTypeString || (ArrayBuffer.isView(value) && value.BYTES_PER_ELEMENT == 1))) { + throwBindingError("Cannot pass non-string to std::string"); + } + if (stdStringIsUTF8 && valueIsOfTypeString) { + length = lengthBytesUTF8(value); + } else { + length = value.length; + } + // assumes POINTER_SIZE alignment + var base = _malloc(4 + length + 1); + var ptr = base + 4; + HEAPU32[((base) >> 2)] = length; + if (valueIsOfTypeString) { + if (stdStringIsUTF8) { + stringToUTF8(value, ptr, length + 1); + } else { + for (var i = 0; i < length; ++i) { + var charCode = value.charCodeAt(i); + if (charCode > 255) { + _free(base); + throwBindingError("String has UTF-16 code units that do not fit in 8 bits"); + } + HEAPU8[ptr + i] = charCode; + } + } + } else { + HEAPU8.set(value, ptr); + } + if (destructors !== null) { + destructors.push(_free, base); + } + return base; + }, + readValueFromPointer: readPointer, + destructorFunction(ptr) { + _free(ptr); + } + }); +}; + +var UTF16Decoder = typeof TextDecoder != "undefined" ? new TextDecoder("utf-16le") : undefined; + +var UTF16ToString = (ptr, maxBytesToRead, ignoreNul) => { + var idx = ((ptr) >> 1); + var endIdx = findStringEnd(HEAPU16, idx, maxBytesToRead / 2, ignoreNul); + // When using conditional TextDecoder, skip it for short strings as the overhead of the native call is not worth it. + if (endIdx - idx > 16 && UTF16Decoder) return UTF16Decoder.decode(HEAPU16.subarray(idx, endIdx)); + // Fallback: decode without UTF16Decoder + var str = ""; + // If maxBytesToRead is not passed explicitly, it will be undefined, and the + // for-loop's condition will always evaluate to true. The loop is then + // terminated on the first null char. + for (var i = idx; // If building with TextDecoder, we have already computed the string length + // above, so test loop end condition against that + i < endIdx; ++i) { + var codeUnit = HEAPU16[i]; + // fromCharCode constructs a character from a UTF-16 code unit, so we can + // pass the UTF16 string right through. + str += String.fromCharCode(codeUnit); + } + return str; +}; + +var stringToUTF16 = (str, outPtr, maxBytesToWrite) => { + // Backwards compatibility: if max bytes is not specified, assume unsafe unbounded write is allowed. + maxBytesToWrite ??= 2147483647; + if (maxBytesToWrite < 2) return 0; + maxBytesToWrite -= 2; + // Null terminator. + var startPtr = outPtr; + var numCharsToWrite = (maxBytesToWrite < str.length * 2) ? (maxBytesToWrite / 2) : str.length; + for (var i = 0; i < numCharsToWrite; ++i) { + // charCodeAt returns a UTF-16 encoded code unit, so it can be directly written to the HEAP. + var codeUnit = str.charCodeAt(i); + // possibly a lead surrogate + HEAP16[((outPtr) >> 1)] = codeUnit; + outPtr += 2; + } + // Null-terminate the pointer to the HEAP. + HEAP16[((outPtr) >> 1)] = 0; + return outPtr - startPtr; +}; + +var lengthBytesUTF16 = str => str.length * 2; + +var UTF32ToString = (ptr, maxBytesToRead, ignoreNul) => { + var str = ""; + var startIdx = ((ptr) >> 2); + // If maxBytesToRead is not passed explicitly, it will be undefined, and this + // will always evaluate to true. This saves on code size. + for (var i = 0; !(i >= maxBytesToRead / 4); i++) { + var utf32 = HEAPU32[startIdx + i]; + if (!utf32 && !ignoreNul) break; + str += String.fromCodePoint(utf32); + } + return str; +}; + +var stringToUTF32 = (str, outPtr, maxBytesToWrite) => { + // Backwards compatibility: if max bytes is not specified, assume unsafe unbounded write is allowed. + maxBytesToWrite ??= 2147483647; + if (maxBytesToWrite < 4) return 0; + var startPtr = outPtr; + var endPtr = startPtr + maxBytesToWrite - 4; + for (var i = 0; i < str.length; ++i) { + var codePoint = str.codePointAt(i); + // Gotcha: if codePoint is over 0xFFFF, it is represented as a surrogate pair in UTF-16. + // We need to manually skip over the second code unit for correct iteration. + if (codePoint > 65535) { + i++; + } + HEAP32[((outPtr) >> 2)] = codePoint; + outPtr += 4; + if (outPtr + 4 > endPtr) break; + } + // Null-terminate the pointer to the HEAP. + HEAP32[((outPtr) >> 2)] = 0; + return outPtr - startPtr; +}; + +var lengthBytesUTF32 = str => { + var len = 0; + for (var i = 0; i < str.length; ++i) { + var codePoint = str.codePointAt(i); + // Gotcha: if codePoint is over 0xFFFF, it is represented as a surrogate pair in UTF-16. + // We need to manually skip over the second code unit for correct iteration. + if (codePoint > 65535) { + i++; + } + len += 4; + } + return len; +}; + +var __embind_register_std_wstring = (rawType, charSize, name) => { + name = AsciiToString(name); + var decodeString, encodeString, lengthBytesUTF; + if (charSize === 2) { + decodeString = UTF16ToString; + encodeString = stringToUTF16; + lengthBytesUTF = lengthBytesUTF16; + } else { + decodeString = UTF32ToString; + encodeString = stringToUTF32; + lengthBytesUTF = lengthBytesUTF32; + } + registerType(rawType, { + name, + fromWireType: value => { + // Code mostly taken from _embind_register_std_string fromWireType + var length = HEAPU32[((value) >> 2)]; + var str = decodeString(value + 4, length * charSize, true); + _free(value); + return str; + }, + toWireType: (destructors, value) => { + if (!(typeof value == "string")) { + throwBindingError(`Cannot pass non-string to C++ string type ${name}`); + } + // assumes POINTER_SIZE alignment + var length = lengthBytesUTF(value); + var ptr = _malloc(4 + length + charSize); + HEAPU32[((ptr) >> 2)] = length / charSize; + encodeString(value, ptr + 4, length + charSize); + if (destructors !== null) { + destructors.push(_free, ptr); + } + return ptr; + }, + readValueFromPointer: readPointer, + destructorFunction(ptr) { + _free(ptr); + } + }); +}; + +var __embind_register_value_object = (rawType, name, constructorSignature, rawConstructor, destructorSignature, rawDestructor) => { + structRegistrations[rawType] = { + name: AsciiToString(name), + rawConstructor: embind__requireFunction(constructorSignature, rawConstructor), + rawDestructor: embind__requireFunction(destructorSignature, rawDestructor), + fields: [] + }; +}; + +var __embind_register_value_object_field = (structType, fieldName, getterReturnType, getterSignature, getter, getterContext, setterArgumentType, setterSignature, setter, setterContext) => { + structRegistrations[structType].fields.push({ + fieldName: AsciiToString(fieldName), + getterReturnType, + getter: embind__requireFunction(getterSignature, getter), + getterContext, + setterArgumentType, + setter: embind__requireFunction(setterSignature, setter), + setterContext + }); +}; + +var __embind_register_void = (rawType, name) => { + name = AsciiToString(name); + registerType(rawType, { + isVoid: true, + // void return values can be optimized out sometimes + name, + fromWireType: () => undefined, + // TODO: assert if anything else is given? + toWireType: (destructors, o) => undefined + }); +}; + +var emval_methodCallers = []; + +var emval_addMethodCaller = caller => { + var id = emval_methodCallers.length; + emval_methodCallers.push(caller); + return id; +}; + +var requireRegisteredType = (rawType, humanName) => { + var impl = registeredTypes[rawType]; + if (undefined === impl) { + throwBindingError(`${humanName} has unknown type ${getTypeName(rawType)}`); + } + return impl; +}; + +var emval_lookupTypes = (argCount, argTypes) => { + var a = new Array(argCount); + for (var i = 0; i < argCount; ++i) { + a[i] = requireRegisteredType(HEAPU32[(((argTypes) + (i * 4)) >> 2)], `parameter ${i}`); + } + return a; +}; + +var emval_returnValue = (toReturnWire, destructorsRef, handle) => { + var destructors = []; + var result = toReturnWire(destructors, handle); + if (destructors.length) { + // void, primitives and any other types w/o destructors don't need to allocate a handle + HEAPU32[((destructorsRef) >> 2)] = Emval.toHandle(destructors); + } + return result; +}; + +var emval_symbols = {}; + +var getStringOrSymbol = address => { + var symbol = emval_symbols[address]; + if (symbol === undefined) { + return AsciiToString(address); + } + return symbol; +}; + +var __emval_create_invoker = (argCount, argTypesPtr, kind) => { + var GenericWireTypeSize = 8; + var [retType, ...argTypes] = emval_lookupTypes(argCount, argTypesPtr); + var toReturnWire = retType.toWireType.bind(retType); + var argFromPtr = argTypes.map(type => type.readValueFromPointer.bind(type)); + argCount--; + // remove the extracted return type + var captures = { + "toValue": Emval.toValue + }; + var args = argFromPtr.map((argFromPtr, i) => { + var captureName = `argFromPtr${i}`; + captures[captureName] = argFromPtr; + return `${captureName}(args${i ? "+" + i * GenericWireTypeSize : ""})`; + }); + var functionBody; + switch (kind) { + case 0: + functionBody = "toValue(handle)"; + break; + + case 2: + functionBody = "new (toValue(handle))"; + break; + + case 3: + functionBody = ""; + break; + + case 1: + captures["getStringOrSymbol"] = getStringOrSymbol; + functionBody = "toValue(handle)[getStringOrSymbol(methodName)]"; + break; + } + functionBody += `(${args})`; + if (!retType.isVoid) { + captures["toReturnWire"] = toReturnWire; + captures["emval_returnValue"] = emval_returnValue; + functionBody = `return emval_returnValue(toReturnWire, destructorsRef, ${functionBody})`; + } + functionBody = `return function (handle, methodName, destructorsRef, args) {\n ${functionBody}\n }`; + var invokerFunction = new Function(Object.keys(captures), functionBody)(...Object.values(captures)); + var functionName = `methodCaller<(${argTypes.map(t => t.name)}) => ${retType.name}>`; + return emval_addMethodCaller(createNamedFunction(functionName, invokerFunction)); +}; + +var __emval_get_property = (handle, key) => { + handle = Emval.toValue(handle); + key = Emval.toValue(key); + return Emval.toHandle(handle[key]); +}; + +var __emval_incref = handle => { + if (handle > 9) { + emval_handles[handle + 1] += 1; + } +}; + +var __emval_invoke = (caller, handle, methodName, destructorsRef, args) => emval_methodCallers[caller](handle, methodName, destructorsRef, args); + +var __emval_new_array = () => Emval.toHandle([]); + +var __emval_new_array_from_memory_view = view => { + view = Emval.toValue(view); + // using for..loop is faster than Array.from + var a = new Array(view.length); + for (var i = 0; i < view.length; i++) a[i] = view[i]; + return Emval.toHandle(a); +}; + +var __emval_new_cstring = v => Emval.toHandle(getStringOrSymbol(v)); + +var __emval_run_destructors = handle => { + var destructors = Emval.toValue(handle); + runDestructors(destructors); + __emval_decref(handle); +}; + +var abortOnCannotGrowMemory = requestedSize => { + abort("OOM"); +}; + +var _emscripten_resize_heap = requestedSize => { + var oldSize = HEAPU8.length; + // With CAN_ADDRESS_2GB or MEMORY64, pointers are already unsigned. + requestedSize >>>= 0; + abortOnCannotGrowMemory(requestedSize); +}; + +// End JS library code +// include: postlibrary.js +// This file is included after the automatically-generated JS library code +// but before the wasm module is created. +{ + // Begin ATMODULES hooks + if (Module["noExitRuntime"]) noExitRuntime = Module["noExitRuntime"]; + if (Module["print"]) out = Module["print"]; + if (Module["printErr"]) err = Module["printErr"]; + if (Module["wasmBinary"]) wasmBinary = Module["wasmBinary"]; + // End ATMODULES hooks + if (Module["arguments"]) arguments_ = Module["arguments"]; + if (Module["thisProgram"]) thisProgram = Module["thisProgram"]; +} + +// Begin runtime exports +// End runtime exports +// Begin JS library exports +// End JS library exports +// end include: postlibrary.js +// Imports from the Wasm binary. +var ___getTypeName, _malloc, _free; + +function assignWasmExports(wasmExports) { + ___getTypeName = wasmExports["C"]; + _malloc = wasmExports["D"]; + _free = wasmExports["E"]; +} + +var wasmImports = { + /** @export */ i: ___cxa_throw, + /** @export */ y: __abort_js, + /** @export */ x: __embind_finalize_value_object, + /** @export */ m: __embind_register_bigint, + /** @export */ w: __embind_register_bool, + /** @export */ v: __embind_register_emval, + /** @export */ l: __embind_register_float, + /** @export */ u: __embind_register_function, + /** @export */ b: __embind_register_integer, + /** @export */ a: __embind_register_memory_view, + /** @export */ t: __embind_register_std_string, + /** @export */ h: __embind_register_std_wstring, + /** @export */ s: __embind_register_value_object, + /** @export */ g: __embind_register_value_object_field, + /** @export */ r: __embind_register_void, + /** @export */ f: __emval_create_invoker, + /** @export */ c: __emval_decref, + /** @export */ k: __emval_get_property, + /** @export */ j: __emval_incref, + /** @export */ e: __emval_invoke, + /** @export */ q: __emval_new_array, + /** @export */ p: __emval_new_array_from_memory_view, + /** @export */ o: __emval_new_cstring, + /** @export */ d: __emval_run_destructors, + /** @export */ n: _emscripten_resize_heap +}; + +var wasmExports = await createWasm(); + +// include: postamble.js +// === Auto-generated postamble setup entry stuff === +function run() { + if (runDependencies > 0) { + dependenciesFulfilled = run; + return; + } + preRun(); + // a preRun added a dependency, run will be called later + if (runDependencies > 0) { + dependenciesFulfilled = run; + return; + } + function doRun() { + // run may have just been called through dependencies being fulfilled just in this very frame, + // or while the async setStatus time below was happening + Module["calledRun"] = true; + if (ABORT) return; + initRuntime(); + readyPromiseResolve?.(Module); + Module["onRuntimeInitialized"]?.(); + postRun(); + } + if (Module["setStatus"]) { + Module["setStatus"]("Running..."); + setTimeout(() => { + setTimeout(() => Module["setStatus"](""), 1); + doRun(); + }, 1); + } else { + doRun(); + } +} + +function preInit() { + if (Module["preInit"]) { + if (typeof Module["preInit"] == "function") Module["preInit"] = [ Module["preInit"] ]; + while (Module["preInit"].length > 0) { + Module["preInit"].shift()(); + } + } +} + +preInit(); + +run(); + +// end include: postamble.js +// include: postamble_modularize.js +// In MODULARIZE mode we wrap the generated code in a factory function +// and return either the Module itself, or a promise of the module. +// We assign to the `moduleRtn` global here and configure closure to see +// this as and extern so it won't get minified. +if (runtimeInitialized) { + moduleRtn = Module; +} else { + // Set up the promise that indicates the Module is initialized + moduleRtn = new Promise((resolve, reject) => { + readyPromiseResolve = resolve; + readyPromiseReject = reject; + }); +} + + + return moduleRtn; +} + +// Export using a UMD style export, or ES6 exports if selected +export default Module; + diff --git a/js/worker/transmatrix_wasm.wasm b/js/worker/transmatrix_wasm.wasm new file mode 100644 index 0000000000000000000000000000000000000000..3ab5bac9f61e2dc9170d46c20ba779eefac809bb GIT binary patch literal 100275 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%0A>0XH0p9|)A@_lgAwLG5Kz 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 kHD< +#include +#include +#include +#include +#include +#include + +constexpr const uint16_t Terms[][32] = { + { + 0b0000, + 0b1111, + 0b1100, + 0b1010, + 0b0011, + 0b0101, + 0b0110, + 0b1001 + }, + { + 0b00000000, + 0b11111111, + 0b11110000, + 0b11001100, + 0b10101010, + 0b00001111, + 0b00110011, + 0b01010101, + 0b00111100, + 0b01011010, + 0b01100110, + 0b11000011, + 0b10100101, + 0b10011001, + 0b10010110, + 0b01101001 + }, + { + 0b0000000000000000, + 0b1111111111111111, + 0b1111111100000000, + 0b1111000011110000, + 0b1100110011001100, + 0b1010101010101010, + 0b0000000011111111, + 0b0000111100001111, + 0b0011001100110011, + 0b0101010101010101, + 0b0000111111110000, + 0b0011001111001100, + 0b0101010110101010, + 0b0011110000111100, + 0b0101101001011010, + 0b0110011001100110, + 0b1111000000001111, + 0b1100110000110011, + 0b1010101001010101, + 0b1100001111000011, + 0b1010010110100101, + 0b1001100110011001, + 0b1100001100111100, + 0b1010010101011010, + 0b1001100101100110, + 0b1001011010010110, + 0b0011110011000011, + 0b0101101010100101, + 0b0110011010011001, + 0b0110100101101001, + 0b0110100110010110, + 0b1001011001101001 + } +}; + +constexpr const std::pair Symbols[][32] = { + { + {"0", 0b00000}, + {"1", 0b00001}, + {"a", 0b00010}, + {"b", 0b00100}, + {"¬a", 0b00011}, + {"¬b", 0b00101}, + {"ab", 0b00111}, + {"¬ab", 0b00111} + }, + { + {"0", 0b00000}, + {"1", 0b00001}, + {"a", 0b00010}, + {"b", 0b00100}, + {"c", 0b01000}, + {"¬a", 0b00011}, + {"¬b", 0b00101}, + {"¬c", 0b01001}, + {"ab", 0b00110}, + {"ac", 0b01010}, + {"bc", 0b01100}, + {"¬ab", 0b00111}, + {"¬ac", 0b01011}, + {"¬bc", 0b01101}, + {"abc", 0b01110}, + {"¬abc", 0b01111} + }, + { + {"0", 0b00000}, + {"1", 0b00001}, + {"a", 0b00010}, + {"b", 0b00100}, + {"c", 0b01000}, + {"d", 0b10000}, + {"¬a", 0b00011}, + {"¬b", 0b00101}, + {"¬c", 0b01001}, + {"¬d", 0b10001}, + {"ab", 0b00110}, + {"ac", 0b01010}, + {"ad", 0b10010}, + {"bc", 0b01100}, + {"bd", 0b10100}, + {"cd", 0b11000}, + {"¬ab", 0b00111}, + {"¬ac", 0b01011}, + {"¬ad", 0b10011}, + {"¬bc", 0b01101}, + {"¬bd", 0b10101}, + {"¬cd", 0b11001}, + {"abc", 0b01110}, + {"abd", 0b10110}, + {"acd", 0b11010}, + {"bcd", 0b11100}, + {"¬abc", 0b01111}, + {"¬abd", 0b10111}, + {"¬acd", 0b11011}, + {"¬bcd", 0b11101}, + {"abcd", 0b11110}, + {"¬abcd", 0b11111} + } +}; + +uint16_t negate(uint16_t term, size_t var_count) { + return ~term & ((1 << (1 << var_count)) - 1); +} + +struct Chain { + const Chain* prev; + size_t idx; + uint16_t CACHE_0; + uint16_t CACHE_1; +}; + +uint16_t OR_GATE(Chain* numbers, uint16_t mask) { + if(numbers->prev) { + return numbers->CACHE_0 = numbers->prev->CACHE_0 | mask; + } + return numbers->CACHE_0 = mask; +} + +uint16_t XOR_GATE(Chain* numbers, uint16_t mask) { + if(numbers->prev) { + uint16_t over = numbers->prev->CACHE_1 | (mask & numbers->prev->CACHE_0); + uint16_t encountered = numbers->CACHE_0; + numbers->CACHE_1 = over; + return ~over & encountered; + } + return mask; +} + + + +template +struct inplace_vector { + using value_type = T; + constexpr static size_t size = S; + std::array backing; + size_t _size; + void resize(size_t size) {this->_size = size;} + auto end() {return backing.begin() + this->_size;} + auto cend() const {return backing.cbegin() + this->_size;} + auto begin() {return backing.begin();} + auto cbegin() const {return backing.cbegin();} + T& operator[](std::size_t idx) { return backing[idx]; } + const T& operator[](std::size_t idx) const { return backing[idx]; } +}; + + +struct Solution { + std::string symbol_string; + inplace_vector wire_lamps; +}; + +void identity(const uint16_t* legalTerms, Chain* val, size_t count, std::vector& solutions, uint16_t term, uint16_t neg_term, const std::pair* symbols) { + auto vterm = legalTerms[val->idx]; + if(count == 1) { + if(vterm == term) { + const auto& symbol_pair = symbols[val->idx]; + solutions.emplace_back(Solution { std::string {std::get<0>(symbol_pair) }, { std::get<1>(symbol_pair) } }); + } + } else { + { + auto t = OR_GATE(val, vterm); + if(t == term || t == neg_term) { + Solution& solution = solutions.emplace_back(); + + std::string& symbol_string = solution.symbol_string; + auto& wire_lamps = solution.wire_lamps; + wire_lamps.resize(count); + symbol_string = std::get<0>(symbols[val->idx]); + symbol_string.push_back(')'); + const Chain* current = val->prev; + auto index = count; + wire_lamps[index--] = std::get<1>(symbols[val->idx]); + while(current != nullptr) { + const auto& cterm = symbols[current->idx]; + symbol_string.insert(0, ", "); + symbol_string.insert(0, std::get<0>(cterm)); + wire_lamps[--index] = std::get<1>(cterm); + current = current->prev; + } + symbol_string.insert(0, t == term ? "∨(" : "¬∨("); + } + } + { + auto t = XOR_GATE(val, vterm); + if(t == term || t == neg_term) { + Solution& solution = solutions.emplace_back(); + + std::string& symbol_string = solution.symbol_string; + auto& wire_lamps = solution.wire_lamps; + wire_lamps.resize(count); + symbol_string = std::get<0>(symbols[val->idx]); + symbol_string.push_back(')'); + const Chain* current = val->prev; + auto index = count; + wire_lamps[index--] = std::get<1>(symbols[val->idx]); + while(current != nullptr) { + const auto& cterm = symbols[current->idx]; + symbol_string.insert(0, ", "); + symbol_string.insert(0, std::get<0>(cterm)); + wire_lamps[--index] = std::get<1>(cterm); + current = current->prev; + } + symbol_string.insert(0, t == term ? "⊕(" : "¬⊕("); + } + } + } +} + +Chain chains[242824]; +uint16_t real_legal_terms[32]; + +std::vector makeExpressionsBFS(size_t varCount, size_t maxDepth, uint16_t term, uint16_t mask) { + uint16_t neg_term = negate(term, varCount); + term = term & ~mask; + const auto& legalTerms = Terms[varCount - 2]; + const auto& legalSymbols = Symbols[varCount - 2]; + const size_t num_terms = 2 << varCount; + + Chain* queueTail = chains; + + for (size_t i = 0; i < num_terms; i++) { + real_legal_terms[i] = legalTerms[i] & ~mask; + queueTail->CACHE_0 = real_legal_terms[i]; + queueTail->CACHE_1 = 0; + queueTail->idx = i; + queueTail->prev = nullptr; + queueTail++; + } + + Chain* queueEnd = queueTail; + Chain* queueHead = chains; + + std::vector solutions; + + size_t count = 0; + queueEnd = queueTail; + while (queueHead != queueEnd) { + count++; + while(queueHead != queueEnd) { + Chain* val = queueHead++; + + identity(real_legal_terms, val, count, solutions, term, neg_term, legalSymbols); + + if (count < maxDepth) { + if((val->CACHE_1 & term) && (val->CACHE_1 & neg_term)) { + continue; + } + for (size_t i = val->idx + 1; i < num_terms; i++) { + queueTail->prev = val; + queueTail->idx = i; + queueTail++; + } + } + } + queueEnd = queueTail; + } + return solutions; +} + +EMSCRIPTEN_BINDINGS(my_module) { + emscripten::function("makeExpressionsBFS", &makeExpressionsBFS); + emscripten::value_array("Solution") + .element(&Solution::symbol_string) + .element(&Solution::wire_lamps); +} + +template +inplace_vector inplacevecFromJSArray(const emscripten::val& v, Policies... policies) { + const uint32_t l = v["length"].as(); + + inplace_vector rv; + rv.resize(l); + for (uint32_t i = 0; i < l; ++i) { + rv[i] = v[i].as(std::forward(policies)...); + } + + return rv; +} + +namespace emscripten { +namespace internal { + +template +struct BindingType> { + using ValBinding = BindingType; + using WireType = ValBinding::WireType; + + static WireType toWireType(const std::vector &vec, rvp::default_tag) { + return ValBinding::toWireType(val::array(vec), rvp::default_tag{}); + } + + static std::vector fromWireType(WireType value) { + return vecFromJSArray(ValBinding::fromWireType(value)); + } +}; + +template +struct BindingType> { + using ValBinding = BindingType; + using WireType = ValBinding::WireType; + + static WireType toWireType(const inplace_vector &vec, rvp::default_tag) { + return ValBinding::toWireType(val::array(vec.cbegin(), vec.cend()), rvp::default_tag{}); + } + + static inplace_vector fromWireType(WireType value) { + return inplacevecFromJSArray(ValBinding::fromWireType(value)); + } +}; + +template +struct TypeID< + T, + typename std::enable_if_t::type, + std::vector::type::value_type, + typename Canonicalized::type::allocator_type>>::value>> { + static constexpr TYPEID get() { return TypeID::get(); } +}; + +template +struct TypeID< + T, + typename std::enable_if_t::type, + inplace_vector::type::value_type, Canonicalized::type::size>>::value>> { + static constexpr TYPEID get() { return TypeID::get(); } +}; + +} // namespace internal +} // namespace emscripten \ No newline at end of file diff --git a/js/worker/worker.js b/js/worker/worker.js index 7d8386e..9b2185c 100644 --- a/js/worker/worker.js +++ b/js/worker/worker.js @@ -1,3 +1,4 @@ +import Module from "./worker_wasm.mjs" import { Terms } from "../data/terms.js"; import { Gates, negate } from "../data/gates.js"; import { Dictionary } from "../data/dictionary.js"; @@ -34,29 +35,31 @@ const testfunc = (terms, varCount, val, count, solutions) => { * @param {number} neg_term: The complement of the desired term to reach, in case we can reach it using a negated output * @param {number} mask: a mask taking care of don't cares */ -const identity = (terms, val, count, solutions, term, neg_term, mask) => { +const identity = (terms, val, count, solutions, term, neg_term, mask, symbols) => { let vterm = terms[val.idx]; if (count === 1) { - for (let gate of Gates) { - gate.combine(terms, val); + for(let i = 0; i < Gates.length; i++) { + let gate = Gates[i]; + gate.combine(val, vterm); } - if ((vterm[1] | mask) == term) { - solutions.push([vterm[0], vterm[2]]); + if (vterm == term) { + solutions.push([symbols[val.idx][0], [symbols[val.idx][1]]]); } } else { - for (let gate of Gates) { - const t = gate.combine(terms, val); - const t_m = t | mask; + for(let i = 0; i < Gates.length; i++) { + let gate = Gates[i]; + const t = gate.combine(val, vterm); + const t_m = t; if (t_m == term || t_m == neg_term) { - let symbol_string = vterm[0]; + let symbol_string = symbols[val.idx][0]; let current = val.prev; let wire_lamps = new Array(count); let index = count; - + wire_lamps[--index] = symbols[val.idx][1]; do { - let cterm = terms[current.idx]; + let cterm = symbols[current.idx]; symbol_string = cterm[0] + ", " + symbol_string; - wire_lamps[--index] = cterm[2]; + wire_lamps[--index] = cterm[1]; current = current.prev; } while(current != null); @@ -87,18 +90,23 @@ function makeExpressionsBFS({ mask, callback = identity, }) { - const neg_term = negate(term ^ mask, varCount) | mask; - const legalTerms = Terms[varCount]; - + let legalTerms = Terms[varCount]; + let neg_term; + let symbols; + if(callback == identity) { + neg_term = negate(term, varCount); + term = term ^ mask; + symbols = legalTerms.map(term => [term[0], term[2]]); + legalTerms = legalTerms.map(term => term[1] & ~mask); + } // Initialize the queue with the individual terms. let queue = new Queue(); let next_queue = new Queue(); for(let i = 0; i < legalTerms.length; i++) { next_queue.enqueue({ - XOR_CACHE_O: 0, - XOR_CACHE_E: 0, - AND_CACHE: 0, + CACHE_0: 0, + CACHE_1: 0, prev: null, next: null, idx: i, @@ -117,13 +125,15 @@ function makeExpressionsBFS({ while (!queue.empty()) { let val = queue.dequeue(); - callback(legalTerms, val, count, solutions, term, neg_term, mask); + callback(legalTerms, val, count, solutions, term, neg_term, mask, symbols); if (count < maxDepth) { + if((val.CACHE_1 & term) && (val.CACHE_1 & neg_term)) { + continue; + } for (let i = val.idx + 1; i < legalTerms.length; i++) { next_queue.enqueue({ - XOR_CACHE_O: 0, - XOR_CACHE_E: 0, - AND_CACHE: 0, + CACHE_0: 0, + CACHE_1: 0, prev: val, next: null, idx: i, @@ -136,43 +146,48 @@ function makeExpressionsBFS({ return solutions.length > 0 ? solutions : undefined; } -onmessage = (e) => { +let module = Module({}); +async function wasmWorkerWrapper(varCount, maxDepth, term, mask) { + let results = (await module).makeExpressionsBFS(varCount, maxDepth, term, mask); + if (results.length == 0) { + return undefined; + } + console.log(results); + return results; +} + +onmessage = async (e) => { switch (e.data.action) { case "search": - const maskedDictionary = Dictionary[e.data.varCount - 2].map((a) => [ - a[0] | e.data.mask, - a[1], - ]); - if (maskedDictionary.find((a) => a[0] == e.data.term)) { - const results = makeExpressionsBFS({ - varCount: e.data.varCount, - maxDepth: e.data.maxDepth, - term: e.data.term, - mask: e.data.mask, - }); - postMessage({ action: "result", results: results }); + let results = await wasmWorkerWrapper( + e.data.varCount, e.data.maxDepth, e.data.term, e.data.mask + ); + + if(results != undefined) { + postMessage({ action: "result", results }); } else { - // Preprocessing... - let maskedDictionaryMap = new Map(); - for(let i = 0; i < maskedDictionary.length; i++) { - let [term, complexity] = maskedDictionary[i]; - if(maskedDictionaryMap.has(term)) { - if(complexity < maskedDictionaryMap.get(term)) { - maskedDictionaryMap.set(term, complexity); + let dictionary = Dictionary[e.data.varCount - 2]; + let maskedDictionary = new Map(); + for(let i = 0; i < dictionary.length; i++) { + let dict = dictionary[i]; + let maskedTerm = dict[0] | e.data.mask; + let complexity = dict[1]; + if(maskedDictionary.has(maskedTerm)) { + if(complexity < maskedDictionary.get(maskedTerm)) { + maskedDictionary.set(maskedTerm, complexity); } } else { - maskedDictionaryMap.set(term, complexity); + maskedDictionary.set(maskedTerm, complexity); } } // find the two terms of the shortest combined complexity that, when XOR'ed together, give the searched term let pair = [], min = Infinity; - for (let i = 0; i < maskedDictionary.length; i++) { - let term0 = maskedDictionary[i]; + for (let term0 of maskedDictionary) { let complementary = (e.data.term ^ term0[0]) | e.data.mask; - if(maskedDictionaryMap.has(complementary)) { - let term1Complexity = maskedDictionaryMap.get(complementary); + if(maskedDictionary.has(complementary)) { + let term1Complexity = maskedDictionary.get(complementary); if (term1Complexity + term0[1] < min) { pair = [complementary, term0[0]]; min = term1Complexity + term0[1]; diff --git a/js/worker/worker_wasm.mjs b/js/worker/worker_wasm.mjs new file mode 100644 index 0000000..ccf9d0b --- /dev/null +++ b/js/worker/worker_wasm.mjs @@ -0,0 +1,1788 @@ +// This code implements the `-sMODULARIZE` settings by taking the generated +// JS program code (INNER_JS_CODE) and wrapping it in a factory function. + +// When targetting node and ES6 we use `await import ..` in the generated code +// so the outer function needs to be marked as async. +async function Module(moduleArg = {}) { + var moduleRtn; + +// include: shell.js +// The Module object: Our interface to the outside world. We import +// and export values on it. There are various ways Module can be used: +// 1. Not defined. We create it here +// 2. A function parameter, function(moduleArg) => Promise +// 3. pre-run appended it, var Module = {}; ..generated code.. +// 4. External script tag defines var Module. +// We need to check if Module already exists (e.g. case 3 above). +// Substitution will be replaced with actual code on later stage of the build, +// this way Closure Compiler will not mangle it (e.g. case 4. above). +// Note that if you want to run closure, and also to use Module +// after the generated code, you will need to define var Module = {}; +// before the code. Then that object will be used in the code, and you +// can continue to use Module afterwards as well. +var Module = moduleArg; + +// Determine the runtime environment we are in. You can customize this by +// setting the ENVIRONMENT setting at compile time (see settings.js). +// Attempt to auto-detect the environment +var ENVIRONMENT_IS_WEB = typeof window == "object"; + +var ENVIRONMENT_IS_WORKER = typeof WorkerGlobalScope != "undefined"; + +// N.b. Electron.js environment is simultaneously a NODE-environment, but +// also a web environment. +var ENVIRONMENT_IS_NODE = typeof process == "object" && process.versions?.node && process.type != "renderer"; + +if (ENVIRONMENT_IS_NODE) { + // When building an ES module `require` is not normally available. + // We need to use `createRequire()` to construct the require()` function. + const {createRequire} = await import("module"); + /** @suppress{duplicate} */ var require = createRequire(import.meta.url); +} + +// --pre-jses are emitted after the Module integration code, so that they can +// refer to Module (if they choose; they can also define Module) +var arguments_ = []; + +var thisProgram = "./this.program"; + +var quit_ = (status, toThrow) => { + throw toThrow; +}; + +var _scriptName = import.meta.url; + +// `/` should be present at the end if `scriptDirectory` is not empty +var scriptDirectory = ""; + +function locateFile(path) { + if (Module["locateFile"]) { + return Module["locateFile"](path, scriptDirectory); + } + return scriptDirectory + path; +} + +// Hooks that are implemented differently in different runtime environments. +var readAsync, readBinary; + +if (ENVIRONMENT_IS_NODE) { + // These modules will usually be used on Node.js. Load them eagerly to avoid + // the complexity of lazy-loading. + var fs = require("fs"); + if (_scriptName.startsWith("file:")) { + scriptDirectory = require("path").dirname(require("url").fileURLToPath(_scriptName)) + "/"; + } + // include: node_shell_read.js + readBinary = filename => { + // We need to re-wrap `file://` strings to URLs. + filename = isFileURI(filename) ? new URL(filename) : filename; + var ret = fs.readFileSync(filename); + return ret; + }; + readAsync = async (filename, binary = true) => { + // See the comment in the `readBinary` function. + filename = isFileURI(filename) ? new URL(filename) : filename; + var ret = fs.readFileSync(filename, binary ? undefined : "utf8"); + return ret; + }; + // end include: node_shell_read.js + if (process.argv.length > 1) { + thisProgram = process.argv[1].replace(/\\/g, "/"); + } + arguments_ = process.argv.slice(2); + quit_ = (status, toThrow) => { + process.exitCode = status; + throw toThrow; + }; +} else // Note that this includes Node.js workers when relevant (pthreads is enabled). +// Node.js workers are detected as a combination of ENVIRONMENT_IS_WORKER and +// ENVIRONMENT_IS_NODE. +if (ENVIRONMENT_IS_WEB || ENVIRONMENT_IS_WORKER) { + try { + scriptDirectory = new URL(".", _scriptName).href; + } catch {} + { + // include: web_or_worker_shell_read.js + if (ENVIRONMENT_IS_WORKER) { + readBinary = url => { + var xhr = new XMLHttpRequest; + xhr.open("GET", url, false); + xhr.responseType = "arraybuffer"; + xhr.send(null); + return new Uint8Array(/** @type{!ArrayBuffer} */ (xhr.response)); + }; + } + readAsync = async url => { + // Fetch has some additional restrictions over XHR, like it can't be used on a file:// url. + // See https://github.com/github/fetch/pull/92#issuecomment-140665932 + // Cordova or Electron apps are typically loaded from a file:// url. + // So use XHR on webview if URL is a file URL. + if (isFileURI(url)) { + return new Promise((resolve, reject) => { + var xhr = new XMLHttpRequest; + xhr.open("GET", url, true); + xhr.responseType = "arraybuffer"; + xhr.onload = () => { + if (xhr.status == 200 || (xhr.status == 0 && xhr.response)) { + // file URLs can return 0 + resolve(xhr.response); + return; + } + reject(xhr.status); + }; + xhr.onerror = reject; + xhr.send(null); + }); + } + var response = await fetch(url, { + credentials: "same-origin" + }); + if (response.ok) { + return response.arrayBuffer(); + } + throw new Error(response.status + " : " + response.url); + }; + } +} else {} + +var out = console.log.bind(console); + +var err = console.error.bind(console); + +// end include: shell.js +// include: preamble.js +// === Preamble library stuff === +// Documentation for the public APIs defined in this file must be updated in: +// site/source/docs/api_reference/preamble.js.rst +// A prebuilt local version of the documentation is available at: +// site/build/text/docs/api_reference/preamble.js.txt +// You can also build docs locally as HTML or other formats in site/ +// An online HTML version (which may be of a different version of Emscripten) +// is up at http://kripken.github.io/emscripten-site/docs/api_reference/preamble.js.html +var wasmBinary; + +// Wasm globals +//======================================== +// Runtime essentials +//======================================== +// whether we are quitting the application. no code should run after this. +// set in exit() and abort() +var ABORT = false; + +/** + * Indicates whether filename is delivered via file protocol (as opposed to http/https) + * @noinline + */ var isFileURI = filename => filename.startsWith("file://"); + +// include: runtime_common.js +// include: runtime_stack_check.js +// end include: runtime_stack_check.js +// include: runtime_exceptions.js +// end include: runtime_exceptions.js +// include: runtime_debug.js +// end include: runtime_debug.js +var readyPromiseResolve, readyPromiseReject; + +// Memory management +var wasmMemory; + +var /** @type {!Int8Array} */ HEAP8, /** @type {!Uint8Array} */ HEAPU8, /** @type {!Int16Array} */ HEAP16, /** @type {!Uint16Array} */ HEAPU16, /** @type {!Int32Array} */ HEAP32, /** @type {!Uint32Array} */ HEAPU32, /** @type {!Float32Array} */ HEAPF32, /** @type {!Float64Array} */ HEAPF64; + +// BigInt64Array type is not correctly defined in closure +var /** not-@type {!BigInt64Array} */ HEAP64, /* BigUint64Array type is not correctly defined in closure +/** not-@type {!BigUint64Array} */ HEAPU64; + +var runtimeInitialized = false; + +function updateMemoryViews() { + var b = wasmMemory.buffer; + HEAP8 = new Int8Array(b); + HEAP16 = new Int16Array(b); + HEAPU8 = new Uint8Array(b); + HEAPU16 = new Uint16Array(b); + HEAP32 = new Int32Array(b); + HEAPU32 = new Uint32Array(b); + HEAPF32 = new Float32Array(b); + HEAPF64 = new Float64Array(b); + HEAP64 = new BigInt64Array(b); + HEAPU64 = new BigUint64Array(b); +} + +// include: memoryprofiler.js +// end include: memoryprofiler.js +// end include: runtime_common.js +function preRun() { + if (Module["preRun"]) { + if (typeof Module["preRun"] == "function") Module["preRun"] = [ Module["preRun"] ]; + while (Module["preRun"].length) { + addOnPreRun(Module["preRun"].shift()); + } + } + // Begin ATPRERUNS hooks + callRuntimeCallbacks(onPreRuns); +} + +function initRuntime() { + runtimeInitialized = true; + // No ATINITS hooks + wasmExports["A"](); +} + +function postRun() { + // PThreads reuse the runtime from the main thread. + if (Module["postRun"]) { + if (typeof Module["postRun"] == "function") Module["postRun"] = [ Module["postRun"] ]; + while (Module["postRun"].length) { + addOnPostRun(Module["postRun"].shift()); + } + } + // Begin ATPOSTRUNS hooks + callRuntimeCallbacks(onPostRuns); +} + +// A counter of dependencies for calling run(). If we need to +// do asynchronous work before running, increment this and +// decrement it. Incrementing must happen in a place like +// Module.preRun (used by emcc to add file preloading). +// Note that you can add dependencies in preRun, even though +// it happens right before run - run will be postponed until +// the dependencies are met. +var runDependencies = 0; + +var dependenciesFulfilled = null; + +// overridden to take different actions when all run dependencies are fulfilled +function addRunDependency(id) { + runDependencies++; + Module["monitorRunDependencies"]?.(runDependencies); +} + +function removeRunDependency(id) { + runDependencies--; + Module["monitorRunDependencies"]?.(runDependencies); + if (runDependencies == 0) { + if (dependenciesFulfilled) { + var callback = dependenciesFulfilled; + dependenciesFulfilled = null; + callback(); + } + } +} + +/** @param {string|number=} what */ function abort(what) { + Module["onAbort"]?.(what); + what = "Aborted(" + what + ")"; + // TODO(sbc): Should we remove printing and leave it up to whoever + // catches the exception? + err(what); + ABORT = true; + what += ". Build with -sASSERTIONS for more info."; + // Use a wasm runtime error, because a JS error might be seen as a foreign + // exception, which means we'd run destructors on it. We need the error to + // simply make the program stop. + // FIXME This approach does not work in Wasm EH because it currently does not assume + // all RuntimeErrors are from traps; it decides whether a RuntimeError is from + // a trap or not based on a hidden field within the object. So at the moment + // we don't have a way of throwing a wasm trap from JS. TODO Make a JS API that + // allows this in the wasm spec. + // Suppress closure compiler warning here. Closure compiler's builtin extern + // definition for WebAssembly.RuntimeError claims it takes no arguments even + // though it can. + // TODO(https://github.com/google/closure-compiler/pull/3913): Remove if/when upstream closure gets fixed. + /** @suppress {checkTypes} */ var e = new WebAssembly.RuntimeError(what); + readyPromiseReject?.(e); + // Throw the error whether or not MODULARIZE is set because abort is used + // in code paths apart from instantiation where an exception is expected + // to be thrown when abort is called. + throw e; +} + +var wasmBinaryFile; + +function findWasmBinary() { + if (Module["locateFile"]) { + return locateFile("worker_wasm.wasm"); + } + // Use bundler-friendly `new URL(..., import.meta.url)` pattern; works in browsers too. + return new URL("worker_wasm.wasm", import.meta.url).href; +} + +function getBinarySync(file) { + if (file == wasmBinaryFile && wasmBinary) { + return new Uint8Array(wasmBinary); + } + if (readBinary) { + return readBinary(file); + } + throw "both async and sync fetching of the wasm failed"; +} + +async function getWasmBinary(binaryFile) { + // If we don't have the binary yet, load it asynchronously using readAsync. + if (!wasmBinary) { + // Fetch the binary using readAsync + try { + var response = await readAsync(binaryFile); + return new Uint8Array(response); + } catch {} + } + // Otherwise, getBinarySync should be able to get it synchronously + return getBinarySync(binaryFile); +} + +async function instantiateArrayBuffer(binaryFile, imports) { + try { + var binary = await getWasmBinary(binaryFile); + var instance = await WebAssembly.instantiate(binary, imports); + return instance; + } catch (reason) { + err(`failed to asynchronously prepare wasm: ${reason}`); + abort(reason); + } +} + +async function instantiateAsync(binary, binaryFile, imports) { + if (!binary && typeof WebAssembly.instantiateStreaming == "function" && !isFileURI(binaryFile) && !ENVIRONMENT_IS_NODE) { + try { + var response = fetch(binaryFile, { + credentials: "same-origin" + }); + var instantiationResult = await WebAssembly.instantiateStreaming(response, imports); + return instantiationResult; + } catch (reason) { + // We expect the most common failure cause to be a bad MIME type for the binary, + // in which case falling back to ArrayBuffer instantiation should work. + err(`wasm streaming compile failed: ${reason}`); + err("falling back to ArrayBuffer instantiation"); + } + } + return instantiateArrayBuffer(binaryFile, imports); +} + +function getWasmImports() { + // prepare imports + return { + "a": wasmImports + }; +} + +// Create the wasm instance. +// Receives the wasm imports, returns the exports. +async function createWasm() { + // Load the wasm module and create an instance of using native support in the JS engine. + // handle a generated wasm instance, receiving its exports and + // performing other necessary setup + /** @param {WebAssembly.Module=} module*/ function receiveInstance(instance, module) { + wasmExports = instance.exports; + wasmMemory = wasmExports["z"]; + updateMemoryViews(); + wasmTable = wasmExports["B"]; + assignWasmExports(wasmExports); + removeRunDependency("wasm-instantiate"); + return wasmExports; + } + // wait for the pthread pool (if any) + addRunDependency("wasm-instantiate"); + // Prefer streaming instantiation if available. + function receiveInstantiationResult(result) { + // 'result' is a ResultObject object which has both the module and instance. + // receiveInstance() will swap in the exports (to Module.asm) so they can be called + // TODO: Due to Closure regression https://github.com/google/closure-compiler/issues/3193, the above line no longer optimizes out down to the following line. + // When the regression is fixed, can restore the above PTHREADS-enabled path. + return receiveInstance(result["instance"]); + } + var info = getWasmImports(); + // User shell pages can write their own Module.instantiateWasm = function(imports, successCallback) callback + // to manually instantiate the Wasm module themselves. This allows pages to + // run the instantiation parallel to any other async startup actions they are + // performing. + // Also pthreads and wasm workers initialize the wasm instance through this + // path. + if (Module["instantiateWasm"]) { + return new Promise((resolve, reject) => { + Module["instantiateWasm"](info, (mod, inst) => { + resolve(receiveInstance(mod, inst)); + }); + }); + } + wasmBinaryFile ??= findWasmBinary(); + var result = await instantiateAsync(wasmBinary, wasmBinaryFile, info); + var exports = receiveInstantiationResult(result); + return exports; +} + +// end include: preamble.js +// Begin JS library code +class ExitStatus { + name="ExitStatus"; + constructor(status) { + this.message = `Program terminated with exit(${status})`; + this.status = status; + } +} + +var callRuntimeCallbacks = callbacks => { + while (callbacks.length > 0) { + // Pass the module as the first argument. + callbacks.shift()(Module); + } +}; + +var onPostRuns = []; + +var addOnPostRun = cb => onPostRuns.push(cb); + +var onPreRuns = []; + +var addOnPreRun = cb => onPreRuns.push(cb); + +var noExitRuntime = true; + +class ExceptionInfo { + // excPtr - Thrown object pointer to wrap. Metadata pointer is calculated from it. + constructor(excPtr) { + this.excPtr = excPtr; + this.ptr = excPtr - 24; + } + set_type(type) { + HEAPU32[(((this.ptr) + (4)) >> 2)] = type; + } + get_type() { + return HEAPU32[(((this.ptr) + (4)) >> 2)]; + } + set_destructor(destructor) { + HEAPU32[(((this.ptr) + (8)) >> 2)] = destructor; + } + get_destructor() { + return HEAPU32[(((this.ptr) + (8)) >> 2)]; + } + set_caught(caught) { + caught = caught ? 1 : 0; + HEAP8[(this.ptr) + (12)] = caught; + } + get_caught() { + return HEAP8[(this.ptr) + (12)] != 0; + } + set_rethrown(rethrown) { + rethrown = rethrown ? 1 : 0; + HEAP8[(this.ptr) + (13)] = rethrown; + } + get_rethrown() { + return HEAP8[(this.ptr) + (13)] != 0; + } + // Initialize native structure fields. Should be called once after allocated. + init(type, destructor) { + this.set_adjusted_ptr(0); + this.set_type(type); + this.set_destructor(destructor); + } + set_adjusted_ptr(adjustedPtr) { + HEAPU32[(((this.ptr) + (16)) >> 2)] = adjustedPtr; + } + get_adjusted_ptr() { + return HEAPU32[(((this.ptr) + (16)) >> 2)]; + } +} + +var exceptionLast = 0; + +var uncaughtExceptionCount = 0; + +var ___cxa_throw = (ptr, type, destructor) => { + var info = new ExceptionInfo(ptr); + // Initialize ExceptionInfo content after it was allocated in __cxa_allocate_exception. + info.init(type, destructor); + exceptionLast = ptr; + uncaughtExceptionCount++; + throw exceptionLast; +}; + +var __abort_js = () => abort(""); + +var tupleRegistrations = {}; + +var runDestructors = destructors => { + while (destructors.length) { + var ptr = destructors.pop(); + var del = destructors.pop(); + del(ptr); + } +}; + +/** @suppress {globalThis} */ function readPointer(pointer) { + return this.fromWireType(HEAPU32[((pointer) >> 2)]); +} + +var awaitingDependencies = {}; + +var registeredTypes = {}; + +var typeDependencies = {}; + +var InternalError = class InternalError extends Error { + constructor(message) { + super(message); + this.name = "InternalError"; + } +}; + +var throwInternalError = message => { + throw new InternalError(message); +}; + +var whenDependentTypesAreResolved = (myTypes, dependentTypes, getTypeConverters) => { + myTypes.forEach(type => typeDependencies[type] = dependentTypes); + function onComplete(typeConverters) { + var myTypeConverters = getTypeConverters(typeConverters); + if (myTypeConverters.length !== myTypes.length) { + throwInternalError("Mismatched type converter count"); + } + for (var i = 0; i < myTypes.length; ++i) { + registerType(myTypes[i], myTypeConverters[i]); + } + } + var typeConverters = new Array(dependentTypes.length); + var unregisteredTypes = []; + var registered = 0; + dependentTypes.forEach((dt, i) => { + if (registeredTypes.hasOwnProperty(dt)) { + typeConverters[i] = registeredTypes[dt]; + } else { + unregisteredTypes.push(dt); + if (!awaitingDependencies.hasOwnProperty(dt)) { + awaitingDependencies[dt] = []; + } + awaitingDependencies[dt].push(() => { + typeConverters[i] = registeredTypes[dt]; + ++registered; + if (registered === unregisteredTypes.length) { + onComplete(typeConverters); + } + }); + } + }); + if (0 === unregisteredTypes.length) { + onComplete(typeConverters); + } +}; + +var __embind_finalize_value_array = rawTupleType => { + var reg = tupleRegistrations[rawTupleType]; + delete tupleRegistrations[rawTupleType]; + var elements = reg.elements; + var elementsLength = elements.length; + var elementTypes = elements.map(elt => elt.getterReturnType).concat(elements.map(elt => elt.setterArgumentType)); + var rawConstructor = reg.rawConstructor; + var rawDestructor = reg.rawDestructor; + whenDependentTypesAreResolved([ rawTupleType ], elementTypes, elementTypes => { + elements.forEach((elt, i) => { + var getterReturnType = elementTypes[i]; + var getter = elt.getter; + var getterContext = elt.getterContext; + var setterArgumentType = elementTypes[i + elementsLength]; + var setter = elt.setter; + var setterContext = elt.setterContext; + elt.read = ptr => getterReturnType.fromWireType(getter(getterContext, ptr)); + elt.write = (ptr, o) => { + var destructors = []; + setter(setterContext, ptr, setterArgumentType.toWireType(destructors, o)); + runDestructors(destructors); + }; + }); + return [ { + name: reg.name, + fromWireType: ptr => { + var rv = new Array(elementsLength); + for (var i = 0; i < elementsLength; ++i) { + rv[i] = elements[i].read(ptr); + } + rawDestructor(ptr); + return rv; + }, + toWireType: (destructors, o) => { + if (elementsLength !== o.length) { + throw new TypeError(`Incorrect number of tuple elements for ${reg.name}: expected=${elementsLength}, actual=${o.length}`); + } + var ptr = rawConstructor(); + for (var i = 0; i < elementsLength; ++i) { + elements[i].write(ptr, o[i]); + } + if (destructors !== null) { + destructors.push(rawDestructor, ptr); + } + return ptr; + }, + readValueFromPointer: readPointer, + destructorFunction: rawDestructor + } ]; + }); +}; + +var AsciiToString = ptr => { + var str = ""; + while (1) { + var ch = HEAPU8[ptr++]; + if (!ch) return str; + str += String.fromCharCode(ch); + } +}; + +var BindingError = class BindingError extends Error { + constructor(message) { + super(message); + this.name = "BindingError"; + } +}; + +var throwBindingError = message => { + throw new BindingError(message); +}; + +/** @param {Object=} options */ function sharedRegisterType(rawType, registeredInstance, options = {}) { + var name = registeredInstance.name; + if (!rawType) { + throwBindingError(`type "${name}" must have a positive integer typeid pointer`); + } + if (registeredTypes.hasOwnProperty(rawType)) { + if (options.ignoreDuplicateRegistrations) { + return; + } else { + throwBindingError(`Cannot register type '${name}' twice`); + } + } + registeredTypes[rawType] = registeredInstance; + delete typeDependencies[rawType]; + if (awaitingDependencies.hasOwnProperty(rawType)) { + var callbacks = awaitingDependencies[rawType]; + delete awaitingDependencies[rawType]; + callbacks.forEach(cb => cb()); + } +} + +/** @param {Object=} options */ function registerType(rawType, registeredInstance, options = {}) { + return sharedRegisterType(rawType, registeredInstance, options); +} + +var integerReadValueFromPointer = (name, width, signed) => { + // integers are quite common, so generate very specialized functions + switch (width) { + case 1: + return signed ? pointer => HEAP8[pointer] : pointer => HEAPU8[pointer]; + + case 2: + return signed ? pointer => HEAP16[((pointer) >> 1)] : pointer => HEAPU16[((pointer) >> 1)]; + + case 4: + return signed ? pointer => HEAP32[((pointer) >> 2)] : pointer => HEAPU32[((pointer) >> 2)]; + + case 8: + return signed ? pointer => HEAP64[((pointer) >> 3)] : pointer => HEAPU64[((pointer) >> 3)]; + + default: + throw new TypeError(`invalid integer width (${width}): ${name}`); + } +}; + +/** @suppress {globalThis} */ var __embind_register_bigint = (primitiveType, name, size, minRange, maxRange) => { + name = AsciiToString(name); + const isUnsignedType = minRange === 0n; + let fromWireType = value => value; + if (isUnsignedType) { + // uint64 get converted to int64 in ABI, fix them up like we do for 32-bit integers. + const bitSize = size * 8; + fromWireType = value => BigInt.asUintN(bitSize, value); + maxRange = fromWireType(maxRange); + } + registerType(primitiveType, { + name, + fromWireType, + toWireType: (destructors, value) => { + if (typeof value == "number") { + value = BigInt(value); + } + return value; + }, + readValueFromPointer: integerReadValueFromPointer(name, size, !isUnsignedType), + destructorFunction: null + }); +}; + +/** @suppress {globalThis} */ var __embind_register_bool = (rawType, name, trueValue, falseValue) => { + name = AsciiToString(name); + registerType(rawType, { + name, + fromWireType: function(wt) { + // ambiguous emscripten ABI: sometimes return values are + // true or false, and sometimes integers (0 or 1) + return !!wt; + }, + toWireType: function(destructors, o) { + return o ? trueValue : falseValue; + }, + readValueFromPointer: function(pointer) { + return this.fromWireType(HEAPU8[pointer]); + }, + destructorFunction: null + }); +}; + +var emval_freelist = []; + +var emval_handles = [ 0, 1, , 1, null, 1, true, 1, false, 1 ]; + +var __emval_decref = handle => { + if (handle > 9 && 0 === --emval_handles[handle + 1]) { + emval_handles[handle] = undefined; + emval_freelist.push(handle); + } +}; + +var Emval = { + toValue: handle => { + if (!handle) { + throwBindingError(`Cannot use deleted val. handle = ${handle}`); + } + return emval_handles[handle]; + }, + toHandle: value => { + switch (value) { + case undefined: + return 2; + + case null: + return 4; + + case true: + return 6; + + case false: + return 8; + + default: + { + const handle = emval_freelist.pop() || emval_handles.length; + emval_handles[handle] = value; + emval_handles[handle + 1] = 1; + return handle; + } + } + } +}; + +var EmValType = { + name: "emscripten::val", + fromWireType: handle => { + var rv = Emval.toValue(handle); + __emval_decref(handle); + return rv; + }, + toWireType: (destructors, value) => Emval.toHandle(value), + readValueFromPointer: readPointer, + destructorFunction: null +}; + +var __embind_register_emval = rawType => registerType(rawType, EmValType); + +var floatReadValueFromPointer = (name, width) => { + switch (width) { + case 4: + return function(pointer) { + return this.fromWireType(HEAPF32[((pointer) >> 2)]); + }; + + case 8: + return function(pointer) { + return this.fromWireType(HEAPF64[((pointer) >> 3)]); + }; + + default: + throw new TypeError(`invalid float width (${width}): ${name}`); + } +}; + +var __embind_register_float = (rawType, name, size) => { + name = AsciiToString(name); + registerType(rawType, { + name, + fromWireType: value => value, + toWireType: (destructors, value) => value, + readValueFromPointer: floatReadValueFromPointer(name, size), + destructorFunction: null + }); +}; + +var createNamedFunction = (name, func) => Object.defineProperty(func, "name", { + value: name +}); + +function usesDestructorStack(argTypes) { + // Skip return value at index 0 - it's not deleted here. + for (var i = 1; i < argTypes.length; ++i) { + // The type does not define a destructor function - must use dynamic stack + if (argTypes[i] !== null && argTypes[i].destructorFunction === undefined) { + return true; + } + } + return false; +} + +function createJsInvoker(argTypes, isClassMethodFunc, returns, isAsync) { + var needsDestructorStack = usesDestructorStack(argTypes); + var argCount = argTypes.length - 2; + var argsList = []; + var argsListWired = [ "fn" ]; + if (isClassMethodFunc) { + argsListWired.push("thisWired"); + } + for (var i = 0; i < argCount; ++i) { + argsList.push(`arg${i}`); + argsListWired.push(`arg${i}Wired`); + } + argsList = argsList.join(","); + argsListWired = argsListWired.join(","); + var invokerFnBody = `return function (${argsList}) {\n`; + if (needsDestructorStack) { + invokerFnBody += "var destructors = [];\n"; + } + var dtorStack = needsDestructorStack ? "destructors" : "null"; + var args1 = [ "humanName", "throwBindingError", "invoker", "fn", "runDestructors", "fromRetWire", "toClassParamWire" ]; + if (isClassMethodFunc) { + invokerFnBody += `var thisWired = toClassParamWire(${dtorStack}, this);\n`; + } + for (var i = 0; i < argCount; ++i) { + var argName = `toArg${i}Wire`; + invokerFnBody += `var arg${i}Wired = ${argName}(${dtorStack}, arg${i});\n`; + args1.push(argName); + } + invokerFnBody += (returns || isAsync ? "var rv = " : "") + `invoker(${argsListWired});\n`; + if (needsDestructorStack) { + invokerFnBody += "runDestructors(destructors);\n"; + } else { + for (var i = isClassMethodFunc ? 1 : 2; i < argTypes.length; ++i) { + // Skip return value at index 0 - it's not deleted here. Also skip class type if not a method. + var paramName = (i === 1 ? "thisWired" : ("arg" + (i - 2) + "Wired")); + if (argTypes[i].destructorFunction !== null) { + invokerFnBody += `${paramName}_dtor(${paramName});\n`; + args1.push(`${paramName}_dtor`); + } + } + } + if (returns) { + invokerFnBody += "var ret = fromRetWire(rv);\n" + "return ret;\n"; + } else {} + invokerFnBody += "}\n"; + return new Function(args1, invokerFnBody); +} + +function craftInvokerFunction(humanName, argTypes, classType, cppInvokerFunc, cppTargetFunc, /** boolean= */ isAsync) { + // humanName: a human-readable string name for the function to be generated. + // argTypes: An array that contains the embind type objects for all types in the function signature. + // argTypes[0] is the type object for the function return value. + // argTypes[1] is the type object for function this object/class type, or null if not crafting an invoker for a class method. + // argTypes[2...] are the actual function parameters. + // classType: The embind type object for the class to be bound, or null if this is not a method of a class. + // cppInvokerFunc: JS Function object to the C++-side function that interops into C++ code. + // cppTargetFunc: Function pointer (an integer to FUNCTION_TABLE) to the target C++ function the cppInvokerFunc will end up calling. + // isAsync: Optional. If true, returns an async function. Async bindings are only supported with JSPI. + var argCount = argTypes.length; + if (argCount < 2) { + throwBindingError("argTypes array size mismatch! Must at least get return value and 'this' types!"); + } + var isClassMethodFunc = (argTypes[1] !== null && classType !== null); + // Free functions with signature "void function()" do not need an invoker that marshalls between wire types. + // TODO: This omits argument count check - enable only at -O3 or similar. + // if (ENABLE_UNSAFE_OPTS && argCount == 2 && argTypes[0].name == "void" && !isClassMethodFunc) { + // return FUNCTION_TABLE[fn]; + // } + // Determine if we need to use a dynamic stack to store the destructors for the function parameters. + // TODO: Remove this completely once all function invokers are being dynamically generated. + var needsDestructorStack = usesDestructorStack(argTypes); + var returns = !argTypes[0].isVoid; + // Builld the arguments that will be passed into the closure around the invoker + // function. + var retType = argTypes[0]; + var instType = argTypes[1]; + var closureArgs = [ humanName, throwBindingError, cppInvokerFunc, cppTargetFunc, runDestructors, retType.fromWireType.bind(retType), instType?.toWireType.bind(instType) ]; + for (var i = 2; i < argCount; ++i) { + var argType = argTypes[i]; + closureArgs.push(argType.toWireType.bind(argType)); + } + if (!needsDestructorStack) { + // Skip return value at index 0 - it's not deleted here. Also skip class type if not a method. + for (var i = isClassMethodFunc ? 1 : 2; i < argTypes.length; ++i) { + if (argTypes[i].destructorFunction !== null) { + closureArgs.push(argTypes[i].destructorFunction); + } + } + } + let invokerFactory = createJsInvoker(argTypes, isClassMethodFunc, returns, isAsync); + var invokerFn = invokerFactory(...closureArgs); + return createNamedFunction(humanName, invokerFn); +} + +var ensureOverloadTable = (proto, methodName, humanName) => { + if (undefined === proto[methodName].overloadTable) { + var prevFunc = proto[methodName]; + // Inject an overload resolver function that routes to the appropriate overload based on the number of arguments. + proto[methodName] = function(...args) { + // TODO This check can be removed in -O3 level "unsafe" optimizations. + if (!proto[methodName].overloadTable.hasOwnProperty(args.length)) { + throwBindingError(`Function '${humanName}' called with an invalid number of arguments (${args.length}) - expects one of (${proto[methodName].overloadTable})!`); + } + return proto[methodName].overloadTable[args.length].apply(this, args); + }; + // Move the previous function into the overload table. + proto[methodName].overloadTable = []; + proto[methodName].overloadTable[prevFunc.argCount] = prevFunc; + } +}; + +/** @param {number=} numArguments */ var exposePublicSymbol = (name, value, numArguments) => { + if (Module.hasOwnProperty(name)) { + if (undefined === numArguments || (undefined !== Module[name].overloadTable && undefined !== Module[name].overloadTable[numArguments])) { + throwBindingError(`Cannot register public name '${name}' twice`); + } + // We are exposing a function with the same name as an existing function. Create an overload table and a function selector + // that routes between the two. + ensureOverloadTable(Module, name, name); + if (Module[name].overloadTable.hasOwnProperty(numArguments)) { + throwBindingError(`Cannot register multiple overloads of a function with the same number of arguments (${numArguments})!`); + } + // Add the new function into the overload table. + Module[name].overloadTable[numArguments] = value; + } else { + Module[name] = value; + Module[name].argCount = numArguments; + } +}; + +var heap32VectorToArray = (count, firstElement) => { + var array = []; + for (var i = 0; i < count; i++) { + // TODO(https://github.com/emscripten-core/emscripten/issues/17310): + // Find a way to hoist the `>> 2` or `>> 3` out of this loop. + array.push(HEAPU32[(((firstElement) + (i * 4)) >> 2)]); + } + return array; +}; + +/** @param {number=} numArguments */ var replacePublicSymbol = (name, value, numArguments) => { + if (!Module.hasOwnProperty(name)) { + throwInternalError("Replacing nonexistent public symbol"); + } + // If there's an overload table for this symbol, replace the symbol in the overload table instead. + if (undefined !== Module[name].overloadTable && undefined !== numArguments) { + Module[name].overloadTable[numArguments] = value; + } else { + Module[name] = value; + Module[name].argCount = numArguments; + } +}; + +var wasmTableMirror = []; + +/** @type {WebAssembly.Table} */ var wasmTable; + +var getWasmTableEntry = funcPtr => { + var func = wasmTableMirror[funcPtr]; + if (!func) { + /** @suppress {checkTypes} */ wasmTableMirror[funcPtr] = func = wasmTable.get(funcPtr); + } + return func; +}; + +var embind__requireFunction = (signature, rawFunction, isAsync = false) => { + signature = AsciiToString(signature); + function makeDynCaller() { + var rtn = getWasmTableEntry(rawFunction); + return rtn; + } + var fp = makeDynCaller(); + if (typeof fp != "function") { + throwBindingError(`unknown function pointer with signature ${signature}: ${rawFunction}`); + } + return fp; +}; + +class UnboundTypeError extends Error {} + +var getTypeName = type => { + var ptr = ___getTypeName(type); + var rv = AsciiToString(ptr); + _free(ptr); + return rv; +}; + +var throwUnboundTypeError = (message, types) => { + var unboundTypes = []; + var seen = {}; + function visit(type) { + if (seen[type]) { + return; + } + if (registeredTypes[type]) { + return; + } + if (typeDependencies[type]) { + typeDependencies[type].forEach(visit); + return; + } + unboundTypes.push(type); + seen[type] = true; + } + types.forEach(visit); + throw new UnboundTypeError(`${message}: ` + unboundTypes.map(getTypeName).join([ ", " ])); +}; + +var getFunctionName = signature => { + signature = signature.trim(); + const argsIndex = signature.indexOf("("); + if (argsIndex === -1) return signature; + return signature.slice(0, argsIndex); +}; + +var __embind_register_function = (name, argCount, rawArgTypesAddr, signature, rawInvoker, fn, isAsync, isNonnullReturn) => { + var argTypes = heap32VectorToArray(argCount, rawArgTypesAddr); + name = AsciiToString(name); + name = getFunctionName(name); + rawInvoker = embind__requireFunction(signature, rawInvoker, isAsync); + exposePublicSymbol(name, function() { + throwUnboundTypeError(`Cannot call ${name} due to unbound types`, argTypes); + }, argCount - 1); + whenDependentTypesAreResolved([], argTypes, argTypes => { + var invokerArgsArray = [ argTypes[0], null ].concat(argTypes.slice(1)); + replacePublicSymbol(name, craftInvokerFunction(name, invokerArgsArray, null, rawInvoker, fn, isAsync), argCount - 1); + return []; + }); +}; + +/** @suppress {globalThis} */ var __embind_register_integer = (primitiveType, name, size, minRange, maxRange) => { + name = AsciiToString(name); + const isUnsignedType = minRange === 0; + let fromWireType = value => value; + if (isUnsignedType) { + var bitshift = 32 - 8 * size; + fromWireType = value => (value << bitshift) >>> bitshift; + maxRange = fromWireType(maxRange); + } + registerType(primitiveType, { + name, + fromWireType, + toWireType: (destructors, value) => value, + readValueFromPointer: integerReadValueFromPointer(name, size, minRange !== 0), + destructorFunction: null + }); +}; + +var __embind_register_memory_view = (rawType, dataTypeIndex, name) => { + var typeMapping = [ Int8Array, Uint8Array, Int16Array, Uint16Array, Int32Array, Uint32Array, Float32Array, Float64Array, BigInt64Array, BigUint64Array ]; + var TA = typeMapping[dataTypeIndex]; + function decodeMemoryView(handle) { + var size = HEAPU32[((handle) >> 2)]; + var data = HEAPU32[(((handle) + (4)) >> 2)]; + return new TA(HEAP8.buffer, data, size); + } + name = AsciiToString(name); + registerType(rawType, { + name, + fromWireType: decodeMemoryView, + readValueFromPointer: decodeMemoryView + }, { + ignoreDuplicateRegistrations: true + }); +}; + +var stringToUTF8Array = (str, heap, outIdx, maxBytesToWrite) => { + // Parameter maxBytesToWrite is not optional. Negative values, 0, null, + // undefined and false each don't write out any bytes. + if (!(maxBytesToWrite > 0)) return 0; + var startIdx = outIdx; + var endIdx = outIdx + maxBytesToWrite - 1; + // -1 for string null terminator. + for (var i = 0; i < str.length; ++i) { + // For UTF8 byte structure, see http://en.wikipedia.org/wiki/UTF-8#Description + // and https://www.ietf.org/rfc/rfc2279.txt + // and https://tools.ietf.org/html/rfc3629 + var u = str.codePointAt(i); + if (u <= 127) { + if (outIdx >= endIdx) break; + heap[outIdx++] = u; + } else if (u <= 2047) { + if (outIdx + 1 >= endIdx) break; + heap[outIdx++] = 192 | (u >> 6); + heap[outIdx++] = 128 | (u & 63); + } else if (u <= 65535) { + if (outIdx + 2 >= endIdx) break; + heap[outIdx++] = 224 | (u >> 12); + heap[outIdx++] = 128 | ((u >> 6) & 63); + heap[outIdx++] = 128 | (u & 63); + } else { + if (outIdx + 3 >= endIdx) break; + heap[outIdx++] = 240 | (u >> 18); + heap[outIdx++] = 128 | ((u >> 12) & 63); + heap[outIdx++] = 128 | ((u >> 6) & 63); + heap[outIdx++] = 128 | (u & 63); + // Gotcha: if codePoint is over 0xFFFF, it is represented as a surrogate pair in UTF-16. + // We need to manually skip over the second code unit for correct iteration. + i++; + } + } + // Null-terminate the pointer to the buffer. + heap[outIdx] = 0; + return outIdx - startIdx; +}; + +var stringToUTF8 = (str, outPtr, maxBytesToWrite) => stringToUTF8Array(str, HEAPU8, outPtr, maxBytesToWrite); + +var lengthBytesUTF8 = str => { + var len = 0; + for (var i = 0; i < str.length; ++i) { + // Gotcha: charCodeAt returns a 16-bit word that is a UTF-16 encoded code + // unit, not a Unicode code point of the character! So decode + // UTF16->UTF32->UTF8. + // See http://unicode.org/faq/utf_bom.html#utf16-3 + var c = str.charCodeAt(i); + // possibly a lead surrogate + if (c <= 127) { + len++; + } else if (c <= 2047) { + len += 2; + } else if (c >= 55296 && c <= 57343) { + len += 4; + ++i; + } else { + len += 3; + } + } + return len; +}; + +var UTF8Decoder = typeof TextDecoder != "undefined" ? new TextDecoder : undefined; + +var findStringEnd = (heapOrArray, idx, maxBytesToRead, ignoreNul) => { + var maxIdx = idx + maxBytesToRead; + if (ignoreNul) return maxIdx; + // TextDecoder needs to know the byte length in advance, it doesn't stop on + // null terminator by itself. + // As a tiny code save trick, compare idx against maxIdx using a negation, + // so that maxBytesToRead=undefined/NaN means Infinity. + while (heapOrArray[idx] && !(idx >= maxIdx)) ++idx; + return idx; +}; + +/** + * Given a pointer 'idx' to a null-terminated UTF8-encoded string in the given + * array that contains uint8 values, returns a copy of that string as a + * Javascript String object. + * heapOrArray is either a regular array, or a JavaScript typed array view. + * @param {number=} idx + * @param {number=} maxBytesToRead + * @param {boolean=} ignoreNul - If true, the function will not stop on a NUL character. + * @return {string} + */ var UTF8ArrayToString = (heapOrArray, idx = 0, maxBytesToRead, ignoreNul) => { + var endPtr = findStringEnd(heapOrArray, idx, maxBytesToRead, ignoreNul); + // When using conditional TextDecoder, skip it for short strings as the overhead of the native call is not worth it. + if (endPtr - idx > 16 && heapOrArray.buffer && UTF8Decoder) { + return UTF8Decoder.decode(heapOrArray.subarray(idx, endPtr)); + } + var str = ""; + // If building with TextDecoder, we have already computed the string length + // above, so test loop end condition against that + while (idx < endPtr) { + // For UTF8 byte structure, see: + // http://en.wikipedia.org/wiki/UTF-8#Description + // https://www.ietf.org/rfc/rfc2279.txt + // https://tools.ietf.org/html/rfc3629 + var u0 = heapOrArray[idx++]; + if (!(u0 & 128)) { + str += String.fromCharCode(u0); + continue; + } + var u1 = heapOrArray[idx++] & 63; + if ((u0 & 224) == 192) { + str += String.fromCharCode(((u0 & 31) << 6) | u1); + continue; + } + var u2 = heapOrArray[idx++] & 63; + if ((u0 & 240) == 224) { + u0 = ((u0 & 15) << 12) | (u1 << 6) | u2; + } else { + u0 = ((u0 & 7) << 18) | (u1 << 12) | (u2 << 6) | (heapOrArray[idx++] & 63); + } + if (u0 < 65536) { + str += String.fromCharCode(u0); + } else { + var ch = u0 - 65536; + str += String.fromCharCode(55296 | (ch >> 10), 56320 | (ch & 1023)); + } + } + return str; +}; + +/** + * Given a pointer 'ptr' to a null-terminated UTF8-encoded string in the + * emscripten HEAP, returns a copy of that string as a Javascript String object. + * + * @param {number} ptr + * @param {number=} maxBytesToRead - An optional length that specifies the + * maximum number of bytes to read. You can omit this parameter to scan the + * string until the first 0 byte. If maxBytesToRead is passed, and the string + * at [ptr, ptr+maxBytesToReadr[ contains a null byte in the middle, then the + * string will cut short at that byte index. + * @param {boolean=} ignoreNul - If true, the function will not stop on a NUL character. + * @return {string} + */ var UTF8ToString = (ptr, maxBytesToRead, ignoreNul) => ptr ? UTF8ArrayToString(HEAPU8, ptr, maxBytesToRead, ignoreNul) : ""; + +var __embind_register_std_string = (rawType, name) => { + name = AsciiToString(name); + var stdStringIsUTF8 = true; + registerType(rawType, { + name, + // For some method names we use string keys here since they are part of + // the public/external API and/or used by the runtime-generated code. + fromWireType(value) { + var length = HEAPU32[((value) >> 2)]; + var payload = value + 4; + var str; + if (stdStringIsUTF8) { + str = UTF8ToString(payload, length, true); + } else { + str = ""; + for (var i = 0; i < length; ++i) { + str += String.fromCharCode(HEAPU8[payload + i]); + } + } + _free(value); + return str; + }, + toWireType(destructors, value) { + if (value instanceof ArrayBuffer) { + value = new Uint8Array(value); + } + var length; + var valueIsOfTypeString = (typeof value == "string"); + // We accept `string` or array views with single byte elements + if (!(valueIsOfTypeString || (ArrayBuffer.isView(value) && value.BYTES_PER_ELEMENT == 1))) { + throwBindingError("Cannot pass non-string to std::string"); + } + if (stdStringIsUTF8 && valueIsOfTypeString) { + length = lengthBytesUTF8(value); + } else { + length = value.length; + } + // assumes POINTER_SIZE alignment + var base = _malloc(4 + length + 1); + var ptr = base + 4; + HEAPU32[((base) >> 2)] = length; + if (valueIsOfTypeString) { + if (stdStringIsUTF8) { + stringToUTF8(value, ptr, length + 1); + } else { + for (var i = 0; i < length; ++i) { + var charCode = value.charCodeAt(i); + if (charCode > 255) { + _free(base); + throwBindingError("String has UTF-16 code units that do not fit in 8 bits"); + } + HEAPU8[ptr + i] = charCode; + } + } + } else { + HEAPU8.set(value, ptr); + } + if (destructors !== null) { + destructors.push(_free, base); + } + return base; + }, + readValueFromPointer: readPointer, + destructorFunction(ptr) { + _free(ptr); + } + }); +}; + +var UTF16Decoder = typeof TextDecoder != "undefined" ? new TextDecoder("utf-16le") : undefined; + +var UTF16ToString = (ptr, maxBytesToRead, ignoreNul) => { + var idx = ((ptr) >> 1); + var endIdx = findStringEnd(HEAPU16, idx, maxBytesToRead / 2, ignoreNul); + // When using conditional TextDecoder, skip it for short strings as the overhead of the native call is not worth it. + if (endIdx - idx > 16 && UTF16Decoder) return UTF16Decoder.decode(HEAPU16.subarray(idx, endIdx)); + // Fallback: decode without UTF16Decoder + var str = ""; + // If maxBytesToRead is not passed explicitly, it will be undefined, and the + // for-loop's condition will always evaluate to true. The loop is then + // terminated on the first null char. + for (var i = idx; // If building with TextDecoder, we have already computed the string length + // above, so test loop end condition against that + i < endIdx; ++i) { + var codeUnit = HEAPU16[i]; + // fromCharCode constructs a character from a UTF-16 code unit, so we can + // pass the UTF16 string right through. + str += String.fromCharCode(codeUnit); + } + return str; +}; + +var stringToUTF16 = (str, outPtr, maxBytesToWrite) => { + // Backwards compatibility: if max bytes is not specified, assume unsafe unbounded write is allowed. + maxBytesToWrite ??= 2147483647; + if (maxBytesToWrite < 2) return 0; + maxBytesToWrite -= 2; + // Null terminator. + var startPtr = outPtr; + var numCharsToWrite = (maxBytesToWrite < str.length * 2) ? (maxBytesToWrite / 2) : str.length; + for (var i = 0; i < numCharsToWrite; ++i) { + // charCodeAt returns a UTF-16 encoded code unit, so it can be directly written to the HEAP. + var codeUnit = str.charCodeAt(i); + // possibly a lead surrogate + HEAP16[((outPtr) >> 1)] = codeUnit; + outPtr += 2; + } + // Null-terminate the pointer to the HEAP. + HEAP16[((outPtr) >> 1)] = 0; + return outPtr - startPtr; +}; + +var lengthBytesUTF16 = str => str.length * 2; + +var UTF32ToString = (ptr, maxBytesToRead, ignoreNul) => { + var str = ""; + var startIdx = ((ptr) >> 2); + // If maxBytesToRead is not passed explicitly, it will be undefined, and this + // will always evaluate to true. This saves on code size. + for (var i = 0; !(i >= maxBytesToRead / 4); i++) { + var utf32 = HEAPU32[startIdx + i]; + if (!utf32 && !ignoreNul) break; + str += String.fromCodePoint(utf32); + } + return str; +}; + +var stringToUTF32 = (str, outPtr, maxBytesToWrite) => { + // Backwards compatibility: if max bytes is not specified, assume unsafe unbounded write is allowed. + maxBytesToWrite ??= 2147483647; + if (maxBytesToWrite < 4) return 0; + var startPtr = outPtr; + var endPtr = startPtr + maxBytesToWrite - 4; + for (var i = 0; i < str.length; ++i) { + var codePoint = str.codePointAt(i); + // Gotcha: if codePoint is over 0xFFFF, it is represented as a surrogate pair in UTF-16. + // We need to manually skip over the second code unit for correct iteration. + if (codePoint > 65535) { + i++; + } + HEAP32[((outPtr) >> 2)] = codePoint; + outPtr += 4; + if (outPtr + 4 > endPtr) break; + } + // Null-terminate the pointer to the HEAP. + HEAP32[((outPtr) >> 2)] = 0; + return outPtr - startPtr; +}; + +var lengthBytesUTF32 = str => { + var len = 0; + for (var i = 0; i < str.length; ++i) { + var codePoint = str.codePointAt(i); + // Gotcha: if codePoint is over 0xFFFF, it is represented as a surrogate pair in UTF-16. + // We need to manually skip over the second code unit for correct iteration. + if (codePoint > 65535) { + i++; + } + len += 4; + } + return len; +}; + +var __embind_register_std_wstring = (rawType, charSize, name) => { + name = AsciiToString(name); + var decodeString, encodeString, lengthBytesUTF; + if (charSize === 2) { + decodeString = UTF16ToString; + encodeString = stringToUTF16; + lengthBytesUTF = lengthBytesUTF16; + } else { + decodeString = UTF32ToString; + encodeString = stringToUTF32; + lengthBytesUTF = lengthBytesUTF32; + } + registerType(rawType, { + name, + fromWireType: value => { + // Code mostly taken from _embind_register_std_string fromWireType + var length = HEAPU32[((value) >> 2)]; + var str = decodeString(value + 4, length * charSize, true); + _free(value); + return str; + }, + toWireType: (destructors, value) => { + if (!(typeof value == "string")) { + throwBindingError(`Cannot pass non-string to C++ string type ${name}`); + } + // assumes POINTER_SIZE alignment + var length = lengthBytesUTF(value); + var ptr = _malloc(4 + length + charSize); + HEAPU32[((ptr) >> 2)] = length / charSize; + encodeString(value, ptr + 4, length + charSize); + if (destructors !== null) { + destructors.push(_free, ptr); + } + return ptr; + }, + readValueFromPointer: readPointer, + destructorFunction(ptr) { + _free(ptr); + } + }); +}; + +var __embind_register_value_array = (rawType, name, constructorSignature, rawConstructor, destructorSignature, rawDestructor) => { + tupleRegistrations[rawType] = { + name: AsciiToString(name), + rawConstructor: embind__requireFunction(constructorSignature, rawConstructor), + rawDestructor: embind__requireFunction(destructorSignature, rawDestructor), + elements: [] + }; +}; + +var __embind_register_value_array_element = (rawTupleType, getterReturnType, getterSignature, getter, getterContext, setterArgumentType, setterSignature, setter, setterContext) => { + tupleRegistrations[rawTupleType].elements.push({ + getterReturnType, + getter: embind__requireFunction(getterSignature, getter), + getterContext, + setterArgumentType, + setter: embind__requireFunction(setterSignature, setter), + setterContext + }); +}; + +var __embind_register_void = (rawType, name) => { + name = AsciiToString(name); + registerType(rawType, { + isVoid: true, + // void return values can be optimized out sometimes + name, + fromWireType: () => undefined, + // TODO: assert if anything else is given? + toWireType: (destructors, o) => undefined + }); +}; + +var emval_methodCallers = []; + +var emval_addMethodCaller = caller => { + var id = emval_methodCallers.length; + emval_methodCallers.push(caller); + return id; +}; + +var requireRegisteredType = (rawType, humanName) => { + var impl = registeredTypes[rawType]; + if (undefined === impl) { + throwBindingError(`${humanName} has unknown type ${getTypeName(rawType)}`); + } + return impl; +}; + +var emval_lookupTypes = (argCount, argTypes) => { + var a = new Array(argCount); + for (var i = 0; i < argCount; ++i) { + a[i] = requireRegisteredType(HEAPU32[(((argTypes) + (i * 4)) >> 2)], `parameter ${i}`); + } + return a; +}; + +var emval_returnValue = (toReturnWire, destructorsRef, handle) => { + var destructors = []; + var result = toReturnWire(destructors, handle); + if (destructors.length) { + // void, primitives and any other types w/o destructors don't need to allocate a handle + HEAPU32[((destructorsRef) >> 2)] = Emval.toHandle(destructors); + } + return result; +}; + +var emval_symbols = {}; + +var getStringOrSymbol = address => { + var symbol = emval_symbols[address]; + if (symbol === undefined) { + return AsciiToString(address); + } + return symbol; +}; + +var __emval_create_invoker = (argCount, argTypesPtr, kind) => { + var GenericWireTypeSize = 8; + var [retType, ...argTypes] = emval_lookupTypes(argCount, argTypesPtr); + var toReturnWire = retType.toWireType.bind(retType); + var argFromPtr = argTypes.map(type => type.readValueFromPointer.bind(type)); + argCount--; + // remove the extracted return type + var captures = { + "toValue": Emval.toValue + }; + var args = argFromPtr.map((argFromPtr, i) => { + var captureName = `argFromPtr${i}`; + captures[captureName] = argFromPtr; + return `${captureName}(args${i ? "+" + i * GenericWireTypeSize : ""})`; + }); + var functionBody; + switch (kind) { + case 0: + functionBody = "toValue(handle)"; + break; + + case 2: + functionBody = "new (toValue(handle))"; + break; + + case 3: + functionBody = ""; + break; + + case 1: + captures["getStringOrSymbol"] = getStringOrSymbol; + functionBody = "toValue(handle)[getStringOrSymbol(methodName)]"; + break; + } + functionBody += `(${args})`; + if (!retType.isVoid) { + captures["toReturnWire"] = toReturnWire; + captures["emval_returnValue"] = emval_returnValue; + functionBody = `return emval_returnValue(toReturnWire, destructorsRef, ${functionBody})`; + } + functionBody = `return function (handle, methodName, destructorsRef, args) {\n ${functionBody}\n }`; + var invokerFunction = new Function(Object.keys(captures), functionBody)(...Object.values(captures)); + var functionName = `methodCaller<(${argTypes.map(t => t.name)}) => ${retType.name}>`; + return emval_addMethodCaller(createNamedFunction(functionName, invokerFunction)); +}; + +var __emval_get_property = (handle, key) => { + handle = Emval.toValue(handle); + key = Emval.toValue(key); + return Emval.toHandle(handle[key]); +}; + +var __emval_incref = handle => { + if (handle > 9) { + emval_handles[handle + 1] += 1; + } +}; + +var __emval_invoke = (caller, handle, methodName, destructorsRef, args) => emval_methodCallers[caller](handle, methodName, destructorsRef, args); + +var __emval_new_array = () => Emval.toHandle([]); + +var __emval_new_array_from_memory_view = view => { + view = Emval.toValue(view); + // using for..loop is faster than Array.from + var a = new Array(view.length); + for (var i = 0; i < view.length; i++) a[i] = view[i]; + return Emval.toHandle(a); +}; + +var __emval_new_cstring = v => Emval.toHandle(getStringOrSymbol(v)); + +var __emval_run_destructors = handle => { + var destructors = Emval.toValue(handle); + runDestructors(destructors); + __emval_decref(handle); +}; + +var getHeapMax = () => // Stay one Wasm page short of 4GB: while e.g. Chrome is able to allocate +// full 4GB Wasm memories, the size will wrap back to 0 bytes in Wasm side +// for any code that deals with heap sizes, which would require special +// casing all heap size related code to treat 0 specially. +2147483648; + +var alignMemory = (size, alignment) => Math.ceil(size / alignment) * alignment; + +var growMemory = size => { + var oldHeapSize = wasmMemory.buffer.byteLength; + var pages = ((size - oldHeapSize + 65535) / 65536) | 0; + try { + // round size grow request up to wasm page size (fixed 64KB per spec) + wasmMemory.grow(pages); + // .grow() takes a delta compared to the previous size + updateMemoryViews(); + return 1; + } catch (e) {} +}; + +var _emscripten_resize_heap = requestedSize => { + var oldSize = HEAPU8.length; + // With CAN_ADDRESS_2GB or MEMORY64, pointers are already unsigned. + requestedSize >>>= 0; + // With multithreaded builds, races can happen (another thread might increase the size + // in between), so return a failure, and let the caller retry. + // Memory resize rules: + // 1. Always increase heap size to at least the requested size, rounded up + // to next page multiple. + // 2a. If MEMORY_GROWTH_LINEAR_STEP == -1, excessively resize the heap + // geometrically: increase the heap size according to + // MEMORY_GROWTH_GEOMETRIC_STEP factor (default +20%), At most + // overreserve by MEMORY_GROWTH_GEOMETRIC_CAP bytes (default 96MB). + // 2b. If MEMORY_GROWTH_LINEAR_STEP != -1, excessively resize the heap + // linearly: increase the heap size by at least + // MEMORY_GROWTH_LINEAR_STEP bytes. + // 3. Max size for the heap is capped at 2048MB-WASM_PAGE_SIZE, or by + // MAXIMUM_MEMORY, or by ASAN limit, depending on which is smallest + // 4. If we were unable to allocate as much memory, it may be due to + // over-eager decision to excessively reserve due to (3) above. + // Hence if an allocation fails, cut down on the amount of excess + // growth, in an attempt to succeed to perform a smaller allocation. + // A limit is set for how much we can grow. We should not exceed that + // (the wasm binary specifies it, so if we tried, we'd fail anyhow). + var maxHeapSize = getHeapMax(); + if (requestedSize > maxHeapSize) { + return false; + } + // Loop through potential heap size increases. If we attempt a too eager + // reservation that fails, cut down on the attempted size and reserve a + // smaller bump instead. (max 3 times, chosen somewhat arbitrarily) + for (var cutDown = 1; cutDown <= 4; cutDown *= 2) { + var overGrownHeapSize = oldSize * (1 + .2 / cutDown); + // ensure geometric growth + // but limit overreserving (default to capping at +96MB overgrowth at most) + overGrownHeapSize = Math.min(overGrownHeapSize, requestedSize + 100663296); + var newSize = Math.min(maxHeapSize, alignMemory(Math.max(requestedSize, overGrownHeapSize), 65536)); + var replacement = growMemory(newSize); + if (replacement) { + return true; + } + } + return false; +}; + +// End JS library code +// include: postlibrary.js +// This file is included after the automatically-generated JS library code +// but before the wasm module is created. +{ + // Begin ATMODULES hooks + if (Module["noExitRuntime"]) noExitRuntime = Module["noExitRuntime"]; + if (Module["print"]) out = Module["print"]; + if (Module["printErr"]) err = Module["printErr"]; + if (Module["wasmBinary"]) wasmBinary = Module["wasmBinary"]; + // End ATMODULES hooks + if (Module["arguments"]) arguments_ = Module["arguments"]; + if (Module["thisProgram"]) thisProgram = Module["thisProgram"]; +} + +// Begin runtime exports +// End runtime exports +// Begin JS library exports +// End JS library exports +// end include: postlibrary.js +// Imports from the Wasm binary. +var _malloc, ___getTypeName, _free; + +function assignWasmExports(wasmExports) { + _malloc = wasmExports["C"]; + ___getTypeName = wasmExports["D"]; + _free = wasmExports["E"]; +} + +var wasmImports = { + /** @export */ m: ___cxa_throw, + /** @export */ y: __abort_js, + /** @export */ x: __embind_finalize_value_array, + /** @export */ l: __embind_register_bigint, + /** @export */ w: __embind_register_bool, + /** @export */ v: __embind_register_emval, + /** @export */ k: __embind_register_float, + /** @export */ u: __embind_register_function, + /** @export */ b: __embind_register_integer, + /** @export */ a: __embind_register_memory_view, + /** @export */ t: __embind_register_std_string, + /** @export */ g: __embind_register_std_wstring, + /** @export */ s: __embind_register_value_array, + /** @export */ j: __embind_register_value_array_element, + /** @export */ r: __embind_register_void, + /** @export */ f: __emval_create_invoker, + /** @export */ c: __emval_decref, + /** @export */ i: __emval_get_property, + /** @export */ h: __emval_incref, + /** @export */ e: __emval_invoke, + /** @export */ q: __emval_new_array, + /** @export */ p: __emval_new_array_from_memory_view, + /** @export */ o: __emval_new_cstring, + /** @export */ d: __emval_run_destructors, + /** @export */ n: _emscripten_resize_heap +}; + +var wasmExports = await createWasm(); + +// include: postamble.js +// === Auto-generated postamble setup entry stuff === +function run() { + if (runDependencies > 0) { + dependenciesFulfilled = run; + return; + } + preRun(); + // a preRun added a dependency, run will be called later + if (runDependencies > 0) { + dependenciesFulfilled = run; + return; + } + function doRun() { + // run may have just been called through dependencies being fulfilled just in this very frame, + // or while the async setStatus time below was happening + Module["calledRun"] = true; + if (ABORT) return; + initRuntime(); + readyPromiseResolve?.(Module); + Module["onRuntimeInitialized"]?.(); + postRun(); + } + if (Module["setStatus"]) { + Module["setStatus"]("Running..."); + setTimeout(() => { + setTimeout(() => Module["setStatus"](""), 1); + doRun(); + }, 1); + } else { + doRun(); + } +} + +function preInit() { + if (Module["preInit"]) { + if (typeof Module["preInit"] == "function") Module["preInit"] = [ Module["preInit"] ]; + while (Module["preInit"].length > 0) { + Module["preInit"].shift()(); + } + } +} + +preInit(); + +run(); + +// end include: postamble.js +// include: postamble_modularize.js +// In MODULARIZE mode we wrap the generated code in a factory function +// and return either the Module itself, or a promise of the module. +// We assign to the `moduleRtn` global here and configure closure to see +// this as and extern so it won't get minified. +if (runtimeInitialized) { + moduleRtn = Module; +} else { + // Set up the promise that indicates the Module is initialized + moduleRtn = new Promise((resolve, reject) => { + readyPromiseResolve = resolve; + readyPromiseReject = reject; + }); +} + + + return moduleRtn; +} + +// Export using a UMD style export, or ES6 exports if selected +export default Module; + diff --git a/js/worker/worker_wasm.wasm b/js/worker/worker_wasm.wasm new file mode 100644 index 0000000000000000000000000000000000000000..55a68a16c862d2fc33ca980320107da8ac497852 GIT binary patch literal 26346 zcmc(ndyHJyec#W0%wzZNk|Ue4S6oWEGg?`@G%3DhN?I}W9$BPB%e2$VZUd*qYPcMV z``|u@4+V~vj@{Nx+*E%!j+Cf@P}s4c7=@9zg@C%K92=>M2&oX*t=+nSVYsae1c-_l zjs8%;e!jnRXLfd%yOjKBD9^p;p8GrJ{Lb(F`<=UX&6Nw0b1wSCO^-*b(JB}BxO0yu ztE)6hTy-zookkj-^%mH;b7csR0Xq7`<9z{~YnbAxr`+S!PM>?cQZzgBN2~E~N4G@H zsOb`}XI#p4%0*ny+O_2}+UHz_>k|fZ-ukCqm7WKi9K}16C@RIVi^~bK zCS06LYt?G((o(siUw>MP7Ne1oQYDK1RebeoT<(Lm{_1o8Cdw+el%rpXUF4mQ9*kV{ z0e5@!kb5vX;cn?0i|EYmI5=|r7al$O{(C3xyZgYw+ur-$lec~Fk%v#+_Rt4T+;;4? z2W}g`Wu#B>pKtl1rDDj>c}FlnH96UJ-aP31jl;Xgokyd^D~Oqz1FA5vQwp;&;uI zG^EyuPYi;hugzrjG?~cLdO4395%2414zj?rnTYq{nE`_?%gf$r-6YFPqjAdqlO>-# zJec^;fnu(Ac?l9c1$HSUfYi%smF(5dEMJdWoOxG|vb+Lmp&)qeX{0`GH{#LwYrn&U z$w?>?d$nh@DKHw0{L>Tz_hpCo>(=r^qU+*KH5IlE#)y zW`y*1lD3|Ah!q2e>Qx9;lIV4&=@GpkCPDN{CVBvw=*4;ICltMybs_jh3G40@*$hHe z4MN3=8-z;Sd0RqN%BzJ?vDreXtkok_RS8wt-DaVpA0k{=s5%!ecceq zDpGbk=7*)OU8~3dIsYDh)k{w_;@L|GJS2DiAh+!Y397FZUSB0bVw=hw3Y1Yf`-2U)z8+20SI@l-KgdoBv z2a!a7>m?Z`Py#AOAkw9oMp@F8nw`?*HBFw!_0-$ulSY>o4O@Jmpa)=V6g*sp6-2XU z@>HZN=wqxY3)e48+jNoPiDnzlujX!;H(7QpV$-5JFHR5FqhtbW6xD8TIC%Ny@7j-tRD%%qyry!c!wSr947n z5`=oci|XLdO>fw{m#E~4Zm^m8AWoP#`(7NCSMPAXHruF-xR{;ncbTtTDzGq?sOOqn z!bPxZ+=T!Zfs&+Lt1Ll?lJC#(is`K6204coU0B0b8)lz%G&h|HYbGNiFs@-n5}D+s zAc}|;ywU#X#3O!$8M#;U>ZA2Ca);GmAm)P&fm3>-QN=3j#}s+`X1~KrY2z+04@*>q z_=!dt0R2jO7l05N-t)R=-;(Ooa7DD(__(N5@owDhWMF9~uk3d_$6eSCD{78BnMM4B zQ&bxhv@p#6j^yF{qXF*;<$kOXqQ^ee=*wpO8wno3XQzfy%j8nSUBclf zODS`(-PIK-IqnIk-sXkbnFe^`i$STuz1lF(X7&XWoX5fQ!dr9j133hSn=rsvxXgK+F z`3=dhForH{W1!yvcQqoy$=G~4K(z+J6^NKmFC_#63Q6G>;UuCVY$CJ|NiUumATy0> zX{UXeU&Zn||L<2HHLwgh0qJ_VO96$5IH)QzVS7f#3qMuHPa$vkDHr?{7C88+D$1|_ z;8T}y5#%90kZkCNINZYP;B~6O>%@u1n3M*(VUQI1MKWKF1U#I$${fTubZd7hmJB}Q zmE?$wASZ`;nGUlCR=5qFwPOt^Ee9M*hfE;Xr5z3uB@{^i1A|HA@OTLX3{0LBJxCRrFR;)KajU)<$-t%oe?9)}9c~ z*d0PR$b|&5{lIS1%pP{zbHVO3u)ET$^(9%VA`z;)7|}6N^)*?3Q&M^RkVZheA`KAZ z%&17w=&w;2WA=xp5TWe0$}RD2rbFq>ogx+y_W@kq}J8vuktU|v%vFyKQQAL zm;85L{Pv5b72)v)-61)6rQ5oiXN_ov7!XOslP{sJ<V91(kIZyIJ16XqCyBUPD&e5Dz%cC$<5m>CKL-boj4*Mm2DCtF=QJ($Am z%BewtvkEMDcra2HoN7WguU?Zl<`r%yv751}kr0A3{vg4f&_^&xjXUgMkm48N6VKwP zYqth?3ldlqU^dCFNXIjym|fVHH;a$8uiYw9A0$xjz0^FtbvRd$*jrpAL zGz&_V`ccKrS0IL$u;O<$t9HjY#RoiUhOWxTGk%n)%)cN+ejMlnjOrRN?X;4CJb5&1 ze85+i)GFf2G|Zc@Tw==+-IzkJ%gCWUL%=Gm49*sfMTZZWd%0|8(D(CT|>!=HU zgqWp5ec}lyW_Fp7P|mebnP?!ETiEY}JPsi1s#|O@3Lq0nEb0`5x>2H%6jaU}*_NcW zfMOGAD>ou7E0z3Rc}XOj@duy`6jkI+;23%G9VK4hf)itLk^ad**hAI&d0i!}zrJX7 z1qi4iqC}G;Fh$E4#YF|OoGn@)pOCSzZ}Y~ToF973VqpTC5E@n@Ad8D6Sv9#LNv69S z1mi;hQM?v%Q43<}vUn{7^cJr{-`=NNc;< zv0KZIqj(~o=*Be2xZ+&1yVfbO4e_Jp#`0}3@d*-XSup{SvSR3g-KkrcrKsG(yVz7; zS+VR6@kUT0WyR#swMI$gw5+#QWbZ@1N>GwCB22)5mSQRlhwU1Qvw5XuY=oE#kRj+W zz|g`0OFM#X>UvJx-D!d&^PRMRV&93`TFZf0I)qulVVeS=RT38%9jwRx2^;Z) z5?tBZyo&pstyds=VL$V9o7!AuV{J}+?-Xfm;1-p)O#>xFfj*)v97r*G)Jm1m!yiK1 zKJ_A8v7ST8mkxzru`rZ)c4U`KOXZzTnG@zf45bj*GAo@haHw8pCJc@&i%o>I1}L!* zEO<>nX#tU3YJoeC$`^2psRiy)GLb9DRb89F9pN;16i|UZ&lc&+$zva6Ekzz&BjFPP zW|)5u`=o%2ELj0pL_^O*0oPa`QI9TaZPudJrpkhhKDC%3?FHn4 z!*;8HYulxO8}_Jx*Iw-EzNqAVGh`(xH>pIbs6aNSV^un4k@_2XzI;KY;7es|i&A;} z79}W^%5DYwuq?6GD)N~MmZfrC%L1Xvv3e{EXAPaY8|07IEQ=YtcB8abb;F|uOV_n5 z6)X!z)GSL}WIp1!Q#P4L4TThJJg>;ID6^3OgiOZ4Qdt%&6twP=s ziC|R3DhqV7>OGg&O4clVkhQmj3gSZur zOnH{XO-DOL-9S65F+18Io$qW^+ty-Mw_tVc8=EL%q(R(lNI?_jwn5y?I`#!4#@IcC zIfxsKHzOv43}i53&=S^m#4QWr))lrm?<>q#pQvuaW-ZKDN7(u#_GU`2BW(1OJZ~p# zc;5BGM$o)b*szg>u+c(KdxVV)+JtRGaVw<7ru|mP4y7&3!$Df+a-DtXSZ) zjvP(YOz^6~by_JcWZzm>5sfrFBfYg!uFFcUcF1Kzs)0wf-Pl5#Q&Y=fWWO3EI#QUx zEvZ^5(kNY3BI9;uGF3`4!mG$$;h+!#Gh(r#Nlt}-?bB6}+z}1r$+Ext$zS_4I%YQl zOu_2#(~9MqoG#)al7cLQw6&4lR(d^Tb#4EnyG#TmuLCNoDQ?nf0NApKcaI<~5tZ89 zWqa9_PiyyJ8s2!1jqjms{fHo-p`@83ED>j*fh1(%KtxftXsn)Ww}nfak4!>1lIVY}pJK|q6wVtIZ;iVh0MM~x+$le{V+N$=fA&dg zekX}aIu^+7G$&B20Vyc!&*U++wCkb7mWe~Vth7UOW91$lnv;!V!2&B|SgDhZ1}C9v z?U`xx8$YGb#?O8TpS@*%*0H@6^RL{n>qGJ~S^#du5P5~;${H`7JVAAqZ z!D1C{s2p<>r^B%jvQ4CyGN`;Z2#CDAUM~99$%Pi{kqanoR#u4yRcajoAQwsQtX$wwrxtPds785nXS#@jh1VJSJej0z1M zgJHMlu-m?h?Mn*Vmvk&=t%1%D&eV2ea`6`mRJ3NeY2E=#Hc$mVTEQxb^5M*meF-q} z&rlMQUHQVO$H}_vkNV^4YV=f40NEX}qtTBr``3Pp^YR0ct5-3h%ocL6B(G9BgvnG{ z=Wrha$4JZkeS`pnXNvqbfCDotMf=KfgF_$CCPgY^1Ax6&nN=KuJZc-9U|*I`S#YTewQ7h=I;jP@`3#R#x1oTngV0;ZJ#GjgdijagB*i5`TNXWGvGG-`x}%nuY|z80{&VpuDvg7 z5PvciU$9A;9Ic_*hVm1sjFbT)H+Fm}-|=AnnJ?A$=2`77!;sv$PXW)MosV{*kzL8K z&_`ru>wO8>FjIXX&-`mO)N@a+*{P(VX9H|C=aSMp$b1N6-%LKxnZyVI=`+TDv*!P} zR&1XS!5aO;KJ{f{28N1ab&ip=Dr+Bz`U~1EEjOwU@Z^k=IKL%%8u8ua$v)8QP|x(i zv?|?#dPUkJq3BYNWCAnSr5^8y{I;fEyhc3>7qN1jF5j4Xh**buHoH+z+qR*QKr9T@ z!*&N2tWhuae_HeZv8IimY`8!;2jO(kRrsY*m;I*vlK)4UFZq{;{a+4yVmt3R!`S6t z81|p+^Z$34S8ojaa_t>NvAfZI3BNVN8Gzv49QNPX<8kI{{f9js15!h}418b>+?s%Y zYuJD8R!>f()-$*Iegl7Dxc2Vszb4Kp;JuifOI8}ZMwL6CWue__ObjR@OcUBw^O zBLDJ;|JS|GUmfv(q-WL9c>U^#|EHYz;>@2ychvKp5r0)Z`nW0K`G+I^nJRm=FfiD0 zdS4&$|6IKs+wk<}i2oMb*Z}jHJN=)kH^6-EPXF~jUwu&X*uT{W0i=& z_uwi|U%t~n$NaT^|I(fQU-aV}`$e+9>Z`reKYuHeez&hy_CLB6M6ap!)!XR%&3;cQxXfI(>hwmd*E%2Wi=S|3h##-z(~~`F>w5oA1wrfz9`2wO+3Ks{akOepL5; z{(lSZ>4q=+KhZ2NHGIYYUajV`6v0)dH$ zELP0QR`4DpS+)ag{A+HecDt_Ge~F7vj^!GOC8XFK9^%T(Z6_PuHUKzKbK9IL$Zb=3 zGq+vpxb0$$+%~Rou2Dfh(Nvt>4QwA)y>Q96>bxwM9M=h)>IsIPc&u>Av_L|xFbXc& z41^pQ{pOMl)?BiDvA&=%r^=MUCC6QtTsT*DEsq)tOe@PJYo{dRyfVJxe|6BL7|1-g zxo83_bJ4=oTryF3;gRov&XSYvQfu=GQtM@Z67j7=2%D1;SSRAAAu`0%8pqQR5~d0X z`M@!Rgj8jMDIp|ODhv|hL#HG~OA)lvXF|f%LPD+z300)%e7dF&;)n-6|xF( z^tAw+C+xw#cCuOai*>)2#+B9R6Cornu@e?jd|C3J{_Q`6P($I3GCK-gd;FLCYCAYT zufmzs_bKE}Yn*j|`SaoH0KRyp;t=~c_xPk%s;BlsT7&%nMEit4Nf?>baL%LzQl8ji zGXsK@KtNOCV&iKqCHxV)8zF$=jJ-PpdRtQ6fDr4=q(RN!iYpdwrxQt0(GZ7(eVyRm zf3=G$n0|!^iHTAf(EjwT1=<1%XbYl)wve!38uWsL$JZINxKw9q>6;0kxIpH#(FbMv zYWf<0j2C)|+stn?Rhh9%I!0P%%+v!7!dU;cE`EWOpA9&L7Xhc2gp<|hG^*Z9j|~*v zrbf|S>nXZR9}47&@U$qg*5Et}LMm1(zVI?sDRtEBxkhTDN=t*)6*!c204wcN zykInL#9?nSVv%FjSR3igOBQHL3RNfUj+Sg1mAL%tqjijq zF`S`KE!B5e7wLPs?Z3|fR#|ToNI`~$hrhtUkB+U(;Q`&t>h7ZK7@vF*=y$e?9XGtF6MP9e&) z-zQUAYLt8D6-sn$L@8v-if>DNE64b&$((=w9W(WQcB+W1hpvzeYF0&(669_0VJ~?_ zeE@nyp?tu2*k9or2Kq{f4e3ihkoVX2L*o)LHh!hNdo=zf_4_id4_QlJ8*6d`cv|;ZE1@-NEfu`>SWA9c?E5}{Fd=Bp zk(GX#O6cnd>{5v*Vh>9v*HNo@%^&2*Vvd48A@a;fg@MX)2!$c{*CGe1PZ!m;U)@_rbBgM)?F zrWL%lX`Rfa9ZRS6I5rWkAW2dE+Y9qK}s6op#jqsncASzlMpl}?eS=(bkP zrNl=DJb)v&OgMb=W9@-;B{=+5s)N8-VnTVVAEDDPLduGYP^cz@i0Zd^aBa${)5wtsCRBFwYW6`@4IwvUv9kz- z#Vtlk_edj=`AdlyRg71>6Tw-FBs2g*Bou8zr76z-b3`#NuvGrOJE>|bTA(@;UOHYT zv#Oo?FLZ?r)B1cMntdqjWB+Q10r)18{vdFIFg(NqT*v@7g+9RunGwZukUP$BDIBVy z!56h1N2Su?&h_pz3N9y-%hA`v;3vn(M%B)KKO)-@4jB~ipHoXhU%NZBU#0_M=$)Dd zs)ujt!4lF}xQE2Q>0z&0FRS%EegDr> z_NA2Sym>=DEo?}d?N39}RdLu~P2~l}KX%t)TBz(2p__5$#flEU6o5hqYvs=P!Rd!a zhBh~35sR|lS!pqrxn)jU(oWCd5}yy7G$;NOOI9aO{LB1tqU0j=6IeDr!Va?p^fe#i zXTH#)HSyK@prI@;Zwa2TmueODH(C_+Wu9qK^pjnsl^>1s&>B%{XMNOiWq*0Q?`XU) zwDMMGNgxP!E65mxEz_uh57_;5xxu{BSEmq55Pj(D={ zH%xUAT7{Ow#%-2>_}Cxa$@jwtaj4jyObKXi{U}=j4iJCMXla@T>>>fxUM>4Y3?RS$ zoJcB~GZ=_{KD8+o`rKp2puv;~BC;c|gbXmvO(i<_yZ43aIj610sr~LA5*dA<1^wvJ z%ouIOKg>Le)ER3n(N-o*XOR<|**L14SXMMFXim_U8^RT4*}X1oj)+p5Go*m29o{?) zUUl)z4t2&+J?f6D9oaZ4jM#Hi*=7AULg3k#qR!|pN#8mL$mar4w_pJjSYts!C~;yP zy}}G5Vi|NPC`L<$_Gp*V+3qf$8>o|IL!DRa36N!9EQRpnH9mJu&9{d?TElGCi0F2E zmSGROyWXD&5DYjr=kK0%Cny_GA6cr*0Vi*03NK_4RMZCW={qzT+QW0IPw#YsXa2q( zF)#K-Nn3*QjyTrippm~}Fomp_*4}gesZb?RPEdSFITD`sh1)KsU|H3Jp1wm^;gE%r z^&SJ}lc6McHM*BLk7|RtSzhCTIC3PFuwbhz+dPuq?HRUuu_2eUn?bjRQg^-YH^O>0 zWmrD-*a{}!Me^?NdXujPI(Ud{58&p*!ad7M#^VY7r-es%#4f_g(Hsh>AOI(aLo;7% z?o%_^dZCMuh)QTN+Qkh>=@~7PAE`dds}M90JSWyy5m??+bBozBvQFQe$ovm!1NUhI zMC#-2QEq$&p34x(hC^SeH}8(d4=HM8$C6Af11Y6U3MuzBTrd=Td;=BPb#f;A7GzAHO%S&>+!ndG+G_%JdWS zt+V;c`Gw`S>po7;x81q9g=X8`xiWs|+420&6?dsM)m~U$gPA(tTy_Uq7go;B>N>SN zz1VKeA6R*ErQN!4U~c-1ep6SjG|x;QSXrJru(&*Zso8E#wx3*VP0ycOxO-}G(LJ^> zcd8O$uCd0&o5kT=gs+i;mi!2c)wet`S|#S)`f-TCnqmWw=N$uRvzE- zb(hCCfI|e{!X(>5nFMV!34`yO+-8*5jOMxnu6*?wtFE`=Wc+ecnwo>Za^>qifgPwbx&N z_0<<&yykZ9JaXh?AA5c0t4Ch^*s)_D|Mc?LE#y7tB#b=*A_KlB!@!YeY z|NJ+OeevVZo|~TjJpY@hIv2U{?|9MH^QTIoKc>A}v{Txjq@8fr?@H0;=APmr*b2W- z&=xEP^ZA>ze;2*oH7+q;IDpQU>wOFu;n2sgvv!&G#R89h+KWY7C)R5?Ik!T;@XPp} zFWQ5&7ieqF9sDlP=6_J$KR=YcRQqZ6@E8+mKQ(?^(XV$uBLyBe0l(GW{w^@0_dEFY z?(=lfzl;6{i}n!ht@i(mz=#&_`3ZZ>2p>Tln0@?>^e%>FxY#Z1e?~^eXqSaKEqX1bNB7 zZ_)P|-s$&C#ZR!`qyNK)4zAh#BbS zHTB`gCJ!Bwg_vwFH>cYxr>0Jvpzr>syi^nSu8tEnC)44dh08~oPwW2!&D*>Fp+h}> z=hS(|xkcbKMnARhDV{Z#P00Q<*9%+XczF|!mp9@_ht|?OuWvceLo1smdT3?iOzP28 zHrKJ8ThZ;I>CJOZZ<>pq?p&YITwBu$Du*?{vOQe01NWWn;n+r)Pl~zCy6q0!==N}I zCCvAW+r!Ot;I3>BH`jrCetWnJ9k^Gvhr7~&dwqMjCp&OM7@%$Fa;^h6u|3>b!TlJy zn*;743=?xsPKF@&(jh{P$(8fd7c9h`RE!IBfPW77$HUw`@b}VIc(-8yW4;G0DrEK> z)|Vewp@J z+WPl2xQYgJ;kyD2WZUHrWXol%^=}uQf|D)og_Ez4otGUK&vM{2=Q^GphJP#5Td~1C z#~ArL*>?E={d=kClZ}^c*S}8}eX{R4KiQ_w()U>V{%c99vqdgnJ_#5-$%1@&J4e~-@S5oI*+Wmn`)OAmSxpR+!sW>xR}l?udP@x5dZM))5Ap`DHhH!+wcI+FysLOz zzBo@8dD%tfpetzyYzE?j93gBcq>HoY?0TDsVr8@05*E6Vv4 ziFSMMzI=;r;WoDCpG5YWIBI;nH;y`{2&x!sFMA>?dw0C|WjD48ua1w8PtUI)UF&h( zmur$PUhDU9Yr1k~dG@w@yIVbr=(Ss;;v<__2V5)-F`t+hF(=z&x8HId;$1Mj@}bEf zhLc@WWG-xUto~;`yD#FM7Hb?2dCOQyzwejAEaVH>St8>3_IL4hc98M>jIcB~WoUteN6Z;vB29Y*z< z>WvHBg^lbi@UxUy72Vk3)aKFEcZA$`2^;8^30QyP4ioe zbIqyNMkU>#YCp|mkG_xX{nXEGQ-qhY1g$GLVN9$sa0@f@-e3KBv9&orztEOz4u)&J zdXJ6;eD>YHw)|U=gkJjXeG_Qot5@sZrb71G7h9>v z-W1Pk+gWT*FZWonUa<{DTWzKn89jF_r`pGHDP3W+j$&hDcjFn&yHC$gw z?8Uj(=-7dqdtVejb9C(By&Ar^$5cb>g~{gGvnoKZ=S;AqCNg`+4wcLqAO2Ldmchs> zZOCB8$BCY%m`kYF)OidmwfyWaY^0 z`gyiQ;@kpB5vFUU6%c)k>x0JHV)x)A6|Z&OR5zr5U$bMOdkOkBB}qhVT`+TFHgE%{;q2oR7`)9XM-r4;4_}(B#=xV2r=JiSW zAlV8hE*~Y^*+Nr)y6p$Kh6s0EoLA;__O88S_q`mwecnvZ2T>`cY@Joum%s1goPveT zl)mw>E{)y--6l_*p8R|MLwm>Wzs;=Nx;W|b`DVLg)W`SO`>w`}kN3WP;4XW6y-asK z;IS}GH%MLo_7{F}^BLNjA5bdLV?8%KUe|Vy9sgu%U#Tv^YL~wso#a zh&v4zYQ}xHt~a~S4TPq Date: Sun, 3 Aug 2025 16:35:51 -0400 Subject: [PATCH 10/10] Revert "WebAssembly port complete" This reverts commit 4de42ceca507c377505ff36f41e84789bf7b7d18. --- js/data/gates.js | 28 +- js/main.js | 14 +- js/state/handler.js | 17 +- js/worker/transmatrix.cpp | 6893 ------------------------------- js/worker/transmatrix.js | 65 +- js/worker/transmatrix_wasm.mjs | 1744 -------- js/worker/transmatrix_wasm.wasm | Bin 100275 -> 0 bytes js/worker/worker.cpp | 369 -- js/worker/worker.js | 109 +- js/worker/worker_wasm.mjs | 1788 -------- js/worker/worker_wasm.wasm | Bin 26346 -> 0 bytes 11 files changed, 93 insertions(+), 10934 deletions(-) delete mode 100644 js/worker/transmatrix.cpp delete mode 100644 js/worker/transmatrix_wasm.mjs delete mode 100644 js/worker/transmatrix_wasm.wasm delete mode 100644 js/worker/worker.cpp delete mode 100644 js/worker/worker_wasm.mjs delete mode 100644 js/worker/worker_wasm.wasm diff --git a/js/data/gates.js b/js/data/gates.js index 5c16f8d..aa20d06 100644 --- a/js/data/gates.js +++ b/js/data/gates.js @@ -1,4 +1,5 @@ -export function negate(term, var_count) { +// Special negation function, since js stores 32 bit integers, but we need 4/8/16 bits. +export function negate(term,var_count){ return ~term & ((1 << (2 ** var_count)) - 1); } @@ -9,23 +10,28 @@ export const Gates = [ // }, { symbol:"⊕", - combine: (numbers, mask) => { + combine: (terms, numbers) => { + let mask = terms[numbers.idx][1]; if(numbers.prev) { - let over = numbers.prev.CACHE_1 | (mask & numbers.prev.CACHE_0); - let encountered = mask | numbers.prev.CACHE_0; - numbers.CACHE_1 = over; - numbers.CACHE_0 = encountered; + let over = numbers.prev.XOR_CACHE_O | (mask & numbers.prev.XOR_CACHE_E); + let encountered = mask | numbers.prev.XOR_CACHE_E; + numbers.XOR_CACHE_O = over; + numbers.XOR_CACHE_E = encountered; return ~over & encountered; } - numbers.CACHE_1 = 0; - numbers.CACHE_0 = mask; + numbers.XOR_CACHE_O = 0; + numbers.XOR_CACHE_E = mask; return mask; } }, { - symbol:"∨", - combine: (numbers, mask) => { - return numbers.CACHE_0; + symbol:"∧", + combine: (terms, numbers) => { + let mask = terms[numbers.idx][1]; + if(numbers.prev) { + return numbers.AND_CACHE = numbers.prev.AND_CACHE & mask; + } + return numbers.AND_CACHE = mask; } }, // { diff --git a/js/main.js b/js/main.js index 30d995d..c11898d 100644 --- a/js/main.js +++ b/js/main.js @@ -154,10 +154,9 @@ worker.onmessage = (e) => { }; let index = 0; -let matrixResults = JSON.parse(localStorage.getItem("matrices")); -let matrices = matrixResults?.matrices; +let matrices = JSON.parse(localStorage.getItem("matrices")); UI.setNextPrevState(index, matrices); -if (matrixResults != null) UI.displayMatrix(matrices[index], matrixResults.varCount, matrixResults.outputs); +if (matrices != null) UI.displayMatrix(matrices[index]); // Multi input worker. Generates transition matrices. transmatrix.onmessage = (e) => transmatrix_onmessage(e); @@ -168,11 +167,10 @@ function transmatrix_onmessage(e) { if (e.data.results) { localStorage.setItem("matrices", JSON.stringify(e.data.results)); - matrixResults = e.data.results; - matrices = matrixResults.matrices; + matrices = e.data.results; index = 0; UI.setNextPrevState(index, matrices); - UI.displayMatrix(matrices[index], matrixResults.varCount, matrixResults.outputs); + UI.displayMatrix(matrices[index]); } break; case "count": @@ -185,13 +183,13 @@ function next() { if (matrices != null && index < matrices.length - 1) index++; UI.setNextPrevState(index, matrices); - UI.displayMatrix(matrices[index], matrixResults.varCount, matrixResults.outputs); + UI.displayMatrix(matrices[index]); } function prev() { if (index > 0) index--; UI.setNextPrevState(index, matrices); - UI.displayMatrix(matrices[index], matrixResults.varCount, matrixResults.outputs); + UI.displayMatrix(matrices[index]); } function display() { diff --git a/js/state/handler.js b/js/state/handler.js index 5000f00..24b4ccc 100644 --- a/js/state/handler.js +++ b/js/state/handler.js @@ -205,17 +205,18 @@ export default class UIStateHandler { } } - static displayMatrix({ complexity, rows, transitioned, mask }, varCount, outputs) { + static displayMatrix({ complexity, rows, transitioned, mask }) { let text = ``; - for (let i = 0; i < rows.length; i++) { - let num = transitioned[i].toString(2).padStart(2 ** varCount, "0"); + for (let i in rows) { + let num = transitioned[i].toString(2).padStart(16, "0"); let txtMask = mask.toString(2).padStart(16, "0"); num = num.split('').map((a, idx) => (txtMask[idx] == "1" ? "x" : a)).join(''); - text += ``; - for(let j = 0; j < outputs; j++) { - text += ``; - } - text += ``; + text += ``; + text += ``; } text += `
${num}${((rows[i] >> j) & 1).toString(2)}
${(rows[i] + 2 ** transitioned.length) + .toString(2) + .substring(1) + .split("") + .join("")}${num}
`; diff --git a/js/worker/transmatrix.cpp b/js/worker/transmatrix.cpp deleted file mode 100644 index 5381a7e..0000000 --- a/js/worker/transmatrix.cpp +++ /dev/null @@ -1,6893 +0,0 @@ -#include -#include -#include - -#ifdef __EMSCRIPTEN__ -#include -#else -#include -#endif - -#include -#include -#include -#include -#include -#include - -constexpr std::pair Dictionary[][12960] = { - {{0b00, 1}, - {0b01, 2}, - {0b10, 2}, - {0b11, 1}, - {0b100, 2}, - {0b101, 1}, - {0b110, 1}, - {0b111, 2}, - {0b1000, 2}, - {0b1001, 1}, - {0b1010, 1}, - {0b1011, 2}, - {0b1100, 1}, - {0b1101, 2}, - {0b1110, 2}, - {0b1111, 1}}, - {{0b0000, 1}, {0b0001, 3}, {0b0010, 3}, {0b0011, 2}, - {0b0100, 3}, {0b0101, 2}, {0b0110, 2}, {0b0111, 3}, - {0b1000, 3}, {0b1001, 2}, {0b1010, 2}, {0b1011, 3}, - {0b1100, 2}, {0b1101, 3}, {0b1110, 3}, {0b1111, 1}, - {0b10000, 3}, {0b10001, 2}, {0b10010, 2}, {0b10011, 3}, - {0b10100, 2}, {0b10101, 3}, {0b10110, 3}, {0b10111, 4}, - {0b11000, 2}, {0b11001, 3}, {0b11010, 3}, {0b11011, 4}, - {0b11100, 3}, {0b11101, 4}, {0b11110, 4}, {0b11111, 3}, - {0b100000, 3}, {0b100001, 2}, {0b100010, 2}, {0b100011, 3}, - {0b100100, 2}, {0b100101, 3}, {0b100110, 3}, {0b100111, 4}, - {0b101000, 2}, {0b101001, 3}, {0b101010, 3}, {0b101011, 4}, - {0b101100, 3}, {0b101101, 4}, {0b101110, 4}, {0b101111, 3}, - {0b110000, 2}, {0b110001, 3}, {0b110010, 3}, {0b110011, 1}, - {0b110100, 3}, {0b110101, 4}, {0b110110, 4}, {0b110111, 3}, - {0b111000, 3}, {0b111001, 4}, {0b111010, 4}, {0b111011, 3}, - {0b111100, 1}, {0b111101, 3}, {0b111110, 3}, {0b111111, 2}, - {0b1000000, 3}, {0b1000001, 2}, {0b1000010, 2}, {0b1000011, 3}, - {0b1000100, 2}, {0b1000101, 3}, {0b1000110, 3}, {0b1000111, 4}, - {0b1001000, 2}, {0b1001001, 3}, {0b1001010, 3}, {0b1001011, 4}, - {0b1001100, 3}, {0b1001101, 4}, {0b1001110, 4}, {0b1001111, 3}, - {0b1010000, 2}, {0b1010001, 3}, {0b1010010, 3}, {0b1010011, 4}, - {0b1010100, 3}, {0b1010101, 1}, {0b1010110, 4}, {0b1010111, 3}, - {0b1011000, 3}, {0b1011001, 4}, {0b1011010, 1}, {0b1011011, 3}, - {0b1011100, 4}, {0b1011101, 3}, {0b1011110, 3}, {0b1011111, 2}, - {0b1100000, 2}, {0b1100001, 3}, {0b1100010, 3}, {0b1100011, 4}, - {0b1100100, 3}, {0b1100101, 4}, {0b1100110, 1}, {0b1100111, 3}, - {0b1101000, 3}, {0b1101001, 1}, {0b1101010, 4}, {0b1101011, 3}, - {0b1101100, 4}, {0b1101101, 3}, {0b1101110, 3}, {0b1101111, 2}, - {0b1110000, 3}, {0b1110001, 4}, {0b1110010, 4}, {0b1110011, 3}, - {0b1110100, 4}, {0b1110101, 3}, {0b1110110, 3}, {0b1110111, 2}, - {0b1111000, 4}, {0b1111001, 3}, {0b1111010, 3}, {0b1111011, 2}, - {0b1111100, 3}, {0b1111101, 2}, {0b1111110, 2}, {0b1111111, 3}, - {0b10000000, 3}, {0b10000001, 2}, {0b10000010, 2}, {0b10000011, 3}, - {0b10000100, 2}, {0b10000101, 3}, {0b10000110, 3}, {0b10000111, 4}, - {0b10001000, 2}, {0b10001001, 3}, {0b10001010, 3}, {0b10001011, 4}, - {0b10001100, 3}, {0b10001101, 4}, {0b10001110, 4}, {0b10001111, 3}, - {0b10010000, 2}, {0b10010001, 3}, {0b10010010, 3}, {0b10010011, 4}, - {0b10010100, 3}, {0b10010101, 4}, {0b10010110, 1}, {0b10010111, 3}, - {0b10011000, 3}, {0b10011001, 1}, {0b10011010, 4}, {0b10011011, 3}, - {0b10011100, 4}, {0b10011101, 3}, {0b10011110, 3}, {0b10011111, 2}, - {0b10100000, 2}, {0b10100001, 3}, {0b10100010, 3}, {0b10100011, 4}, - {0b10100100, 3}, {0b10100101, 1}, {0b10100110, 4}, {0b10100111, 3}, - {0b10101000, 3}, {0b10101001, 4}, {0b10101010, 1}, {0b10101011, 3}, - {0b10101100, 4}, {0b10101101, 3}, {0b10101110, 3}, {0b10101111, 2}, - {0b10110000, 3}, {0b10110001, 4}, {0b10110010, 4}, {0b10110011, 3}, - {0b10110100, 4}, {0b10110101, 3}, {0b10110110, 3}, {0b10110111, 2}, - {0b10111000, 4}, {0b10111001, 3}, {0b10111010, 3}, {0b10111011, 2}, - {0b10111100, 3}, {0b10111101, 2}, {0b10111110, 2}, {0b10111111, 3}, - {0b11000000, 2}, {0b11000001, 3}, {0b11000010, 3}, {0b11000011, 1}, - {0b11000100, 3}, {0b11000101, 4}, {0b11000110, 4}, {0b11000111, 3}, - {0b11001000, 3}, {0b11001001, 4}, {0b11001010, 4}, {0b11001011, 3}, - {0b11001100, 1}, {0b11001101, 3}, {0b11001110, 3}, {0b11001111, 2}, - {0b11010000, 3}, {0b11010001, 4}, {0b11010010, 4}, {0b11010011, 3}, - {0b11010100, 4}, {0b11010101, 3}, {0b11010110, 3}, {0b11010111, 2}, - {0b11011000, 4}, {0b11011001, 3}, {0b11011010, 3}, {0b11011011, 2}, - {0b11011100, 3}, {0b11011101, 2}, {0b11011110, 2}, {0b11011111, 3}, - {0b11100000, 3}, {0b11100001, 4}, {0b11100010, 4}, {0b11100011, 3}, - {0b11100100, 4}, {0b11100101, 3}, {0b11100110, 3}, {0b11100111, 2}, - {0b11101000, 4}, {0b11101001, 3}, {0b11101010, 3}, {0b11101011, 2}, - {0b11101100, 3}, {0b11101101, 2}, {0b11101110, 2}, {0b11101111, 3}, - {0b11110000, 1}, {0b11110001, 3}, {0b11110010, 3}, {0b11110011, 2}, - {0b11110100, 3}, {0b11110101, 2}, {0b11110110, 2}, {0b11110111, 3}, - {0b11111000, 3}, {0b11111001, 2}, {0b11111010, 2}, {0b11111011, 3}, - {0b11111100, 2}, {0b11111101, 3}, {0b11111110, 3}, {0b11111111, 1}}, - {{0b00000000, 1}, {0b00000001, 4}, - {0b00000010, 4}, {0b00000011, 3}, - {0b00000100, 4}, {0b00000101, 3}, - {0b00000110, 3}, {0b00000111, 5}, - {0b00001000, 4}, {0b00001001, 3}, - {0b00001010, 3}, {0b00001011, 5}, - {0b00001100, 3}, {0b00001101, 5}, - {0b00001110, 5}, {0b00001111, 2}, - {0b00010000, 4}, {0b00010001, 3}, - {0b00010010, 3}, {0b00010011, 5}, - {0b00010100, 3}, {0b00010101, 5}, - {0b00010110, 5}, {0b00010111, 4}, - {0b00011000, 3}, {0b00011001, 5}, - {0b00011010, 5}, {0b00011011, 4}, - {0b00011100, 5}, {0b00011101, 4}, - {0b00011110, 4}, {0b00100000, 4}, - {0b00100001, 3}, {0b00100010, 3}, - {0b00100011, 5}, {0b00100100, 3}, - {0b00100101, 5}, {0b00100110, 5}, - {0b00100111, 4}, {0b00101000, 3}, - {0b00101001, 5}, {0b00101010, 5}, - {0b00101011, 4}, {0b00101100, 5}, - {0b00101101, 4}, {0b00101110, 4}, - {0b00110000, 3}, {0b00110001, 5}, - {0b00110010, 5}, {0b00110011, 2}, - {0b00110100, 5}, {0b00110101, 4}, - {0b00110110, 4}, {0b00111000, 5}, - {0b00111001, 4}, {0b00111010, 4}, - {0b00111100, 2}, {0b00111111, 3}, - {0b01000000, 4}, {0b01000001, 3}, - {0b01000010, 3}, {0b01000011, 5}, - {0b01000100, 3}, {0b01000101, 5}, - {0b01000110, 5}, {0b01000111, 4}, - {0b01001000, 3}, {0b01001001, 5}, - {0b01001010, 5}, {0b01001011, 4}, - {0b01001100, 5}, {0b01001101, 4}, - {0b01001110, 4}, {0b01010000, 3}, - {0b01010001, 5}, {0b01010010, 5}, - {0b01010011, 4}, {0b01010100, 5}, - {0b01010101, 2}, {0b01010110, 4}, - {0b01011000, 5}, {0b01011001, 4}, - {0b01011010, 2}, {0b01011100, 4}, - {0b01011111, 3}, {0b01100000, 3}, - {0b01100001, 5}, {0b01100010, 5}, - {0b01100011, 4}, {0b01100100, 5}, - {0b01100101, 4}, {0b01100110, 2}, - {0b01101000, 5}, {0b01101001, 2}, - {0b01101010, 4}, {0b01101100, 4}, - {0b01101111, 3}, {0b01110000, 5}, - {0b01110001, 4}, {0b01110010, 4}, - {0b01110100, 4}, {0b01110111, 3}, - {0b01111000, 4}, {0b01111011, 3}, - {0b01111101, 3}, {0b01111110, 3}, - {0b10000000, 4}, {0b10000001, 3}, - {0b10000010, 3}, {0b10000011, 5}, - {0b10000100, 3}, {0b10000101, 5}, - {0b10000110, 5}, {0b10000111, 4}, - {0b10001000, 3}, {0b10001001, 5}, - {0b10001010, 5}, {0b10001011, 4}, - {0b10001100, 5}, {0b10001101, 4}, - {0b10001110, 4}, {0b10010000, 3}, - {0b10010001, 5}, {0b10010010, 5}, - {0b10010011, 4}, {0b10010100, 5}, - {0b10010101, 4}, {0b10010110, 2}, - {0b10011000, 5}, {0b10011001, 2}, - {0b10011010, 4}, {0b10011100, 4}, - {0b10011111, 3}, {0b10100000, 3}, - {0b10100001, 5}, {0b10100010, 5}, - {0b10100011, 4}, {0b10100100, 5}, - {0b10100101, 2}, {0b10100110, 4}, - {0b10101000, 5}, {0b10101001, 4}, - {0b10101010, 2}, {0b10101100, 4}, - {0b10101111, 3}, {0b10110000, 5}, - {0b10110001, 4}, {0b10110010, 4}, - {0b10110100, 4}, {0b10110111, 3}, - {0b10111000, 4}, {0b10111011, 3}, - {0b10111101, 3}, {0b10111110, 3}, - {0b11000000, 3}, {0b11000001, 5}, - {0b11000010, 5}, {0b11000011, 2}, - {0b11000100, 5}, {0b11000101, 4}, - {0b11000110, 4}, {0b11001000, 5}, - {0b11001001, 4}, {0b11001010, 4}, - {0b11001100, 2}, {0b11001111, 3}, - {0b11010000, 5}, {0b11010001, 4}, - {0b11010010, 4}, {0b11010100, 4}, - {0b11010111, 3}, {0b11011000, 4}, - {0b11011011, 3}, {0b11011101, 3}, - {0b11011110, 3}, {0b11100000, 5}, - {0b11100001, 4}, {0b11100010, 4}, - {0b11100100, 4}, {0b11100111, 3}, - {0b11101000, 4}, {0b11101011, 3}, - {0b11101101, 3}, {0b11101110, 3}, - {0b11110000, 2}, {0b11110011, 3}, - {0b11110101, 3}, {0b11110110, 3}, - {0b11111001, 3}, {0b11111010, 3}, - {0b11111100, 3}, {0b11111111, 1}, - {0b100000000, 4}, {0b100000001, 3}, - {0b100000010, 3}, {0b100000011, 5}, - {0b100000100, 3}, {0b100000101, 5}, - {0b100000110, 5}, {0b100000111, 4}, - {0b100001000, 3}, {0b100001001, 5}, - {0b100001010, 5}, {0b100001011, 4}, - {0b100001100, 5}, {0b100001101, 4}, - {0b100001110, 4}, {0b100010000, 3}, - {0b100010001, 5}, {0b100010010, 5}, - {0b100010011, 4}, {0b100010100, 5}, - {0b100010101, 4}, {0b100010110, 4}, - {0b100010111, 5}, {0b100011000, 5}, - {0b100011001, 4}, {0b100011010, 4}, - {0b100011011, 5}, {0b100011100, 4}, - {0b100011101, 5}, {0b100011110, 5}, - {0b100100000, 3}, {0b100100001, 5}, - {0b100100010, 5}, {0b100100011, 4}, - {0b100100100, 5}, {0b100100101, 4}, - {0b100100110, 4}, {0b100100111, 5}, - {0b100101000, 5}, {0b100101001, 4}, - {0b100101010, 4}, {0b100101011, 5}, - {0b100101100, 4}, {0b100101101, 5}, - {0b100101110, 5}, {0b100110000, 5}, - {0b100110001, 4}, {0b100110010, 4}, - {0b100110100, 4}, {0b100110101, 5}, - {0b100110110, 5}, {0b100111000, 4}, - {0b100111001, 5}, {0b100111010, 5}, - {0b101000000, 3}, {0b101000001, 5}, - {0b101000010, 5}, {0b101000011, 4}, - {0b101000100, 5}, {0b101000101, 4}, - {0b101000110, 4}, {0b101000111, 5}, - {0b101001000, 5}, {0b101001001, 4}, - {0b101001010, 4}, {0b101001011, 5}, - {0b101001100, 4}, {0b101001101, 5}, - {0b101001110, 5}, {0b101010000, 5}, - {0b101010001, 4}, {0b101010010, 4}, - {0b101010011, 5}, {0b101010100, 4}, - {0b101010110, 5}, {0b101011000, 4}, - {0b101011001, 5}, {0b101011100, 5}, - {0b101100000, 5}, {0b101100001, 4}, - {0b101100010, 4}, {0b101100011, 5}, - {0b101100100, 4}, {0b101100101, 5}, - {0b101101000, 4}, {0b101101010, 5}, - {0b101101100, 5}, {0b101110000, 4}, - {0b101110001, 5}, {0b101110010, 5}, - {0b101110100, 5}, {0b101111000, 5}, - {0b110000000, 3}, {0b110000001, 5}, - {0b110000010, 5}, {0b110000011, 4}, - {0b110000100, 5}, {0b110000101, 4}, - {0b110000110, 4}, {0b110000111, 5}, - {0b110001000, 5}, {0b110001001, 4}, - {0b110001010, 4}, {0b110001011, 5}, - {0b110001100, 4}, {0b110001101, 5}, - {0b110001110, 5}, {0b110010000, 5}, - {0b110010001, 4}, {0b110010010, 4}, - {0b110010011, 5}, {0b110010100, 4}, - {0b110010101, 5}, {0b110011000, 4}, - {0b110011010, 5}, {0b110011100, 5}, - {0b110100000, 5}, {0b110100001, 4}, - {0b110100010, 4}, {0b110100011, 5}, - {0b110100100, 4}, {0b110100110, 5}, - {0b110101000, 4}, {0b110101001, 5}, - {0b110101100, 5}, {0b110110000, 4}, - {0b110110001, 5}, {0b110110010, 5}, - {0b110110100, 5}, {0b110111000, 5}, - {0b111000000, 5}, {0b111000001, 4}, - {0b111000010, 4}, {0b111000100, 4}, - {0b111000101, 5}, {0b111000110, 5}, - {0b111001000, 4}, {0b111001001, 5}, - {0b111001010, 5}, {0b111010000, 4}, - {0b111010001, 5}, {0b111010010, 5}, - {0b111010100, 5}, {0b111011000, 5}, - {0b111100000, 4}, {0b111100001, 5}, - {0b111100010, 5}, {0b111100100, 5}, - {0b111101000, 5}, {0b1000000000, 4}, - {0b1000000001, 3}, {0b1000000010, 3}, - {0b1000000011, 5}, {0b1000000100, 3}, - {0b1000000101, 5}, {0b1000000110, 5}, - {0b1000000111, 4}, {0b1000001000, 3}, - {0b1000001001, 5}, {0b1000001010, 5}, - {0b1000001011, 4}, {0b1000001100, 5}, - {0b1000001101, 4}, {0b1000001110, 4}, - {0b1000010000, 3}, {0b1000010001, 5}, - {0b1000010010, 5}, {0b1000010011, 4}, - {0b1000010100, 5}, {0b1000010101, 4}, - {0b1000010110, 4}, {0b1000010111, 5}, - {0b1000011000, 5}, {0b1000011001, 4}, - {0b1000011010, 4}, {0b1000011011, 5}, - {0b1000011100, 4}, {0b1000011101, 5}, - {0b1000011110, 5}, {0b1000100000, 3}, - {0b1000100001, 5}, {0b1000100010, 5}, - {0b1000100011, 4}, {0b1000100100, 5}, - {0b1000100101, 4}, {0b1000100110, 4}, - {0b1000100111, 5}, {0b1000101000, 5}, - {0b1000101001, 4}, {0b1000101010, 4}, - {0b1000101011, 5}, {0b1000101100, 4}, - {0b1000101101, 5}, {0b1000101110, 5}, - {0b1000110000, 5}, {0b1000110001, 4}, - {0b1000110010, 4}, {0b1000110100, 4}, - {0b1000110101, 5}, {0b1000110110, 5}, - {0b1000111000, 4}, {0b1000111001, 5}, - {0b1000111010, 5}, {0b1001000000, 3}, - {0b1001000001, 5}, {0b1001000010, 5}, - {0b1001000011, 4}, {0b1001000100, 5}, - {0b1001000101, 4}, {0b1001000110, 4}, - {0b1001000111, 5}, {0b1001001000, 5}, - {0b1001001001, 4}, {0b1001001010, 4}, - {0b1001001011, 5}, {0b1001001100, 4}, - {0b1001001101, 5}, {0b1001001110, 5}, - {0b1001010000, 5}, {0b1001010001, 4}, - {0b1001010010, 4}, {0b1001010011, 5}, - {0b1001010100, 4}, {0b1001010110, 5}, - {0b1001011000, 4}, {0b1001011001, 5}, - {0b1001011100, 5}, {0b1001100000, 5}, - {0b1001100001, 4}, {0b1001100010, 4}, - {0b1001100011, 5}, {0b1001100100, 4}, - {0b1001100101, 5}, {0b1001101000, 4}, - {0b1001101010, 5}, {0b1001101100, 5}, - {0b1001110000, 4}, {0b1001110001, 5}, - {0b1001110010, 5}, {0b1001110100, 5}, - {0b1001111000, 5}, {0b1010000000, 3}, - {0b1010000001, 5}, {0b1010000010, 5}, - {0b1010000011, 4}, {0b1010000100, 5}, - {0b1010000101, 4}, {0b1010000110, 4}, - {0b1010000111, 5}, {0b1010001000, 5}, - {0b1010001001, 4}, {0b1010001010, 4}, - {0b1010001011, 5}, {0b1010001100, 4}, - {0b1010001101, 5}, {0b1010001110, 5}, - {0b1010010000, 5}, {0b1010010001, 4}, - {0b1010010010, 4}, {0b1010010011, 5}, - {0b1010010100, 4}, {0b1010010101, 5}, - {0b1010011000, 4}, {0b1010011010, 5}, - {0b1010011100, 5}, {0b1010100000, 5}, - {0b1010100001, 4}, {0b1010100010, 4}, - {0b1010100011, 5}, {0b1010100100, 4}, - {0b1010100110, 5}, {0b1010101000, 4}, - {0b1010101001, 5}, {0b1010101100, 5}, - {0b1010110000, 4}, {0b1010110001, 5}, - {0b1010110010, 5}, {0b1010110100, 5}, - {0b1010111000, 5}, {0b1011000000, 5}, - {0b1011000001, 4}, {0b1011000010, 4}, - {0b1011000100, 4}, {0b1011000101, 5}, - {0b1011000110, 5}, {0b1011001000, 4}, - {0b1011001001, 5}, {0b1011001010, 5}, - {0b1011010000, 4}, {0b1011010001, 5}, - {0b1011010010, 5}, {0b1011010100, 5}, - {0b1011011000, 5}, {0b1011100000, 4}, - {0b1011100001, 5}, {0b1011100010, 5}, - {0b1011100100, 5}, {0b1011101000, 5}, - {0b1100000000, 3}, {0b1100000001, 5}, - {0b1100000010, 5}, {0b1100000011, 2}, - {0b1100000100, 5}, {0b1100000101, 4}, - {0b1100000110, 4}, {0b1100001000, 5}, - {0b1100001001, 4}, {0b1100001010, 4}, - {0b1100001100, 2}, {0b1100001111, 3}, - {0b1100010000, 5}, {0b1100010001, 4}, - {0b1100010010, 4}, {0b1100010100, 4}, - {0b1100010101, 5}, {0b1100010110, 5}, - {0b1100011000, 4}, {0b1100011001, 5}, - {0b1100011010, 5}, {0b1100100000, 5}, - {0b1100100001, 4}, {0b1100100010, 4}, - {0b1100100100, 4}, {0b1100100101, 5}, - {0b1100100110, 5}, {0b1100101000, 4}, - {0b1100101001, 5}, {0b1100101010, 5}, - {0b1100110000, 2}, {0b1100110011, 3}, - {0b1100111100, 3}, {0b1100111111, 4}, - {0b1101000000, 5}, {0b1101000001, 4}, - {0b1101000010, 4}, {0b1101000100, 4}, - {0b1101000101, 5}, {0b1101000110, 5}, - {0b1101001000, 4}, {0b1101001001, 5}, - {0b1101001010, 5}, {0b1101010000, 4}, - {0b1101010001, 5}, {0b1101010010, 5}, - {0b1101010100, 5}, {0b1101011000, 5}, - {0b1101100000, 4}, {0b1101100001, 5}, - {0b1101100010, 5}, {0b1101100100, 5}, - {0b1101101000, 5}, {0b1110000000, 5}, - {0b1110000001, 4}, {0b1110000010, 4}, - {0b1110000100, 4}, {0b1110000101, 5}, - {0b1110000110, 5}, {0b1110001000, 4}, - {0b1110001001, 5}, {0b1110001010, 5}, - {0b1110010000, 4}, {0b1110010001, 5}, - {0b1110010010, 5}, {0b1110010100, 5}, - {0b1110011000, 5}, {0b1110100000, 4}, - {0b1110100001, 5}, {0b1110100010, 5}, - {0b1110100100, 5}, {0b1110101000, 5}, - {0b1111000000, 2}, {0b1111000011, 3}, - {0b1111001100, 3}, {0b1111001111, 4}, - {0b1111110000, 3}, {0b1111110011, 4}, - {0b1111111100, 4}, {0b1111111111, 3}, - {0b10000000000, 4}, {0b10000000001, 3}, - {0b10000000010, 3}, {0b10000000011, 5}, - {0b10000000100, 3}, {0b10000000101, 5}, - {0b10000000110, 5}, {0b10000000111, 4}, - {0b10000001000, 3}, {0b10000001001, 5}, - {0b10000001010, 5}, {0b10000001011, 4}, - {0b10000001100, 5}, {0b10000001101, 4}, - {0b10000001110, 4}, {0b10000010000, 3}, - {0b10000010001, 5}, {0b10000010010, 5}, - {0b10000010011, 4}, {0b10000010100, 5}, - {0b10000010101, 4}, {0b10000010110, 4}, - {0b10000010111, 5}, {0b10000011000, 5}, - {0b10000011001, 4}, {0b10000011010, 4}, - {0b10000011011, 5}, {0b10000011100, 4}, - {0b10000011101, 5}, {0b10000011110, 5}, - {0b10000100000, 3}, {0b10000100001, 5}, - {0b10000100010, 5}, {0b10000100011, 4}, - {0b10000100100, 5}, {0b10000100101, 4}, - {0b10000100110, 4}, {0b10000100111, 5}, - {0b10000101000, 5}, {0b10000101001, 4}, - {0b10000101010, 4}, {0b10000101011, 5}, - {0b10000101100, 4}, {0b10000101101, 5}, - {0b10000101110, 5}, {0b10000110000, 5}, - {0b10000110001, 4}, {0b10000110010, 4}, - {0b10000110100, 4}, {0b10000110101, 5}, - {0b10000110110, 5}, {0b10000111000, 4}, - {0b10000111001, 5}, {0b10000111010, 5}, - {0b10001000000, 3}, {0b10001000001, 5}, - {0b10001000010, 5}, {0b10001000011, 4}, - {0b10001000100, 5}, {0b10001000101, 4}, - {0b10001000110, 4}, {0b10001000111, 5}, - {0b10001001000, 5}, {0b10001001001, 4}, - {0b10001001010, 4}, {0b10001001011, 5}, - {0b10001001100, 4}, {0b10001001101, 5}, - {0b10001001110, 5}, {0b10001010000, 5}, - {0b10001010001, 4}, {0b10001010010, 4}, - {0b10001010011, 5}, {0b10001010100, 4}, - {0b10001010110, 5}, {0b10001011000, 4}, - {0b10001011001, 5}, {0b10001011100, 5}, - {0b10001100000, 5}, {0b10001100001, 4}, - {0b10001100010, 4}, {0b10001100011, 5}, - {0b10001100100, 4}, {0b10001100101, 5}, - {0b10001101000, 4}, {0b10001101010, 5}, - {0b10001101100, 5}, {0b10001110000, 4}, - {0b10001110001, 5}, {0b10001110010, 5}, - {0b10001110100, 5}, {0b10001111000, 5}, - {0b10010000000, 3}, {0b10010000001, 5}, - {0b10010000010, 5}, {0b10010000011, 4}, - {0b10010000100, 5}, {0b10010000101, 4}, - {0b10010000110, 4}, {0b10010000111, 5}, - {0b10010001000, 5}, {0b10010001001, 4}, - {0b10010001010, 4}, {0b10010001011, 5}, - {0b10010001100, 4}, {0b10010001101, 5}, - {0b10010001110, 5}, {0b10010010000, 5}, - {0b10010010001, 4}, {0b10010010010, 4}, - {0b10010010011, 5}, {0b10010010100, 4}, - {0b10010010101, 5}, {0b10010011000, 4}, - {0b10010011010, 5}, {0b10010011100, 5}, - {0b10010100000, 5}, {0b10010100001, 4}, - {0b10010100010, 4}, {0b10010100011, 5}, - {0b10010100100, 4}, {0b10010100110, 5}, - {0b10010101000, 4}, {0b10010101001, 5}, - {0b10010101100, 5}, {0b10010110000, 4}, - {0b10010110001, 5}, {0b10010110010, 5}, - {0b10010110100, 5}, {0b10010111000, 5}, - {0b10011000000, 5}, {0b10011000001, 4}, - {0b10011000010, 4}, {0b10011000100, 4}, - {0b10011000101, 5}, {0b10011000110, 5}, - {0b10011001000, 4}, {0b10011001001, 5}, - {0b10011001010, 5}, {0b10011010000, 4}, - {0b10011010001, 5}, {0b10011010010, 5}, - {0b10011010100, 5}, {0b10011011000, 5}, - {0b10011100000, 4}, {0b10011100001, 5}, - {0b10011100010, 5}, {0b10011100100, 5}, - {0b10011101000, 5}, {0b10100000000, 3}, - {0b10100000001, 5}, {0b10100000010, 5}, - {0b10100000011, 4}, {0b10100000100, 5}, - {0b10100000101, 2}, {0b10100000110, 4}, - {0b10100001000, 5}, {0b10100001001, 4}, - {0b10100001010, 2}, {0b10100001100, 4}, - {0b10100001111, 3}, {0b10100010000, 5}, - {0b10100010001, 4}, {0b10100010010, 4}, - {0b10100010011, 5}, {0b10100010100, 4}, - {0b10100010110, 5}, {0b10100011000, 4}, - {0b10100011001, 5}, {0b10100011100, 5}, - {0b10100100000, 5}, {0b10100100001, 4}, - {0b10100100010, 4}, {0b10100100011, 5}, - {0b10100100100, 4}, {0b10100100110, 5}, - {0b10100101000, 4}, {0b10100101001, 5}, - {0b10100101100, 5}, {0b10100110000, 4}, - {0b10100110001, 5}, {0b10100110010, 5}, - {0b10100110100, 5}, {0b10100111000, 5}, - {0b10101000000, 5}, {0b10101000001, 4}, - {0b10101000010, 4}, {0b10101000011, 5}, - {0b10101000100, 4}, {0b10101000110, 5}, - {0b10101001000, 4}, {0b10101001001, 5}, - {0b10101001100, 5}, {0b10101010000, 2}, - {0b10101010101, 3}, {0b10101011010, 3}, - {0b10101011111, 4}, {0b10101100000, 4}, - {0b10101100001, 5}, {0b10101100010, 5}, - {0b10101100100, 5}, {0b10101101000, 5}, - {0b10110000000, 5}, {0b10110000001, 4}, - {0b10110000010, 4}, {0b10110000011, 5}, - {0b10110000100, 4}, {0b10110000110, 5}, - {0b10110001000, 4}, {0b10110001001, 5}, - {0b10110001100, 5}, {0b10110010000, 4}, - {0b10110010001, 5}, {0b10110010010, 5}, - {0b10110010100, 5}, {0b10110011000, 5}, - {0b10110100000, 2}, {0b10110100101, 3}, - {0b10110101010, 3}, {0b10110101111, 4}, - {0b10111000000, 4}, {0b10111000001, 5}, - {0b10111000010, 5}, {0b10111000100, 5}, - {0b10111001000, 5}, {0b10111110000, 3}, - {0b10111110101, 4}, {0b10111111010, 4}, - {0b10111111111, 3}, {0b11000000000, 3}, - {0b11000000001, 5}, {0b11000000010, 5}, - {0b11000000011, 4}, {0b11000000100, 5}, - {0b11000000101, 4}, {0b11000000110, 2}, - {0b11000001000, 5}, {0b11000001001, 2}, - {0b11000001010, 4}, {0b11000001100, 4}, - {0b11000001111, 3}, {0b11000010000, 5}, - {0b11000010001, 4}, {0b11000010010, 4}, - {0b11000010011, 5}, {0b11000010100, 4}, - {0b11000010101, 5}, {0b11000011000, 4}, - {0b11000011010, 5}, {0b11000011100, 5}, - {0b11000100000, 5}, {0b11000100001, 4}, - {0b11000100010, 4}, {0b11000100011, 5}, - {0b11000100100, 4}, {0b11000100101, 5}, - {0b11000101000, 4}, {0b11000101010, 5}, - {0b11000101100, 5}, {0b11000110000, 4}, - {0b11000110001, 5}, {0b11000110010, 5}, - {0b11000110100, 5}, {0b11000111000, 5}, - {0b11001000000, 5}, {0b11001000001, 4}, - {0b11001000010, 4}, {0b11001000011, 5}, - {0b11001000100, 4}, {0b11001000101, 5}, - {0b11001001000, 4}, {0b11001001010, 5}, - {0b11001001100, 5}, {0b11001010000, 4}, - {0b11001010001, 5}, {0b11001010010, 5}, - {0b11001010100, 5}, {0b11001011000, 5}, - {0b11001100000, 2}, {0b11001100110, 3}, - {0b11001101001, 3}, {0b11001101111, 4}, - {0b11010000000, 5}, {0b11010000001, 4}, - {0b11010000010, 4}, {0b11010000011, 5}, - {0b11010000100, 4}, {0b11010000101, 5}, - {0b11010001000, 4}, {0b11010001010, 5}, - {0b11010001100, 5}, {0b11010010000, 2}, - {0b11010010110, 3}, {0b11010011001, 3}, - {0b11010011111, 4}, {0b11010100000, 4}, - {0b11010100001, 5}, {0b11010100010, 5}, - {0b11010100100, 5}, {0b11010101000, 5}, - {0b11011000000, 4}, {0b11011000001, 5}, - {0b11011000010, 5}, {0b11011000100, 5}, - {0b11011001000, 5}, {0b11011110000, 3}, - {0b11011110110, 4}, {0b11011111001, 4}, - {0b11011111111, 3}, {0b11100000000, 5}, - {0b11100000001, 4}, {0b11100000010, 4}, - {0b11100000100, 4}, {0b11100000111, 3}, - {0b11100001000, 4}, {0b11100001011, 3}, - {0b11100001101, 3}, {0b11100001110, 3}, - {0b11100010000, 4}, {0b11100010001, 5}, - {0b11100010010, 5}, {0b11100010100, 5}, - {0b11100011000, 5}, {0b11100100000, 4}, - {0b11100100001, 5}, {0b11100100010, 5}, - {0b11100100100, 5}, {0b11100101000, 5}, - {0b11101000000, 4}, {0b11101000001, 5}, - {0b11101000010, 5}, {0b11101000100, 5}, - {0b11101001000, 5}, {0b11101110000, 3}, - {0b11110000000, 4}, {0b11110000001, 5}, - {0b11110000010, 5}, {0b11110000100, 5}, - {0b11110001000, 5}, {0b11110110000, 3}, - {0b11111010000, 3}, {0b11111100000, 3}, - {0b100000000000, 4}, {0b100000000001, 3}, - {0b100000000010, 3}, {0b100000000011, 5}, - {0b100000000100, 3}, {0b100000000101, 5}, - {0b100000000110, 5}, {0b100000000111, 4}, - {0b100000001000, 3}, {0b100000001001, 5}, - {0b100000001010, 5}, {0b100000001011, 4}, - {0b100000001100, 5}, {0b100000001101, 4}, - {0b100000001110, 4}, {0b100000010000, 3}, - {0b100000010001, 5}, {0b100000010010, 5}, - {0b100000010011, 4}, {0b100000010100, 5}, - {0b100000010101, 4}, {0b100000010110, 4}, - {0b100000010111, 5}, {0b100000011000, 5}, - {0b100000011001, 4}, {0b100000011010, 4}, - {0b100000011011, 5}, {0b100000011100, 4}, - {0b100000011101, 5}, {0b100000011110, 5}, - {0b100000100000, 3}, {0b100000100001, 5}, - {0b100000100010, 5}, {0b100000100011, 4}, - {0b100000100100, 5}, {0b100000100101, 4}, - {0b100000100110, 4}, {0b100000100111, 5}, - {0b100000101000, 5}, {0b100000101001, 4}, - {0b100000101010, 4}, {0b100000101011, 5}, - {0b100000101100, 4}, {0b100000101101, 5}, - {0b100000101110, 5}, {0b100000110000, 5}, - {0b100000110001, 4}, {0b100000110010, 4}, - {0b100000110100, 4}, {0b100000110101, 5}, - {0b100000110110, 5}, {0b100000111000, 4}, - {0b100000111001, 5}, {0b100000111010, 5}, - {0b100001000000, 3}, {0b100001000001, 5}, - {0b100001000010, 5}, {0b100001000011, 4}, - {0b100001000100, 5}, {0b100001000101, 4}, - {0b100001000110, 4}, {0b100001000111, 5}, - {0b100001001000, 5}, {0b100001001001, 4}, - {0b100001001010, 4}, {0b100001001011, 5}, - {0b100001001100, 4}, {0b100001001101, 5}, - {0b100001001110, 5}, {0b100001010000, 5}, - {0b100001010001, 4}, {0b100001010010, 4}, - {0b100001010011, 5}, {0b100001010100, 4}, - {0b100001010110, 5}, {0b100001011000, 4}, - {0b100001011001, 5}, {0b100001011100, 5}, - {0b100001100000, 5}, {0b100001100001, 4}, - {0b100001100010, 4}, {0b100001100011, 5}, - {0b100001100100, 4}, {0b100001100101, 5}, - {0b100001101000, 4}, {0b100001101010, 5}, - {0b100001101100, 5}, {0b100001110000, 4}, - {0b100001110001, 5}, {0b100001110010, 5}, - {0b100001110100, 5}, {0b100001111000, 5}, - {0b100010000000, 3}, {0b100010000001, 5}, - {0b100010000010, 5}, {0b100010000011, 4}, - {0b100010000100, 5}, {0b100010000101, 4}, - {0b100010000110, 4}, {0b100010000111, 5}, - {0b100010001000, 5}, {0b100010001001, 4}, - {0b100010001010, 4}, {0b100010001011, 5}, - {0b100010001100, 4}, {0b100010001101, 5}, - {0b100010001110, 5}, {0b100010010000, 5}, - {0b100010010001, 4}, {0b100010010010, 4}, - {0b100010010011, 5}, {0b100010010100, 4}, - {0b100010010101, 5}, {0b100010011000, 4}, - {0b100010011010, 5}, {0b100010011100, 5}, - {0b100010100000, 5}, {0b100010100001, 4}, - {0b100010100010, 4}, {0b100010100011, 5}, - {0b100010100100, 4}, {0b100010100110, 5}, - {0b100010101000, 4}, {0b100010101001, 5}, - {0b100010101100, 5}, {0b100010110000, 4}, - {0b100010110001, 5}, {0b100010110010, 5}, - {0b100010110100, 5}, {0b100010111000, 5}, - {0b100011000000, 5}, {0b100011000001, 4}, - {0b100011000010, 4}, {0b100011000100, 4}, - {0b100011000101, 5}, {0b100011000110, 5}, - {0b100011001000, 4}, {0b100011001001, 5}, - {0b100011001010, 5}, {0b100011010000, 4}, - {0b100011010001, 5}, {0b100011010010, 5}, - {0b100011010100, 5}, {0b100011011000, 5}, - {0b100011100000, 4}, {0b100011100001, 5}, - {0b100011100010, 5}, {0b100011100100, 5}, - {0b100011101000, 5}, {0b100100000000, 3}, - {0b100100000001, 5}, {0b100100000010, 5}, - {0b100100000011, 4}, {0b100100000100, 5}, - {0b100100000101, 4}, {0b100100000110, 2}, - {0b100100001000, 5}, {0b100100001001, 2}, - {0b100100001010, 4}, {0b100100001100, 4}, - {0b100100001111, 3}, {0b100100010000, 5}, - {0b100100010001, 4}, {0b100100010010, 4}, - {0b100100010011, 5}, {0b100100010100, 4}, - {0b100100010101, 5}, {0b100100011000, 4}, - {0b100100011010, 5}, {0b100100011100, 5}, - {0b100100100000, 5}, {0b100100100001, 4}, - {0b100100100010, 4}, {0b100100100011, 5}, - {0b100100100100, 4}, {0b100100100101, 5}, - {0b100100101000, 4}, {0b100100101010, 5}, - {0b100100101100, 5}, {0b100100110000, 4}, - {0b100100110001, 5}, {0b100100110010, 5}, - {0b100100110100, 5}, {0b100100111000, 5}, - {0b100101000000, 5}, {0b100101000001, 4}, - {0b100101000010, 4}, {0b100101000011, 5}, - {0b100101000100, 4}, {0b100101000101, 5}, - {0b100101001000, 4}, {0b100101001010, 5}, - {0b100101001100, 5}, {0b100101010000, 4}, - {0b100101010001, 5}, {0b100101010010, 5}, - {0b100101010100, 5}, {0b100101011000, 5}, - {0b100101100000, 2}, {0b100101100110, 3}, - {0b100101101001, 3}, {0b100101101111, 4}, - {0b100110000000, 5}, {0b100110000001, 4}, - {0b100110000010, 4}, {0b100110000011, 5}, - {0b100110000100, 4}, {0b100110000101, 5}, - {0b100110001000, 4}, {0b100110001010, 5}, - {0b100110001100, 5}, {0b100110010000, 2}, - {0b100110010110, 3}, {0b100110011001, 3}, - {0b100110011111, 4}, {0b100110100000, 4}, - {0b100110100001, 5}, {0b100110100010, 5}, - {0b100110100100, 5}, {0b100110101000, 5}, - {0b100111000000, 4}, {0b100111000001, 5}, - {0b100111000010, 5}, {0b100111000100, 5}, - {0b100111001000, 5}, {0b100111110000, 3}, - {0b100111110110, 4}, {0b100111111001, 4}, - {0b100111111111, 3}, {0b101000000000, 3}, - {0b101000000001, 5}, {0b101000000010, 5}, - {0b101000000011, 4}, {0b101000000100, 5}, - {0b101000000101, 2}, {0b101000000110, 4}, - {0b101000001000, 5}, {0b101000001001, 4}, - {0b101000001010, 2}, {0b101000001100, 4}, - {0b101000001111, 3}, {0b101000010000, 5}, - {0b101000010001, 4}, {0b101000010010, 4}, - {0b101000010011, 5}, {0b101000010100, 4}, - {0b101000010110, 5}, {0b101000011000, 4}, - {0b101000011001, 5}, {0b101000011100, 5}, - {0b101000100000, 5}, {0b101000100001, 4}, - {0b101000100010, 4}, {0b101000100011, 5}, - {0b101000100100, 4}, {0b101000100110, 5}, - {0b101000101000, 4}, {0b101000101001, 5}, - {0b101000101100, 5}, {0b101000110000, 4}, - {0b101000110001, 5}, {0b101000110010, 5}, - {0b101000110100, 5}, {0b101000111000, 5}, - {0b101001000000, 5}, {0b101001000001, 4}, - {0b101001000010, 4}, {0b101001000011, 5}, - {0b101001000100, 4}, {0b101001000110, 5}, - {0b101001001000, 4}, {0b101001001001, 5}, - {0b101001001100, 5}, {0b101001010000, 2}, - {0b101001010101, 3}, {0b101001011010, 3}, - {0b101001011111, 4}, {0b101001100000, 4}, - {0b101001100001, 5}, {0b101001100010, 5}, - {0b101001100100, 5}, {0b101001101000, 5}, - {0b101010000000, 5}, {0b101010000001, 4}, - {0b101010000010, 4}, {0b101010000011, 5}, - {0b101010000100, 4}, {0b101010000110, 5}, - {0b101010001000, 4}, {0b101010001001, 5}, - {0b101010001100, 5}, {0b101010010000, 4}, - {0b101010010001, 5}, {0b101010010010, 5}, - {0b101010010100, 5}, {0b101010011000, 5}, - {0b101010100000, 2}, {0b101010100101, 3}, - {0b101010101010, 3}, {0b101010101111, 4}, - {0b101011000000, 4}, {0b101011000001, 5}, - {0b101011000010, 5}, {0b101011000100, 5}, - {0b101011001000, 5}, {0b101011110000, 3}, - {0b101011110101, 4}, {0b101011111010, 4}, - {0b101011111111, 3}, {0b101100000000, 5}, - {0b101100000001, 4}, {0b101100000010, 4}, - {0b101100000100, 4}, {0b101100000111, 3}, - {0b101100001000, 4}, {0b101100001011, 3}, - {0b101100001101, 3}, {0b101100001110, 3}, - {0b101100010000, 4}, {0b101100010001, 5}, - {0b101100010010, 5}, {0b101100010100, 5}, - {0b101100011000, 5}, {0b101100100000, 4}, - {0b101100100001, 5}, {0b101100100010, 5}, - {0b101100100100, 5}, {0b101100101000, 5}, - {0b101101000000, 4}, {0b101101000001, 5}, - {0b101101000010, 5}, {0b101101000100, 5}, - {0b101101001000, 5}, {0b101101110000, 3}, - {0b101110000000, 4}, {0b101110000001, 5}, - {0b101110000010, 5}, {0b101110000100, 5}, - {0b101110001000, 5}, {0b101110110000, 3}, - {0b101111010000, 3}, {0b101111100000, 3}, - {0b110000000000, 3}, {0b110000000001, 5}, - {0b110000000010, 5}, {0b110000000011, 2}, - {0b110000000100, 5}, {0b110000000101, 4}, - {0b110000000110, 4}, {0b110000001000, 5}, - {0b110000001001, 4}, {0b110000001010, 4}, - {0b110000001100, 2}, {0b110000001111, 3}, - {0b110000010000, 5}, {0b110000010001, 4}, - {0b110000010010, 4}, {0b110000010100, 4}, - {0b110000010101, 5}, {0b110000010110, 5}, - {0b110000011000, 4}, {0b110000011001, 5}, - {0b110000011010, 5}, {0b110000100000, 5}, - {0b110000100001, 4}, {0b110000100010, 4}, - {0b110000100100, 4}, {0b110000100101, 5}, - {0b110000100110, 5}, {0b110000101000, 4}, - {0b110000101001, 5}, {0b110000101010, 5}, - {0b110000110000, 2}, {0b110000110011, 3}, - {0b110000111100, 3}, {0b110000111111, 4}, - {0b110001000000, 5}, {0b110001000001, 4}, - {0b110001000010, 4}, {0b110001000100, 4}, - {0b110001000101, 5}, {0b110001000110, 5}, - {0b110001001000, 4}, {0b110001001001, 5}, - {0b110001001010, 5}, {0b110001010000, 4}, - {0b110001010001, 5}, {0b110001010010, 5}, - {0b110001010100, 5}, {0b110001011000, 5}, - {0b110001100000, 4}, {0b110001100001, 5}, - {0b110001100010, 5}, {0b110001100100, 5}, - {0b110001101000, 5}, {0b110010000000, 5}, - {0b110010000001, 4}, {0b110010000010, 4}, - {0b110010000100, 4}, {0b110010000101, 5}, - {0b110010000110, 5}, {0b110010001000, 4}, - {0b110010001001, 5}, {0b110010001010, 5}, - {0b110010010000, 4}, {0b110010010001, 5}, - {0b110010010010, 5}, {0b110010010100, 5}, - {0b110010011000, 5}, {0b110010100000, 4}, - {0b110010100001, 5}, {0b110010100010, 5}, - {0b110010100100, 5}, {0b110010101000, 5}, - {0b110011000000, 2}, {0b110011000011, 3}, - {0b110011001100, 3}, {0b110011001111, 4}, - {0b110011110000, 3}, {0b110011110011, 4}, - {0b110011111100, 4}, {0b110011111111, 3}, - {0b110100000000, 5}, {0b110100000001, 4}, - {0b110100000010, 4}, {0b110100000100, 4}, - {0b110100000111, 3}, {0b110100001000, 4}, - {0b110100001011, 3}, {0b110100001101, 3}, - {0b110100001110, 3}, {0b110100010000, 4}, - {0b110100010001, 5}, {0b110100010010, 5}, - {0b110100010100, 5}, {0b110100011000, 5}, - {0b110100100000, 4}, {0b110100100001, 5}, - {0b110100100010, 5}, {0b110100100100, 5}, - {0b110100101000, 5}, {0b110101000000, 4}, - {0b110101000001, 5}, {0b110101000010, 5}, - {0b110101000100, 5}, {0b110101001000, 5}, - {0b110101110000, 3}, {0b110110000000, 4}, - {0b110110000001, 5}, {0b110110000010, 5}, - {0b110110000100, 5}, {0b110110001000, 5}, - {0b110110110000, 3}, {0b110111010000, 3}, - {0b110111100000, 3}, {0b111000000000, 5}, - {0b111000000001, 4}, {0b111000000010, 4}, - {0b111000000100, 4}, {0b111000000111, 3}, - {0b111000001000, 4}, {0b111000001011, 3}, - {0b111000001101, 3}, {0b111000001110, 3}, - {0b111000010000, 4}, {0b111000010001, 5}, - {0b111000010010, 5}, {0b111000010100, 5}, - {0b111000011000, 5}, {0b111000100000, 4}, - {0b111000100001, 5}, {0b111000100010, 5}, - {0b111000100100, 5}, {0b111000101000, 5}, - {0b111001000000, 4}, {0b111001000001, 5}, - {0b111001000010, 5}, {0b111001000100, 5}, - {0b111001001000, 5}, {0b111001110000, 3}, - {0b111010000000, 4}, {0b111010000001, 5}, - {0b111010000010, 5}, {0b111010000100, 5}, - {0b111010001000, 5}, {0b111010110000, 3}, - {0b111011010000, 3}, {0b111011100000, 3}, - {0b111100000000, 2}, {0b111100000011, 3}, - {0b111100000101, 3}, {0b111100000110, 3}, - {0b111100001001, 3}, {0b111100001010, 3}, - {0b111100001100, 3}, {0b111100001111, 1}, - {0b111100110000, 3}, {0b111100110011, 4}, - {0b111100111100, 4}, {0b111100111111, 3}, - {0b111101010000, 3}, {0b111101010101, 4}, - {0b111101011010, 4}, {0b111101011111, 3}, - {0b111101100000, 3}, {0b111101100110, 4}, - {0b111101101001, 4}, {0b111101101111, 3}, - {0b111110010000, 3}, {0b111110010110, 4}, - {0b111110011001, 4}, {0b111110011111, 3}, - {0b111110100000, 3}, {0b111110100101, 4}, - {0b111110101010, 4}, {0b111110101111, 3}, - {0b111111000000, 3}, {0b111111000011, 4}, - {0b111111001100, 4}, {0b111111001111, 3}, - {0b111111110000, 1}, {0b111111110011, 3}, - {0b111111110101, 3}, {0b111111110110, 3}, - {0b111111111001, 3}, {0b111111111010, 3}, - {0b111111111100, 3}, {0b111111111111, 2}, - {0b1000000000000, 4}, {0b1000000000001, 3}, - {0b1000000000010, 3}, {0b1000000000011, 5}, - {0b1000000000100, 3}, {0b1000000000101, 5}, - {0b1000000000110, 5}, {0b1000000000111, 4}, - {0b1000000001000, 3}, {0b1000000001001, 5}, - {0b1000000001010, 5}, {0b1000000001011, 4}, - {0b1000000001100, 5}, {0b1000000001101, 4}, - {0b1000000001110, 4}, {0b1000000010000, 3}, - {0b1000000010001, 5}, {0b1000000010010, 5}, - {0b1000000010011, 4}, {0b1000000010100, 5}, - {0b1000000010101, 4}, {0b1000000010110, 4}, - {0b1000000010111, 5}, {0b1000000011000, 5}, - {0b1000000011001, 4}, {0b1000000011010, 4}, - {0b1000000011011, 5}, {0b1000000011100, 4}, - {0b1000000011101, 5}, {0b1000000011110, 5}, - {0b1000000100000, 3}, {0b1000000100001, 5}, - {0b1000000100010, 5}, {0b1000000100011, 4}, - {0b1000000100100, 5}, {0b1000000100101, 4}, - {0b1000000100110, 4}, {0b1000000100111, 5}, - {0b1000000101000, 5}, {0b1000000101001, 4}, - {0b1000000101010, 4}, {0b1000000101011, 5}, - {0b1000000101100, 4}, {0b1000000101101, 5}, - {0b1000000101110, 5}, {0b1000000110000, 5}, - {0b1000000110001, 4}, {0b1000000110010, 4}, - {0b1000000110100, 4}, {0b1000000110101, 5}, - {0b1000000110110, 5}, {0b1000000111000, 4}, - {0b1000000111001, 5}, {0b1000000111010, 5}, - {0b1000001000000, 3}, {0b1000001000001, 5}, - {0b1000001000010, 5}, {0b1000001000011, 4}, - {0b1000001000100, 5}, {0b1000001000101, 4}, - {0b1000001000110, 4}, {0b1000001000111, 5}, - {0b1000001001000, 5}, {0b1000001001001, 4}, - {0b1000001001010, 4}, {0b1000001001011, 5}, - {0b1000001001100, 4}, {0b1000001001101, 5}, - {0b1000001001110, 5}, {0b1000001010000, 5}, - {0b1000001010001, 4}, {0b1000001010010, 4}, - {0b1000001010011, 5}, {0b1000001010100, 4}, - {0b1000001010110, 5}, {0b1000001011000, 4}, - {0b1000001011001, 5}, {0b1000001011100, 5}, - {0b1000001100000, 5}, {0b1000001100001, 4}, - {0b1000001100010, 4}, {0b1000001100011, 5}, - {0b1000001100100, 4}, {0b1000001100101, 5}, - {0b1000001101000, 4}, {0b1000001101010, 5}, - {0b1000001101100, 5}, {0b1000001110000, 4}, - {0b1000001110001, 5}, {0b1000001110010, 5}, - {0b1000001110100, 5}, {0b1000001111000, 5}, - {0b1000010000000, 3}, {0b1000010000001, 5}, - {0b1000010000010, 5}, {0b1000010000011, 4}, - {0b1000010000100, 5}, {0b1000010000101, 4}, - {0b1000010000110, 4}, {0b1000010000111, 5}, - {0b1000010001000, 5}, {0b1000010001001, 4}, - {0b1000010001010, 4}, {0b1000010001011, 5}, - {0b1000010001100, 4}, {0b1000010001101, 5}, - {0b1000010001110, 5}, {0b1000010010000, 5}, - {0b1000010010001, 4}, {0b1000010010010, 4}, - {0b1000010010011, 5}, {0b1000010010100, 4}, - {0b1000010010101, 5}, {0b1000010011000, 4}, - {0b1000010011010, 5}, {0b1000010011100, 5}, - {0b1000010100000, 5}, {0b1000010100001, 4}, - {0b1000010100010, 4}, {0b1000010100011, 5}, - {0b1000010100100, 4}, {0b1000010100110, 5}, - {0b1000010101000, 4}, {0b1000010101001, 5}, - {0b1000010101100, 5}, {0b1000010110000, 4}, - {0b1000010110001, 5}, {0b1000010110010, 5}, - {0b1000010110100, 5}, {0b1000010111000, 5}, - {0b1000011000000, 5}, {0b1000011000001, 4}, - {0b1000011000010, 4}, {0b1000011000100, 4}, - {0b1000011000101, 5}, {0b1000011000110, 5}, - {0b1000011001000, 4}, {0b1000011001001, 5}, - {0b1000011001010, 5}, {0b1000011010000, 4}, - {0b1000011010001, 5}, {0b1000011010010, 5}, - {0b1000011010100, 5}, {0b1000011011000, 5}, - {0b1000011100000, 4}, {0b1000011100001, 5}, - {0b1000011100010, 5}, {0b1000011100100, 5}, - {0b1000011101000, 5}, {0b1000100000000, 3}, - {0b1000100000001, 5}, {0b1000100000010, 5}, - {0b1000100000011, 4}, {0b1000100000100, 5}, - {0b1000100000101, 4}, {0b1000100000110, 4}, - {0b1000100000111, 5}, {0b1000100001000, 5}, - {0b1000100001001, 4}, {0b1000100001010, 4}, - {0b1000100001011, 5}, {0b1000100001100, 4}, - {0b1000100001101, 5}, {0b1000100001110, 5}, - {0b1000100010000, 5}, {0b1000100010001, 2}, - {0b1000100010010, 4}, {0b1000100010100, 4}, - {0b1000100010110, 5}, {0b1000100011000, 4}, - {0b1000100011010, 5}, {0b1000100011100, 5}, - {0b1000100100000, 5}, {0b1000100100001, 4}, - {0b1000100100010, 2}, {0b1000100100100, 4}, - {0b1000100100101, 5}, {0b1000100101000, 4}, - {0b1000100101001, 5}, {0b1000100101100, 5}, - {0b1000100110000, 4}, {0b1000100110011, 3}, - {0b1000100110100, 5}, {0b1000100111000, 5}, - {0b1000101000000, 5}, {0b1000101000001, 4}, - {0b1000101000010, 4}, {0b1000101000011, 5}, - {0b1000101000100, 2}, {0b1000101001000, 4}, - {0b1000101001001, 5}, {0b1000101001010, 5}, - {0b1000101010000, 4}, {0b1000101010010, 5}, - {0b1000101010101, 3}, {0b1000101011000, 5}, - {0b1000101100000, 4}, {0b1000101100001, 5}, - {0b1000101100110, 3}, {0b1000101101000, 5}, - {0b1000101110000, 5}, {0b1000101110111, 4}, - {0b1000110000000, 5}, {0b1000110000001, 4}, - {0b1000110000010, 4}, {0b1000110000011, 5}, - {0b1000110000100, 4}, {0b1000110000101, 5}, - {0b1000110000110, 5}, {0b1000110001000, 2}, - {0b1000110010000, 4}, {0b1000110010010, 5}, - {0b1000110010100, 5}, {0b1000110011001, 3}, - {0b1000110100000, 4}, {0b1000110100001, 5}, - {0b1000110100100, 5}, {0b1000110101010, 3}, - {0b1000110110000, 5}, {0b1000110111011, 4}, - {0b1000111000000, 4}, {0b1000111000001, 5}, - {0b1000111000010, 5}, {0b1000111001100, 3}, - {0b1000111010000, 5}, {0b1000111011101, 4}, - {0b1000111100000, 5}, {0b1000111101110, 4}, - {0b1000111111111, 3}, {0b1001000000000, 3}, - {0b1001000000001, 5}, {0b1001000000010, 5}, - {0b1001000000011, 4}, {0b1001000000100, 5}, - {0b1001000000101, 4}, {0b1001000000110, 4}, - {0b1001000000111, 5}, {0b1001000001000, 5}, - {0b1001000001001, 4}, {0b1001000001010, 4}, - {0b1001000001011, 5}, {0b1001000001100, 4}, - {0b1001000001101, 5}, {0b1001000001110, 5}, - {0b1001000010000, 5}, {0b1001000010001, 4}, - {0b1001000010010, 2}, {0b1001000010100, 4}, - {0b1001000010101, 5}, {0b1001000011000, 4}, - {0b1001000011001, 5}, {0b1001000011100, 5}, - {0b1001000100000, 5}, {0b1001000100001, 2}, - {0b1001000100010, 4}, {0b1001000100100, 4}, - {0b1001000100110, 5}, {0b1001000101000, 4}, - {0b1001000101010, 5}, {0b1001000101100, 5}, - {0b1001000110000, 4}, {0b1001000110011, 3}, - {0b1001000110100, 5}, {0b1001000111000, 5}, - {0b1001001000000, 5}, {0b1001001000001, 4}, - {0b1001001000010, 4}, {0b1001001000011, 5}, - {0b1001001000100, 4}, {0b1001001000101, 5}, - {0b1001001000110, 5}, {0b1001001001000, 2}, - {0b1001001010000, 4}, {0b1001001010001, 5}, - {0b1001001010100, 5}, {0b1001001011010, 3}, - {0b1001001100000, 4}, {0b1001001100010, 5}, - {0b1001001100100, 5}, {0b1001001101001, 3}, - {0b1001001110000, 5}, {0b1001001111011, 4}, - {0b1001010000000, 5}, {0b1001010000001, 4}, - {0b1001010000010, 4}, {0b1001010000011, 5}, - {0b1001010000100, 2}, {0b1001010001000, 4}, - {0b1001010001001, 5}, {0b1001010001010, 5}, - {0b1001010010000, 4}, {0b1001010010001, 5}, - {0b1001010010110, 3}, {0b1001010011000, 5}, - {0b1001010100000, 4}, {0b1001010100010, 5}, - {0b1001010100101, 3}, {0b1001010101000, 5}, - {0b1001010110000, 5}, {0b1001010110111, 4}, - {0b1001011000000, 4}, {0b1001011000001, 5}, - {0b1001011000010, 5}, {0b1001011001100, 3}, - {0b1001011010000, 5}, {0b1001011011110, 4}, - {0b1001011100000, 5}, {0b1001011101101, 4}, - {0b1001011111111, 3}, {0b1001100000000, 5}, - {0b1001100000001, 4}, {0b1001100000010, 4}, - {0b1001100000100, 4}, {0b1001100000101, 5}, - {0b1001100000110, 5}, {0b1001100001000, 4}, - {0b1001100001001, 5}, {0b1001100001010, 5}, - {0b1001100010000, 4}, {0b1001100010011, 3}, - {0b1001100010100, 5}, {0b1001100011000, 5}, - {0b1001100100000, 4}, {0b1001100100011, 3}, - {0b1001100100100, 5}, {0b1001100101000, 5}, - {0b1001100110001, 3}, {0b1001100110010, 3}, - {0b1001101000000, 4}, {0b1001101000001, 5}, - {0b1001101000010, 5}, {0b1001101001100, 3}, - {0b1001101010000, 5}, {0b1001101100000, 5}, - {0b1001110000000, 4}, {0b1001110000001, 5}, - {0b1001110000010, 5}, {0b1001110001100, 3}, - {0b1001110010000, 5}, {0b1001110100000, 5}, - {0b1001111000100, 3}, {0b1001111001000, 3}, - {0b1010000000000, 3}, {0b1010000000001, 5}, - {0b1010000000010, 5}, {0b1010000000011, 4}, - {0b1010000000100, 5}, {0b1010000000101, 4}, - {0b1010000000110, 4}, {0b1010000000111, 5}, - {0b1010000001000, 5}, {0b1010000001001, 4}, - {0b1010000001010, 4}, {0b1010000001011, 5}, - {0b1010000001100, 4}, {0b1010000001101, 5}, - {0b1010000001110, 5}, {0b1010000010000, 5}, - {0b1010000010001, 4}, {0b1010000010010, 4}, - {0b1010000010011, 5}, {0b1010000010100, 2}, - {0b1010000011000, 4}, {0b1010000011001, 5}, - {0b1010000011010, 5}, {0b1010000100000, 5}, - {0b1010000100001, 4}, {0b1010000100010, 4}, - {0b1010000100011, 5}, {0b1010000100100, 4}, - {0b1010000100101, 5}, {0b1010000100110, 5}, - {0b1010000101000, 2}, {0b1010000110000, 4}, - {0b1010000110001, 5}, {0b1010000110010, 5}, - {0b1010000111100, 3}, {0b1010001000000, 5}, - {0b1010001000001, 2}, {0b1010001000010, 4}, - {0b1010001000100, 4}, {0b1010001000110, 5}, - {0b1010001001000, 4}, {0b1010001001010, 5}, - {0b1010001001100, 5}, {0b1010001010000, 4}, - {0b1010001010010, 5}, {0b1010001010101, 3}, - {0b1010001011000, 5}, {0b1010001100000, 4}, - {0b1010001100010, 5}, {0b1010001100100, 5}, - {0b1010001101001, 3}, {0b1010001110000, 5}, - {0b1010001111101, 4}, {0b1010010000000, 5}, - {0b1010010000001, 4}, {0b1010010000010, 2}, - {0b1010010000100, 4}, {0b1010010000101, 5}, - {0b1010010001000, 4}, {0b1010010001001, 5}, - {0b1010010001100, 5}, {0b1010010010000, 4}, - {0b1010010010001, 5}, {0b1010010010110, 3}, - {0b1010010011000, 5}, {0b1010010100000, 4}, - {0b1010010100001, 5}, {0b1010010100100, 5}, - {0b1010010101010, 3}, {0b1010010110000, 5}, - {0b1010010111110, 4}, {0b1010011000000, 4}, - {0b1010011000011, 3}, {0b1010011000100, 5}, - {0b1010011001000, 5}, {0b1010011010000, 5}, - {0b1010011010111, 4}, {0b1010011100000, 5}, - {0b1010011101011, 4}, {0b1010011111111, 3}, - {0b1010100000000, 5}, {0b1010100000001, 4}, - {0b1010100000010, 4}, {0b1010100000011, 5}, - {0b1010100000100, 4}, {0b1010100000110, 5}, - {0b1010100001000, 4}, {0b1010100001001, 5}, - {0b1010100001100, 5}, {0b1010100010000, 4}, - {0b1010100010010, 5}, {0b1010100010101, 3}, - {0b1010100011000, 5}, {0b1010100100000, 4}, - {0b1010100100001, 5}, {0b1010100100100, 5}, - {0b1010100101010, 3}, {0b1010100110000, 5}, - {0b1010101000000, 4}, {0b1010101000010, 5}, - {0b1010101000101, 3}, {0b1010101001000, 5}, - {0b1010101010001, 3}, {0b1010101010100, 3}, - {0b1010101100000, 5}, {0b1010110000000, 4}, - {0b1010110000001, 5}, {0b1010110000100, 5}, - {0b1010110001010, 3}, {0b1010110010000, 5}, - {0b1010110100010, 3}, {0b1010110101000, 3}, - {0b1010111000000, 5}, {0b1011000000000, 5}, - {0b1011000000001, 4}, {0b1011000000010, 4}, - {0b1011000000011, 5}, {0b1011000000100, 4}, - {0b1011000000101, 5}, {0b1011000001000, 4}, - {0b1011000001010, 5}, {0b1011000001100, 5}, - {0b1011000010000, 4}, {0b1011000010001, 5}, - {0b1011000010110, 3}, {0b1011000011000, 5}, - {0b1011000100000, 4}, {0b1011000100010, 5}, - {0b1011000100100, 5}, {0b1011000101001, 3}, - {0b1011000110000, 5}, {0b1011001000000, 4}, - {0b1011001000010, 5}, {0b1011001000100, 5}, - {0b1011001001001, 3}, {0b1011001010000, 5}, - {0b1011001100001, 3}, {0b1011001101000, 3}, - {0b1011010000000, 4}, {0b1011010000001, 5}, - {0b1011010000110, 3}, {0b1011010001000, 5}, - {0b1011010010010, 3}, {0b1011010010100, 3}, - {0b1011010100000, 5}, {0b1011011000000, 5}, - {0b1011100000000, 4}, {0b1011100000001, 5}, - {0b1011100000010, 5}, {0b1011100000100, 5}, - {0b1011100001000, 5}, {0b1011100010000, 5}, - {0b1011100010111, 4}, {0b1011100100000, 5}, - {0b1011100101011, 4}, {0b1011101000000, 5}, - {0b1011101001101, 4}, {0b1011101110001, 4}, - {0b1011101111111, 5}, {0b1011110000000, 5}, - {0b1011110001110, 4}, {0b1011110110010, 4}, - {0b1011110111111, 5}, {0b1011111010100, 4}, - {0b1011111011111, 5}, {0b1011111101000, 4}, - {0b1011111101111, 5}, {0b1011111110111, 5}, - {0b1011111111011, 5}, {0b1011111111101, 5}, - {0b1011111111110, 5}, {0b1011111111111, 4}, - {0b1100000000000, 3}, {0b1100000000001, 5}, - {0b1100000000010, 5}, {0b1100000000011, 4}, - {0b1100000000100, 5}, {0b1100000000101, 4}, - {0b1100000000110, 4}, {0b1100000000111, 5}, - {0b1100000001000, 5}, {0b1100000001001, 4}, - {0b1100000001010, 4}, {0b1100000001011, 5}, - {0b1100000001100, 4}, {0b1100000001101, 5}, - {0b1100000001110, 5}, {0b1100000010000, 5}, - {0b1100000010001, 4}, {0b1100000010010, 4}, - {0b1100000010011, 5}, {0b1100000010100, 4}, - {0b1100000010101, 5}, {0b1100000010110, 5}, - {0b1100000011000, 2}, {0b1100000100000, 5}, - {0b1100000100001, 4}, {0b1100000100010, 4}, - {0b1100000100011, 5}, {0b1100000100100, 2}, - {0b1100000101000, 4}, {0b1100000101001, 5}, - {0b1100000101010, 5}, {0b1100000110000, 4}, - {0b1100000110001, 5}, {0b1100000110010, 5}, - {0b1100000111100, 3}, {0b1100001000000, 5}, - {0b1100001000001, 4}, {0b1100001000010, 2}, - {0b1100001000100, 4}, {0b1100001000101, 5}, - {0b1100001001000, 4}, {0b1100001001001, 5}, - {0b1100001001100, 5}, {0b1100001010000, 4}, - {0b1100001010001, 5}, {0b1100001010100, 5}, - {0b1100001011010, 3}, {0b1100001100000, 4}, - {0b1100001100001, 5}, {0b1100001100110, 3}, - {0b1100001101000, 5}, {0b1100001110000, 5}, - {0b1100001111110, 4}, {0b1100010000000, 5}, - {0b1100010000001, 2}, {0b1100010000010, 4}, - {0b1100010000100, 4}, {0b1100010000110, 5}, - {0b1100010001000, 4}, {0b1100010001010, 5}, - {0b1100010001100, 5}, {0b1100010010000, 4}, - {0b1100010010010, 5}, {0b1100010010100, 5}, - {0b1100010011001, 3}, {0b1100010100000, 4}, - {0b1100010100010, 5}, {0b1100010100101, 3}, - {0b1100010101000, 5}, {0b1100010110000, 5}, - {0b1100010111101, 4}, {0b1100011000000, 4}, - {0b1100011000011, 3}, {0b1100011000100, 5}, - {0b1100011001000, 5}, {0b1100011010000, 5}, - {0b1100011011011, 4}, {0b1100011100000, 5}, - {0b1100011100111, 4}, {0b1100011111111, 3}, - {0b1100100000000, 5}, {0b1100100000001, 4}, - {0b1100100000010, 4}, {0b1100100000011, 5}, - {0b1100100000100, 4}, {0b1100100000101, 5}, - {0b1100100001000, 4}, {0b1100100001010, 5}, - {0b1100100001100, 5}, {0b1100100010000, 4}, - {0b1100100010010, 5}, {0b1100100010100, 5}, - {0b1100100011001, 3}, {0b1100100100000, 4}, - {0b1100100100001, 5}, {0b1100100100110, 3}, - {0b1100100101000, 5}, {0b1100100110000, 5}, - {0b1100101000000, 4}, {0b1100101000001, 5}, - {0b1100101000110, 3}, {0b1100101001000, 5}, - {0b1100101010000, 5}, {0b1100101100010, 3}, - {0b1100101100100, 3}, {0b1100110000000, 4}, - {0b1100110000010, 5}, {0b1100110000100, 5}, - {0b1100110001001, 3}, {0b1100110010001, 3}, - {0b1100110011000, 3}, {0b1100110100000, 5}, - {0b1100111000000, 5}, {0b1101000000000, 5}, - {0b1101000000001, 4}, {0b1101000000010, 4}, - {0b1101000000011, 5}, {0b1101000000100, 4}, - {0b1101000000110, 5}, {0b1101000001000, 4}, - {0b1101000001001, 5}, {0b1101000001100, 5}, - {0b1101000010000, 4}, {0b1101000010001, 5}, - {0b1101000010100, 5}, {0b1101000011010, 3}, - {0b1101000100000, 4}, {0b1101000100010, 5}, - {0b1101000100101, 3}, {0b1101000101000, 5}, - {0b1101000110000, 5}, {0b1101001000000, 4}, - {0b1101001000001, 5}, {0b1101001000100, 5}, - {0b1101001001010, 3}, {0b1101001010010, 3}, - {0b1101001011000, 3}, {0b1101001100000, 5}, - {0b1101010000000, 4}, {0b1101010000010, 5}, - {0b1101010000101, 3}, {0b1101010001000, 5}, - {0b1101010010000, 5}, {0b1101010100001, 3}, - {0b1101010100100, 3}, {0b1101011000000, 5}, - {0b1101100000000, 4}, {0b1101100000001, 5}, - {0b1101100000010, 5}, {0b1101100000100, 5}, - {0b1101100001000, 5}, {0b1101100010000, 5}, - {0b1101100011011, 4}, {0b1101100100000, 5}, - {0b1101100100111, 4}, {0b1101101000000, 5}, - {0b1101101001110, 4}, {0b1101101110010, 4}, - {0b1101101111111, 5}, {0b1101110000000, 5}, - {0b1101110001101, 4}, {0b1101110110001, 4}, - {0b1101110111111, 5}, {0b1101111011000, 4}, - {0b1101111011111, 5}, {0b1101111100100, 4}, - {0b1101111101111, 5}, {0b1101111110111, 5}, - {0b1101111111011, 5}, {0b1101111111101, 5}, - {0b1101111111110, 5}, {0b1101111111111, 4}, - {0b1110000000000, 5}, {0b1110000000001, 4}, - {0b1110000000010, 4}, {0b1110000000100, 4}, - {0b1110000000101, 5}, {0b1110000000110, 5}, - {0b1110000001000, 4}, {0b1110000001001, 5}, - {0b1110000001010, 5}, {0b1110000010000, 4}, - {0b1110000010001, 5}, {0b1110000010010, 5}, - {0b1110000011100, 3}, {0b1110000100000, 4}, - {0b1110000100001, 5}, {0b1110000100010, 5}, - {0b1110000101100, 3}, {0b1110000110100, 3}, - {0b1110000111000, 3}, {0b1110001000000, 4}, - {0b1110001000011, 3}, {0b1110001000100, 5}, - {0b1110001001000, 5}, {0b1110001010000, 5}, - {0b1110001100000, 5}, {0b1110010000000, 4}, - {0b1110010000011, 3}, {0b1110010000100, 5}, - {0b1110010001000, 5}, {0b1110010010000, 5}, - {0b1110010100000, 5}, {0b1110011000001, 3}, - {0b1110011000010, 3}, {0b1110100000000, 4}, - {0b1110100000001, 5}, {0b1110100000010, 5}, - {0b1110100000100, 5}, {0b1110100001000, 5}, - {0b1110100010000, 5}, {0b1110100011101, 4}, - {0b1110100100000, 5}, {0b1110100101110, 4}, - {0b1110101000000, 5}, {0b1110101000111, 4}, - {0b1110101110100, 4}, {0b1110101111111, 5}, - {0b1110110000000, 5}, {0b1110110001011, 4}, - {0b1110110111000, 4}, {0b1110110111111, 5}, - {0b1110111010001, 4}, {0b1110111011111, 5}, - {0b1110111100010, 4}, {0b1110111101111, 5}, - {0b1110111110111, 5}, {0b1110111111011, 5}, - {0b1110111111101, 5}, {0b1110111111110, 5}, - {0b1110111111111, 4}, {0b1111000000000, 4}, - {0b1111000000001, 5}, {0b1111000000010, 5}, - {0b1111000000100, 5}, {0b1111000001000, 5}, - {0b1111000010000, 5}, {0b1111000011110, 4}, - {0b1111000100000, 5}, {0b1111000101101, 4}, - {0b1111001000000, 5}, {0b1111001001011, 4}, - {0b1111001111000, 4}, {0b1111001111111, 5}, - {0b1111010000000, 5}, {0b1111010000111, 4}, - {0b1111010110100, 4}, {0b1111010111111, 5}, - {0b1111011010010, 4}, {0b1111011011111, 5}, - {0b1111011100001, 4}, {0b1111011101111, 5}, - {0b1111011110111, 5}, {0b1111011111011, 5}, - {0b1111011111101, 5}, {0b1111011111110, 5}, - {0b1111011111111, 4}, {0b1111100011111, 3}, - {0b1111100101111, 3}, {0b1111101001111, 3}, - {0b1111101110111, 5}, {0b1111101111011, 5}, - {0b1111101111101, 5}, {0b1111101111110, 5}, - {0b1111101111111, 4}, {0b1111110001111, 3}, - {0b1111110110111, 5}, {0b1111110111011, 5}, - {0b1111110111101, 5}, {0b1111110111110, 5}, - {0b1111110111111, 4}, {0b1111111010111, 5}, - {0b1111111011011, 5}, {0b1111111011101, 5}, - {0b1111111011110, 5}, {0b1111111011111, 4}, - {0b1111111100111, 5}, {0b1111111101011, 5}, - {0b1111111101101, 5}, {0b1111111101110, 5}, - {0b1111111101111, 4}, {0b1111111110001, 3}, - {0b1111111110010, 3}, {0b1111111110100, 3}, - {0b1111111110111, 4}, {0b1111111111000, 3}, - {0b1111111111011, 4}, {0b1111111111101, 4}, - {0b1111111111110, 4}, {0b1111111111111, 5}, - {0b10000000000000, 4}, {0b10000000000001, 3}, - {0b10000000000010, 3}, {0b10000000000011, 5}, - {0b10000000000100, 3}, {0b10000000000101, 5}, - {0b10000000000110, 5}, {0b10000000000111, 4}, - {0b10000000001000, 3}, {0b10000000001001, 5}, - {0b10000000001010, 5}, {0b10000000001011, 4}, - {0b10000000001100, 5}, {0b10000000001101, 4}, - {0b10000000001110, 4}, {0b10000000010000, 3}, - {0b10000000010001, 5}, {0b10000000010010, 5}, - {0b10000000010011, 4}, {0b10000000010100, 5}, - {0b10000000010101, 4}, {0b10000000010110, 4}, - {0b10000000010111, 5}, {0b10000000011000, 5}, - {0b10000000011001, 4}, {0b10000000011010, 4}, - {0b10000000011011, 5}, {0b10000000011100, 4}, - {0b10000000011101, 5}, {0b10000000011110, 5}, - {0b10000000100000, 3}, {0b10000000100001, 5}, - {0b10000000100010, 5}, {0b10000000100011, 4}, - {0b10000000100100, 5}, {0b10000000100101, 4}, - {0b10000000100110, 4}, {0b10000000100111, 5}, - {0b10000000101000, 5}, {0b10000000101001, 4}, - {0b10000000101010, 4}, {0b10000000101011, 5}, - {0b10000000101100, 4}, {0b10000000101101, 5}, - {0b10000000101110, 5}, {0b10000000110000, 5}, - {0b10000000110001, 4}, {0b10000000110010, 4}, - {0b10000000110100, 4}, {0b10000000110101, 5}, - {0b10000000110110, 5}, {0b10000000111000, 4}, - {0b10000000111001, 5}, {0b10000000111010, 5}, - {0b10000001000000, 3}, {0b10000001000001, 5}, - {0b10000001000010, 5}, {0b10000001000011, 4}, - {0b10000001000100, 5}, {0b10000001000101, 4}, - {0b10000001000110, 4}, {0b10000001000111, 5}, - {0b10000001001000, 5}, {0b10000001001001, 4}, - {0b10000001001010, 4}, {0b10000001001011, 5}, - {0b10000001001100, 4}, {0b10000001001101, 5}, - {0b10000001001110, 5}, {0b10000001010000, 5}, - {0b10000001010001, 4}, {0b10000001010010, 4}, - {0b10000001010011, 5}, {0b10000001010100, 4}, - {0b10000001010110, 5}, {0b10000001011000, 4}, - {0b10000001011001, 5}, {0b10000001011100, 5}, - {0b10000001100000, 5}, {0b10000001100001, 4}, - {0b10000001100010, 4}, {0b10000001100011, 5}, - {0b10000001100100, 4}, {0b10000001100101, 5}, - {0b10000001101000, 4}, {0b10000001101010, 5}, - {0b10000001101100, 5}, {0b10000001110000, 4}, - {0b10000001110001, 5}, {0b10000001110010, 5}, - {0b10000001110100, 5}, {0b10000001111000, 5}, - {0b10000010000000, 3}, {0b10000010000001, 5}, - {0b10000010000010, 5}, {0b10000010000011, 4}, - {0b10000010000100, 5}, {0b10000010000101, 4}, - {0b10000010000110, 4}, {0b10000010000111, 5}, - {0b10000010001000, 5}, {0b10000010001001, 4}, - {0b10000010001010, 4}, {0b10000010001011, 5}, - {0b10000010001100, 4}, {0b10000010001101, 5}, - {0b10000010001110, 5}, {0b10000010010000, 5}, - {0b10000010010001, 4}, {0b10000010010010, 4}, - {0b10000010010011, 5}, {0b10000010010100, 4}, - {0b10000010010101, 5}, {0b10000010011000, 4}, - {0b10000010011010, 5}, {0b10000010011100, 5}, - {0b10000010100000, 5}, {0b10000010100001, 4}, - {0b10000010100010, 4}, {0b10000010100011, 5}, - {0b10000010100100, 4}, {0b10000010100110, 5}, - {0b10000010101000, 4}, {0b10000010101001, 5}, - {0b10000010101100, 5}, {0b10000010110000, 4}, - {0b10000010110001, 5}, {0b10000010110010, 5}, - {0b10000010110100, 5}, {0b10000010111000, 5}, - {0b10000011000000, 5}, {0b10000011000001, 4}, - {0b10000011000010, 4}, {0b10000011000100, 4}, - {0b10000011000101, 5}, {0b10000011000110, 5}, - {0b10000011001000, 4}, {0b10000011001001, 5}, - {0b10000011001010, 5}, {0b10000011010000, 4}, - {0b10000011010001, 5}, {0b10000011010010, 5}, - {0b10000011010100, 5}, {0b10000011011000, 5}, - {0b10000011100000, 4}, {0b10000011100001, 5}, - {0b10000011100010, 5}, {0b10000011100100, 5}, - {0b10000011101000, 5}, {0b10000100000000, 3}, - {0b10000100000001, 5}, {0b10000100000010, 5}, - {0b10000100000011, 4}, {0b10000100000100, 5}, - {0b10000100000101, 4}, {0b10000100000110, 4}, - {0b10000100000111, 5}, {0b10000100001000, 5}, - {0b10000100001001, 4}, {0b10000100001010, 4}, - {0b10000100001011, 5}, {0b10000100001100, 4}, - {0b10000100001101, 5}, {0b10000100001110, 5}, - {0b10000100010000, 5}, {0b10000100010001, 4}, - {0b10000100010010, 2}, {0b10000100010100, 4}, - {0b10000100010101, 5}, {0b10000100011000, 4}, - {0b10000100011001, 5}, {0b10000100011100, 5}, - {0b10000100100000, 5}, {0b10000100100001, 2}, - {0b10000100100010, 4}, {0b10000100100100, 4}, - {0b10000100100110, 5}, {0b10000100101000, 4}, - {0b10000100101010, 5}, {0b10000100101100, 5}, - {0b10000100110000, 4}, {0b10000100110011, 3}, - {0b10000100110100, 5}, {0b10000100111000, 5}, - {0b10000101000000, 5}, {0b10000101000001, 4}, - {0b10000101000010, 4}, {0b10000101000011, 5}, - {0b10000101000100, 4}, {0b10000101000101, 5}, - {0b10000101000110, 5}, {0b10000101001000, 2}, - {0b10000101010000, 4}, {0b10000101010001, 5}, - {0b10000101010100, 5}, {0b10000101011010, 3}, - {0b10000101100000, 4}, {0b10000101100010, 5}, - {0b10000101100100, 5}, {0b10000101101001, 3}, - {0b10000101110000, 5}, {0b10000101111011, 4}, - {0b10000110000000, 5}, {0b10000110000001, 4}, - {0b10000110000010, 4}, {0b10000110000011, 5}, - {0b10000110000100, 2}, {0b10000110001000, 4}, - {0b10000110001001, 5}, {0b10000110001010, 5}, - {0b10000110010000, 4}, {0b10000110010001, 5}, - {0b10000110010110, 3}, {0b10000110011000, 5}, - {0b10000110100000, 4}, {0b10000110100010, 5}, - {0b10000110100101, 3}, {0b10000110101000, 5}, - {0b10000110110000, 5}, {0b10000110110111, 4}, - {0b10000111000000, 4}, {0b10000111000001, 5}, - {0b10000111000010, 5}, {0b10000111001100, 3}, - {0b10000111010000, 5}, {0b10000111011110, 4}, - {0b10000111100000, 5}, {0b10000111101101, 4}, - {0b10000111111111, 3}, {0b10001000000000, 3}, - {0b10001000000001, 5}, {0b10001000000010, 5}, - {0b10001000000011, 4}, {0b10001000000100, 5}, - {0b10001000000101, 4}, {0b10001000000110, 4}, - {0b10001000000111, 5}, {0b10001000001000, 5}, - {0b10001000001001, 4}, {0b10001000001010, 4}, - {0b10001000001011, 5}, {0b10001000001100, 4}, - {0b10001000001101, 5}, {0b10001000001110, 5}, - {0b10001000010000, 5}, {0b10001000010001, 2}, - {0b10001000010010, 4}, {0b10001000010100, 4}, - {0b10001000010110, 5}, {0b10001000011000, 4}, - {0b10001000011010, 5}, {0b10001000011100, 5}, - {0b10001000100000, 5}, {0b10001000100001, 4}, - {0b10001000100010, 2}, {0b10001000100100, 4}, - {0b10001000100101, 5}, {0b10001000101000, 4}, - {0b10001000101001, 5}, {0b10001000101100, 5}, - {0b10001000110000, 4}, {0b10001000110011, 3}, - {0b10001000110100, 5}, {0b10001000111000, 5}, - {0b10001001000000, 5}, {0b10001001000001, 4}, - {0b10001001000010, 4}, {0b10001001000011, 5}, - {0b10001001000100, 2}, {0b10001001001000, 4}, - {0b10001001001001, 5}, {0b10001001001010, 5}, - {0b10001001010000, 4}, {0b10001001010010, 5}, - {0b10001001010101, 3}, {0b10001001011000, 5}, - {0b10001001100000, 4}, {0b10001001100001, 5}, - {0b10001001100110, 3}, {0b10001001101000, 5}, - {0b10001001110000, 5}, {0b10001001110111, 4}, - {0b10001010000000, 5}, {0b10001010000001, 4}, - {0b10001010000010, 4}, {0b10001010000011, 5}, - {0b10001010000100, 4}, {0b10001010000101, 5}, - {0b10001010000110, 5}, {0b10001010001000, 2}, - {0b10001010010000, 4}, {0b10001010010010, 5}, - {0b10001010010100, 5}, {0b10001010011001, 3}, - {0b10001010100000, 4}, {0b10001010100001, 5}, - {0b10001010100100, 5}, {0b10001010101010, 3}, - {0b10001010110000, 5}, {0b10001010111011, 4}, - {0b10001011000000, 4}, {0b10001011000001, 5}, - {0b10001011000010, 5}, {0b10001011001100, 3}, - {0b10001011010000, 5}, {0b10001011011101, 4}, - {0b10001011100000, 5}, {0b10001011101110, 4}, - {0b10001011111111, 3}, {0b10001100000000, 5}, - {0b10001100000001, 4}, {0b10001100000010, 4}, - {0b10001100000100, 4}, {0b10001100000101, 5}, - {0b10001100000110, 5}, {0b10001100001000, 4}, - {0b10001100001001, 5}, {0b10001100001010, 5}, - {0b10001100010000, 4}, {0b10001100010011, 3}, - {0b10001100010100, 5}, {0b10001100011000, 5}, - {0b10001100100000, 4}, {0b10001100100011, 3}, - {0b10001100100100, 5}, {0b10001100101000, 5}, - {0b10001100110001, 3}, {0b10001100110010, 3}, - {0b10001101000000, 4}, {0b10001101000001, 5}, - {0b10001101000010, 5}, {0b10001101001100, 3}, - {0b10001101010000, 5}, {0b10001101100000, 5}, - {0b10001110000000, 4}, {0b10001110000001, 5}, - {0b10001110000010, 5}, {0b10001110001100, 3}, - {0b10001110010000, 5}, {0b10001110100000, 5}, - {0b10001111000100, 3}, {0b10001111001000, 3}, - {0b10010000000000, 3}, {0b10010000000001, 5}, - {0b10010000000010, 5}, {0b10010000000011, 4}, - {0b10010000000100, 5}, {0b10010000000101, 4}, - {0b10010000000110, 4}, {0b10010000000111, 5}, - {0b10010000001000, 5}, {0b10010000001001, 4}, - {0b10010000001010, 4}, {0b10010000001011, 5}, - {0b10010000001100, 4}, {0b10010000001101, 5}, - {0b10010000001110, 5}, {0b10010000010000, 5}, - {0b10010000010001, 4}, {0b10010000010010, 4}, - {0b10010000010011, 5}, {0b10010000010100, 4}, - {0b10010000010101, 5}, {0b10010000010110, 5}, - {0b10010000011000, 2}, {0b10010000100000, 5}, - {0b10010000100001, 4}, {0b10010000100010, 4}, - {0b10010000100011, 5}, {0b10010000100100, 2}, - {0b10010000101000, 4}, {0b10010000101001, 5}, - {0b10010000101010, 5}, {0b10010000110000, 4}, - {0b10010000110001, 5}, {0b10010000110010, 5}, - {0b10010000111100, 3}, {0b10010001000000, 5}, - {0b10010001000001, 4}, {0b10010001000010, 2}, - {0b10010001000100, 4}, {0b10010001000101, 5}, - {0b10010001001000, 4}, {0b10010001001001, 5}, - {0b10010001001100, 5}, {0b10010001010000, 4}, - {0b10010001010001, 5}, {0b10010001010100, 5}, - {0b10010001011010, 3}, {0b10010001100000, 4}, - {0b10010001100001, 5}, {0b10010001100110, 3}, - {0b10010001101000, 5}, {0b10010001110000, 5}, - {0b10010001111110, 4}, {0b10010010000000, 5}, - {0b10010010000001, 2}, {0b10010010000010, 4}, - {0b10010010000100, 4}, {0b10010010000110, 5}, - {0b10010010001000, 4}, {0b10010010001010, 5}, - {0b10010010001100, 5}, {0b10010010010000, 4}, - {0b10010010010010, 5}, {0b10010010010100, 5}, - {0b10010010011001, 3}, {0b10010010100000, 4}, - {0b10010010100010, 5}, {0b10010010100101, 3}, - {0b10010010101000, 5}, {0b10010010110000, 5}, - {0b10010010111101, 4}, {0b10010011000000, 4}, - {0b10010011000011, 3}, {0b10010011000100, 5}, - {0b10010011001000, 5}, {0b10010011010000, 5}, - {0b10010011011011, 4}, {0b10010011100000, 5}, - {0b10010011100111, 4}, {0b10010011111111, 3}, - {0b10010100000000, 5}, {0b10010100000001, 4}, - {0b10010100000010, 4}, {0b10010100000011, 5}, - {0b10010100000100, 4}, {0b10010100000110, 5}, - {0b10010100001000, 4}, {0b10010100001001, 5}, - {0b10010100001100, 5}, {0b10010100010000, 4}, - {0b10010100010001, 5}, {0b10010100010100, 5}, - {0b10010100011010, 3}, {0b10010100100000, 4}, - {0b10010100100010, 5}, {0b10010100100101, 3}, - {0b10010100101000, 5}, {0b10010100110000, 5}, - {0b10010101000000, 4}, {0b10010101000001, 5}, - {0b10010101000100, 5}, {0b10010101001010, 3}, - {0b10010101010010, 3}, {0b10010101011000, 3}, - {0b10010101100000, 5}, {0b10010110000000, 4}, - {0b10010110000010, 5}, {0b10010110000101, 3}, - {0b10010110001000, 5}, {0b10010110010000, 5}, - {0b10010110100001, 3}, {0b10010110100100, 3}, - {0b10010111000000, 5}, {0b10011000000000, 5}, - {0b10011000000001, 4}, {0b10011000000010, 4}, - {0b10011000000011, 5}, {0b10011000000100, 4}, - {0b10011000000101, 5}, {0b10011000001000, 4}, - {0b10011000001010, 5}, {0b10011000001100, 5}, - {0b10011000010000, 4}, {0b10011000010010, 5}, - {0b10011000010100, 5}, {0b10011000011001, 3}, - {0b10011000100000, 4}, {0b10011000100001, 5}, - {0b10011000100110, 3}, {0b10011000101000, 5}, - {0b10011000110000, 5}, {0b10011001000000, 4}, - {0b10011001000001, 5}, {0b10011001000110, 3}, - {0b10011001001000, 5}, {0b10011001010000, 5}, - {0b10011001100010, 3}, {0b10011001100100, 3}, - {0b10011010000000, 4}, {0b10011010000010, 5}, - {0b10011010000100, 5}, {0b10011010001001, 3}, - {0b10011010010001, 3}, {0b10011010011000, 3}, - {0b10011010100000, 5}, {0b10011011000000, 5}, - {0b10011100000000, 4}, {0b10011100000001, 5}, - {0b10011100000010, 5}, {0b10011100000100, 5}, - {0b10011100001000, 5}, {0b10011100010000, 5}, - {0b10011100011011, 4}, {0b10011100100000, 5}, - {0b10011100100111, 4}, {0b10011101000000, 5}, - {0b10011101001110, 4}, {0b10011101110010, 4}, - {0b10011101111111, 5}, {0b10011110000000, 5}, - {0b10011110001101, 4}, {0b10011110110001, 4}, - {0b10011110111111, 5}, {0b10011111011000, 4}, - {0b10011111011111, 5}, {0b10011111100100, 4}, - {0b10011111101111, 5}, {0b10011111110111, 5}, - {0b10011111111011, 5}, {0b10011111111101, 5}, - {0b10011111111110, 5}, {0b10011111111111, 4}, - {0b10100000000000, 3}, {0b10100000000001, 5}, - {0b10100000000010, 5}, {0b10100000000011, 4}, - {0b10100000000100, 5}, {0b10100000000101, 4}, - {0b10100000000110, 4}, {0b10100000000111, 5}, - {0b10100000001000, 5}, {0b10100000001001, 4}, - {0b10100000001010, 4}, {0b10100000001011, 5}, - {0b10100000001100, 4}, {0b10100000001101, 5}, - {0b10100000001110, 5}, {0b10100000010000, 5}, - {0b10100000010001, 4}, {0b10100000010010, 4}, - {0b10100000010011, 5}, {0b10100000010100, 2}, - {0b10100000011000, 4}, {0b10100000011001, 5}, - {0b10100000011010, 5}, {0b10100000100000, 5}, - {0b10100000100001, 4}, {0b10100000100010, 4}, - {0b10100000100011, 5}, {0b10100000100100, 4}, - {0b10100000100101, 5}, {0b10100000100110, 5}, - {0b10100000101000, 2}, {0b10100000110000, 4}, - {0b10100000110001, 5}, {0b10100000110010, 5}, - {0b10100000111100, 3}, {0b10100001000000, 5}, - {0b10100001000001, 2}, {0b10100001000010, 4}, - {0b10100001000100, 4}, {0b10100001000110, 5}, - {0b10100001001000, 4}, {0b10100001001010, 5}, - {0b10100001001100, 5}, {0b10100001010000, 4}, - {0b10100001010010, 5}, {0b10100001010101, 3}, - {0b10100001011000, 5}, {0b10100001100000, 4}, - {0b10100001100010, 5}, {0b10100001100100, 5}, - {0b10100001101001, 3}, {0b10100001110000, 5}, - {0b10100001111101, 4}, {0b10100010000000, 5}, - {0b10100010000001, 4}, {0b10100010000010, 2}, - {0b10100010000100, 4}, {0b10100010000101, 5}, - {0b10100010001000, 4}, {0b10100010001001, 5}, - {0b10100010001100, 5}, {0b10100010010000, 4}, - {0b10100010010001, 5}, {0b10100010010110, 3}, - {0b10100010011000, 5}, {0b10100010100000, 4}, - {0b10100010100001, 5}, {0b10100010100100, 5}, - {0b10100010101010, 3}, {0b10100010110000, 5}, - {0b10100010111110, 4}, {0b10100011000000, 4}, - {0b10100011000011, 3}, {0b10100011000100, 5}, - {0b10100011001000, 5}, {0b10100011010000, 5}, - {0b10100011010111, 4}, {0b10100011100000, 5}, - {0b10100011101011, 4}, {0b10100011111111, 3}, - {0b10100100000000, 5}, {0b10100100000001, 4}, - {0b10100100000010, 4}, {0b10100100000011, 5}, - {0b10100100000100, 4}, {0b10100100000101, 5}, - {0b10100100001000, 4}, {0b10100100001010, 5}, - {0b10100100001100, 5}, {0b10100100010000, 4}, - {0b10100100010001, 5}, {0b10100100010110, 3}, - {0b10100100011000, 5}, {0b10100100100000, 4}, - {0b10100100100010, 5}, {0b10100100100100, 5}, - {0b10100100101001, 3}, {0b10100100110000, 5}, - {0b10100101000000, 4}, {0b10100101000010, 5}, - {0b10100101000100, 5}, {0b10100101001001, 3}, - {0b10100101010000, 5}, {0b10100101100001, 3}, - {0b10100101101000, 3}, {0b10100110000000, 4}, - {0b10100110000001, 5}, {0b10100110000110, 3}, - {0b10100110001000, 5}, {0b10100110010010, 3}, - {0b10100110010100, 3}, {0b10100110100000, 5}, - {0b10100111000000, 5}, {0b10101000000000, 5}, - {0b10101000000001, 4}, {0b10101000000010, 4}, - {0b10101000000011, 5}, {0b10101000000100, 4}, - {0b10101000000110, 5}, {0b10101000001000, 4}, - {0b10101000001001, 5}, {0b10101000001100, 5}, - {0b10101000010000, 4}, {0b10101000010010, 5}, - {0b10101000010101, 3}, {0b10101000011000, 5}, - {0b10101000100000, 4}, {0b10101000100001, 5}, - {0b10101000100100, 5}, {0b10101000101010, 3}, - {0b10101000110000, 5}, {0b10101001000000, 4}, - {0b10101001000010, 5}, {0b10101001000101, 3}, - {0b10101001001000, 5}, {0b10101001010001, 3}, - {0b10101001010100, 3}, {0b10101001100000, 5}, - {0b10101010000000, 4}, {0b10101010000001, 5}, - {0b10101010000100, 5}, {0b10101010001010, 3}, - {0b10101010010000, 5}, {0b10101010100010, 3}, - {0b10101010101000, 3}, {0b10101011000000, 5}, - {0b10101100000000, 4}, {0b10101100000001, 5}, - {0b10101100000010, 5}, {0b10101100000100, 5}, - {0b10101100001000, 5}, {0b10101100010000, 5}, - {0b10101100010111, 4}, {0b10101100100000, 5}, - {0b10101100101011, 4}, {0b10101101000000, 5}, - {0b10101101001101, 4}, {0b10101101110001, 4}, - {0b10101101111111, 5}, {0b10101110000000, 5}, - {0b10101110001110, 4}, {0b10101110110010, 4}, - {0b10101110111111, 5}, {0b10101111010100, 4}, - {0b10101111011111, 5}, {0b10101111101000, 4}, - {0b10101111101111, 5}, {0b10101111110111, 5}, - {0b10101111111011, 5}, {0b10101111111101, 5}, - {0b10101111111110, 5}, {0b10101111111111, 4}, - {0b10110000000000, 5}, {0b10110000000001, 4}, - {0b10110000000010, 4}, {0b10110000000100, 4}, - {0b10110000000101, 5}, {0b10110000000110, 5}, - {0b10110000001000, 4}, {0b10110000001001, 5}, - {0b10110000001010, 5}, {0b10110000010000, 4}, - {0b10110000010001, 5}, {0b10110000010010, 5}, - {0b10110000011100, 3}, {0b10110000100000, 4}, - {0b10110000100001, 5}, {0b10110000100010, 5}, - {0b10110000101100, 3}, {0b10110000110100, 3}, - {0b10110000111000, 3}, {0b10110001000000, 4}, - {0b10110001000011, 3}, {0b10110001000100, 5}, - {0b10110001001000, 5}, {0b10110001010000, 5}, - {0b10110001100000, 5}, {0b10110010000000, 4}, - {0b10110010000011, 3}, {0b10110010000100, 5}, - {0b10110010001000, 5}, {0b10110010010000, 5}, - {0b10110010100000, 5}, {0b10110011000001, 3}, - {0b10110011000010, 3}, {0b10110100000000, 4}, - {0b10110100000001, 5}, {0b10110100000010, 5}, - {0b10110100000100, 5}, {0b10110100001000, 5}, - {0b10110100010000, 5}, {0b10110100011110, 4}, - {0b10110100100000, 5}, {0b10110100101101, 4}, - {0b10110101000000, 5}, {0b10110101001011, 4}, - {0b10110101111000, 4}, {0b10110101111111, 5}, - {0b10110110000000, 5}, {0b10110110000111, 4}, - {0b10110110110100, 4}, {0b10110110111111, 5}, - {0b10110111010010, 4}, {0b10110111011111, 5}, - {0b10110111100001, 4}, {0b10110111101111, 5}, - {0b10110111110111, 5}, {0b10110111111011, 5}, - {0b10110111111101, 5}, {0b10110111111110, 5}, - {0b10110111111111, 4}, {0b10111000000000, 4}, - {0b10111000000001, 5}, {0b10111000000010, 5}, - {0b10111000000100, 5}, {0b10111000001000, 5}, - {0b10111000010000, 5}, {0b10111000011101, 4}, - {0b10111000100000, 5}, {0b10111000101110, 4}, - {0b10111001000000, 5}, {0b10111001000111, 4}, - {0b10111001110100, 4}, {0b10111001111111, 5}, - {0b10111010000000, 5}, {0b10111010001011, 4}, - {0b10111010111000, 4}, {0b10111010111111, 5}, - {0b10111011010001, 4}, {0b10111011011111, 5}, - {0b10111011100010, 4}, {0b10111011101111, 5}, - {0b10111011110111, 5}, {0b10111011111011, 5}, - {0b10111011111101, 5}, {0b10111011111110, 5}, - {0b10111011111111, 4}, {0b10111100011111, 3}, - {0b10111100101111, 3}, {0b10111101001111, 3}, - {0b10111101110111, 5}, {0b10111101111011, 5}, - {0b10111101111101, 5}, {0b10111101111110, 5}, - {0b10111101111111, 4}, {0b10111110001111, 3}, - {0b10111110110111, 5}, {0b10111110111011, 5}, - {0b10111110111101, 5}, {0b10111110111110, 5}, - {0b10111110111111, 4}, {0b10111111010111, 5}, - {0b10111111011011, 5}, {0b10111111011101, 5}, - {0b10111111011110, 5}, {0b10111111011111, 4}, - {0b10111111100111, 5}, {0b10111111101011, 5}, - {0b10111111101101, 5}, {0b10111111101110, 5}, - {0b10111111101111, 4}, {0b10111111110001, 3}, - {0b10111111110010, 3}, {0b10111111110100, 3}, - {0b10111111110111, 4}, {0b10111111111000, 3}, - {0b10111111111011, 4}, {0b10111111111101, 4}, - {0b10111111111110, 4}, {0b10111111111111, 5}, - {0b11000000000000, 3}, {0b11000000000001, 5}, - {0b11000000000010, 5}, {0b11000000000011, 2}, - {0b11000000000100, 5}, {0b11000000000101, 4}, - {0b11000000000110, 4}, {0b11000000001000, 5}, - {0b11000000001001, 4}, {0b11000000001010, 4}, - {0b11000000001100, 2}, {0b11000000001111, 3}, - {0b11000000010000, 5}, {0b11000000010001, 4}, - {0b11000000010010, 4}, {0b11000000010100, 4}, - {0b11000000010101, 5}, {0b11000000010110, 5}, - {0b11000000011000, 4}, {0b11000000011001, 5}, - {0b11000000011010, 5}, {0b11000000100000, 5}, - {0b11000000100001, 4}, {0b11000000100010, 4}, - {0b11000000100100, 4}, {0b11000000100101, 5}, - {0b11000000100110, 5}, {0b11000000101000, 4}, - {0b11000000101001, 5}, {0b11000000101010, 5}, - {0b11000000110000, 2}, {0b11000000110011, 3}, - {0b11000000111100, 3}, {0b11000000111111, 4}, - {0b11000001000000, 5}, {0b11000001000001, 4}, - {0b11000001000010, 4}, {0b11000001000100, 4}, - {0b11000001000101, 5}, {0b11000001000110, 5}, - {0b11000001001000, 4}, {0b11000001001001, 5}, - {0b11000001001010, 5}, {0b11000001010000, 4}, - {0b11000001010001, 5}, {0b11000001010010, 5}, - {0b11000001010100, 5}, {0b11000001011000, 5}, - {0b11000001100000, 4}, {0b11000001100001, 5}, - {0b11000001100010, 5}, {0b11000001100100, 5}, - {0b11000001101000, 5}, {0b11000010000000, 5}, - {0b11000010000001, 4}, {0b11000010000010, 4}, - {0b11000010000100, 4}, {0b11000010000101, 5}, - {0b11000010000110, 5}, {0b11000010001000, 4}, - {0b11000010001001, 5}, {0b11000010001010, 5}, - {0b11000010010000, 4}, {0b11000010010001, 5}, - {0b11000010010010, 5}, {0b11000010010100, 5}, - {0b11000010011000, 5}, {0b11000010100000, 4}, - {0b11000010100001, 5}, {0b11000010100010, 5}, - {0b11000010100100, 5}, {0b11000010101000, 5}, - {0b11000011000000, 2}, {0b11000011000011, 3}, - {0b11000011001100, 3}, {0b11000011001111, 4}, - {0b11000011110000, 3}, {0b11000011110011, 4}, - {0b11000011111100, 4}, {0b11000011111111, 3}, - {0b11000100000000, 5}, {0b11000100000001, 4}, - {0b11000100000010, 4}, {0b11000100000100, 4}, - {0b11000100000101, 5}, {0b11000100000110, 5}, - {0b11000100001000, 4}, {0b11000100001001, 5}, - {0b11000100001010, 5}, {0b11000100010000, 4}, - {0b11000100010011, 3}, {0b11000100010100, 5}, - {0b11000100011000, 5}, {0b11000100100000, 4}, - {0b11000100100011, 3}, {0b11000100100100, 5}, - {0b11000100101000, 5}, {0b11000100110001, 3}, - {0b11000100110010, 3}, {0b11000101000000, 4}, - {0b11000101000001, 5}, {0b11000101000010, 5}, - {0b11000101001100, 3}, {0b11000101010000, 5}, - {0b11000101100000, 5}, {0b11000110000000, 4}, - {0b11000110000001, 5}, {0b11000110000010, 5}, - {0b11000110001100, 3}, {0b11000110010000, 5}, - {0b11000110100000, 5}, {0b11000111000100, 3}, - {0b11000111001000, 3}, {0b11001000000000, 5}, - {0b11001000000001, 4}, {0b11001000000010, 4}, - {0b11001000000100, 4}, {0b11001000000101, 5}, - {0b11001000000110, 5}, {0b11001000001000, 4}, - {0b11001000001001, 5}, {0b11001000001010, 5}, - {0b11001000010000, 4}, {0b11001000010011, 3}, - {0b11001000010100, 5}, {0b11001000011000, 5}, - {0b11001000100000, 4}, {0b11001000100011, 3}, - {0b11001000100100, 5}, {0b11001000101000, 5}, - {0b11001000110001, 3}, {0b11001000110010, 3}, - {0b11001001000000, 4}, {0b11001001000001, 5}, - {0b11001001000010, 5}, {0b11001001001100, 3}, - {0b11001001010000, 5}, {0b11001001100000, 5}, - {0b11001010000000, 4}, {0b11001010000001, 5}, - {0b11001010000010, 5}, {0b11001010001100, 3}, - {0b11001010010000, 5}, {0b11001010100000, 5}, - {0b11001011000100, 3}, {0b11001011001000, 3}, - {0b11001100000000, 2}, {0b11001100000011, 3}, - {0b11001100001100, 3}, {0b11001100001111, 4}, - {0b11001100010001, 3}, {0b11001100010010, 3}, - {0b11001100100001, 3}, {0b11001100100010, 3}, - {0b11001100110000, 3}, {0b11001100110011, 1}, - {0b11001100111100, 4}, {0b11001100111111, 3}, - {0b11001101000100, 3}, {0b11001101001000, 3}, - {0b11001101010101, 4}, {0b11001101011010, 4}, - {0b11001101100110, 4}, {0b11001101101001, 4}, - {0b11001101110111, 3}, {0b11001101111011, 3}, - {0b11001110000100, 3}, {0b11001110001000, 3}, - {0b11001110010110, 4}, {0b11001110011001, 4}, - {0b11001110100101, 4}, {0b11001110101010, 4}, - {0b11001110110111, 3}, {0b11001110111011, 3}, - {0b11001111000000, 3}, {0b11001111000011, 4}, - {0b11001111001100, 1}, {0b11001111001111, 3}, - {0b11001111011101, 3}, {0b11001111011110, 3}, - {0b11001111101101, 3}, {0b11001111101110, 3}, - {0b11001111110000, 4}, {0b11001111110011, 3}, - {0b11001111111100, 3}, {0b11001111111111, 2}, - {0b11010000000000, 5}, {0b11010000000001, 4}, - {0b11010000000010, 4}, {0b11010000000100, 4}, - {0b11010000000101, 5}, {0b11010000000110, 5}, - {0b11010000001000, 4}, {0b11010000001001, 5}, - {0b11010000001010, 5}, {0b11010000010000, 4}, - {0b11010000010001, 5}, {0b11010000010010, 5}, - {0b11010000011100, 3}, {0b11010000100000, 4}, - {0b11010000100001, 5}, {0b11010000100010, 5}, - {0b11010000101100, 3}, {0b11010000110100, 3}, - {0b11010000111000, 3}, {0b11010001000000, 4}, - {0b11010001000011, 3}, {0b11010001000100, 5}, - {0b11010001001000, 5}, {0b11010001010000, 5}, - {0b11010001100000, 5}, {0b11010010000000, 4}, - {0b11010010000011, 3}, {0b11010010000100, 5}, - {0b11010010001000, 5}, {0b11010010010000, 5}, - {0b11010010100000, 5}, {0b11010011000001, 3}, - {0b11010011000010, 3}, {0b11010100000000, 4}, - {0b11010100000001, 5}, {0b11010100000010, 5}, - {0b11010100000100, 5}, {0b11010100001000, 5}, - {0b11010100010000, 5}, {0b11010100100000, 5}, - {0b11010100110101, 4}, {0b11010100111010, 4}, - {0b11010101000000, 5}, {0b11010101010011, 4}, - {0b11010101011100, 4}, {0b11010101111111, 5}, - {0b11010110000000, 5}, {0b11010110100011, 4}, - {0b11010110101100, 4}, {0b11010110111111, 5}, - {0b11010111000101, 4}, {0b11010111001010, 4}, - {0b11010111011111, 5}, {0b11010111101111, 5}, - {0b11010111110111, 5}, {0b11010111111011, 5}, - {0b11010111111101, 5}, {0b11010111111110, 5}, - {0b11010111111111, 4}, {0b11011000000000, 4}, - {0b11011000000001, 5}, {0b11011000000010, 5}, - {0b11011000000100, 5}, {0b11011000001000, 5}, - {0b11011000010000, 5}, {0b11011000100000, 5}, - {0b11011000110110, 4}, {0b11011000111001, 4}, - {0b11011001000000, 5}, {0b11011001100011, 4}, - {0b11011001101100, 4}, {0b11011001111111, 5}, - {0b11011010000000, 5}, {0b11011010010011, 4}, - {0b11011010011100, 4}, {0b11011010111111, 5}, - {0b11011011000110, 4}, {0b11011011001001, 4}, - {0b11011011011111, 5}, {0b11011011101111, 5}, - {0b11011011110111, 5}, {0b11011011111011, 5}, - {0b11011011111101, 5}, {0b11011011111110, 5}, - {0b11011011111111, 4}, {0b11011100110111, 3}, - {0b11011100111011, 3}, {0b11011101011111, 5}, - {0b11011101101111, 5}, {0b11011101110011, 3}, - {0b11011101111101, 5}, {0b11011101111110, 5}, - {0b11011101111111, 4}, {0b11011110011111, 5}, - {0b11011110101111, 5}, {0b11011110110011, 3}, - {0b11011110111101, 5}, {0b11011110111110, 5}, - {0b11011110111111, 4}, {0b11011111001101, 3}, - {0b11011111001110, 3}, {0b11011111010111, 5}, - {0b11011111011011, 5}, {0b11011111011100, 3}, - {0b11011111011111, 4}, {0b11011111100111, 5}, - {0b11011111101011, 5}, {0b11011111101100, 3}, - {0b11011111101111, 4}, {0b11011111110101, 5}, - {0b11011111110110, 5}, {0b11011111110111, 4}, - {0b11011111111001, 5}, {0b11011111111010, 5}, - {0b11011111111011, 4}, {0b11011111111101, 4}, - {0b11011111111110, 4}, {0b11011111111111, 5}, - {0b11100000000000, 5}, {0b11100000000001, 4}, - {0b11100000000010, 4}, {0b11100000000100, 4}, - {0b11100000000101, 5}, {0b11100000000110, 5}, - {0b11100000001000, 4}, {0b11100000001001, 5}, - {0b11100000001010, 5}, {0b11100000010000, 4}, - {0b11100000010001, 5}, {0b11100000010010, 5}, - {0b11100000011100, 3}, {0b11100000100000, 4}, - {0b11100000100001, 5}, {0b11100000100010, 5}, - {0b11100000101100, 3}, {0b11100000110100, 3}, - {0b11100000111000, 3}, {0b11100001000000, 4}, - {0b11100001000011, 3}, {0b11100001000100, 5}, - {0b11100001001000, 5}, {0b11100001010000, 5}, - {0b11100001100000, 5}, {0b11100010000000, 4}, - {0b11100010000011, 3}, {0b11100010000100, 5}, - {0b11100010001000, 5}, {0b11100010010000, 5}, - {0b11100010100000, 5}, {0b11100011000001, 3}, - {0b11100011000010, 3}, {0b11100100000000, 4}, - {0b11100100000001, 5}, {0b11100100000010, 5}, - {0b11100100000100, 5}, {0b11100100001000, 5}, - {0b11100100010000, 5}, {0b11100100100000, 5}, - {0b11100100110110, 4}, {0b11100100111001, 4}, - {0b11100101000000, 5}, {0b11100101100011, 4}, - {0b11100101101100, 4}, {0b11100101111111, 5}, - {0b11100110000000, 5}, {0b11100110010011, 4}, - {0b11100110011100, 4}, {0b11100110111111, 5}, - {0b11100111000110, 4}, {0b11100111001001, 4}, - {0b11100111011111, 5}, {0b11100111101111, 5}, - {0b11100111110111, 5}, {0b11100111111011, 5}, - {0b11100111111101, 5}, {0b11100111111110, 5}, - {0b11100111111111, 4}, {0b11101000000000, 4}, - {0b11101000000001, 5}, {0b11101000000010, 5}, - {0b11101000000100, 5}, {0b11101000001000, 5}, - {0b11101000010000, 5}, {0b11101000100000, 5}, - {0b11101000110101, 4}, {0b11101000111010, 4}, - {0b11101001000000, 5}, {0b11101001010011, 4}, - {0b11101001011100, 4}, {0b11101001111111, 5}, - {0b11101010000000, 5}, {0b11101010100011, 4}, - {0b11101010101100, 4}, {0b11101010111111, 5}, - {0b11101011000101, 4}, {0b11101011001010, 4}, - {0b11101011011111, 5}, {0b11101011101111, 5}, - {0b11101011110111, 5}, {0b11101011111011, 5}, - {0b11101011111101, 5}, {0b11101011111110, 5}, - {0b11101011111111, 4}, {0b11101100110111, 3}, - {0b11101100111011, 3}, {0b11101101011111, 5}, - {0b11101101101111, 5}, {0b11101101110011, 3}, - {0b11101101111101, 5}, {0b11101101111110, 5}, - {0b11101101111111, 4}, {0b11101110011111, 5}, - {0b11101110101111, 5}, {0b11101110110011, 3}, - {0b11101110111101, 5}, {0b11101110111110, 5}, - {0b11101110111111, 4}, {0b11101111001101, 3}, - {0b11101111001110, 3}, {0b11101111010111, 5}, - {0b11101111011011, 5}, {0b11101111011100, 3}, - {0b11101111011111, 4}, {0b11101111100111, 5}, - {0b11101111101011, 5}, {0b11101111101100, 3}, - {0b11101111101111, 4}, {0b11101111110101, 5}, - {0b11101111110110, 5}, {0b11101111110111, 4}, - {0b11101111111001, 5}, {0b11101111111010, 5}, - {0b11101111111011, 4}, {0b11101111111101, 4}, - {0b11101111111110, 4}, {0b11101111111111, 5}, - {0b11110000000000, 2}, {0b11110000000011, 3}, - {0b11110000001100, 3}, {0b11110000001111, 4}, - {0b11110000010100, 3}, {0b11110000011000, 3}, - {0b11110000100100, 3}, {0b11110000101000, 3}, - {0b11110000110000, 3}, {0b11110000110011, 4}, - {0b11110000111100, 1}, {0b11110000111111, 3}, - {0b11110001000001, 3}, {0b11110001000010, 3}, - {0b11110001010101, 4}, {0b11110001011010, 4}, - {0b11110001100110, 4}, {0b11110001101001, 4}, - {0b11110001111101, 3}, {0b11110001111110, 3}, - {0b11110010000001, 3}, {0b11110010000010, 3}, - {0b11110010010110, 4}, {0b11110010011001, 4}, - {0b11110010100101, 4}, {0b11110010101010, 4}, - {0b11110010111101, 3}, {0b11110010111110, 3}, - {0b11110011000000, 3}, {0b11110011000011, 1}, - {0b11110011001100, 4}, {0b11110011001111, 3}, - {0b11110011010111, 3}, {0b11110011011011, 3}, - {0b11110011100111, 3}, {0b11110011101011, 3}, - {0b11110011110000, 4}, {0b11110011110011, 3}, - {0b11110011111100, 3}, {0b11110011111111, 2}, - {0b11110100111101, 3}, {0b11110100111110, 3}, - {0b11110101011111, 5}, {0b11110101101111, 5}, - {0b11110101110111, 5}, {0b11110101111011, 5}, - {0b11110101111100, 3}, {0b11110101111111, 4}, - {0b11110110011111, 5}, {0b11110110101111, 5}, - {0b11110110110111, 5}, {0b11110110111011, 5}, - {0b11110110111100, 3}, {0b11110110111111, 4}, - {0b11110111000111, 3}, {0b11110111001011, 3}, - {0b11110111010011, 3}, {0b11110111011101, 5}, - {0b11110111011110, 5}, {0b11110111011111, 4}, - {0b11110111100011, 3}, {0b11110111101101, 5}, - {0b11110111101110, 5}, {0b11110111101111, 4}, - {0b11110111110101, 5}, {0b11110111110110, 5}, - {0b11110111110111, 4}, {0b11110111111001, 5}, - {0b11110111111010, 5}, {0b11110111111011, 4}, - {0b11110111111101, 4}, {0b11110111111110, 4}, - {0b11110111111111, 5}, {0b11111000111101, 3}, - {0b11111000111110, 3}, {0b11111001011111, 5}, - {0b11111001101111, 5}, {0b11111001110111, 5}, - {0b11111001111011, 5}, {0b11111001111100, 3}, - {0b11111001111111, 4}, {0b11111010011111, 5}, - {0b11111010101111, 5}, {0b11111010110111, 5}, - {0b11111010111011, 5}, {0b11111010111100, 3}, - {0b11111010111111, 4}, {0b11111011000111, 3}, - {0b11111011001011, 3}, {0b11111011010011, 3}, - {0b11111011011101, 5}, {0b11111011011110, 5}, - {0b11111011011111, 4}, {0b11111011100011, 3}, - {0b11111011101101, 5}, {0b11111011101110, 5}, - {0b11111011101111, 4}, {0b11111011110101, 5}, - {0b11111011110110, 5}, {0b11111011110111, 4}, - {0b11111011111001, 5}, {0b11111011111010, 5}, - {0b11111011111011, 4}, {0b11111011111101, 4}, - {0b11111011111110, 4}, {0b11111011111111, 5}, - {0b11111100000000, 3}, {0b11111100000011, 4}, - {0b11111100001100, 4}, {0b11111100001111, 3}, - {0b11111100110000, 4}, {0b11111100110011, 3}, - {0b11111100111100, 3}, {0b11111100111111, 2}, - {0b11111101010111, 5}, {0b11111101011011, 5}, - {0b11111101011101, 5}, {0b11111101011110, 5}, - {0b11111101011111, 4}, {0b11111101100111, 5}, - {0b11111101101011, 5}, {0b11111101101101, 5}, - {0b11111101101110, 5}, {0b11111101101111, 4}, - {0b11111101110101, 5}, {0b11111101110110, 5}, - {0b11111101110111, 4}, {0b11111101111001, 5}, - {0b11111101111010, 5}, {0b11111101111011, 4}, - {0b11111101111101, 4}, {0b11111101111110, 4}, - {0b11111101111111, 5}, {0b11111110010111, 5}, - {0b11111110011011, 5}, {0b11111110011101, 5}, - {0b11111110011110, 5}, {0b11111110011111, 4}, - {0b11111110100111, 5}, {0b11111110101011, 5}, - {0b11111110101101, 5}, {0b11111110101110, 5}, - {0b11111110101111, 4}, {0b11111110110101, 5}, - {0b11111110110110, 5}, {0b11111110110111, 4}, - {0b11111110111001, 5}, {0b11111110111010, 5}, - {0b11111110111011, 4}, {0b11111110111101, 4}, - {0b11111110111110, 4}, {0b11111110111111, 5}, - {0b11111111000000, 4}, {0b11111111000011, 3}, - {0b11111111001100, 3}, {0b11111111001111, 2}, - {0b11111111010101, 5}, {0b11111111010110, 5}, - {0b11111111010111, 4}, {0b11111111011001, 5}, - {0b11111111011010, 5}, {0b11111111011011, 4}, - {0b11111111011101, 4}, {0b11111111011110, 4}, - {0b11111111011111, 5}, {0b11111111100101, 5}, - {0b11111111100110, 5}, {0b11111111100111, 4}, - {0b11111111101001, 5}, {0b11111111101010, 5}, - {0b11111111101011, 4}, {0b11111111101101, 4}, - {0b11111111101110, 4}, {0b11111111101111, 5}, - {0b11111111110000, 3}, {0b11111111110011, 2}, - {0b11111111110101, 4}, {0b11111111110110, 4}, - {0b11111111110111, 5}, {0b11111111111001, 4}, - {0b11111111111010, 4}, {0b11111111111011, 5}, - {0b11111111111100, 2}, {0b11111111111101, 5}, - {0b11111111111110, 5}, {0b11111111111111, 3}, - {0b100000000000000, 4}, {0b100000000000001, 3}, - {0b100000000000010, 3}, {0b100000000000011, 5}, - {0b100000000000100, 3}, {0b100000000000101, 5}, - {0b100000000000110, 5}, {0b100000000000111, 4}, - {0b100000000001000, 3}, {0b100000000001001, 5}, - {0b100000000001010, 5}, {0b100000000001011, 4}, - {0b100000000001100, 5}, {0b100000000001101, 4}, - {0b100000000001110, 4}, {0b100000000010000, 3}, - {0b100000000010001, 5}, {0b100000000010010, 5}, - {0b100000000010011, 4}, {0b100000000010100, 5}, - {0b100000000010101, 4}, {0b100000000010110, 4}, - {0b100000000010111, 5}, {0b100000000011000, 5}, - {0b100000000011001, 4}, {0b100000000011010, 4}, - {0b100000000011011, 5}, {0b100000000011100, 4}, - {0b100000000011101, 5}, {0b100000000011110, 5}, - {0b100000000100000, 3}, {0b100000000100001, 5}, - {0b100000000100010, 5}, {0b100000000100011, 4}, - {0b100000000100100, 5}, {0b100000000100101, 4}, - {0b100000000100110, 4}, {0b100000000100111, 5}, - {0b100000000101000, 5}, {0b100000000101001, 4}, - {0b100000000101010, 4}, {0b100000000101011, 5}, - {0b100000000101100, 4}, {0b100000000101101, 5}, - {0b100000000101110, 5}, {0b100000000110000, 5}, - {0b100000000110001, 4}, {0b100000000110010, 4}, - {0b100000000110100, 4}, {0b100000000110101, 5}, - {0b100000000110110, 5}, {0b100000000111000, 4}, - {0b100000000111001, 5}, {0b100000000111010, 5}, - {0b100000001000000, 3}, {0b100000001000001, 5}, - {0b100000001000010, 5}, {0b100000001000011, 4}, - {0b100000001000100, 5}, {0b100000001000101, 4}, - {0b100000001000110, 4}, {0b100000001000111, 5}, - {0b100000001001000, 5}, {0b100000001001001, 4}, - {0b100000001001010, 4}, {0b100000001001011, 5}, - {0b100000001001100, 4}, {0b100000001001101, 5}, - {0b100000001001110, 5}, {0b100000001010000, 5}, - {0b100000001010001, 4}, {0b100000001010010, 4}, - {0b100000001010011, 5}, {0b100000001010100, 4}, - {0b100000001010110, 5}, {0b100000001011000, 4}, - {0b100000001011001, 5}, {0b100000001011100, 5}, - {0b100000001100000, 5}, {0b100000001100001, 4}, - {0b100000001100010, 4}, {0b100000001100011, 5}, - {0b100000001100100, 4}, {0b100000001100101, 5}, - {0b100000001101000, 4}, {0b100000001101010, 5}, - {0b100000001101100, 5}, {0b100000001110000, 4}, - {0b100000001110001, 5}, {0b100000001110010, 5}, - {0b100000001110100, 5}, {0b100000001111000, 5}, - {0b100000010000000, 3}, {0b100000010000001, 5}, - {0b100000010000010, 5}, {0b100000010000011, 4}, - {0b100000010000100, 5}, {0b100000010000101, 4}, - {0b100000010000110, 4}, {0b100000010000111, 5}, - {0b100000010001000, 5}, {0b100000010001001, 4}, - {0b100000010001010, 4}, {0b100000010001011, 5}, - {0b100000010001100, 4}, {0b100000010001101, 5}, - {0b100000010001110, 5}, {0b100000010010000, 5}, - {0b100000010010001, 4}, {0b100000010010010, 4}, - {0b100000010010011, 5}, {0b100000010010100, 4}, - {0b100000010010101, 5}, {0b100000010011000, 4}, - {0b100000010011010, 5}, {0b100000010011100, 5}, - {0b100000010100000, 5}, {0b100000010100001, 4}, - {0b100000010100010, 4}, {0b100000010100011, 5}, - {0b100000010100100, 4}, {0b100000010100110, 5}, - {0b100000010101000, 4}, {0b100000010101001, 5}, - {0b100000010101100, 5}, {0b100000010110000, 4}, - {0b100000010110001, 5}, {0b100000010110010, 5}, - {0b100000010110100, 5}, {0b100000010111000, 5}, - {0b100000011000000, 5}, {0b100000011000001, 4}, - {0b100000011000010, 4}, {0b100000011000100, 4}, - {0b100000011000101, 5}, {0b100000011000110, 5}, - {0b100000011001000, 4}, {0b100000011001001, 5}, - {0b100000011001010, 5}, {0b100000011010000, 4}, - {0b100000011010001, 5}, {0b100000011010010, 5}, - {0b100000011010100, 5}, {0b100000011011000, 5}, - {0b100000011100000, 4}, {0b100000011100001, 5}, - {0b100000011100010, 5}, {0b100000011100100, 5}, - {0b100000011101000, 5}, {0b100000100000000, 3}, - {0b100000100000001, 5}, {0b100000100000010, 5}, - {0b100000100000011, 4}, {0b100000100000100, 5}, - {0b100000100000101, 4}, {0b100000100000110, 4}, - {0b100000100000111, 5}, {0b100000100001000, 5}, - {0b100000100001001, 4}, {0b100000100001010, 4}, - {0b100000100001011, 5}, {0b100000100001100, 4}, - {0b100000100001101, 5}, {0b100000100001110, 5}, - {0b100000100010000, 5}, {0b100000100010001, 4}, - {0b100000100010010, 4}, {0b100000100010011, 5}, - {0b100000100010100, 2}, {0b100000100011000, 4}, - {0b100000100011001, 5}, {0b100000100011010, 5}, - {0b100000100100000, 5}, {0b100000100100001, 4}, - {0b100000100100010, 4}, {0b100000100100011, 5}, - {0b100000100100100, 4}, {0b100000100100101, 5}, - {0b100000100100110, 5}, {0b100000100101000, 2}, - {0b100000100110000, 4}, {0b100000100110001, 5}, - {0b100000100110010, 5}, {0b100000100111100, 3}, - {0b100000101000000, 5}, {0b100000101000001, 2}, - {0b100000101000010, 4}, {0b100000101000100, 4}, - {0b100000101000110, 5}, {0b100000101001000, 4}, - {0b100000101001010, 5}, {0b100000101001100, 5}, - {0b100000101010000, 4}, {0b100000101010010, 5}, - {0b100000101010101, 3}, {0b100000101011000, 5}, - {0b100000101100000, 4}, {0b100000101100010, 5}, - {0b100000101100100, 5}, {0b100000101101001, 3}, - {0b100000101110000, 5}, {0b100000101111101, 4}, - {0b100000110000000, 5}, {0b100000110000001, 4}, - {0b100000110000010, 2}, {0b100000110000100, 4}, - {0b100000110000101, 5}, {0b100000110001000, 4}, - {0b100000110001001, 5}, {0b100000110001100, 5}, - {0b100000110010000, 4}, {0b100000110010001, 5}, - {0b100000110010110, 3}, {0b100000110011000, 5}, - {0b100000110100000, 4}, {0b100000110100001, 5}, - {0b100000110100100, 5}, {0b100000110101010, 3}, - {0b100000110110000, 5}, {0b100000110111110, 4}, - {0b100000111000000, 4}, {0b100000111000011, 3}, - {0b100000111000100, 5}, {0b100000111001000, 5}, - {0b100000111010000, 5}, {0b100000111010111, 4}, - {0b100000111100000, 5}, {0b100000111101011, 4}, - {0b100000111111111, 3}, {0b100001000000000, 3}, - {0b100001000000001, 5}, {0b100001000000010, 5}, - {0b100001000000011, 4}, {0b100001000000100, 5}, - {0b100001000000101, 4}, {0b100001000000110, 4}, - {0b100001000000111, 5}, {0b100001000001000, 5}, - {0b100001000001001, 4}, {0b100001000001010, 4}, - {0b100001000001011, 5}, {0b100001000001100, 4}, - {0b100001000001101, 5}, {0b100001000001110, 5}, - {0b100001000010000, 5}, {0b100001000010001, 4}, - {0b100001000010010, 4}, {0b100001000010011, 5}, - {0b100001000010100, 4}, {0b100001000010101, 5}, - {0b100001000010110, 5}, {0b100001000011000, 2}, - {0b100001000100000, 5}, {0b100001000100001, 4}, - {0b100001000100010, 4}, {0b100001000100011, 5}, - {0b100001000100100, 2}, {0b100001000101000, 4}, - {0b100001000101001, 5}, {0b100001000101010, 5}, - {0b100001000110000, 4}, {0b100001000110001, 5}, - {0b100001000110010, 5}, {0b100001000111100, 3}, - {0b100001001000000, 5}, {0b100001001000001, 4}, - {0b100001001000010, 2}, {0b100001001000100, 4}, - {0b100001001000101, 5}, {0b100001001001000, 4}, - {0b100001001001001, 5}, {0b100001001001100, 5}, - {0b100001001010000, 4}, {0b100001001010001, 5}, - {0b100001001010100, 5}, {0b100001001011010, 3}, - {0b100001001100000, 4}, {0b100001001100001, 5}, - {0b100001001100110, 3}, {0b100001001101000, 5}, - {0b100001001110000, 5}, {0b100001001111110, 4}, - {0b100001010000000, 5}, {0b100001010000001, 2}, - {0b100001010000010, 4}, {0b100001010000100, 4}, - {0b100001010000110, 5}, {0b100001010001000, 4}, - {0b100001010001010, 5}, {0b100001010001100, 5}, - {0b100001010010000, 4}, {0b100001010010010, 5}, - {0b100001010010100, 5}, {0b100001010011001, 3}, - {0b100001010100000, 4}, {0b100001010100010, 5}, - {0b100001010100101, 3}, {0b100001010101000, 5}, - {0b100001010110000, 5}, {0b100001010111101, 4}, - {0b100001011000000, 4}, {0b100001011000011, 3}, - {0b100001011000100, 5}, {0b100001011001000, 5}, - {0b100001011010000, 5}, {0b100001011011011, 4}, - {0b100001011100000, 5}, {0b100001011100111, 4}, - {0b100001011111111, 3}, {0b100001100000000, 5}, - {0b100001100000001, 4}, {0b100001100000010, 4}, - {0b100001100000100, 4}, {0b100001100000101, 5}, - {0b100001100000110, 5}, {0b100001100001000, 4}, - {0b100001100001001, 5}, {0b100001100001010, 5}, - {0b100001100010000, 4}, {0b100001100010001, 5}, - {0b100001100010010, 5}, {0b100001100011100, 3}, - {0b100001100100000, 4}, {0b100001100100001, 5}, - {0b100001100100010, 5}, {0b100001100101100, 3}, - {0b100001100110100, 3}, {0b100001100111000, 3}, - {0b100001101000000, 4}, {0b100001101000011, 3}, - {0b100001101000100, 5}, {0b100001101001000, 5}, - {0b100001101010000, 5}, {0b100001101100000, 5}, - {0b100001110000000, 4}, {0b100001110000011, 3}, - {0b100001110000100, 5}, {0b100001110001000, 5}, - {0b100001110010000, 5}, {0b100001110100000, 5}, - {0b100001111000001, 3}, {0b100001111000010, 3}, - {0b100010000000000, 3}, {0b100010000000001, 5}, - {0b100010000000010, 5}, {0b100010000000011, 4}, - {0b100010000000100, 5}, {0b100010000000101, 4}, - {0b100010000000110, 4}, {0b100010000000111, 5}, - {0b100010000001000, 5}, {0b100010000001001, 4}, - {0b100010000001010, 4}, {0b100010000001011, 5}, - {0b100010000001100, 4}, {0b100010000001101, 5}, - {0b100010000001110, 5}, {0b100010000010000, 5}, - {0b100010000010001, 2}, {0b100010000010010, 4}, - {0b100010000010100, 4}, {0b100010000010110, 5}, - {0b100010000011000, 4}, {0b100010000011010, 5}, - {0b100010000011100, 5}, {0b100010000100000, 5}, - {0b100010000100001, 4}, {0b100010000100010, 2}, - {0b100010000100100, 4}, {0b100010000100101, 5}, - {0b100010000101000, 4}, {0b100010000101001, 5}, - {0b100010000101100, 5}, {0b100010000110000, 4}, - {0b100010000110011, 3}, {0b100010000110100, 5}, - {0b100010000111000, 5}, {0b100010001000000, 5}, - {0b100010001000001, 4}, {0b100010001000010, 4}, - {0b100010001000011, 5}, {0b100010001000100, 2}, - {0b100010001001000, 4}, {0b100010001001001, 5}, - {0b100010001001010, 5}, {0b100010001010000, 4}, - {0b100010001010010, 5}, {0b100010001010101, 3}, - {0b100010001011000, 5}, {0b100010001100000, 4}, - {0b100010001100001, 5}, {0b100010001100110, 3}, - {0b100010001101000, 5}, {0b100010001110000, 5}, - {0b100010001110111, 4}, {0b100010010000000, 5}, - {0b100010010000001, 4}, {0b100010010000010, 4}, - {0b100010010000011, 5}, {0b100010010000100, 4}, - {0b100010010000101, 5}, {0b100010010000110, 5}, - {0b100010010001000, 2}, {0b100010010010000, 4}, - {0b100010010010010, 5}, {0b100010010010100, 5}, - {0b100010010011001, 3}, {0b100010010100000, 4}, - {0b100010010100001, 5}, {0b100010010100100, 5}, - {0b100010010101010, 3}, {0b100010010110000, 5}, - {0b100010010111011, 4}, {0b100010011000000, 4}, - {0b100010011000001, 5}, {0b100010011000010, 5}, - {0b100010011001100, 3}, {0b100010011010000, 5}, - {0b100010011011101, 4}, {0b100010011100000, 5}, - {0b100010011101110, 4}, {0b100010011111111, 3}, - {0b100010100000000, 5}, {0b100010100000001, 4}, - {0b100010100000010, 4}, {0b100010100000011, 5}, - {0b100010100000100, 4}, {0b100010100000110, 5}, - {0b100010100001000, 4}, {0b100010100001001, 5}, - {0b100010100001100, 5}, {0b100010100010000, 4}, - {0b100010100010010, 5}, {0b100010100010101, 3}, - {0b100010100011000, 5}, {0b100010100100000, 4}, - {0b100010100100001, 5}, {0b100010100100100, 5}, - {0b100010100101010, 3}, {0b100010100110000, 5}, - {0b100010101000000, 4}, {0b100010101000010, 5}, - {0b100010101000101, 3}, {0b100010101001000, 5}, - {0b100010101010001, 3}, {0b100010101010100, 3}, - {0b100010101100000, 5}, {0b100010110000000, 4}, - {0b100010110000001, 5}, {0b100010110000100, 5}, - {0b100010110001010, 3}, {0b100010110010000, 5}, - {0b100010110100010, 3}, {0b100010110101000, 3}, - {0b100010111000000, 5}, {0b100011000000000, 5}, - {0b100011000000001, 4}, {0b100011000000010, 4}, - {0b100011000000011, 5}, {0b100011000000100, 4}, - {0b100011000000101, 5}, {0b100011000001000, 4}, - {0b100011000001010, 5}, {0b100011000001100, 5}, - {0b100011000010000, 4}, {0b100011000010010, 5}, - {0b100011000010100, 5}, {0b100011000011001, 3}, - {0b100011000100000, 4}, {0b100011000100001, 5}, - {0b100011000100110, 3}, {0b100011000101000, 5}, - {0b100011000110000, 5}, {0b100011001000000, 4}, - {0b100011001000001, 5}, {0b100011001000110, 3}, - {0b100011001001000, 5}, {0b100011001010000, 5}, - {0b100011001100010, 3}, {0b100011001100100, 3}, - {0b100011010000000, 4}, {0b100011010000010, 5}, - {0b100011010000100, 5}, {0b100011010001001, 3}, - {0b100011010010001, 3}, {0b100011010011000, 3}, - {0b100011010100000, 5}, {0b100011011000000, 5}, - {0b100011100000000, 4}, {0b100011100000001, 5}, - {0b100011100000010, 5}, {0b100011100000100, 5}, - {0b100011100001000, 5}, {0b100011100010000, 5}, - {0b100011100011101, 4}, {0b100011100100000, 5}, - {0b100011100101110, 4}, {0b100011101000000, 5}, - {0b100011101000111, 4}, {0b100011101110100, 4}, - {0b100011101111111, 5}, {0b100011110000000, 5}, - {0b100011110001011, 4}, {0b100011110111000, 4}, - {0b100011110111111, 5}, {0b100011111010001, 4}, - {0b100011111011111, 5}, {0b100011111100010, 4}, - {0b100011111101111, 5}, {0b100011111110111, 5}, - {0b100011111111011, 5}, {0b100011111111101, 5}, - {0b100011111111110, 5}, {0b100011111111111, 4}, - {0b100100000000000, 3}, {0b100100000000001, 5}, - {0b100100000000010, 5}, {0b100100000000011, 4}, - {0b100100000000100, 5}, {0b100100000000101, 4}, - {0b100100000000110, 4}, {0b100100000000111, 5}, - {0b100100000001000, 5}, {0b100100000001001, 4}, - {0b100100000001010, 4}, {0b100100000001011, 5}, - {0b100100000001100, 4}, {0b100100000001101, 5}, - {0b100100000001110, 5}, {0b100100000010000, 5}, - {0b100100000010001, 4}, {0b100100000010010, 2}, - {0b100100000010100, 4}, {0b100100000010101, 5}, - {0b100100000011000, 4}, {0b100100000011001, 5}, - {0b100100000011100, 5}, {0b100100000100000, 5}, - {0b100100000100001, 2}, {0b100100000100010, 4}, - {0b100100000100100, 4}, {0b100100000100110, 5}, - {0b100100000101000, 4}, {0b100100000101010, 5}, - {0b100100000101100, 5}, {0b100100000110000, 4}, - {0b100100000110011, 3}, {0b100100000110100, 5}, - {0b100100000111000, 5}, {0b100100001000000, 5}, - {0b100100001000001, 4}, {0b100100001000010, 4}, - {0b100100001000011, 5}, {0b100100001000100, 4}, - {0b100100001000101, 5}, {0b100100001000110, 5}, - {0b100100001001000, 2}, {0b100100001010000, 4}, - {0b100100001010001, 5}, {0b100100001010100, 5}, - {0b100100001011010, 3}, {0b100100001100000, 4}, - {0b100100001100010, 5}, {0b100100001100100, 5}, - {0b100100001101001, 3}, {0b100100001110000, 5}, - {0b100100001111011, 4}, {0b100100010000000, 5}, - {0b100100010000001, 4}, {0b100100010000010, 4}, - {0b100100010000011, 5}, {0b100100010000100, 2}, - {0b100100010001000, 4}, {0b100100010001001, 5}, - {0b100100010001010, 5}, {0b100100010010000, 4}, - {0b100100010010001, 5}, {0b100100010010110, 3}, - {0b100100010011000, 5}, {0b100100010100000, 4}, - {0b100100010100010, 5}, {0b100100010100101, 3}, - {0b100100010101000, 5}, {0b100100010110000, 5}, - {0b100100010110111, 4}, {0b100100011000000, 4}, - {0b100100011000001, 5}, {0b100100011000010, 5}, - {0b100100011001100, 3}, {0b100100011010000, 5}, - {0b100100011011110, 4}, {0b100100011100000, 5}, - {0b100100011101101, 4}, {0b100100011111111, 3}, - {0b100100100000000, 5}, {0b100100100000001, 4}, - {0b100100100000010, 4}, {0b100100100000011, 5}, - {0b100100100000100, 4}, {0b100100100000101, 5}, - {0b100100100001000, 4}, {0b100100100001010, 5}, - {0b100100100001100, 5}, {0b100100100010000, 4}, - {0b100100100010001, 5}, {0b100100100010110, 3}, - {0b100100100011000, 5}, {0b100100100100000, 4}, - {0b100100100100010, 5}, {0b100100100100100, 5}, - {0b100100100101001, 3}, {0b100100100110000, 5}, - {0b100100101000000, 4}, {0b100100101000010, 5}, - {0b100100101000100, 5}, {0b100100101001001, 3}, - {0b100100101010000, 5}, {0b100100101100001, 3}, - {0b100100101101000, 3}, {0b100100110000000, 4}, - {0b100100110000001, 5}, {0b100100110000110, 3}, - {0b100100110001000, 5}, {0b100100110010010, 3}, - {0b100100110010100, 3}, {0b100100110100000, 5}, - {0b100100111000000, 5}, {0b100101000000000, 5}, - {0b100101000000001, 4}, {0b100101000000010, 4}, - {0b100101000000011, 5}, {0b100101000000100, 4}, - {0b100101000000110, 5}, {0b100101000001000, 4}, - {0b100101000001001, 5}, {0b100101000001100, 5}, - {0b100101000010000, 4}, {0b100101000010001, 5}, - {0b100101000010100, 5}, {0b100101000011010, 3}, - {0b100101000100000, 4}, {0b100101000100010, 5}, - {0b100101000100101, 3}, {0b100101000101000, 5}, - {0b100101000110000, 5}, {0b100101001000000, 4}, - {0b100101001000001, 5}, {0b100101001000100, 5}, - {0b100101001001010, 3}, {0b100101001010010, 3}, - {0b100101001011000, 3}, {0b100101001100000, 5}, - {0b100101010000000, 4}, {0b100101010000010, 5}, - {0b100101010000101, 3}, {0b100101010001000, 5}, - {0b100101010010000, 5}, {0b100101010100001, 3}, - {0b100101010100100, 3}, {0b100101011000000, 5}, - {0b100101100000000, 4}, {0b100101100000001, 5}, - {0b100101100000010, 5}, {0b100101100000100, 5}, - {0b100101100001000, 5}, {0b100101100010000, 5}, - {0b100101100011110, 4}, {0b100101100100000, 5}, - {0b100101100101101, 4}, {0b100101101000000, 5}, - {0b100101101001011, 4}, {0b100101101111000, 4}, - {0b100101101111111, 5}, {0b100101110000000, 5}, - {0b100101110000111, 4}, {0b100101110110100, 4}, - {0b100101110111111, 5}, {0b100101111010010, 4}, - {0b100101111011111, 5}, {0b100101111100001, 4}, - {0b100101111101111, 5}, {0b100101111110111, 5}, - {0b100101111111011, 5}, {0b100101111111101, 5}, - {0b100101111111110, 5}, {0b100101111111111, 4}, - {0b100110000000000, 5}, {0b100110000000001, 4}, - {0b100110000000010, 4}, {0b100110000000100, 4}, - {0b100110000000101, 5}, {0b100110000000110, 5}, - {0b100110000001000, 4}, {0b100110000001001, 5}, - {0b100110000001010, 5}, {0b100110000010000, 4}, - {0b100110000010011, 3}, {0b100110000010100, 5}, - {0b100110000011000, 5}, {0b100110000100000, 4}, - {0b100110000100011, 3}, {0b100110000100100, 5}, - {0b100110000101000, 5}, {0b100110000110001, 3}, - {0b100110000110010, 3}, {0b100110001000000, 4}, - {0b100110001000001, 5}, {0b100110001000010, 5}, - {0b100110001001100, 3}, {0b100110001010000, 5}, - {0b100110001100000, 5}, {0b100110010000000, 4}, - {0b100110010000001, 5}, {0b100110010000010, 5}, - {0b100110010001100, 3}, {0b100110010010000, 5}, - {0b100110010100000, 5}, {0b100110011000100, 3}, - {0b100110011001000, 3}, {0b100110100000000, 4}, - {0b100110100000001, 5}, {0b100110100000010, 5}, - {0b100110100000100, 5}, {0b100110100001000, 5}, - {0b100110100010000, 5}, {0b100110100010111, 4}, - {0b100110100100000, 5}, {0b100110100101011, 4}, - {0b100110101000000, 5}, {0b100110101001101, 4}, - {0b100110101110001, 4}, {0b100110101111111, 5}, - {0b100110110000000, 5}, {0b100110110001110, 4}, - {0b100110110110010, 4}, {0b100110110111111, 5}, - {0b100110111010100, 4}, {0b100110111011111, 5}, - {0b100110111101000, 4}, {0b100110111101111, 5}, - {0b100110111110111, 5}, {0b100110111111011, 5}, - {0b100110111111101, 5}, {0b100110111111110, 5}, - {0b100110111111111, 4}, {0b100111000000000, 4}, - {0b100111000000001, 5}, {0b100111000000010, 5}, - {0b100111000000100, 5}, {0b100111000001000, 5}, - {0b100111000010000, 5}, {0b100111000011011, 4}, - {0b100111000100000, 5}, {0b100111000100111, 4}, - {0b100111001000000, 5}, {0b100111001001110, 4}, - {0b100111001110010, 4}, {0b100111001111111, 5}, - {0b100111010000000, 5}, {0b100111010001101, 4}, - {0b100111010110001, 4}, {0b100111010111111, 5}, - {0b100111011011000, 4}, {0b100111011011111, 5}, - {0b100111011100100, 4}, {0b100111011101111, 5}, - {0b100111011110111, 5}, {0b100111011111011, 5}, - {0b100111011111101, 5}, {0b100111011111110, 5}, - {0b100111011111111, 4}, {0b100111100011111, 3}, - {0b100111100101111, 3}, {0b100111101001111, 3}, - {0b100111101110111, 5}, {0b100111101111011, 5}, - {0b100111101111101, 5}, {0b100111101111110, 5}, - {0b100111101111111, 4}, {0b100111110001111, 3}, - {0b100111110110111, 5}, {0b100111110111011, 5}, - {0b100111110111101, 5}, {0b100111110111110, 5}, - {0b100111110111111, 4}, {0b100111111010111, 5}, - {0b100111111011011, 5}, {0b100111111011101, 5}, - {0b100111111011110, 5}, {0b100111111011111, 4}, - {0b100111111100111, 5}, {0b100111111101011, 5}, - {0b100111111101101, 5}, {0b100111111101110, 5}, - {0b100111111101111, 4}, {0b100111111110001, 3}, - {0b100111111110010, 3}, {0b100111111110100, 3}, - {0b100111111110111, 4}, {0b100111111111000, 3}, - {0b100111111111011, 4}, {0b100111111111101, 4}, - {0b100111111111110, 4}, {0b100111111111111, 5}, - {0b101000000000000, 3}, {0b101000000000001, 5}, - {0b101000000000010, 5}, {0b101000000000011, 4}, - {0b101000000000100, 5}, {0b101000000000101, 2}, - {0b101000000000110, 4}, {0b101000000001000, 5}, - {0b101000000001001, 4}, {0b101000000001010, 2}, - {0b101000000001100, 4}, {0b101000000001111, 3}, - {0b101000000010000, 5}, {0b101000000010001, 4}, - {0b101000000010010, 4}, {0b101000000010011, 5}, - {0b101000000010100, 4}, {0b101000000010110, 5}, - {0b101000000011000, 4}, {0b101000000011001, 5}, - {0b101000000011100, 5}, {0b101000000100000, 5}, - {0b101000000100001, 4}, {0b101000000100010, 4}, - {0b101000000100011, 5}, {0b101000000100100, 4}, - {0b101000000100110, 5}, {0b101000000101000, 4}, - {0b101000000101001, 5}, {0b101000000101100, 5}, - {0b101000000110000, 4}, {0b101000000110001, 5}, - {0b101000000110010, 5}, {0b101000000110100, 5}, - {0b101000000111000, 5}, {0b101000001000000, 5}, - {0b101000001000001, 4}, {0b101000001000010, 4}, - {0b101000001000011, 5}, {0b101000001000100, 4}, - {0b101000001000110, 5}, {0b101000001001000, 4}, - {0b101000001001001, 5}, {0b101000001001100, 5}, - {0b101000001010000, 2}, {0b101000001010101, 3}, - {0b101000001011010, 3}, {0b101000001011111, 4}, - {0b101000001100000, 4}, {0b101000001100001, 5}, - {0b101000001100010, 5}, {0b101000001100100, 5}, - {0b101000001101000, 5}, {0b101000010000000, 5}, - {0b101000010000001, 4}, {0b101000010000010, 4}, - {0b101000010000011, 5}, {0b101000010000100, 4}, - {0b101000010000110, 5}, {0b101000010001000, 4}, - {0b101000010001001, 5}, {0b101000010001100, 5}, - {0b101000010010000, 4}, {0b101000010010001, 5}, - {0b101000010010010, 5}, {0b101000010010100, 5}, - {0b101000010011000, 5}, {0b101000010100000, 2}, - {0b101000010100101, 3}, {0b101000010101010, 3}, - {0b101000010101111, 4}, {0b101000011000000, 4}, - {0b101000011000001, 5}, {0b101000011000010, 5}, - {0b101000011000100, 5}, {0b101000011001000, 5}, - {0b101000011110000, 3}, {0b101000011110101, 4}, - {0b101000011111010, 4}, {0b101000011111111, 3}, - {0b101000100000000, 5}, {0b101000100000001, 4}, - {0b101000100000010, 4}, {0b101000100000011, 5}, - {0b101000100000100, 4}, {0b101000100000110, 5}, - {0b101000100001000, 4}, {0b101000100001001, 5}, - {0b101000100001100, 5}, {0b101000100010000, 4}, - {0b101000100010010, 5}, {0b101000100010101, 3}, - {0b101000100011000, 5}, {0b101000100100000, 4}, - {0b101000100100001, 5}, {0b101000100100100, 5}, - {0b101000100101010, 3}, {0b101000100110000, 5}, - {0b101000101000000, 4}, {0b101000101000010, 5}, - {0b101000101000101, 3}, {0b101000101001000, 5}, - {0b101000101010001, 3}, {0b101000101010100, 3}, - {0b101000101100000, 5}, {0b101000110000000, 4}, - {0b101000110000001, 5}, {0b101000110000100, 5}, - {0b101000110001010, 3}, {0b101000110010000, 5}, - {0b101000110100010, 3}, {0b101000110101000, 3}, - {0b101000111000000, 5}, {0b101001000000000, 5}, - {0b101001000000001, 4}, {0b101001000000010, 4}, - {0b101001000000011, 5}, {0b101001000000100, 4}, - {0b101001000000110, 5}, {0b101001000001000, 4}, - {0b101001000001001, 5}, {0b101001000001100, 5}, - {0b101001000010000, 4}, {0b101001000010001, 5}, - {0b101001000010100, 5}, {0b101001000011010, 3}, - {0b101001000100000, 4}, {0b101001000100010, 5}, - {0b101001000100101, 3}, {0b101001000101000, 5}, - {0b101001000110000, 5}, {0b101001001000000, 4}, - {0b101001001000001, 5}, {0b101001001000100, 5}, - {0b101001001001010, 3}, {0b101001001010010, 3}, - {0b101001001011000, 3}, {0b101001001100000, 5}, - {0b101001010000000, 4}, {0b101001010000010, 5}, - {0b101001010000101, 3}, {0b101001010001000, 5}, - {0b101001010010000, 5}, {0b101001010100001, 3}, - {0b101001010100100, 3}, {0b101001011000000, 5}, - {0b101001100000000, 4}, {0b101001100000001, 5}, - {0b101001100000010, 5}, {0b101001100000100, 5}, - {0b101001100001000, 5}, {0b101001100010000, 5}, - {0b101001100100000, 5}, {0b101001100110101, 4}, - {0b101001100111010, 4}, {0b101001101000000, 5}, - {0b101001101010011, 4}, {0b101001101011100, 4}, - {0b101001101111111, 5}, {0b101001110000000, 5}, - {0b101001110100011, 4}, {0b101001110101100, 4}, - {0b101001110111111, 5}, {0b101001111000101, 4}, - {0b101001111001010, 4}, {0b101001111011111, 5}, - {0b101001111101111, 5}, {0b101001111110111, 5}, - {0b101001111111011, 5}, {0b101001111111101, 5}, - {0b101001111111110, 5}, {0b101001111111111, 4}, - {0b101010000000000, 5}, {0b101010000000001, 4}, - {0b101010000000010, 4}, {0b101010000000011, 5}, - {0b101010000000100, 4}, {0b101010000000110, 5}, - {0b101010000001000, 4}, {0b101010000001001, 5}, - {0b101010000001100, 5}, {0b101010000010000, 4}, - {0b101010000010010, 5}, {0b101010000010101, 3}, - {0b101010000011000, 5}, {0b101010000100000, 4}, - {0b101010000100001, 5}, {0b101010000100100, 5}, - {0b101010000101010, 3}, {0b101010000110000, 5}, - {0b101010001000000, 4}, {0b101010001000010, 5}, - {0b101010001000101, 3}, {0b101010001001000, 5}, - {0b101010001010001, 3}, {0b101010001010100, 3}, - {0b101010001100000, 5}, {0b101010010000000, 4}, - {0b101010010000001, 5}, {0b101010010000100, 5}, - {0b101010010001010, 3}, {0b101010010010000, 5}, - {0b101010010100010, 3}, {0b101010010101000, 3}, - {0b101010011000000, 5}, {0b101010100000000, 2}, - {0b101010100000101, 3}, {0b101010100001010, 3}, - {0b101010100001111, 4}, {0b101010100010001, 3}, - {0b101010100010100, 3}, {0b101010100100010, 3}, - {0b101010100101000, 3}, {0b101010100110011, 4}, - {0b101010100111100, 4}, {0b101010101000001, 3}, - {0b101010101000100, 3}, {0b101010101010000, 3}, - {0b101010101010101, 1}, {0b101010101011010, 4}, - {0b101010101011111, 3}, {0b101010101100110, 4}, - {0b101010101101001, 4}, {0b101010101110111, 3}, - {0b101010101111101, 3}, {0b101010110000010, 3}, - {0b101010110001000, 3}, {0b101010110010110, 4}, - {0b101010110011001, 4}, {0b101010110100000, 3}, - {0b101010110100101, 4}, {0b101010110101010, 1}, - {0b101010110101111, 3}, {0b101010110111011, 3}, - {0b101010110111110, 3}, {0b101010111000011, 4}, - {0b101010111001100, 4}, {0b101010111010111, 3}, - {0b101010111011101, 3}, {0b101010111101011, 3}, - {0b101010111101110, 3}, {0b101010111110000, 4}, - {0b101010111110101, 3}, {0b101010111111010, 3}, - {0b101010111111111, 2}, {0b101011000000000, 4}, - {0b101011000000001, 5}, {0b101011000000010, 5}, - {0b101011000000100, 5}, {0b101011000001000, 5}, - {0b101011000010000, 5}, {0b101011000100000, 5}, - {0b101011001000000, 5}, {0b101011001010110, 4}, - {0b101011001011001, 4}, {0b101011001100101, 4}, - {0b101011001101010, 4}, {0b101011001111111, 5}, - {0b101011010000000, 5}, {0b101011010010101, 4}, - {0b101011010011010, 4}, {0b101011010100110, 4}, - {0b101011010101001, 4}, {0b101011010111111, 5}, - {0b101011011011111, 5}, {0b101011011101111, 5}, - {0b101011011110111, 5}, {0b101011011111011, 5}, - {0b101011011111101, 5}, {0b101011011111110, 5}, - {0b101011011111111, 4}, {0b101011100111111, 5}, - {0b101011101010111, 3}, {0b101011101011101, 3}, - {0b101011101101111, 5}, {0b101011101110101, 3}, - {0b101011101111011, 5}, {0b101011101111110, 5}, - {0b101011101111111, 4}, {0b101011110011111, 5}, - {0b101011110101011, 3}, {0b101011110101110, 3}, - {0b101011110110111, 5}, {0b101011110111010, 3}, - {0b101011110111101, 5}, {0b101011110111111, 4}, - {0b101011111001111, 5}, {0b101011111010101, 3}, - {0b101011111011011, 5}, {0b101011111011110, 5}, - {0b101011111011111, 4}, {0b101011111100111, 5}, - {0b101011111101010, 3}, {0b101011111101101, 5}, - {0b101011111101111, 4}, {0b101011111110011, 5}, - {0b101011111110110, 5}, {0b101011111110111, 4}, - {0b101011111111001, 5}, {0b101011111111011, 4}, - {0b101011111111100, 5}, {0b101011111111101, 4}, - {0b101011111111110, 4}, {0b101011111111111, 5}, - {0b101100000000000, 5}, {0b101100000000001, 4}, - {0b101100000000010, 4}, {0b101100000000011, 5}, - {0b101100000000100, 4}, {0b101100000000110, 5}, - {0b101100000001000, 4}, {0b101100000001001, 5}, - {0b101100000001100, 5}, {0b101100000010000, 4}, - {0b101100000010001, 5}, {0b101100000010100, 5}, - {0b101100000011010, 3}, {0b101100000100000, 4}, - {0b101100000100010, 5}, {0b101100000100101, 3}, - {0b101100000101000, 5}, {0b101100000110000, 5}, - {0b101100001000000, 4}, {0b101100001000001, 5}, - {0b101100001000100, 5}, {0b101100001001010, 3}, - {0b101100001010010, 3}, {0b101100001011000, 3}, - {0b101100001100000, 5}, {0b101100010000000, 4}, - {0b101100010000010, 5}, {0b101100010000101, 3}, - {0b101100010001000, 5}, {0b101100010010000, 5}, - {0b101100010100001, 3}, {0b101100010100100, 3}, - {0b101100011000000, 5}, {0b101100100000000, 4}, - {0b101100100000001, 5}, {0b101100100000010, 5}, - {0b101100100000100, 5}, {0b101100100001000, 5}, - {0b101100100010000, 5}, {0b101100100100000, 5}, - {0b101100101000000, 5}, {0b101100101010110, 4}, - {0b101100101011001, 4}, {0b101100101100101, 4}, - {0b101100101101010, 4}, {0b101100101111111, 5}, - {0b101100110000000, 5}, {0b101100110010101, 4}, - {0b101100110011010, 4}, {0b101100110100110, 4}, - {0b101100110101001, 4}, {0b101100110111111, 5}, - {0b101100111011111, 5}, {0b101100111101111, 5}, - {0b101100111110111, 5}, {0b101100111111011, 5}, - {0b101100111111101, 5}, {0b101100111111110, 5}, - {0b101100111111111, 4}, {0b101101000000000, 2}, - {0b101101000000101, 3}, {0b101101000001010, 3}, - {0b101101000001111, 4}, {0b101101000010010, 3}, - {0b101101000011000, 3}, {0b101101000100001, 3}, - {0b101101000100100, 3}, {0b101101000110011, 4}, - {0b101101000111100, 4}, {0b101101001000010, 3}, - {0b101101001001000, 3}, {0b101101001010000, 3}, - {0b101101001010101, 4}, {0b101101001011010, 1}, - {0b101101001011111, 3}, {0b101101001100110, 4}, - {0b101101001101001, 4}, {0b101101001111011, 3}, - {0b101101001111110, 3}, {0b101101010000001, 3}, - {0b101101010000100, 3}, {0b101101010010110, 4}, - {0b101101010011001, 4}, {0b101101010100000, 3}, - {0b101101010100101, 1}, {0b101101010101010, 4}, - {0b101101010101111, 3}, {0b101101010110111, 3}, - {0b101101010111101, 3}, {0b101101011000011, 4}, - {0b101101011001100, 4}, {0b101101011011011, 3}, - {0b101101011011110, 3}, {0b101101011100111, 3}, - {0b101101011101101, 3}, {0b101101011110000, 4}, - {0b101101011110101, 3}, {0b101101011111010, 3}, - {0b101101011111111, 2}, {0b101101100111111, 5}, - {0b101101101011011, 3}, {0b101101101011110, 3}, - {0b101101101101111, 5}, {0b101101101110111, 5}, - {0b101101101111010, 3}, {0b101101101111101, 5}, - {0b101101101111111, 4}, {0b101101110011111, 5}, - {0b101101110100111, 3}, {0b101101110101101, 3}, - {0b101101110110101, 3}, {0b101101110111011, 5}, - {0b101101110111110, 5}, {0b101101110111111, 4}, - {0b101101111001111, 5}, {0b101101111010111, 5}, - {0b101101111011010, 3}, {0b101101111011101, 5}, - {0b101101111011111, 4}, {0b101101111100101, 3}, - {0b101101111101011, 5}, {0b101101111101110, 5}, - {0b101101111101111, 4}, {0b101101111110011, 5}, - {0b101101111110110, 5}, {0b101101111110111, 4}, - {0b101101111111001, 5}, {0b101101111111011, 4}, - {0b101101111111100, 5}, {0b101101111111101, 4}, - {0b101101111111110, 4}, {0b101101111111111, 5}, - {0b101110000000000, 4}, {0b101110000000001, 5}, - {0b101110000000010, 5}, {0b101110000000100, 5}, - {0b101110000001000, 5}, {0b101110000010000, 5}, - {0b101110000100000, 5}, {0b101110000110101, 4}, - {0b101110000111010, 4}, {0b101110001000000, 5}, - {0b101110001010011, 4}, {0b101110001011100, 4}, - {0b101110001111111, 5}, {0b101110010000000, 5}, - {0b101110010100011, 4}, {0b101110010101100, 4}, - {0b101110010111111, 5}, {0b101110011000101, 4}, - {0b101110011001010, 4}, {0b101110011011111, 5}, - {0b101110011101111, 5}, {0b101110011110111, 5}, - {0b101110011111011, 5}, {0b101110011111101, 5}, - {0b101110011111110, 5}, {0b101110011111111, 4}, - {0b101110100111111, 5}, {0b101110101010111, 3}, - {0b101110101011101, 3}, {0b101110101101111, 5}, - {0b101110101110101, 3}, {0b101110101111011, 5}, - {0b101110101111110, 5}, {0b101110101111111, 4}, - {0b101110110011111, 5}, {0b101110110101011, 3}, - {0b101110110101110, 3}, {0b101110110110111, 5}, - {0b101110110111010, 3}, {0b101110110111101, 5}, - {0b101110110111111, 4}, {0b101110111001111, 5}, - {0b101110111010101, 3}, {0b101110111011011, 5}, - {0b101110111011110, 5}, {0b101110111011111, 4}, - {0b101110111100111, 5}, {0b101110111101010, 3}, - {0b101110111101101, 5}, {0b101110111101111, 4}, - {0b101110111110011, 5}, {0b101110111110110, 5}, - {0b101110111110111, 4}, {0b101110111111001, 5}, - {0b101110111111011, 4}, {0b101110111111100, 5}, - {0b101110111111101, 4}, {0b101110111111110, 4}, - {0b101110111111111, 5}, {0b101111000111111, 5}, - {0b101111001011011, 3}, {0b101111001011110, 3}, - {0b101111001101111, 5}, {0b101111001110111, 5}, - {0b101111001111010, 3}, {0b101111001111101, 5}, - {0b101111001111111, 4}, {0b101111010011111, 5}, - {0b101111010100111, 3}, {0b101111010101101, 3}, - {0b101111010110101, 3}, {0b101111010111011, 5}, - {0b101111010111110, 5}, {0b101111010111111, 4}, - {0b101111011001111, 5}, {0b101111011010111, 5}, - {0b101111011011010, 3}, {0b101111011011101, 5}, - {0b101111011011111, 4}, {0b101111011100101, 3}, - {0b101111011101011, 5}, {0b101111011101110, 5}, - {0b101111011101111, 4}, {0b101111011110011, 5}, - {0b101111011110110, 5}, {0b101111011110111, 4}, - {0b101111011111001, 5}, {0b101111011111011, 4}, - {0b101111011111100, 5}, {0b101111011111101, 4}, - {0b101111011111110, 4}, {0b101111011111111, 5}, - {0b101111100000000, 3}, {0b101111100000101, 4}, - {0b101111100001010, 4}, {0b101111100001111, 3}, - {0b101111100110111, 5}, {0b101111100111011, 5}, - {0b101111100111101, 5}, {0b101111100111110, 5}, - {0b101111100111111, 4}, {0b101111101010000, 4}, - {0b101111101010101, 3}, {0b101111101011010, 3}, - {0b101111101011111, 2}, {0b101111101100111, 5}, - {0b101111101101011, 5}, {0b101111101101101, 5}, - {0b101111101101110, 5}, {0b101111101101111, 4}, - {0b101111101110011, 5}, {0b101111101110110, 5}, - {0b101111101110111, 4}, {0b101111101111001, 5}, - {0b101111101111011, 4}, {0b101111101111100, 5}, - {0b101111101111101, 4}, {0b101111101111110, 4}, - {0b101111101111111, 5}, {0b101111110010111, 5}, - {0b101111110011011, 5}, {0b101111110011101, 5}, - {0b101111110011110, 5}, {0b101111110011111, 4}, - {0b101111110100000, 4}, {0b101111110100101, 3}, - {0b101111110101010, 3}, {0b101111110101111, 2}, - {0b101111110110011, 5}, {0b101111110110110, 5}, - {0b101111110110111, 4}, {0b101111110111001, 5}, - {0b101111110111011, 4}, {0b101111110111100, 5}, - {0b101111110111101, 4}, {0b101111110111110, 4}, - {0b101111110111111, 5}, {0b101111111000111, 5}, - {0b101111111001011, 5}, {0b101111111001101, 5}, - {0b101111111001110, 5}, {0b101111111001111, 4}, - {0b101111111010011, 5}, {0b101111111010110, 5}, - {0b101111111010111, 4}, {0b101111111011001, 5}, - {0b101111111011011, 4}, {0b101111111011100, 5}, - {0b101111111011101, 4}, {0b101111111011110, 4}, - {0b101111111011111, 5}, {0b101111111100011, 5}, - {0b101111111100110, 5}, {0b101111111100111, 4}, - {0b101111111101001, 5}, {0b101111111101011, 4}, - {0b101111111101100, 5}, {0b101111111101101, 4}, - {0b101111111101110, 4}, {0b101111111101111, 5}, - {0b101111111110000, 3}, {0b101111111110011, 4}, - {0b101111111110101, 2}, {0b101111111110110, 4}, - {0b101111111110111, 5}, {0b101111111111001, 4}, - {0b101111111111010, 2}, {0b101111111111011, 5}, - {0b101111111111100, 4}, {0b101111111111101, 5}, - {0b101111111111110, 5}, {0b101111111111111, 3}, - {0b110000000000000, 3}, {0b110000000000001, 5}, - {0b110000000000010, 5}, {0b110000000000011, 4}, - {0b110000000000100, 5}, {0b110000000000101, 4}, - {0b110000000000110, 2}, {0b110000000001000, 5}, - {0b110000000001001, 2}, {0b110000000001010, 4}, - {0b110000000001100, 4}, {0b110000000001111, 3}, - {0b110000000010000, 5}, {0b110000000010001, 4}, - {0b110000000010010, 4}, {0b110000000010011, 5}, - {0b110000000010100, 4}, {0b110000000010101, 5}, - {0b110000000011000, 4}, {0b110000000011010, 5}, - {0b110000000011100, 5}, {0b110000000100000, 5}, - {0b110000000100001, 4}, {0b110000000100010, 4}, - {0b110000000100011, 5}, {0b110000000100100, 4}, - {0b110000000100101, 5}, {0b110000000101000, 4}, - {0b110000000101010, 5}, {0b110000000101100, 5}, - {0b110000000110000, 4}, {0b110000000110001, 5}, - {0b110000000110010, 5}, {0b110000000110100, 5}, - {0b110000000111000, 5}, {0b110000001000000, 5}, - {0b110000001000001, 4}, {0b110000001000010, 4}, - {0b110000001000011, 5}, {0b110000001000100, 4}, - {0b110000001000101, 5}, {0b110000001001000, 4}, - {0b110000001001010, 5}, {0b110000001001100, 5}, - {0b110000001010000, 4}, {0b110000001010001, 5}, - {0b110000001010010, 5}, {0b110000001010100, 5}, - {0b110000001011000, 5}, {0b110000001100000, 2}, - {0b110000001100110, 3}, {0b110000001101001, 3}, - {0b110000001101111, 4}, {0b110000010000000, 5}, - {0b110000010000001, 4}, {0b110000010000010, 4}, - {0b110000010000011, 5}, {0b110000010000100, 4}, - {0b110000010000101, 5}, {0b110000010001000, 4}, - {0b110000010001010, 5}, {0b110000010001100, 5}, - {0b110000010010000, 2}, {0b110000010010110, 3}, - {0b110000010011001, 3}, {0b110000010011111, 4}, - {0b110000010100000, 4}, {0b110000010100001, 5}, - {0b110000010100010, 5}, {0b110000010100100, 5}, - {0b110000010101000, 5}, {0b110000011000000, 4}, - {0b110000011000001, 5}, {0b110000011000010, 5}, - {0b110000011000100, 5}, {0b110000011001000, 5}, - {0b110000011110000, 3}, {0b110000011110110, 4}, - {0b110000011111001, 4}, {0b110000011111111, 3}, - {0b110000100000000, 5}, {0b110000100000001, 4}, - {0b110000100000010, 4}, {0b110000100000011, 5}, - {0b110000100000100, 4}, {0b110000100000101, 5}, - {0b110000100001000, 4}, {0b110000100001010, 5}, - {0b110000100001100, 5}, {0b110000100010000, 4}, - {0b110000100010001, 5}, {0b110000100010110, 3}, - {0b110000100011000, 5}, {0b110000100100000, 4}, - {0b110000100100010, 5}, {0b110000100100100, 5}, - {0b110000100101001, 3}, {0b110000100110000, 5}, - {0b110000101000000, 4}, {0b110000101000010, 5}, - {0b110000101000100, 5}, {0b110000101001001, 3}, - {0b110000101010000, 5}, {0b110000101100001, 3}, - {0b110000101101000, 3}, {0b110000110000000, 4}, - {0b110000110000001, 5}, {0b110000110000110, 3}, - {0b110000110001000, 5}, {0b110000110010010, 3}, - {0b110000110010100, 3}, {0b110000110100000, 5}, - {0b110000111000000, 5}, {0b110001000000000, 5}, - {0b110001000000001, 4}, {0b110001000000010, 4}, - {0b110001000000011, 5}, {0b110001000000100, 4}, - {0b110001000000101, 5}, {0b110001000001000, 4}, - {0b110001000001010, 5}, {0b110001000001100, 5}, - {0b110001000010000, 4}, {0b110001000010010, 5}, - {0b110001000010100, 5}, {0b110001000011001, 3}, - {0b110001000100000, 4}, {0b110001000100001, 5}, - {0b110001000100110, 3}, {0b110001000101000, 5}, - {0b110001000110000, 5}, {0b110001001000000, 4}, - {0b110001001000001, 5}, {0b110001001000110, 3}, - {0b110001001001000, 5}, {0b110001001010000, 5}, - {0b110001001100010, 3}, {0b110001001100100, 3}, - {0b110001010000000, 4}, {0b110001010000010, 5}, - {0b110001010000100, 5}, {0b110001010001001, 3}, - {0b110001010010001, 3}, {0b110001010011000, 3}, - {0b110001010100000, 5}, {0b110001011000000, 5}, - {0b110001100000000, 4}, {0b110001100000001, 5}, - {0b110001100000010, 5}, {0b110001100000100, 5}, - {0b110001100001000, 5}, {0b110001100010000, 5}, - {0b110001100100000, 5}, {0b110001100110110, 4}, - {0b110001100111001, 4}, {0b110001101000000, 5}, - {0b110001101100011, 4}, {0b110001101101100, 4}, - {0b110001101111111, 5}, {0b110001110000000, 5}, - {0b110001110010011, 4}, {0b110001110011100, 4}, - {0b110001110111111, 5}, {0b110001111000110, 4}, - {0b110001111001001, 4}, {0b110001111011111, 5}, - {0b110001111101111, 5}, {0b110001111110111, 5}, - {0b110001111111011, 5}, {0b110001111111101, 5}, - {0b110001111111110, 5}, {0b110001111111111, 4}, - {0b110010000000000, 5}, {0b110010000000001, 4}, - {0b110010000000010, 4}, {0b110010000000011, 5}, - {0b110010000000100, 4}, {0b110010000000101, 5}, - {0b110010000001000, 4}, {0b110010000001010, 5}, - {0b110010000001100, 5}, {0b110010000010000, 4}, - {0b110010000010010, 5}, {0b110010000010100, 5}, - {0b110010000011001, 3}, {0b110010000100000, 4}, - {0b110010000100001, 5}, {0b110010000100110, 3}, - {0b110010000101000, 5}, {0b110010000110000, 5}, - {0b110010001000000, 4}, {0b110010001000001, 5}, - {0b110010001000110, 3}, {0b110010001001000, 5}, - {0b110010001010000, 5}, {0b110010001100010, 3}, - {0b110010001100100, 3}, {0b110010010000000, 4}, - {0b110010010000010, 5}, {0b110010010000100, 5}, - {0b110010010001001, 3}, {0b110010010010001, 3}, - {0b110010010011000, 3}, {0b110010010100000, 5}, - {0b110010011000000, 5}, {0b110010100000000, 4}, - {0b110010100000001, 5}, {0b110010100000010, 5}, - {0b110010100000100, 5}, {0b110010100001000, 5}, - {0b110010100010000, 5}, {0b110010100100000, 5}, - {0b110010101000000, 5}, {0b110010101010110, 4}, - {0b110010101011001, 4}, {0b110010101100101, 4}, - {0b110010101101010, 4}, {0b110010101111111, 5}, - {0b110010110000000, 5}, {0b110010110010101, 4}, - {0b110010110011010, 4}, {0b110010110100110, 4}, - {0b110010110101001, 4}, {0b110010110111111, 5}, - {0b110010111011111, 5}, {0b110010111101111, 5}, - {0b110010111110111, 5}, {0b110010111111011, 5}, - {0b110010111111101, 5}, {0b110010111111110, 5}, - {0b110010111111111, 4}, {0b110011000000000, 2}, - {0b110011000000110, 3}, {0b110011000001001, 3}, - {0b110011000001111, 4}, {0b110011000010001, 3}, - {0b110011000011000, 3}, {0b110011000100010, 3}, - {0b110011000100100, 3}, {0b110011000110011, 4}, - {0b110011000111100, 4}, {0b110011001000010, 3}, - {0b110011001000100, 3}, {0b110011001010101, 4}, - {0b110011001011010, 4}, {0b110011001100000, 3}, - {0b110011001100110, 1}, {0b110011001101001, 4}, - {0b110011001101111, 3}, {0b110011001110111, 3}, - {0b110011001111110, 3}, {0b110011010000001, 3}, - {0b110011010001000, 3}, {0b110011010010000, 3}, - {0b110011010010110, 4}, {0b110011010011001, 1}, - {0b110011010011111, 3}, {0b110011010100101, 4}, - {0b110011010101010, 4}, {0b110011010111011, 3}, - {0b110011010111101, 3}, {0b110011011000011, 4}, - {0b110011011001100, 4}, {0b110011011011011, 3}, - {0b110011011011101, 3}, {0b110011011100111, 3}, - {0b110011011101110, 3}, {0b110011011110000, 4}, - {0b110011011110110, 3}, {0b110011011111001, 3}, - {0b110011011111111, 2}, {0b110011100111111, 5}, - {0b110011101011111, 5}, {0b110011101100111, 3}, - {0b110011101101110, 3}, {0b110011101110110, 3}, - {0b110011101111011, 5}, {0b110011101111101, 5}, - {0b110011101111111, 4}, {0b110011110011011, 3}, - {0b110011110011101, 3}, {0b110011110101111, 5}, - {0b110011110110111, 5}, {0b110011110111001, 3}, - {0b110011110111110, 5}, {0b110011110111111, 4}, - {0b110011111001111, 5}, {0b110011111010111, 5}, - {0b110011111011001, 3}, {0b110011111011110, 5}, - {0b110011111011111, 4}, {0b110011111100110, 3}, - {0b110011111101011, 5}, {0b110011111101101, 5}, - {0b110011111101111, 4}, {0b110011111110011, 5}, - {0b110011111110101, 5}, {0b110011111110111, 4}, - {0b110011111111010, 5}, {0b110011111111011, 4}, - {0b110011111111100, 5}, {0b110011111111101, 4}, - {0b110011111111110, 4}, {0b110011111111111, 5}, - {0b110100000000000, 5}, {0b110100000000001, 4}, - {0b110100000000010, 4}, {0b110100000000011, 5}, - {0b110100000000100, 4}, {0b110100000000101, 5}, - {0b110100000001000, 4}, {0b110100000001010, 5}, - {0b110100000001100, 5}, {0b110100000010000, 4}, - {0b110100000010001, 5}, {0b110100000010110, 3}, - {0b110100000011000, 5}, {0b110100000100000, 4}, - {0b110100000100010, 5}, {0b110100000100100, 5}, - {0b110100000101001, 3}, {0b110100000110000, 5}, - {0b110100001000000, 4}, {0b110100001000010, 5}, - {0b110100001000100, 5}, {0b110100001001001, 3}, - {0b110100001010000, 5}, {0b110100001100001, 3}, - {0b110100001101000, 3}, {0b110100010000000, 4}, - {0b110100010000001, 5}, {0b110100010000110, 3}, - {0b110100010001000, 5}, {0b110100010010010, 3}, - {0b110100010010100, 3}, {0b110100010100000, 5}, - {0b110100011000000, 5}, {0b110100100000000, 2}, - {0b110100100000110, 3}, {0b110100100001001, 3}, - {0b110100100001111, 4}, {0b110100100010010, 3}, - {0b110100100010100, 3}, {0b110100100100001, 3}, - {0b110100100101000, 3}, {0b110100100110011, 4}, - {0b110100100111100, 4}, {0b110100101000001, 3}, - {0b110100101001000, 3}, {0b110100101010101, 4}, - {0b110100101011010, 4}, {0b110100101100000, 3}, - {0b110100101100110, 4}, {0b110100101101001, 1}, - {0b110100101101111, 3}, {0b110100101111011, 3}, - {0b110100101111101, 3}, {0b110100110000010, 3}, - {0b110100110000100, 3}, {0b110100110010000, 3}, - {0b110100110010110, 1}, {0b110100110011001, 4}, - {0b110100110011111, 3}, {0b110100110100101, 4}, - {0b110100110101010, 4}, {0b110100110110111, 3}, - {0b110100110111110, 3}, {0b110100111000011, 4}, - {0b110100111001100, 4}, {0b110100111010111, 3}, - {0b110100111011110, 3}, {0b110100111101011, 3}, - {0b110100111101101, 3}, {0b110100111110000, 4}, - {0b110100111110110, 3}, {0b110100111111001, 3}, - {0b110100111111111, 2}, {0b110101000000000, 4}, - {0b110101000000001, 5}, {0b110101000000010, 5}, - {0b110101000000100, 5}, {0b110101000001000, 5}, - {0b110101000010000, 5}, {0b110101000100000, 5}, - {0b110101001000000, 5}, {0b110101001010110, 4}, - {0b110101001011001, 4}, {0b110101001100101, 4}, - {0b110101001101010, 4}, {0b110101001111111, 5}, - {0b110101010000000, 5}, {0b110101010010101, 4}, - {0b110101010011010, 4}, {0b110101010100110, 4}, - {0b110101010101001, 4}, {0b110101010111111, 5}, - {0b110101011011111, 5}, {0b110101011101111, 5}, - {0b110101011110111, 5}, {0b110101011111011, 5}, - {0b110101011111101, 5}, {0b110101011111110, 5}, - {0b110101011111111, 4}, {0b110101100111111, 5}, - {0b110101101011111, 5}, {0b110101101101011, 3}, - {0b110101101101101, 3}, {0b110101101110111, 5}, - {0b110101101111001, 3}, {0b110101101111110, 5}, - {0b110101101111111, 4}, {0b110101110010111, 3}, - {0b110101110011110, 3}, {0b110101110101111, 5}, - {0b110101110110110, 3}, {0b110101110111011, 5}, - {0b110101110111101, 5}, {0b110101110111111, 4}, - {0b110101111001111, 5}, {0b110101111010110, 3}, - {0b110101111011011, 5}, {0b110101111011101, 5}, - {0b110101111011111, 4}, {0b110101111100111, 5}, - {0b110101111101001, 3}, {0b110101111101110, 5}, - {0b110101111101111, 4}, {0b110101111110011, 5}, - {0b110101111110101, 5}, {0b110101111110111, 4}, - {0b110101111111010, 5}, {0b110101111111011, 4}, - {0b110101111111100, 5}, {0b110101111111101, 4}, - {0b110101111111110, 4}, {0b110101111111111, 5}, - {0b110110000000000, 4}, {0b110110000000001, 5}, - {0b110110000000010, 5}, {0b110110000000100, 5}, - {0b110110000001000, 5}, {0b110110000010000, 5}, - {0b110110000100000, 5}, {0b110110000110110, 4}, - {0b110110000111001, 4}, {0b110110001000000, 5}, - {0b110110001100011, 4}, {0b110110001101100, 4}, - {0b110110001111111, 5}, {0b110110010000000, 5}, - {0b110110010010011, 4}, {0b110110010011100, 4}, - {0b110110010111111, 5}, {0b110110011000110, 4}, - {0b110110011001001, 4}, {0b110110011011111, 5}, - {0b110110011101111, 5}, {0b110110011110111, 5}, - {0b110110011111011, 5}, {0b110110011111101, 5}, - {0b110110011111110, 5}, {0b110110011111111, 4}, - {0b110110100111111, 5}, {0b110110101011111, 5}, - {0b110110101101011, 3}, {0b110110101101101, 3}, - {0b110110101110111, 5}, {0b110110101111001, 3}, - {0b110110101111110, 5}, {0b110110101111111, 4}, - {0b110110110010111, 3}, {0b110110110011110, 3}, - {0b110110110101111, 5}, {0b110110110110110, 3}, - {0b110110110111011, 5}, {0b110110110111101, 5}, - {0b110110110111111, 4}, {0b110110111001111, 5}, - {0b110110111010110, 3}, {0b110110111011011, 5}, - {0b110110111011101, 5}, {0b110110111011111, 4}, - {0b110110111100111, 5}, {0b110110111101001, 3}, - {0b110110111101110, 5}, {0b110110111101111, 4}, - {0b110110111110011, 5}, {0b110110111110101, 5}, - {0b110110111110111, 4}, {0b110110111111010, 5}, - {0b110110111111011, 4}, {0b110110111111100, 5}, - {0b110110111111101, 4}, {0b110110111111110, 4}, - {0b110110111111111, 5}, {0b110111000111111, 5}, - {0b110111001011111, 5}, {0b110111001100111, 3}, - {0b110111001101110, 3}, {0b110111001110110, 3}, - {0b110111001111011, 5}, {0b110111001111101, 5}, - {0b110111001111111, 4}, {0b110111010011011, 3}, - {0b110111010011101, 3}, {0b110111010101111, 5}, - {0b110111010110111, 5}, {0b110111010111001, 3}, - {0b110111010111110, 5}, {0b110111010111111, 4}, - {0b110111011001111, 5}, {0b110111011010111, 5}, - {0b110111011011001, 3}, {0b110111011011110, 5}, - {0b110111011011111, 4}, {0b110111011100110, 3}, - {0b110111011101011, 5}, {0b110111011101101, 5}, - {0b110111011101111, 4}, {0b110111011110011, 5}, - {0b110111011110101, 5}, {0b110111011110111, 4}, - {0b110111011111010, 5}, {0b110111011111011, 4}, - {0b110111011111100, 5}, {0b110111011111101, 4}, - {0b110111011111110, 4}, {0b110111011111111, 5}, - {0b110111100000000, 3}, {0b110111100000110, 4}, - {0b110111100001001, 4}, {0b110111100001111, 3}, - {0b110111100110111, 5}, {0b110111100111011, 5}, - {0b110111100111101, 5}, {0b110111100111110, 5}, - {0b110111100111111, 4}, {0b110111101010111, 5}, - {0b110111101011011, 5}, {0b110111101011101, 5}, - {0b110111101011110, 5}, {0b110111101011111, 4}, - {0b110111101100000, 4}, {0b110111101100110, 3}, - {0b110111101101001, 3}, {0b110111101101111, 2}, - {0b110111101110011, 5}, {0b110111101110101, 5}, - {0b110111101110111, 4}, {0b110111101111010, 5}, - {0b110111101111011, 4}, {0b110111101111100, 5}, - {0b110111101111101, 4}, {0b110111101111110, 4}, - {0b110111101111111, 5}, {0b110111110010000, 4}, - {0b110111110010110, 3}, {0b110111110011001, 3}, - {0b110111110011111, 2}, {0b110111110100111, 5}, - {0b110111110101011, 5}, {0b110111110101101, 5}, - {0b110111110101110, 5}, {0b110111110101111, 4}, - {0b110111110110011, 5}, {0b110111110110101, 5}, - {0b110111110110111, 4}, {0b110111110111010, 5}, - {0b110111110111011, 4}, {0b110111110111100, 5}, - {0b110111110111101, 4}, {0b110111110111110, 4}, - {0b110111110111111, 5}, {0b110111111000111, 5}, - {0b110111111001011, 5}, {0b110111111001101, 5}, - {0b110111111001110, 5}, {0b110111111001111, 4}, - {0b110111111010011, 5}, {0b110111111010101, 5}, - {0b110111111010111, 4}, {0b110111111011010, 5}, - {0b110111111011011, 4}, {0b110111111011100, 5}, - {0b110111111011101, 4}, {0b110111111011110, 4}, - {0b110111111011111, 5}, {0b110111111100011, 5}, - {0b110111111100101, 5}, {0b110111111100111, 4}, - {0b110111111101010, 5}, {0b110111111101011, 4}, - {0b110111111101100, 5}, {0b110111111101101, 4}, - {0b110111111101110, 4}, {0b110111111101111, 5}, - {0b110111111110000, 3}, {0b110111111110011, 4}, - {0b110111111110101, 4}, {0b110111111110110, 2}, - {0b110111111110111, 5}, {0b110111111111001, 2}, - {0b110111111111010, 4}, {0b110111111111011, 5}, - {0b110111111111100, 4}, {0b110111111111101, 5}, - {0b110111111111110, 5}, {0b110111111111111, 3}, - {0b111000000000000, 5}, {0b111000000000001, 4}, - {0b111000000000010, 4}, {0b111000000000100, 4}, - {0b111000000000111, 3}, {0b111000000001000, 4}, - {0b111000000001011, 3}, {0b111000000001101, 3}, - {0b111000000001110, 3}, {0b111000000010000, 4}, - {0b111000000010001, 5}, {0b111000000010010, 5}, - {0b111000000010100, 5}, {0b111000000011000, 5}, - {0b111000000100000, 4}, {0b111000000100001, 5}, - {0b111000000100010, 5}, {0b111000000100100, 5}, - {0b111000000101000, 5}, {0b111000001000000, 4}, - {0b111000001000001, 5}, {0b111000001000010, 5}, - {0b111000001000100, 5}, {0b111000001001000, 5}, - {0b111000001110000, 3}, {0b111000010000000, 4}, - {0b111000010000001, 5}, {0b111000010000010, 5}, - {0b111000010000100, 5}, {0b111000010001000, 5}, - {0b111000010110000, 3}, {0b111000011010000, 3}, - {0b111000011100000, 3}, {0b111000100000000, 4}, - {0b111000100000001, 5}, {0b111000100000010, 5}, - {0b111000100000100, 5}, {0b111000100001000, 5}, - {0b111000100010000, 5}, {0b111000100010111, 4}, - {0b111000100100000, 5}, {0b111000100101011, 4}, - {0b111000101000000, 5}, {0b111000101001101, 4}, - {0b111000101110001, 4}, {0b111000101111111, 5}, - {0b111000110000000, 5}, {0b111000110001110, 4}, - {0b111000110110010, 4}, {0b111000110111111, 5}, - {0b111000111010100, 4}, {0b111000111011111, 5}, - {0b111000111101000, 4}, {0b111000111101111, 5}, - {0b111000111110111, 5}, {0b111000111111011, 5}, - {0b111000111111101, 5}, {0b111000111111110, 5}, - {0b111000111111111, 4}, {0b111001000000000, 4}, - {0b111001000000001, 5}, {0b111001000000010, 5}, - {0b111001000000100, 5}, {0b111001000001000, 5}, - {0b111001000010000, 5}, {0b111001000011011, 4}, - {0b111001000100000, 5}, {0b111001000100111, 4}, - {0b111001001000000, 5}, {0b111001001001110, 4}, - {0b111001001110010, 4}, {0b111001001111111, 5}, - {0b111001010000000, 5}, {0b111001010001101, 4}, - {0b111001010110001, 4}, {0b111001010111111, 5}, - {0b111001011011000, 4}, {0b111001011011111, 5}, - {0b111001011100100, 4}, {0b111001011101111, 5}, - {0b111001011110111, 5}, {0b111001011111011, 5}, - {0b111001011111101, 5}, {0b111001011111110, 5}, - {0b111001011111111, 4}, {0b111001100110111, 3}, - {0b111001100111011, 3}, {0b111001101011111, 5}, - {0b111001101101111, 5}, {0b111001101110011, 3}, - {0b111001101111101, 5}, {0b111001101111110, 5}, - {0b111001101111111, 4}, {0b111001110011111, 5}, - {0b111001110101111, 5}, {0b111001110110011, 3}, - {0b111001110111101, 5}, {0b111001110111110, 5}, - {0b111001110111111, 4}, {0b111001111001101, 3}, - {0b111001111001110, 3}, {0b111001111010111, 5}, - {0b111001111011011, 5}, {0b111001111011100, 3}, - {0b111001111011111, 4}, {0b111001111100111, 5}, - {0b111001111101011, 5}, {0b111001111101100, 3}, - {0b111001111101111, 4}, {0b111001111110101, 5}, - {0b111001111110110, 5}, {0b111001111110111, 4}, - {0b111001111111001, 5}, {0b111001111111010, 5}, - {0b111001111111011, 4}, {0b111001111111101, 4}, - {0b111001111111110, 4}, {0b111001111111111, 5}, - {0b111010000000000, 4}, {0b111010000000001, 5}, - {0b111010000000010, 5}, {0b111010000000100, 5}, - {0b111010000001000, 5}, {0b111010000010000, 5}, - {0b111010000011101, 4}, {0b111010000100000, 5}, - {0b111010000101110, 4}, {0b111010001000000, 5}, - {0b111010001000111, 4}, {0b111010001110100, 4}, - {0b111010001111111, 5}, {0b111010010000000, 5}, - {0b111010010001011, 4}, {0b111010010111000, 4}, - {0b111010010111111, 5}, {0b111010011010001, 4}, - {0b111010011011111, 5}, {0b111010011100010, 4}, - {0b111010011101111, 5}, {0b111010011110111, 5}, - {0b111010011111011, 5}, {0b111010011111101, 5}, - {0b111010011111110, 5}, {0b111010011111111, 4}, - {0b111010100111111, 5}, {0b111010101010111, 3}, - {0b111010101011101, 3}, {0b111010101101111, 5}, - {0b111010101110101, 3}, {0b111010101111011, 5}, - {0b111010101111110, 5}, {0b111010101111111, 4}, - {0b111010110011111, 5}, {0b111010110101011, 3}, - {0b111010110101110, 3}, {0b111010110110111, 5}, - {0b111010110111010, 3}, {0b111010110111101, 5}, - {0b111010110111111, 4}, {0b111010111001111, 5}, - {0b111010111010101, 3}, {0b111010111011011, 5}, - {0b111010111011110, 5}, {0b111010111011111, 4}, - {0b111010111100111, 5}, {0b111010111101010, 3}, - {0b111010111101101, 5}, {0b111010111101111, 4}, - {0b111010111110011, 5}, {0b111010111110110, 5}, - {0b111010111110111, 4}, {0b111010111111001, 5}, - {0b111010111111011, 4}, {0b111010111111100, 5}, - {0b111010111111101, 4}, {0b111010111111110, 4}, - {0b111010111111111, 5}, {0b111011000111111, 5}, - {0b111011001011111, 5}, {0b111011001100111, 3}, - {0b111011001101110, 3}, {0b111011001110110, 3}, - {0b111011001111011, 5}, {0b111011001111101, 5}, - {0b111011001111111, 4}, {0b111011010011011, 3}, - {0b111011010011101, 3}, {0b111011010101111, 5}, - {0b111011010110111, 5}, {0b111011010111001, 3}, - {0b111011010111110, 5}, {0b111011010111111, 4}, - {0b111011011001111, 5}, {0b111011011010111, 5}, - {0b111011011011001, 3}, {0b111011011011110, 5}, - {0b111011011011111, 4}, {0b111011011100110, 3}, - {0b111011011101011, 5}, {0b111011011101101, 5}, - {0b111011011101111, 4}, {0b111011011110011, 5}, - {0b111011011110101, 5}, {0b111011011110111, 4}, - {0b111011011111010, 5}, {0b111011011111011, 4}, - {0b111011011111100, 5}, {0b111011011111101, 4}, - {0b111011011111110, 4}, {0b111011011111111, 5}, - {0b111011100000000, 3}, {0b111011100010001, 4}, - {0b111011100011111, 5}, {0b111011100100010, 4}, - {0b111011100101111, 5}, {0b111011100110011, 3}, - {0b111011100111101, 5}, {0b111011100111110, 5}, - {0b111011100111111, 4}, {0b111011101000100, 4}, - {0b111011101001111, 5}, {0b111011101010101, 3}, - {0b111011101011011, 5}, {0b111011101011110, 5}, - {0b111011101011111, 4}, {0b111011101100110, 3}, - {0b111011101101011, 5}, {0b111011101101101, 5}, - {0b111011101101111, 4}, {0b111011101110111, 2}, - {0b111011101111001, 5}, {0b111011101111010, 5}, - {0b111011101111011, 4}, {0b111011101111100, 5}, - {0b111011101111101, 4}, {0b111011101111110, 4}, - {0b111011101111111, 5}, {0b111011110001000, 4}, - {0b111011110001111, 5}, {0b111011110010111, 5}, - {0b111011110011001, 3}, {0b111011110011110, 5}, - {0b111011110011111, 4}, {0b111011110100111, 5}, - {0b111011110101010, 3}, {0b111011110101101, 5}, - {0b111011110101111, 4}, {0b111011110110101, 5}, - {0b111011110110110, 5}, {0b111011110110111, 4}, - {0b111011110111011, 2}, {0b111011110111100, 5}, - {0b111011110111101, 4}, {0b111011110111110, 4}, - {0b111011110111111, 5}, {0b111011111000111, 5}, - {0b111011111001011, 5}, {0b111011111001100, 3}, - {0b111011111001111, 4}, {0b111011111010011, 5}, - {0b111011111010110, 5}, {0b111011111010111, 4}, - {0b111011111011010, 5}, {0b111011111011011, 4}, - {0b111011111011101, 2}, {0b111011111011110, 4}, - {0b111011111011111, 5}, {0b111011111100011, 5}, - {0b111011111100101, 5}, {0b111011111100111, 4}, - {0b111011111101001, 5}, {0b111011111101011, 4}, - {0b111011111101101, 4}, {0b111011111101110, 2}, - {0b111011111101111, 5}, {0b111011111110001, 5}, - {0b111011111110010, 5}, {0b111011111110011, 4}, - {0b111011111110100, 5}, {0b111011111110101, 4}, - {0b111011111110110, 4}, {0b111011111110111, 5}, - {0b111011111111000, 5}, {0b111011111111001, 4}, - {0b111011111111010, 4}, {0b111011111111011, 5}, - {0b111011111111100, 4}, {0b111011111111101, 5}, - {0b111011111111110, 5}, {0b111011111111111, 3}, - {0b111100000000000, 4}, {0b111100000000001, 5}, - {0b111100000000010, 5}, {0b111100000000100, 5}, - {0b111100000001000, 5}, {0b111100000010000, 5}, - {0b111100000011110, 4}, {0b111100000100000, 5}, - {0b111100000101101, 4}, {0b111100001000000, 5}, - {0b111100001001011, 4}, {0b111100001111000, 4}, - {0b111100001111111, 5}, {0b111100010000000, 5}, - {0b111100010000111, 4}, {0b111100010110100, 4}, - {0b111100010111111, 5}, {0b111100011010010, 4}, - {0b111100011011111, 5}, {0b111100011100001, 4}, - {0b111100011101111, 5}, {0b111100011110111, 5}, - {0b111100011111011, 5}, {0b111100011111101, 5}, - {0b111100011111110, 5}, {0b111100011111111, 4}, - {0b111100100111111, 5}, {0b111100101011111, 5}, - {0b111100101101011, 3}, {0b111100101101101, 3}, - {0b111100101110111, 5}, {0b111100101111001, 3}, - {0b111100101111110, 5}, {0b111100101111111, 4}, - {0b111100110010111, 3}, {0b111100110011110, 3}, - {0b111100110101111, 5}, {0b111100110110110, 3}, - {0b111100110111011, 5}, {0b111100110111101, 5}, - {0b111100110111111, 4}, {0b111100111001111, 5}, - {0b111100111010110, 3}, {0b111100111011011, 5}, - {0b111100111011101, 5}, {0b111100111011111, 4}, - {0b111100111100111, 5}, {0b111100111101001, 3}, - {0b111100111101110, 5}, {0b111100111101111, 4}, - {0b111100111110011, 5}, {0b111100111110101, 5}, - {0b111100111110111, 4}, {0b111100111111010, 5}, - {0b111100111111011, 4}, {0b111100111111100, 5}, - {0b111100111111101, 4}, {0b111100111111110, 4}, - {0b111100111111111, 5}, {0b111101000111111, 5}, - {0b111101001011011, 3}, {0b111101001011110, 3}, - {0b111101001101111, 5}, {0b111101001110111, 5}, - {0b111101001111010, 3}, {0b111101001111101, 5}, - {0b111101001111111, 4}, {0b111101010011111, 5}, - {0b111101010100111, 3}, {0b111101010101101, 3}, - {0b111101010110101, 3}, {0b111101010111011, 5}, - {0b111101010111110, 5}, {0b111101010111111, 4}, - {0b111101011001111, 5}, {0b111101011010111, 5}, - {0b111101011011010, 3}, {0b111101011011101, 5}, - {0b111101011011111, 4}, {0b111101011100101, 3}, - {0b111101011101011, 5}, {0b111101011101110, 5}, - {0b111101011101111, 4}, {0b111101011110011, 5}, - {0b111101011110110, 5}, {0b111101011110111, 4}, - {0b111101011111001, 5}, {0b111101011111011, 4}, - {0b111101011111100, 5}, {0b111101011111101, 4}, - {0b111101011111110, 4}, {0b111101011111111, 5}, - {0b111101100000000, 3}, {0b111101100010010, 4}, - {0b111101100011111, 5}, {0b111101100100001, 4}, - {0b111101100101111, 5}, {0b111101100110011, 3}, - {0b111101100111101, 5}, {0b111101100111110, 5}, - {0b111101100111111, 4}, {0b111101101001000, 4}, - {0b111101101001111, 5}, {0b111101101010111, 5}, - {0b111101101011010, 3}, {0b111101101011101, 5}, - {0b111101101011111, 4}, {0b111101101100111, 5}, - {0b111101101101001, 3}, {0b111101101101110, 5}, - {0b111101101101111, 4}, {0b111101101110101, 5}, - {0b111101101110110, 5}, {0b111101101110111, 4}, - {0b111101101111011, 2}, {0b111101101111100, 5}, - {0b111101101111101, 4}, {0b111101101111110, 4}, - {0b111101101111111, 5}, {0b111101110000100, 4}, - {0b111101110001111, 5}, {0b111101110010110, 3}, - {0b111101110011011, 5}, {0b111101110011101, 5}, - {0b111101110011111, 4}, {0b111101110100101, 3}, - {0b111101110101011, 5}, {0b111101110101110, 5}, - {0b111101110101111, 4}, {0b111101110110111, 2}, - {0b111101110111001, 5}, {0b111101110111010, 5}, - {0b111101110111011, 4}, {0b111101110111100, 5}, - {0b111101110111101, 4}, {0b111101110111110, 4}, - {0b111101110111111, 5}, {0b111101111000111, 5}, - {0b111101111001011, 5}, {0b111101111001100, 3}, - {0b111101111001111, 4}, {0b111101111010011, 5}, - {0b111101111010101, 5}, {0b111101111010111, 4}, - {0b111101111011001, 5}, {0b111101111011011, 4}, - {0b111101111011101, 4}, {0b111101111011110, 2}, - {0b111101111011111, 5}, {0b111101111100011, 5}, - {0b111101111100110, 5}, {0b111101111100111, 4}, - {0b111101111101010, 5}, {0b111101111101011, 4}, - {0b111101111101101, 2}, {0b111101111101110, 4}, - {0b111101111101111, 5}, {0b111101111110001, 5}, - {0b111101111110010, 5}, {0b111101111110011, 4}, - {0b111101111110100, 5}, {0b111101111110101, 4}, - {0b111101111110110, 4}, {0b111101111110111, 5}, - {0b111101111111000, 5}, {0b111101111111001, 4}, - {0b111101111111010, 4}, {0b111101111111011, 5}, - {0b111101111111100, 4}, {0b111101111111101, 5}, - {0b111101111111110, 5}, {0b111101111111111, 3}, - {0b111110000111101, 3}, {0b111110000111110, 3}, - {0b111110001011111, 5}, {0b111110001101111, 5}, - {0b111110001110111, 5}, {0b111110001111011, 5}, - {0b111110001111100, 3}, {0b111110001111111, 4}, - {0b111110010011111, 5}, {0b111110010101111, 5}, - {0b111110010110111, 5}, {0b111110010111011, 5}, - {0b111110010111100, 3}, {0b111110010111111, 4}, - {0b111110011000111, 3}, {0b111110011001011, 3}, - {0b111110011010011, 3}, {0b111110011011101, 5}, - {0b111110011011110, 5}, {0b111110011011111, 4}, - {0b111110011100011, 3}, {0b111110011101101, 5}, - {0b111110011101110, 5}, {0b111110011101111, 4}, - {0b111110011110101, 5}, {0b111110011110110, 5}, - {0b111110011110111, 4}, {0b111110011111001, 5}, - {0b111110011111010, 5}, {0b111110011111011, 4}, - {0b111110011111101, 4}, {0b111110011111110, 4}, - {0b111110011111111, 5}, {0b111110100000000, 3}, - {0b111110100010100, 4}, {0b111110100011111, 5}, - {0b111110100101000, 4}, {0b111110100101111, 5}, - {0b111110100110111, 5}, {0b111110100111011, 5}, - {0b111110100111100, 3}, {0b111110100111111, 4}, - {0b111110101000001, 4}, {0b111110101001111, 5}, - {0b111110101010101, 3}, {0b111110101011011, 5}, - {0b111110101011110, 5}, {0b111110101011111, 4}, - {0b111110101100111, 5}, {0b111110101101001, 3}, - {0b111110101101110, 5}, {0b111110101101111, 4}, - {0b111110101110011, 5}, {0b111110101110110, 5}, - {0b111110101110111, 4}, {0b111110101111010, 5}, - {0b111110101111011, 4}, {0b111110101111101, 2}, - {0b111110101111110, 4}, {0b111110101111111, 5}, - {0b111110110000010, 4}, {0b111110110001111, 5}, - {0b111110110010110, 3}, {0b111110110011011, 5}, - {0b111110110011101, 5}, {0b111110110011111, 4}, - {0b111110110100111, 5}, {0b111110110101010, 3}, - {0b111110110101101, 5}, {0b111110110101111, 4}, - {0b111110110110011, 5}, {0b111110110110101, 5}, - {0b111110110110111, 4}, {0b111110110111001, 5}, - {0b111110110111011, 4}, {0b111110110111101, 4}, - {0b111110110111110, 2}, {0b111110110111111, 5}, - {0b111110111000011, 3}, {0b111110111001101, 5}, - {0b111110111001110, 5}, {0b111110111001111, 4}, - {0b111110111010111, 2}, {0b111110111011001, 5}, - {0b111110111011010, 5}, {0b111110111011011, 4}, - {0b111110111011100, 5}, {0b111110111011101, 4}, - {0b111110111011110, 4}, {0b111110111011111, 5}, - {0b111110111100101, 5}, {0b111110111100110, 5}, - {0b111110111100111, 4}, {0b111110111101011, 2}, - {0b111110111101100, 5}, {0b111110111101101, 4}, - {0b111110111101110, 4}, {0b111110111101111, 5}, - {0b111110111110001, 5}, {0b111110111110010, 5}, - {0b111110111110011, 4}, {0b111110111110100, 5}, - {0b111110111110101, 4}, {0b111110111110110, 4}, - {0b111110111110111, 5}, {0b111110111111000, 5}, - {0b111110111111001, 4}, {0b111110111111010, 4}, - {0b111110111111011, 5}, {0b111110111111100, 4}, - {0b111110111111101, 5}, {0b111110111111110, 5}, - {0b111110111111111, 3}, {0b111111000000000, 3}, - {0b111111000011000, 4}, {0b111111000011111, 5}, - {0b111111000100100, 4}, {0b111111000101111, 5}, - {0b111111000110111, 5}, {0b111111000111011, 5}, - {0b111111000111100, 3}, {0b111111000111111, 4}, - {0b111111001000010, 4}, {0b111111001001111, 5}, - {0b111111001010111, 5}, {0b111111001011010, 3}, - {0b111111001011101, 5}, {0b111111001011111, 4}, - {0b111111001100110, 3}, {0b111111001101011, 5}, - {0b111111001101101, 5}, {0b111111001101111, 4}, - {0b111111001110011, 5}, {0b111111001110101, 5}, - {0b111111001110111, 4}, {0b111111001111001, 5}, - {0b111111001111011, 4}, {0b111111001111101, 4}, - {0b111111001111110, 2}, {0b111111001111111, 5}, - {0b111111010000001, 4}, {0b111111010001111, 5}, - {0b111111010010111, 5}, {0b111111010011001, 3}, - {0b111111010011110, 5}, {0b111111010011111, 4}, - {0b111111010100101, 3}, {0b111111010101011, 5}, - {0b111111010101110, 5}, {0b111111010101111, 4}, - {0b111111010110011, 5}, {0b111111010110110, 5}, - {0b111111010110111, 4}, {0b111111010111010, 5}, - {0b111111010111011, 4}, {0b111111010111101, 2}, - {0b111111010111110, 4}, {0b111111010111111, 5}, - {0b111111011000011, 3}, {0b111111011001101, 5}, - {0b111111011001110, 5}, {0b111111011001111, 4}, - {0b111111011010101, 5}, {0b111111011010110, 5}, - {0b111111011010111, 4}, {0b111111011011011, 2}, - {0b111111011011100, 5}, {0b111111011011101, 4}, - {0b111111011011110, 4}, {0b111111011011111, 5}, - {0b111111011100111, 2}, {0b111111011101001, 5}, - {0b111111011101010, 5}, {0b111111011101011, 4}, - {0b111111011101100, 5}, {0b111111011101101, 4}, - {0b111111011101110, 4}, {0b111111011101111, 5}, - {0b111111011110001, 5}, {0b111111011110010, 5}, - {0b111111011110011, 4}, {0b111111011110100, 5}, - {0b111111011110101, 4}, {0b111111011110110, 4}, - {0b111111011110111, 5}, {0b111111011111000, 5}, - {0b111111011111001, 4}, {0b111111011111010, 4}, - {0b111111011111011, 5}, {0b111111011111100, 4}, - {0b111111011111101, 5}, {0b111111011111110, 5}, - {0b111111011111111, 3}, {0b111111100010111, 5}, - {0b111111100011011, 5}, {0b111111100011101, 5}, - {0b111111100011110, 5}, {0b111111100011111, 4}, - {0b111111100100111, 5}, {0b111111100101011, 5}, - {0b111111100101101, 5}, {0b111111100101110, 5}, - {0b111111100101111, 4}, {0b111111100110101, 5}, - {0b111111100110110, 5}, {0b111111100110111, 4}, - {0b111111100111001, 5}, {0b111111100111010, 5}, - {0b111111100111011, 4}, {0b111111100111101, 4}, - {0b111111100111110, 4}, {0b111111100111111, 5}, - {0b111111101000111, 5}, {0b111111101001011, 5}, - {0b111111101001101, 5}, {0b111111101001110, 5}, - {0b111111101001111, 4}, {0b111111101010011, 5}, - {0b111111101010110, 5}, {0b111111101010111, 4}, - {0b111111101011001, 5}, {0b111111101011011, 4}, - {0b111111101011100, 5}, {0b111111101011101, 4}, - {0b111111101011110, 4}, {0b111111101011111, 5}, - {0b111111101100011, 5}, {0b111111101100101, 5}, - {0b111111101100111, 4}, {0b111111101101010, 5}, - {0b111111101101011, 4}, {0b111111101101100, 5}, - {0b111111101101101, 4}, {0b111111101101110, 4}, - {0b111111101101111, 5}, {0b111111101110001, 5}, - {0b111111101110010, 5}, {0b111111101110011, 4}, - {0b111111101110100, 5}, {0b111111101110101, 4}, - {0b111111101110110, 4}, {0b111111101110111, 5}, - {0b111111101111000, 5}, {0b111111101111001, 4}, - {0b111111101111010, 4}, {0b111111101111011, 5}, - {0b111111101111100, 4}, {0b111111101111101, 5}, - {0b111111101111110, 5}, {0b111111101111111, 3}, - {0b111111110000111, 5}, {0b111111110001011, 5}, - {0b111111110001101, 5}, {0b111111110001110, 5}, - {0b111111110001111, 4}, {0b111111110010011, 5}, - {0b111111110010101, 5}, {0b111111110010111, 4}, - {0b111111110011010, 5}, {0b111111110011011, 4}, - {0b111111110011100, 5}, {0b111111110011101, 4}, - {0b111111110011110, 4}, {0b111111110011111, 5}, - {0b111111110100011, 5}, {0b111111110100110, 5}, - {0b111111110100111, 4}, {0b111111110101001, 5}, - {0b111111110101011, 4}, {0b111111110101100, 5}, - {0b111111110101101, 4}, {0b111111110101110, 4}, - {0b111111110101111, 5}, {0b111111110110001, 5}, - {0b111111110110010, 5}, {0b111111110110011, 4}, - {0b111111110110100, 5}, {0b111111110110101, 4}, - {0b111111110110110, 4}, {0b111111110110111, 5}, - {0b111111110111000, 5}, {0b111111110111001, 4}, - {0b111111110111010, 4}, {0b111111110111011, 5}, - {0b111111110111100, 4}, {0b111111110111101, 5}, - {0b111111110111110, 5}, {0b111111110111111, 3}, - {0b111111111000101, 5}, {0b111111111000110, 5}, - {0b111111111000111, 4}, {0b111111111001001, 5}, - {0b111111111001010, 5}, {0b111111111001011, 4}, - {0b111111111001101, 4}, {0b111111111001110, 4}, - {0b111111111001111, 5}, {0b111111111010001, 5}, - {0b111111111010010, 5}, {0b111111111010011, 4}, - {0b111111111010100, 5}, {0b111111111010101, 4}, - {0b111111111010110, 4}, {0b111111111010111, 5}, - {0b111111111011000, 5}, {0b111111111011001, 4}, - {0b111111111011010, 4}, {0b111111111011011, 5}, - {0b111111111011100, 4}, {0b111111111011101, 5}, - {0b111111111011110, 5}, {0b111111111011111, 3}, - {0b111111111100001, 5}, {0b111111111100010, 5}, - {0b111111111100011, 4}, {0b111111111100100, 5}, - {0b111111111100101, 4}, {0b111111111100110, 4}, - {0b111111111100111, 5}, {0b111111111101000, 5}, - {0b111111111101001, 4}, {0b111111111101010, 4}, - {0b111111111101011, 5}, {0b111111111101100, 4}, - {0b111111111101101, 5}, {0b111111111101110, 5}, - {0b111111111101111, 3}, {0b111111111110001, 4}, - {0b111111111110010, 4}, {0b111111111110011, 5}, - {0b111111111110100, 4}, {0b111111111110101, 5}, - {0b111111111110110, 5}, {0b111111111110111, 3}, - {0b111111111111000, 4}, {0b111111111111001, 5}, - {0b111111111111010, 5}, {0b111111111111011, 3}, - {0b111111111111100, 5}, {0b111111111111101, 3}, - {0b111111111111110, 3}, {0b111111111111111, 4}, - {0b1000000000000000, 4}, {0b1000000000000001, 3}, - {0b1000000000000010, 3}, {0b1000000000000011, 5}, - {0b1000000000000100, 3}, {0b1000000000000101, 5}, - {0b1000000000000110, 5}, {0b1000000000000111, 4}, - {0b1000000000001000, 3}, {0b1000000000001001, 5}, - {0b1000000000001010, 5}, {0b1000000000001011, 4}, - {0b1000000000001100, 5}, {0b1000000000001101, 4}, - {0b1000000000001110, 4}, {0b1000000000010000, 3}, - {0b1000000000010001, 5}, {0b1000000000010010, 5}, - {0b1000000000010011, 4}, {0b1000000000010100, 5}, - {0b1000000000010101, 4}, {0b1000000000010110, 4}, - {0b1000000000010111, 5}, {0b1000000000011000, 5}, - {0b1000000000011001, 4}, {0b1000000000011010, 4}, - {0b1000000000011011, 5}, {0b1000000000011100, 4}, - {0b1000000000011101, 5}, {0b1000000000011110, 5}, - {0b1000000000100000, 3}, {0b1000000000100001, 5}, - {0b1000000000100010, 5}, {0b1000000000100011, 4}, - {0b1000000000100100, 5}, {0b1000000000100101, 4}, - {0b1000000000100110, 4}, {0b1000000000100111, 5}, - {0b1000000000101000, 5}, {0b1000000000101001, 4}, - {0b1000000000101010, 4}, {0b1000000000101011, 5}, - {0b1000000000101100, 4}, {0b1000000000101101, 5}, - {0b1000000000101110, 5}, {0b1000000000110000, 5}, - {0b1000000000110001, 4}, {0b1000000000110010, 4}, - {0b1000000000110100, 4}, {0b1000000000110101, 5}, - {0b1000000000110110, 5}, {0b1000000000111000, 4}, - {0b1000000000111001, 5}, {0b1000000000111010, 5}, - {0b1000000001000000, 3}, {0b1000000001000001, 5}, - {0b1000000001000010, 5}, {0b1000000001000011, 4}, - {0b1000000001000100, 5}, {0b1000000001000101, 4}, - {0b1000000001000110, 4}, {0b1000000001000111, 5}, - {0b1000000001001000, 5}, {0b1000000001001001, 4}, - {0b1000000001001010, 4}, {0b1000000001001011, 5}, - {0b1000000001001100, 4}, {0b1000000001001101, 5}, - {0b1000000001001110, 5}, {0b1000000001010000, 5}, - {0b1000000001010001, 4}, {0b1000000001010010, 4}, - {0b1000000001010011, 5}, {0b1000000001010100, 4}, - {0b1000000001010110, 5}, {0b1000000001011000, 4}, - {0b1000000001011001, 5}, {0b1000000001011100, 5}, - {0b1000000001100000, 5}, {0b1000000001100001, 4}, - {0b1000000001100010, 4}, {0b1000000001100011, 5}, - {0b1000000001100100, 4}, {0b1000000001100101, 5}, - {0b1000000001101000, 4}, {0b1000000001101010, 5}, - {0b1000000001101100, 5}, {0b1000000001110000, 4}, - {0b1000000001110001, 5}, {0b1000000001110010, 5}, - {0b1000000001110100, 5}, {0b1000000001111000, 5}, - {0b1000000010000000, 3}, {0b1000000010000001, 5}, - {0b1000000010000010, 5}, {0b1000000010000011, 4}, - {0b1000000010000100, 5}, {0b1000000010000101, 4}, - {0b1000000010000110, 4}, {0b1000000010000111, 5}, - {0b1000000010001000, 5}, {0b1000000010001001, 4}, - {0b1000000010001010, 4}, {0b1000000010001011, 5}, - {0b1000000010001100, 4}, {0b1000000010001101, 5}, - {0b1000000010001110, 5}, {0b1000000010010000, 5}, - {0b1000000010010001, 4}, {0b1000000010010010, 4}, - {0b1000000010010011, 5}, {0b1000000010010100, 4}, - {0b1000000010010101, 5}, {0b1000000010011000, 4}, - {0b1000000010011010, 5}, {0b1000000010011100, 5}, - {0b1000000010100000, 5}, {0b1000000010100001, 4}, - {0b1000000010100010, 4}, {0b1000000010100011, 5}, - {0b1000000010100100, 4}, {0b1000000010100110, 5}, - {0b1000000010101000, 4}, {0b1000000010101001, 5}, - {0b1000000010101100, 5}, {0b1000000010110000, 4}, - {0b1000000010110001, 5}, {0b1000000010110010, 5}, - {0b1000000010110100, 5}, {0b1000000010111000, 5}, - {0b1000000011000000, 5}, {0b1000000011000001, 4}, - {0b1000000011000010, 4}, {0b1000000011000100, 4}, - {0b1000000011000101, 5}, {0b1000000011000110, 5}, - {0b1000000011001000, 4}, {0b1000000011001001, 5}, - {0b1000000011001010, 5}, {0b1000000011010000, 4}, - {0b1000000011010001, 5}, {0b1000000011010010, 5}, - {0b1000000011010100, 5}, {0b1000000011011000, 5}, - {0b1000000011100000, 4}, {0b1000000011100001, 5}, - {0b1000000011100010, 5}, {0b1000000011100100, 5}, - {0b1000000011101000, 5}, {0b1000000100000000, 3}, - {0b1000000100000001, 5}, {0b1000000100000010, 5}, - {0b1000000100000011, 4}, {0b1000000100000100, 5}, - {0b1000000100000101, 4}, {0b1000000100000110, 4}, - {0b1000000100000111, 5}, {0b1000000100001000, 5}, - {0b1000000100001001, 4}, {0b1000000100001010, 4}, - {0b1000000100001011, 5}, {0b1000000100001100, 4}, - {0b1000000100001101, 5}, {0b1000000100001110, 5}, - {0b1000000100010000, 5}, {0b1000000100010001, 4}, - {0b1000000100010010, 4}, {0b1000000100010011, 5}, - {0b1000000100010100, 4}, {0b1000000100010101, 5}, - {0b1000000100010110, 5}, {0b1000000100011000, 2}, - {0b1000000100100000, 5}, {0b1000000100100001, 4}, - {0b1000000100100010, 4}, {0b1000000100100011, 5}, - {0b1000000100100100, 2}, {0b1000000100101000, 4}, - {0b1000000100101001, 5}, {0b1000000100101010, 5}, - {0b1000000100110000, 4}, {0b1000000100110001, 5}, - {0b1000000100110010, 5}, {0b1000000100111100, 3}, - {0b1000000101000000, 5}, {0b1000000101000001, 4}, - {0b1000000101000010, 2}, {0b1000000101000100, 4}, - {0b1000000101000101, 5}, {0b1000000101001000, 4}, - {0b1000000101001001, 5}, {0b1000000101001100, 5}, - {0b1000000101010000, 4}, {0b1000000101010001, 5}, - {0b1000000101010100, 5}, {0b1000000101011010, 3}, - {0b1000000101100000, 4}, {0b1000000101100001, 5}, - {0b1000000101100110, 3}, {0b1000000101101000, 5}, - {0b1000000101110000, 5}, {0b1000000101111110, 4}, - {0b1000000110000000, 5}, {0b1000000110000001, 2}, - {0b1000000110000010, 4}, {0b1000000110000100, 4}, - {0b1000000110000110, 5}, {0b1000000110001000, 4}, - {0b1000000110001010, 5}, {0b1000000110001100, 5}, - {0b1000000110010000, 4}, {0b1000000110010010, 5}, - {0b1000000110010100, 5}, {0b1000000110011001, 3}, - {0b1000000110100000, 4}, {0b1000000110100010, 5}, - {0b1000000110100101, 3}, {0b1000000110101000, 5}, - {0b1000000110110000, 5}, {0b1000000110111101, 4}, - {0b1000000111000000, 4}, {0b1000000111000011, 3}, - {0b1000000111000100, 5}, {0b1000000111001000, 5}, - {0b1000000111010000, 5}, {0b1000000111011011, 4}, - {0b1000000111100000, 5}, {0b1000000111100111, 4}, - {0b1000000111111111, 3}, {0b1000001000000000, 3}, - {0b1000001000000001, 5}, {0b1000001000000010, 5}, - {0b1000001000000011, 4}, {0b1000001000000100, 5}, - {0b1000001000000101, 4}, {0b1000001000000110, 4}, - {0b1000001000000111, 5}, {0b1000001000001000, 5}, - {0b1000001000001001, 4}, {0b1000001000001010, 4}, - {0b1000001000001011, 5}, {0b1000001000001100, 4}, - {0b1000001000001101, 5}, {0b1000001000001110, 5}, - {0b1000001000010000, 5}, {0b1000001000010001, 4}, - {0b1000001000010010, 4}, {0b1000001000010011, 5}, - {0b1000001000010100, 2}, {0b1000001000011000, 4}, - {0b1000001000011001, 5}, {0b1000001000011010, 5}, - {0b1000001000100000, 5}, {0b1000001000100001, 4}, - {0b1000001000100010, 4}, {0b1000001000100011, 5}, - {0b1000001000100100, 4}, {0b1000001000100101, 5}, - {0b1000001000100110, 5}, {0b1000001000101000, 2}, - {0b1000001000110000, 4}, {0b1000001000110001, 5}, - {0b1000001000110010, 5}, {0b1000001000111100, 3}, - {0b1000001001000000, 5}, {0b1000001001000001, 2}, - {0b1000001001000010, 4}, {0b1000001001000100, 4}, - {0b1000001001000110, 5}, {0b1000001001001000, 4}, - {0b1000001001001010, 5}, {0b1000001001001100, 5}, - {0b1000001001010000, 4}, {0b1000001001010010, 5}, - {0b1000001001010101, 3}, {0b1000001001011000, 5}, - {0b1000001001100000, 4}, {0b1000001001100010, 5}, - {0b1000001001100100, 5}, {0b1000001001101001, 3}, - {0b1000001001110000, 5}, {0b1000001001111101, 4}, - {0b1000001010000000, 5}, {0b1000001010000001, 4}, - {0b1000001010000010, 2}, {0b1000001010000100, 4}, - {0b1000001010000101, 5}, {0b1000001010001000, 4}, - {0b1000001010001001, 5}, {0b1000001010001100, 5}, - {0b1000001010010000, 4}, {0b1000001010010001, 5}, - {0b1000001010010110, 3}, {0b1000001010011000, 5}, - {0b1000001010100000, 4}, {0b1000001010100001, 5}, - {0b1000001010100100, 5}, {0b1000001010101010, 3}, - {0b1000001010110000, 5}, {0b1000001010111110, 4}, - {0b1000001011000000, 4}, {0b1000001011000011, 3}, - {0b1000001011000100, 5}, {0b1000001011001000, 5}, - {0b1000001011010000, 5}, {0b1000001011010111, 4}, - {0b1000001011100000, 5}, {0b1000001011101011, 4}, - {0b1000001011111111, 3}, {0b1000001100000000, 5}, - {0b1000001100000001, 4}, {0b1000001100000010, 4}, - {0b1000001100000100, 4}, {0b1000001100000101, 5}, - {0b1000001100000110, 5}, {0b1000001100001000, 4}, - {0b1000001100001001, 5}, {0b1000001100001010, 5}, - {0b1000001100010000, 4}, {0b1000001100010001, 5}, - {0b1000001100010010, 5}, {0b1000001100011100, 3}, - {0b1000001100100000, 4}, {0b1000001100100001, 5}, - {0b1000001100100010, 5}, {0b1000001100101100, 3}, - {0b1000001100110100, 3}, {0b1000001100111000, 3}, - {0b1000001101000000, 4}, {0b1000001101000011, 3}, - {0b1000001101000100, 5}, {0b1000001101001000, 5}, - {0b1000001101010000, 5}, {0b1000001101100000, 5}, - {0b1000001110000000, 4}, {0b1000001110000011, 3}, - {0b1000001110000100, 5}, {0b1000001110001000, 5}, - {0b1000001110010000, 5}, {0b1000001110100000, 5}, - {0b1000001111000001, 3}, {0b1000001111000010, 3}, - {0b1000010000000000, 3}, {0b1000010000000001, 5}, - {0b1000010000000010, 5}, {0b1000010000000011, 4}, - {0b1000010000000100, 5}, {0b1000010000000101, 4}, - {0b1000010000000110, 4}, {0b1000010000000111, 5}, - {0b1000010000001000, 5}, {0b1000010000001001, 4}, - {0b1000010000001010, 4}, {0b1000010000001011, 5}, - {0b1000010000001100, 4}, {0b1000010000001101, 5}, - {0b1000010000001110, 5}, {0b1000010000010000, 5}, - {0b1000010000010001, 4}, {0b1000010000010010, 2}, - {0b1000010000010100, 4}, {0b1000010000010101, 5}, - {0b1000010000011000, 4}, {0b1000010000011001, 5}, - {0b1000010000011100, 5}, {0b1000010000100000, 5}, - {0b1000010000100001, 2}, {0b1000010000100010, 4}, - {0b1000010000100100, 4}, {0b1000010000100110, 5}, - {0b1000010000101000, 4}, {0b1000010000101010, 5}, - {0b1000010000101100, 5}, {0b1000010000110000, 4}, - {0b1000010000110011, 3}, {0b1000010000110100, 5}, - {0b1000010000111000, 5}, {0b1000010001000000, 5}, - {0b1000010001000001, 4}, {0b1000010001000010, 4}, - {0b1000010001000011, 5}, {0b1000010001000100, 4}, - {0b1000010001000101, 5}, {0b1000010001000110, 5}, - {0b1000010001001000, 2}, {0b1000010001010000, 4}, - {0b1000010001010001, 5}, {0b1000010001010100, 5}, - {0b1000010001011010, 3}, {0b1000010001100000, 4}, - {0b1000010001100010, 5}, {0b1000010001100100, 5}, - {0b1000010001101001, 3}, {0b1000010001110000, 5}, - {0b1000010001111011, 4}, {0b1000010010000000, 5}, - {0b1000010010000001, 4}, {0b1000010010000010, 4}, - {0b1000010010000011, 5}, {0b1000010010000100, 2}, - {0b1000010010001000, 4}, {0b1000010010001001, 5}, - {0b1000010010001010, 5}, {0b1000010010010000, 4}, - {0b1000010010010001, 5}, {0b1000010010010110, 3}, - {0b1000010010011000, 5}, {0b1000010010100000, 4}, - {0b1000010010100010, 5}, {0b1000010010100101, 3}, - {0b1000010010101000, 5}, {0b1000010010110000, 5}, - {0b1000010010110111, 4}, {0b1000010011000000, 4}, - {0b1000010011000001, 5}, {0b1000010011000010, 5}, - {0b1000010011001100, 3}, {0b1000010011010000, 5}, - {0b1000010011011110, 4}, {0b1000010011100000, 5}, - {0b1000010011101101, 4}, {0b1000010011111111, 3}, - {0b1000010100000000, 5}, {0b1000010100000001, 4}, - {0b1000010100000010, 4}, {0b1000010100000011, 5}, - {0b1000010100000100, 4}, {0b1000010100000110, 5}, - {0b1000010100001000, 4}, {0b1000010100001001, 5}, - {0b1000010100001100, 5}, {0b1000010100010000, 4}, - {0b1000010100010001, 5}, {0b1000010100010100, 5}, - {0b1000010100011010, 3}, {0b1000010100100000, 4}, - {0b1000010100100010, 5}, {0b1000010100100101, 3}, - {0b1000010100101000, 5}, {0b1000010100110000, 5}, - {0b1000010101000000, 4}, {0b1000010101000001, 5}, - {0b1000010101000100, 5}, {0b1000010101001010, 3}, - {0b1000010101010010, 3}, {0b1000010101011000, 3}, - {0b1000010101100000, 5}, {0b1000010110000000, 4}, - {0b1000010110000010, 5}, {0b1000010110000101, 3}, - {0b1000010110001000, 5}, {0b1000010110010000, 5}, - {0b1000010110100001, 3}, {0b1000010110100100, 3}, - {0b1000010111000000, 5}, {0b1000011000000000, 5}, - {0b1000011000000001, 4}, {0b1000011000000010, 4}, - {0b1000011000000011, 5}, {0b1000011000000100, 4}, - {0b1000011000000101, 5}, {0b1000011000001000, 4}, - {0b1000011000001010, 5}, {0b1000011000001100, 5}, - {0b1000011000010000, 4}, {0b1000011000010001, 5}, - {0b1000011000010110, 3}, {0b1000011000011000, 5}, - {0b1000011000100000, 4}, {0b1000011000100010, 5}, - {0b1000011000100100, 5}, {0b1000011000101001, 3}, - {0b1000011000110000, 5}, {0b1000011001000000, 4}, - {0b1000011001000010, 5}, {0b1000011001000100, 5}, - {0b1000011001001001, 3}, {0b1000011001010000, 5}, - {0b1000011001100001, 3}, {0b1000011001101000, 3}, - {0b1000011010000000, 4}, {0b1000011010000001, 5}, - {0b1000011010000110, 3}, {0b1000011010001000, 5}, - {0b1000011010010010, 3}, {0b1000011010010100, 3}, - {0b1000011010100000, 5}, {0b1000011011000000, 5}, - {0b1000011100000000, 4}, {0b1000011100000001, 5}, - {0b1000011100000010, 5}, {0b1000011100000100, 5}, - {0b1000011100001000, 5}, {0b1000011100010000, 5}, - {0b1000011100011110, 4}, {0b1000011100100000, 5}, - {0b1000011100101101, 4}, {0b1000011101000000, 5}, - {0b1000011101001011, 4}, {0b1000011101111000, 4}, - {0b1000011101111111, 5}, {0b1000011110000000, 5}, - {0b1000011110000111, 4}, {0b1000011110110100, 4}, - {0b1000011110111111, 5}, {0b1000011111010010, 4}, - {0b1000011111011111, 5}, {0b1000011111100001, 4}, - {0b1000011111101111, 5}, {0b1000011111110111, 5}, - {0b1000011111111011, 5}, {0b1000011111111101, 5}, - {0b1000011111111110, 5}, {0b1000011111111111, 4}, - {0b1000100000000000, 3}, {0b1000100000000001, 5}, - {0b1000100000000010, 5}, {0b1000100000000011, 4}, - {0b1000100000000100, 5}, {0b1000100000000101, 4}, - {0b1000100000000110, 4}, {0b1000100000000111, 5}, - {0b1000100000001000, 5}, {0b1000100000001001, 4}, - {0b1000100000001010, 4}, {0b1000100000001011, 5}, - {0b1000100000001100, 4}, {0b1000100000001101, 5}, - {0b1000100000001110, 5}, {0b1000100000010000, 5}, - {0b1000100000010001, 2}, {0b1000100000010010, 4}, - {0b1000100000010100, 4}, {0b1000100000010110, 5}, - {0b1000100000011000, 4}, {0b1000100000011010, 5}, - {0b1000100000011100, 5}, {0b1000100000100000, 5}, - {0b1000100000100001, 4}, {0b1000100000100010, 2}, - {0b1000100000100100, 4}, {0b1000100000100101, 5}, - {0b1000100000101000, 4}, {0b1000100000101001, 5}, - {0b1000100000101100, 5}, {0b1000100000110000, 4}, - {0b1000100000110011, 3}, {0b1000100000110100, 5}, - {0b1000100000111000, 5}, {0b1000100001000000, 5}, - {0b1000100001000001, 4}, {0b1000100001000010, 4}, - {0b1000100001000011, 5}, {0b1000100001000100, 2}, - {0b1000100001001000, 4}, {0b1000100001001001, 5}, - {0b1000100001001010, 5}, {0b1000100001010000, 4}, - {0b1000100001010010, 5}, {0b1000100001010101, 3}, - {0b1000100001011000, 5}, {0b1000100001100000, 4}, - {0b1000100001100001, 5}, {0b1000100001100110, 3}, - {0b1000100001101000, 5}, {0b1000100001110000, 5}, - {0b1000100001110111, 4}, {0b1000100010000000, 5}, - {0b1000100010000001, 4}, {0b1000100010000010, 4}, - {0b1000100010000011, 5}, {0b1000100010000100, 4}, - {0b1000100010000101, 5}, {0b1000100010000110, 5}, - {0b1000100010001000, 2}, {0b1000100010010000, 4}, - {0b1000100010010010, 5}, {0b1000100010010100, 5}, - {0b1000100010011001, 3}, {0b1000100010100000, 4}, - {0b1000100010100001, 5}, {0b1000100010100100, 5}, - {0b1000100010101010, 3}, {0b1000100010110000, 5}, - {0b1000100010111011, 4}, {0b1000100011000000, 4}, - {0b1000100011000001, 5}, {0b1000100011000010, 5}, - {0b1000100011001100, 3}, {0b1000100011010000, 5}, - {0b1000100011011101, 4}, {0b1000100011100000, 5}, - {0b1000100011101110, 4}, {0b1000100011111111, 3}, - {0b1000100100000000, 5}, {0b1000100100000001, 4}, - {0b1000100100000010, 4}, {0b1000100100000011, 5}, - {0b1000100100000100, 4}, {0b1000100100000101, 5}, - {0b1000100100001000, 4}, {0b1000100100001010, 5}, - {0b1000100100001100, 5}, {0b1000100100010000, 4}, - {0b1000100100010010, 5}, {0b1000100100010100, 5}, - {0b1000100100011001, 3}, {0b1000100100100000, 4}, - {0b1000100100100001, 5}, {0b1000100100100110, 3}, - {0b1000100100101000, 5}, {0b1000100100110000, 5}, - {0b1000100101000000, 4}, {0b1000100101000001, 5}, - {0b1000100101000110, 3}, {0b1000100101001000, 5}, - {0b1000100101010000, 5}, {0b1000100101100010, 3}, - {0b1000100101100100, 3}, {0b1000100110000000, 4}, - {0b1000100110000010, 5}, {0b1000100110000100, 5}, - {0b1000100110001001, 3}, {0b1000100110010001, 3}, - {0b1000100110011000, 3}, {0b1000100110100000, 5}, - {0b1000100111000000, 5}, {0b1000101000000000, 5}, - {0b1000101000000001, 4}, {0b1000101000000010, 4}, - {0b1000101000000011, 5}, {0b1000101000000100, 4}, - {0b1000101000000110, 5}, {0b1000101000001000, 4}, - {0b1000101000001001, 5}, {0b1000101000001100, 5}, - {0b1000101000010000, 4}, {0b1000101000010010, 5}, - {0b1000101000010101, 3}, {0b1000101000011000, 5}, - {0b1000101000100000, 4}, {0b1000101000100001, 5}, - {0b1000101000100100, 5}, {0b1000101000101010, 3}, - {0b1000101000110000, 5}, {0b1000101001000000, 4}, - {0b1000101001000010, 5}, {0b1000101001000101, 3}, - {0b1000101001001000, 5}, {0b1000101001010001, 3}, - {0b1000101001010100, 3}, {0b1000101001100000, 5}, - {0b1000101010000000, 4}, {0b1000101010000001, 5}, - {0b1000101010000100, 5}, {0b1000101010001010, 3}, - {0b1000101010010000, 5}, {0b1000101010100010, 3}, - {0b1000101010101000, 3}, {0b1000101011000000, 5}, - {0b1000101100000000, 4}, {0b1000101100000001, 5}, - {0b1000101100000010, 5}, {0b1000101100000100, 5}, - {0b1000101100001000, 5}, {0b1000101100010000, 5}, - {0b1000101100011101, 4}, {0b1000101100100000, 5}, - {0b1000101100101110, 4}, {0b1000101101000000, 5}, - {0b1000101101000111, 4}, {0b1000101101110100, 4}, - {0b1000101101111111, 5}, {0b1000101110000000, 5}, - {0b1000101110001011, 4}, {0b1000101110111000, 4}, - {0b1000101110111111, 5}, {0b1000101111010001, 4}, - {0b1000101111011111, 5}, {0b1000101111100010, 4}, - {0b1000101111101111, 5}, {0b1000101111110111, 5}, - {0b1000101111111011, 5}, {0b1000101111111101, 5}, - {0b1000101111111110, 5}, {0b1000101111111111, 4}, - {0b1000110000000000, 5}, {0b1000110000000001, 4}, - {0b1000110000000010, 4}, {0b1000110000000100, 4}, - {0b1000110000000101, 5}, {0b1000110000000110, 5}, - {0b1000110000001000, 4}, {0b1000110000001001, 5}, - {0b1000110000001010, 5}, {0b1000110000010000, 4}, - {0b1000110000010011, 3}, {0b1000110000010100, 5}, - {0b1000110000011000, 5}, {0b1000110000100000, 4}, - {0b1000110000100011, 3}, {0b1000110000100100, 5}, - {0b1000110000101000, 5}, {0b1000110000110001, 3}, - {0b1000110000110010, 3}, {0b1000110001000000, 4}, - {0b1000110001000001, 5}, {0b1000110001000010, 5}, - {0b1000110001001100, 3}, {0b1000110001010000, 5}, - {0b1000110001100000, 5}, {0b1000110010000000, 4}, - {0b1000110010000001, 5}, {0b1000110010000010, 5}, - {0b1000110010001100, 3}, {0b1000110010010000, 5}, - {0b1000110010100000, 5}, {0b1000110011000100, 3}, - {0b1000110011001000, 3}, {0b1000110100000000, 4}, - {0b1000110100000001, 5}, {0b1000110100000010, 5}, - {0b1000110100000100, 5}, {0b1000110100001000, 5}, - {0b1000110100010000, 5}, {0b1000110100011011, 4}, - {0b1000110100100000, 5}, {0b1000110100100111, 4}, - {0b1000110101000000, 5}, {0b1000110101001110, 4}, - {0b1000110101110010, 4}, {0b1000110101111111, 5}, - {0b1000110110000000, 5}, {0b1000110110001101, 4}, - {0b1000110110110001, 4}, {0b1000110110111111, 5}, - {0b1000110111011000, 4}, {0b1000110111011111, 5}, - {0b1000110111100100, 4}, {0b1000110111101111, 5}, - {0b1000110111110111, 5}, {0b1000110111111011, 5}, - {0b1000110111111101, 5}, {0b1000110111111110, 5}, - {0b1000110111111111, 4}, {0b1000111000000000, 4}, - {0b1000111000000001, 5}, {0b1000111000000010, 5}, - {0b1000111000000100, 5}, {0b1000111000001000, 5}, - {0b1000111000010000, 5}, {0b1000111000010111, 4}, - {0b1000111000100000, 5}, {0b1000111000101011, 4}, - {0b1000111001000000, 5}, {0b1000111001001101, 4}, - {0b1000111001110001, 4}, {0b1000111001111111, 5}, - {0b1000111010000000, 5}, {0b1000111010001110, 4}, - {0b1000111010110010, 4}, {0b1000111010111111, 5}, - {0b1000111011010100, 4}, {0b1000111011011111, 5}, - {0b1000111011101000, 4}, {0b1000111011101111, 5}, - {0b1000111011110111, 5}, {0b1000111011111011, 5}, - {0b1000111011111101, 5}, {0b1000111011111110, 5}, - {0b1000111011111111, 4}, {0b1000111100011111, 3}, - {0b1000111100101111, 3}, {0b1000111101001111, 3}, - {0b1000111101110111, 5}, {0b1000111101111011, 5}, - {0b1000111101111101, 5}, {0b1000111101111110, 5}, - {0b1000111101111111, 4}, {0b1000111110001111, 3}, - {0b1000111110110111, 5}, {0b1000111110111011, 5}, - {0b1000111110111101, 5}, {0b1000111110111110, 5}, - {0b1000111110111111, 4}, {0b1000111111010111, 5}, - {0b1000111111011011, 5}, {0b1000111111011101, 5}, - {0b1000111111011110, 5}, {0b1000111111011111, 4}, - {0b1000111111100111, 5}, {0b1000111111101011, 5}, - {0b1000111111101101, 5}, {0b1000111111101110, 5}, - {0b1000111111101111, 4}, {0b1000111111110001, 3}, - {0b1000111111110010, 3}, {0b1000111111110100, 3}, - {0b1000111111110111, 4}, {0b1000111111111000, 3}, - {0b1000111111111011, 4}, {0b1000111111111101, 4}, - {0b1000111111111110, 4}, {0b1000111111111111, 5}, - {0b1001000000000000, 3}, {0b1001000000000001, 5}, - {0b1001000000000010, 5}, {0b1001000000000011, 4}, - {0b1001000000000100, 5}, {0b1001000000000101, 4}, - {0b1001000000000110, 2}, {0b1001000000001000, 5}, - {0b1001000000001001, 2}, {0b1001000000001010, 4}, - {0b1001000000001100, 4}, {0b1001000000001111, 3}, - {0b1001000000010000, 5}, {0b1001000000010001, 4}, - {0b1001000000010010, 4}, {0b1001000000010011, 5}, - {0b1001000000010100, 4}, {0b1001000000010101, 5}, - {0b1001000000011000, 4}, {0b1001000000011010, 5}, - {0b1001000000011100, 5}, {0b1001000000100000, 5}, - {0b1001000000100001, 4}, {0b1001000000100010, 4}, - {0b1001000000100011, 5}, {0b1001000000100100, 4}, - {0b1001000000100101, 5}, {0b1001000000101000, 4}, - {0b1001000000101010, 5}, {0b1001000000101100, 5}, - {0b1001000000110000, 4}, {0b1001000000110001, 5}, - {0b1001000000110010, 5}, {0b1001000000110100, 5}, - {0b1001000000111000, 5}, {0b1001000001000000, 5}, - {0b1001000001000001, 4}, {0b1001000001000010, 4}, - {0b1001000001000011, 5}, {0b1001000001000100, 4}, - {0b1001000001000101, 5}, {0b1001000001001000, 4}, - {0b1001000001001010, 5}, {0b1001000001001100, 5}, - {0b1001000001010000, 4}, {0b1001000001010001, 5}, - {0b1001000001010010, 5}, {0b1001000001010100, 5}, - {0b1001000001011000, 5}, {0b1001000001100000, 2}, - {0b1001000001100110, 3}, {0b1001000001101001, 3}, - {0b1001000001101111, 4}, {0b1001000010000000, 5}, - {0b1001000010000001, 4}, {0b1001000010000010, 4}, - {0b1001000010000011, 5}, {0b1001000010000100, 4}, - {0b1001000010000101, 5}, {0b1001000010001000, 4}, - {0b1001000010001010, 5}, {0b1001000010001100, 5}, - {0b1001000010010000, 2}, {0b1001000010010110, 3}, - {0b1001000010011001, 3}, {0b1001000010011111, 4}, - {0b1001000010100000, 4}, {0b1001000010100001, 5}, - {0b1001000010100010, 5}, {0b1001000010100100, 5}, - {0b1001000010101000, 5}, {0b1001000011000000, 4}, - {0b1001000011000001, 5}, {0b1001000011000010, 5}, - {0b1001000011000100, 5}, {0b1001000011001000, 5}, - {0b1001000011110000, 3}, {0b1001000011110110, 4}, - {0b1001000011111001, 4}, {0b1001000011111111, 3}, - {0b1001000100000000, 5}, {0b1001000100000001, 4}, - {0b1001000100000010, 4}, {0b1001000100000011, 5}, - {0b1001000100000100, 4}, {0b1001000100000101, 5}, - {0b1001000100001000, 4}, {0b1001000100001010, 5}, - {0b1001000100001100, 5}, {0b1001000100010000, 4}, - {0b1001000100010010, 5}, {0b1001000100010100, 5}, - {0b1001000100011001, 3}, {0b1001000100100000, 4}, - {0b1001000100100001, 5}, {0b1001000100100110, 3}, - {0b1001000100101000, 5}, {0b1001000100110000, 5}, - {0b1001000101000000, 4}, {0b1001000101000001, 5}, - {0b1001000101000110, 3}, {0b1001000101001000, 5}, - {0b1001000101010000, 5}, {0b1001000101100010, 3}, - {0b1001000101100100, 3}, {0b1001000110000000, 4}, - {0b1001000110000010, 5}, {0b1001000110000100, 5}, - {0b1001000110001001, 3}, {0b1001000110010001, 3}, - {0b1001000110011000, 3}, {0b1001000110100000, 5}, - {0b1001000111000000, 5}, {0b1001001000000000, 5}, - {0b1001001000000001, 4}, {0b1001001000000010, 4}, - {0b1001001000000011, 5}, {0b1001001000000100, 4}, - {0b1001001000000101, 5}, {0b1001001000001000, 4}, - {0b1001001000001010, 5}, {0b1001001000001100, 5}, - {0b1001001000010000, 4}, {0b1001001000010001, 5}, - {0b1001001000010110, 3}, {0b1001001000011000, 5}, - {0b1001001000100000, 4}, {0b1001001000100010, 5}, - {0b1001001000100100, 5}, {0b1001001000101001, 3}, - {0b1001001000110000, 5}, {0b1001001001000000, 4}, - {0b1001001001000010, 5}, {0b1001001001000100, 5}, - {0b1001001001001001, 3}, {0b1001001001010000, 5}, - {0b1001001001100001, 3}, {0b1001001001101000, 3}, - {0b1001001010000000, 4}, {0b1001001010000001, 5}, - {0b1001001010000110, 3}, {0b1001001010001000, 5}, - {0b1001001010010010, 3}, {0b1001001010010100, 3}, - {0b1001001010100000, 5}, {0b1001001011000000, 5}, - {0b1001001100000000, 4}, {0b1001001100000001, 5}, - {0b1001001100000010, 5}, {0b1001001100000100, 5}, - {0b1001001100001000, 5}, {0b1001001100010000, 5}, - {0b1001001100100000, 5}, {0b1001001100110110, 4}, - {0b1001001100111001, 4}, {0b1001001101000000, 5}, - {0b1001001101100011, 4}, {0b1001001101101100, 4}, - {0b1001001101111111, 5}, {0b1001001110000000, 5}, - {0b1001001110010011, 4}, {0b1001001110011100, 4}, - {0b1001001110111111, 5}, {0b1001001111000110, 4}, - {0b1001001111001001, 4}, {0b1001001111011111, 5}, - {0b1001001111101111, 5}, {0b1001001111110111, 5}, - {0b1001001111111011, 5}, {0b1001001111111101, 5}, - {0b1001001111111110, 5}, {0b1001001111111111, 4}, - {0b1001010000000000, 5}, {0b1001010000000001, 4}, - {0b1001010000000010, 4}, {0b1001010000000011, 5}, - {0b1001010000000100, 4}, {0b1001010000000101, 5}, - {0b1001010000001000, 4}, {0b1001010000001010, 5}, - {0b1001010000001100, 5}, {0b1001010000010000, 4}, - {0b1001010000010001, 5}, {0b1001010000010110, 3}, - {0b1001010000011000, 5}, {0b1001010000100000, 4}, - {0b1001010000100010, 5}, {0b1001010000100100, 5}, - {0b1001010000101001, 3}, {0b1001010000110000, 5}, - {0b1001010001000000, 4}, {0b1001010001000010, 5}, - {0b1001010001000100, 5}, {0b1001010001001001, 3}, - {0b1001010001010000, 5}, {0b1001010001100001, 3}, - {0b1001010001101000, 3}, {0b1001010010000000, 4}, - {0b1001010010000001, 5}, {0b1001010010000110, 3}, - {0b1001010010001000, 5}, {0b1001010010010010, 3}, - {0b1001010010010100, 3}, {0b1001010010100000, 5}, - {0b1001010011000000, 5}, {0b1001010100000000, 4}, - {0b1001010100000001, 5}, {0b1001010100000010, 5}, - {0b1001010100000100, 5}, {0b1001010100001000, 5}, - {0b1001010100010000, 5}, {0b1001010100100000, 5}, - {0b1001010101000000, 5}, {0b1001010101010110, 4}, - {0b1001010101011001, 4}, {0b1001010101100101, 4}, - {0b1001010101101010, 4}, {0b1001010101111111, 5}, - {0b1001010110000000, 5}, {0b1001010110010101, 4}, - {0b1001010110011010, 4}, {0b1001010110100110, 4}, - {0b1001010110101001, 4}, {0b1001010110111111, 5}, - {0b1001010111011111, 5}, {0b1001010111101111, 5}, - {0b1001010111110111, 5}, {0b1001010111111011, 5}, - {0b1001010111111101, 5}, {0b1001010111111110, 5}, - {0b1001010111111111, 4}, {0b1001011000000000, 2}, - {0b1001011000000110, 3}, {0b1001011000001001, 3}, - {0b1001011000001111, 4}, {0b1001011000010010, 3}, - {0b1001011000010100, 3}, {0b1001011000100001, 3}, - {0b1001011000101000, 3}, {0b1001011000110011, 4}, - {0b1001011000111100, 4}, {0b1001011001000001, 3}, - {0b1001011001001000, 3}, {0b1001011001010101, 4}, - {0b1001011001011010, 4}, {0b1001011001100000, 3}, - {0b1001011001100110, 4}, {0b1001011001101001, 1}, - {0b1001011001101111, 3}, {0b1001011001111011, 3}, - {0b1001011001111101, 3}, {0b1001011010000010, 3}, - {0b1001011010000100, 3}, {0b1001011010010000, 3}, - {0b1001011010010110, 1}, {0b1001011010011001, 4}, - {0b1001011010011111, 3}, {0b1001011010100101, 4}, - {0b1001011010101010, 4}, {0b1001011010110111, 3}, - {0b1001011010111110, 3}, {0b1001011011000011, 4}, - {0b1001011011001100, 4}, {0b1001011011010111, 3}, - {0b1001011011011110, 3}, {0b1001011011101011, 3}, - {0b1001011011101101, 3}, {0b1001011011110000, 4}, - {0b1001011011110110, 3}, {0b1001011011111001, 3}, - {0b1001011011111111, 2}, {0b1001011100111111, 5}, - {0b1001011101011111, 5}, {0b1001011101101011, 3}, - {0b1001011101101101, 3}, {0b1001011101110111, 5}, - {0b1001011101111001, 3}, {0b1001011101111110, 5}, - {0b1001011101111111, 4}, {0b1001011110010111, 3}, - {0b1001011110011110, 3}, {0b1001011110101111, 5}, - {0b1001011110110110, 3}, {0b1001011110111011, 5}, - {0b1001011110111101, 5}, {0b1001011110111111, 4}, - {0b1001011111001111, 5}, {0b1001011111010110, 3}, - {0b1001011111011011, 5}, {0b1001011111011101, 5}, - {0b1001011111011111, 4}, {0b1001011111100111, 5}, - {0b1001011111101001, 3}, {0b1001011111101110, 5}, - {0b1001011111101111, 4}, {0b1001011111110011, 5}, - {0b1001011111110101, 5}, {0b1001011111110111, 4}, - {0b1001011111111010, 5}, {0b1001011111111011, 4}, - {0b1001011111111100, 5}, {0b1001011111111101, 4}, - {0b1001011111111110, 4}, {0b1001011111111111, 5}, - {0b1001100000000000, 5}, {0b1001100000000001, 4}, - {0b1001100000000010, 4}, {0b1001100000000011, 5}, - {0b1001100000000100, 4}, {0b1001100000000101, 5}, - {0b1001100000001000, 4}, {0b1001100000001010, 5}, - {0b1001100000001100, 5}, {0b1001100000010000, 4}, - {0b1001100000010010, 5}, {0b1001100000010100, 5}, - {0b1001100000011001, 3}, {0b1001100000100000, 4}, - {0b1001100000100001, 5}, {0b1001100000100110, 3}, - {0b1001100000101000, 5}, {0b1001100000110000, 5}, - {0b1001100001000000, 4}, {0b1001100001000001, 5}, - {0b1001100001000110, 3}, {0b1001100001001000, 5}, - {0b1001100001010000, 5}, {0b1001100001100010, 3}, - {0b1001100001100100, 3}, {0b1001100010000000, 4}, - {0b1001100010000010, 5}, {0b1001100010000100, 5}, - {0b1001100010001001, 3}, {0b1001100010010001, 3}, - {0b1001100010011000, 3}, {0b1001100010100000, 5}, - {0b1001100011000000, 5}, {0b1001100100000000, 2}, - {0b1001100100000110, 3}, {0b1001100100001001, 3}, - {0b1001100100001111, 4}, {0b1001100100010001, 3}, - {0b1001100100011000, 3}, {0b1001100100100010, 3}, - {0b1001100100100100, 3}, {0b1001100100110011, 4}, - {0b1001100100111100, 4}, {0b1001100101000010, 3}, - {0b1001100101000100, 3}, {0b1001100101010101, 4}, - {0b1001100101011010, 4}, {0b1001100101100000, 3}, - {0b1001100101100110, 1}, {0b1001100101101001, 4}, - {0b1001100101101111, 3}, {0b1001100101110111, 3}, - {0b1001100101111110, 3}, {0b1001100110000001, 3}, - {0b1001100110001000, 3}, {0b1001100110010000, 3}, - {0b1001100110010110, 4}, {0b1001100110011001, 1}, - {0b1001100110011111, 3}, {0b1001100110100101, 4}, - {0b1001100110101010, 4}, {0b1001100110111011, 3}, - {0b1001100110111101, 3}, {0b1001100111000011, 4}, - {0b1001100111001100, 4}, {0b1001100111011011, 3}, - {0b1001100111011101, 3}, {0b1001100111100111, 3}, - {0b1001100111101110, 3}, {0b1001100111110000, 4}, - {0b1001100111110110, 3}, {0b1001100111111001, 3}, - {0b1001100111111111, 2}, {0b1001101000000000, 4}, - {0b1001101000000001, 5}, {0b1001101000000010, 5}, - {0b1001101000000100, 5}, {0b1001101000001000, 5}, - {0b1001101000010000, 5}, {0b1001101000100000, 5}, - {0b1001101001000000, 5}, {0b1001101001010110, 4}, - {0b1001101001011001, 4}, {0b1001101001100101, 4}, - {0b1001101001101010, 4}, {0b1001101001111111, 5}, - {0b1001101010000000, 5}, {0b1001101010010101, 4}, - {0b1001101010011010, 4}, {0b1001101010100110, 4}, - {0b1001101010101001, 4}, {0b1001101010111111, 5}, - {0b1001101011011111, 5}, {0b1001101011101111, 5}, - {0b1001101011110111, 5}, {0b1001101011111011, 5}, - {0b1001101011111101, 5}, {0b1001101011111110, 5}, - {0b1001101011111111, 4}, {0b1001101100111111, 5}, - {0b1001101101011111, 5}, {0b1001101101100111, 3}, - {0b1001101101101110, 3}, {0b1001101101110110, 3}, - {0b1001101101111011, 5}, {0b1001101101111101, 5}, - {0b1001101101111111, 4}, {0b1001101110011011, 3}, - {0b1001101110011101, 3}, {0b1001101110101111, 5}, - {0b1001101110110111, 5}, {0b1001101110111001, 3}, - {0b1001101110111110, 5}, {0b1001101110111111, 4}, - {0b1001101111001111, 5}, {0b1001101111010111, 5}, - {0b1001101111011001, 3}, {0b1001101111011110, 5}, - {0b1001101111011111, 4}, {0b1001101111100110, 3}, - {0b1001101111101011, 5}, {0b1001101111101101, 5}, - {0b1001101111101111, 4}, {0b1001101111110011, 5}, - {0b1001101111110101, 5}, {0b1001101111110111, 4}, - {0b1001101111111010, 5}, {0b1001101111111011, 4}, - {0b1001101111111100, 5}, {0b1001101111111101, 4}, - {0b1001101111111110, 4}, {0b1001101111111111, 5}, - {0b1001110000000000, 4}, {0b1001110000000001, 5}, - {0b1001110000000010, 5}, {0b1001110000000100, 5}, - {0b1001110000001000, 5}, {0b1001110000010000, 5}, - {0b1001110000100000, 5}, {0b1001110000110110, 4}, - {0b1001110000111001, 4}, {0b1001110001000000, 5}, - {0b1001110001100011, 4}, {0b1001110001101100, 4}, - {0b1001110001111111, 5}, {0b1001110010000000, 5}, - {0b1001110010010011, 4}, {0b1001110010011100, 4}, - {0b1001110010111111, 5}, {0b1001110011000110, 4}, - {0b1001110011001001, 4}, {0b1001110011011111, 5}, - {0b1001110011101111, 5}, {0b1001110011110111, 5}, - {0b1001110011111011, 5}, {0b1001110011111101, 5}, - {0b1001110011111110, 5}, {0b1001110011111111, 4}, - {0b1001110100111111, 5}, {0b1001110101011111, 5}, - {0b1001110101100111, 3}, {0b1001110101101110, 3}, - {0b1001110101110110, 3}, {0b1001110101111011, 5}, - {0b1001110101111101, 5}, {0b1001110101111111, 4}, - {0b1001110110011011, 3}, {0b1001110110011101, 3}, - {0b1001110110101111, 5}, {0b1001110110110111, 5}, - {0b1001110110111001, 3}, {0b1001110110111110, 5}, - {0b1001110110111111, 4}, {0b1001110111001111, 5}, - {0b1001110111010111, 5}, {0b1001110111011001, 3}, - {0b1001110111011110, 5}, {0b1001110111011111, 4}, - {0b1001110111100110, 3}, {0b1001110111101011, 5}, - {0b1001110111101101, 5}, {0b1001110111101111, 4}, - {0b1001110111110011, 5}, {0b1001110111110101, 5}, - {0b1001110111110111, 4}, {0b1001110111111010, 5}, - {0b1001110111111011, 4}, {0b1001110111111100, 5}, - {0b1001110111111101, 4}, {0b1001110111111110, 4}, - {0b1001110111111111, 5}, {0b1001111000111111, 5}, - {0b1001111001011111, 5}, {0b1001111001101011, 3}, - {0b1001111001101101, 3}, {0b1001111001110111, 5}, - {0b1001111001111001, 3}, {0b1001111001111110, 5}, - {0b1001111001111111, 4}, {0b1001111010010111, 3}, - {0b1001111010011110, 3}, {0b1001111010101111, 5}, - {0b1001111010110110, 3}, {0b1001111010111011, 5}, - {0b1001111010111101, 5}, {0b1001111010111111, 4}, - {0b1001111011001111, 5}, {0b1001111011010110, 3}, - {0b1001111011011011, 5}, {0b1001111011011101, 5}, - {0b1001111011011111, 4}, {0b1001111011100111, 5}, - {0b1001111011101001, 3}, {0b1001111011101110, 5}, - {0b1001111011101111, 4}, {0b1001111011110011, 5}, - {0b1001111011110101, 5}, {0b1001111011110111, 4}, - {0b1001111011111010, 5}, {0b1001111011111011, 4}, - {0b1001111011111100, 5}, {0b1001111011111101, 4}, - {0b1001111011111110, 4}, {0b1001111011111111, 5}, - {0b1001111100000000, 3}, {0b1001111100000110, 4}, - {0b1001111100001001, 4}, {0b1001111100001111, 3}, - {0b1001111100110111, 5}, {0b1001111100111011, 5}, - {0b1001111100111101, 5}, {0b1001111100111110, 5}, - {0b1001111100111111, 4}, {0b1001111101010111, 5}, - {0b1001111101011011, 5}, {0b1001111101011101, 5}, - {0b1001111101011110, 5}, {0b1001111101011111, 4}, - {0b1001111101100000, 4}, {0b1001111101100110, 3}, - {0b1001111101101001, 3}, {0b1001111101101111, 2}, - {0b1001111101110011, 5}, {0b1001111101110101, 5}, - {0b1001111101110111, 4}, {0b1001111101111010, 5}, - {0b1001111101111011, 4}, {0b1001111101111100, 5}, - {0b1001111101111101, 4}, {0b1001111101111110, 4}, - {0b1001111101111111, 5}, {0b1001111110010000, 4}, - {0b1001111110010110, 3}, {0b1001111110011001, 3}, - {0b1001111110011111, 2}, {0b1001111110100111, 5}, - {0b1001111110101011, 5}, {0b1001111110101101, 5}, - {0b1001111110101110, 5}, {0b1001111110101111, 4}, - {0b1001111110110011, 5}, {0b1001111110110101, 5}, - {0b1001111110110111, 4}, {0b1001111110111010, 5}, - {0b1001111110111011, 4}, {0b1001111110111100, 5}, - {0b1001111110111101, 4}, {0b1001111110111110, 4}, - {0b1001111110111111, 5}, {0b1001111111000111, 5}, - {0b1001111111001011, 5}, {0b1001111111001101, 5}, - {0b1001111111001110, 5}, {0b1001111111001111, 4}, - {0b1001111111010011, 5}, {0b1001111111010101, 5}, - {0b1001111111010111, 4}, {0b1001111111011010, 5}, - {0b1001111111011011, 4}, {0b1001111111011100, 5}, - {0b1001111111011101, 4}, {0b1001111111011110, 4}, - {0b1001111111011111, 5}, {0b1001111111100011, 5}, - {0b1001111111100101, 5}, {0b1001111111100111, 4}, - {0b1001111111101010, 5}, {0b1001111111101011, 4}, - {0b1001111111101100, 5}, {0b1001111111101101, 4}, - {0b1001111111101110, 4}, {0b1001111111101111, 5}, - {0b1001111111110000, 3}, {0b1001111111110011, 4}, - {0b1001111111110101, 4}, {0b1001111111110110, 2}, - {0b1001111111110111, 5}, {0b1001111111111001, 2}, - {0b1001111111111010, 4}, {0b1001111111111011, 5}, - {0b1001111111111100, 4}, {0b1001111111111101, 5}, - {0b1001111111111110, 5}, {0b1001111111111111, 3}, - {0b1010000000000000, 3}, {0b1010000000000001, 5}, - {0b1010000000000010, 5}, {0b1010000000000011, 4}, - {0b1010000000000100, 5}, {0b1010000000000101, 2}, - {0b1010000000000110, 4}, {0b1010000000001000, 5}, - {0b1010000000001001, 4}, {0b1010000000001010, 2}, - {0b1010000000001100, 4}, {0b1010000000001111, 3}, - {0b1010000000010000, 5}, {0b1010000000010001, 4}, - {0b1010000000010010, 4}, {0b1010000000010011, 5}, - {0b1010000000010100, 4}, {0b1010000000010110, 5}, - {0b1010000000011000, 4}, {0b1010000000011001, 5}, - {0b1010000000011100, 5}, {0b1010000000100000, 5}, - {0b1010000000100001, 4}, {0b1010000000100010, 4}, - {0b1010000000100011, 5}, {0b1010000000100100, 4}, - {0b1010000000100110, 5}, {0b1010000000101000, 4}, - {0b1010000000101001, 5}, {0b1010000000101100, 5}, - {0b1010000000110000, 4}, {0b1010000000110001, 5}, - {0b1010000000110010, 5}, {0b1010000000110100, 5}, - {0b1010000000111000, 5}, {0b1010000001000000, 5}, - {0b1010000001000001, 4}, {0b1010000001000010, 4}, - {0b1010000001000011, 5}, {0b1010000001000100, 4}, - {0b1010000001000110, 5}, {0b1010000001001000, 4}, - {0b1010000001001001, 5}, {0b1010000001001100, 5}, - {0b1010000001010000, 2}, {0b1010000001010101, 3}, - {0b1010000001011010, 3}, {0b1010000001011111, 4}, - {0b1010000001100000, 4}, {0b1010000001100001, 5}, - {0b1010000001100010, 5}, {0b1010000001100100, 5}, - {0b1010000001101000, 5}, {0b1010000010000000, 5}, - {0b1010000010000001, 4}, {0b1010000010000010, 4}, - {0b1010000010000011, 5}, {0b1010000010000100, 4}, - {0b1010000010000110, 5}, {0b1010000010001000, 4}, - {0b1010000010001001, 5}, {0b1010000010001100, 5}, - {0b1010000010010000, 4}, {0b1010000010010001, 5}, - {0b1010000010010010, 5}, {0b1010000010010100, 5}, - {0b1010000010011000, 5}, {0b1010000010100000, 2}, - {0b1010000010100101, 3}, {0b1010000010101010, 3}, - {0b1010000010101111, 4}, {0b1010000011000000, 4}, - {0b1010000011000001, 5}, {0b1010000011000010, 5}, - {0b1010000011000100, 5}, {0b1010000011001000, 5}, - {0b1010000011110000, 3}, {0b1010000011110101, 4}, - {0b1010000011111010, 4}, {0b1010000011111111, 3}, - {0b1010000100000000, 5}, {0b1010000100000001, 4}, - {0b1010000100000010, 4}, {0b1010000100000011, 5}, - {0b1010000100000100, 4}, {0b1010000100000110, 5}, - {0b1010000100001000, 4}, {0b1010000100001001, 5}, - {0b1010000100001100, 5}, {0b1010000100010000, 4}, - {0b1010000100010001, 5}, {0b1010000100010100, 5}, - {0b1010000100011010, 3}, {0b1010000100100000, 4}, - {0b1010000100100010, 5}, {0b1010000100100101, 3}, - {0b1010000100101000, 5}, {0b1010000100110000, 5}, - {0b1010000101000000, 4}, {0b1010000101000001, 5}, - {0b1010000101000100, 5}, {0b1010000101001010, 3}, - {0b1010000101010010, 3}, {0b1010000101011000, 3}, - {0b1010000101100000, 5}, {0b1010000110000000, 4}, - {0b1010000110000010, 5}, {0b1010000110000101, 3}, - {0b1010000110001000, 5}, {0b1010000110010000, 5}, - {0b1010000110100001, 3}, {0b1010000110100100, 3}, - {0b1010000111000000, 5}, {0b1010001000000000, 5}, - {0b1010001000000001, 4}, {0b1010001000000010, 4}, - {0b1010001000000011, 5}, {0b1010001000000100, 4}, - {0b1010001000000110, 5}, {0b1010001000001000, 4}, - {0b1010001000001001, 5}, {0b1010001000001100, 5}, - {0b1010001000010000, 4}, {0b1010001000010010, 5}, - {0b1010001000010101, 3}, {0b1010001000011000, 5}, - {0b1010001000100000, 4}, {0b1010001000100001, 5}, - {0b1010001000100100, 5}, {0b1010001000101010, 3}, - {0b1010001000110000, 5}, {0b1010001001000000, 4}, - {0b1010001001000010, 5}, {0b1010001001000101, 3}, - {0b1010001001001000, 5}, {0b1010001001010001, 3}, - {0b1010001001010100, 3}, {0b1010001001100000, 5}, - {0b1010001010000000, 4}, {0b1010001010000001, 5}, - {0b1010001010000100, 5}, {0b1010001010001010, 3}, - {0b1010001010010000, 5}, {0b1010001010100010, 3}, - {0b1010001010101000, 3}, {0b1010001011000000, 5}, - {0b1010001100000000, 4}, {0b1010001100000001, 5}, - {0b1010001100000010, 5}, {0b1010001100000100, 5}, - {0b1010001100001000, 5}, {0b1010001100010000, 5}, - {0b1010001100100000, 5}, {0b1010001100110101, 4}, - {0b1010001100111010, 4}, {0b1010001101000000, 5}, - {0b1010001101010011, 4}, {0b1010001101011100, 4}, - {0b1010001101111111, 5}, {0b1010001110000000, 5}, - {0b1010001110100011, 4}, {0b1010001110101100, 4}, - {0b1010001110111111, 5}, {0b1010001111000101, 4}, - {0b1010001111001010, 4}, {0b1010001111011111, 5}, - {0b1010001111101111, 5}, {0b1010001111110111, 5}, - {0b1010001111111011, 5}, {0b1010001111111101, 5}, - {0b1010001111111110, 5}, {0b1010001111111111, 4}, - {0b1010010000000000, 5}, {0b1010010000000001, 4}, - {0b1010010000000010, 4}, {0b1010010000000011, 5}, - {0b1010010000000100, 4}, {0b1010010000000110, 5}, - {0b1010010000001000, 4}, {0b1010010000001001, 5}, - {0b1010010000001100, 5}, {0b1010010000010000, 4}, - {0b1010010000010001, 5}, {0b1010010000010100, 5}, - {0b1010010000011010, 3}, {0b1010010000100000, 4}, - {0b1010010000100010, 5}, {0b1010010000100101, 3}, - {0b1010010000101000, 5}, {0b1010010000110000, 5}, - {0b1010010001000000, 4}, {0b1010010001000001, 5}, - {0b1010010001000100, 5}, {0b1010010001001010, 3}, - {0b1010010001010010, 3}, {0b1010010001011000, 3}, - {0b1010010001100000, 5}, {0b1010010010000000, 4}, - {0b1010010010000010, 5}, {0b1010010010000101, 3}, - {0b1010010010001000, 5}, {0b1010010010010000, 5}, - {0b1010010010100001, 3}, {0b1010010010100100, 3}, - {0b1010010011000000, 5}, {0b1010010100000000, 2}, - {0b1010010100000101, 3}, {0b1010010100001010, 3}, - {0b1010010100001111, 4}, {0b1010010100010010, 3}, - {0b1010010100011000, 3}, {0b1010010100100001, 3}, - {0b1010010100100100, 3}, {0b1010010100110011, 4}, - {0b1010010100111100, 4}, {0b1010010101000010, 3}, - {0b1010010101001000, 3}, {0b1010010101010000, 3}, - {0b1010010101010101, 4}, {0b1010010101011010, 1}, - {0b1010010101011111, 3}, {0b1010010101100110, 4}, - {0b1010010101101001, 4}, {0b1010010101111011, 3}, - {0b1010010101111110, 3}, {0b1010010110000001, 3}, - {0b1010010110000100, 3}, {0b1010010110010110, 4}, - {0b1010010110011001, 4}, {0b1010010110100000, 3}, - {0b1010010110100101, 1}, {0b1010010110101010, 4}, - {0b1010010110101111, 3}, {0b1010010110110111, 3}, - {0b1010010110111101, 3}, {0b1010010111000011, 4}, - {0b1010010111001100, 4}, {0b1010010111011011, 3}, - {0b1010010111011110, 3}, {0b1010010111100111, 3}, - {0b1010010111101101, 3}, {0b1010010111110000, 4}, - {0b1010010111110101, 3}, {0b1010010111111010, 3}, - {0b1010010111111111, 2}, {0b1010011000000000, 4}, - {0b1010011000000001, 5}, {0b1010011000000010, 5}, - {0b1010011000000100, 5}, {0b1010011000001000, 5}, - {0b1010011000010000, 5}, {0b1010011000100000, 5}, - {0b1010011001000000, 5}, {0b1010011001010110, 4}, - {0b1010011001011001, 4}, {0b1010011001100101, 4}, - {0b1010011001101010, 4}, {0b1010011001111111, 5}, - {0b1010011010000000, 5}, {0b1010011010010101, 4}, - {0b1010011010011010, 4}, {0b1010011010100110, 4}, - {0b1010011010101001, 4}, {0b1010011010111111, 5}, - {0b1010011011011111, 5}, {0b1010011011101111, 5}, - {0b1010011011110111, 5}, {0b1010011011111011, 5}, - {0b1010011011111101, 5}, {0b1010011011111110, 5}, - {0b1010011011111111, 4}, {0b1010011100111111, 5}, - {0b1010011101011011, 3}, {0b1010011101011110, 3}, - {0b1010011101101111, 5}, {0b1010011101110111, 5}, - {0b1010011101111010, 3}, {0b1010011101111101, 5}, - {0b1010011101111111, 4}, {0b1010011110011111, 5}, - {0b1010011110100111, 3}, {0b1010011110101101, 3}, - {0b1010011110110101, 3}, {0b1010011110111011, 5}, - {0b1010011110111110, 5}, {0b1010011110111111, 4}, - {0b1010011111001111, 5}, {0b1010011111010111, 5}, - {0b1010011111011010, 3}, {0b1010011111011101, 5}, - {0b1010011111011111, 4}, {0b1010011111100101, 3}, - {0b1010011111101011, 5}, {0b1010011111101110, 5}, - {0b1010011111101111, 4}, {0b1010011111110011, 5}, - {0b1010011111110110, 5}, {0b1010011111110111, 4}, - {0b1010011111111001, 5}, {0b1010011111111011, 4}, - {0b1010011111111100, 5}, {0b1010011111111101, 4}, - {0b1010011111111110, 4}, {0b1010011111111111, 5}, - {0b1010100000000000, 5}, {0b1010100000000001, 4}, - {0b1010100000000010, 4}, {0b1010100000000011, 5}, - {0b1010100000000100, 4}, {0b1010100000000110, 5}, - {0b1010100000001000, 4}, {0b1010100000001001, 5}, - {0b1010100000001100, 5}, {0b1010100000010000, 4}, - {0b1010100000010010, 5}, {0b1010100000010101, 3}, - {0b1010100000011000, 5}, {0b1010100000100000, 4}, - {0b1010100000100001, 5}, {0b1010100000100100, 5}, - {0b1010100000101010, 3}, {0b1010100000110000, 5}, - {0b1010100001000000, 4}, {0b1010100001000010, 5}, - {0b1010100001000101, 3}, {0b1010100001001000, 5}, - {0b1010100001010001, 3}, {0b1010100001010100, 3}, - {0b1010100001100000, 5}, {0b1010100010000000, 4}, - {0b1010100010000001, 5}, {0b1010100010000100, 5}, - {0b1010100010001010, 3}, {0b1010100010010000, 5}, - {0b1010100010100010, 3}, {0b1010100010101000, 3}, - {0b1010100011000000, 5}, {0b1010100100000000, 4}, - {0b1010100100000001, 5}, {0b1010100100000010, 5}, - {0b1010100100000100, 5}, {0b1010100100001000, 5}, - {0b1010100100010000, 5}, {0b1010100100100000, 5}, - {0b1010100101000000, 5}, {0b1010100101010110, 4}, - {0b1010100101011001, 4}, {0b1010100101100101, 4}, - {0b1010100101101010, 4}, {0b1010100101111111, 5}, - {0b1010100110000000, 5}, {0b1010100110010101, 4}, - {0b1010100110011010, 4}, {0b1010100110100110, 4}, - {0b1010100110101001, 4}, {0b1010100110111111, 5}, - {0b1010100111011111, 5}, {0b1010100111101111, 5}, - {0b1010100111110111, 5}, {0b1010100111111011, 5}, - {0b1010100111111101, 5}, {0b1010100111111110, 5}, - {0b1010100111111111, 4}, {0b1010101000000000, 2}, - {0b1010101000000101, 3}, {0b1010101000001010, 3}, - {0b1010101000001111, 4}, {0b1010101000010001, 3}, - {0b1010101000010100, 3}, {0b1010101000100010, 3}, - {0b1010101000101000, 3}, {0b1010101000110011, 4}, - {0b1010101000111100, 4}, {0b1010101001000001, 3}, - {0b1010101001000100, 3}, {0b1010101001010000, 3}, - {0b1010101001010101, 1}, {0b1010101001011010, 4}, - {0b1010101001011111, 3}, {0b1010101001100110, 4}, - {0b1010101001101001, 4}, {0b1010101001110111, 3}, - {0b1010101001111101, 3}, {0b1010101010000010, 3}, - {0b1010101010001000, 3}, {0b1010101010010110, 4}, - {0b1010101010011001, 4}, {0b1010101010100000, 3}, - {0b1010101010100101, 4}, {0b1010101010101010, 1}, - {0b1010101010101111, 3}, {0b1010101010111011, 3}, - {0b1010101010111110, 3}, {0b1010101011000011, 4}, - {0b1010101011001100, 4}, {0b1010101011010111, 3}, - {0b1010101011011101, 3}, {0b1010101011101011, 3}, - {0b1010101011101110, 3}, {0b1010101011110000, 4}, - {0b1010101011110101, 3}, {0b1010101011111010, 3}, - {0b1010101011111111, 2}, {0b1010101100111111, 5}, - {0b1010101101010111, 3}, {0b1010101101011101, 3}, - {0b1010101101101111, 5}, {0b1010101101110101, 3}, - {0b1010101101111011, 5}, {0b1010101101111110, 5}, - {0b1010101101111111, 4}, {0b1010101110011111, 5}, - {0b1010101110101011, 3}, {0b1010101110101110, 3}, - {0b1010101110110111, 5}, {0b1010101110111010, 3}, - {0b1010101110111101, 5}, {0b1010101110111111, 4}, - {0b1010101111001111, 5}, {0b1010101111010101, 3}, - {0b1010101111011011, 5}, {0b1010101111011110, 5}, - {0b1010101111011111, 4}, {0b1010101111100111, 5}, - {0b1010101111101010, 3}, {0b1010101111101101, 5}, - {0b1010101111101111, 4}, {0b1010101111110011, 5}, - {0b1010101111110110, 5}, {0b1010101111110111, 4}, - {0b1010101111111001, 5}, {0b1010101111111011, 4}, - {0b1010101111111100, 5}, {0b1010101111111101, 4}, - {0b1010101111111110, 4}, {0b1010101111111111, 5}, - {0b1010110000000000, 4}, {0b1010110000000001, 5}, - {0b1010110000000010, 5}, {0b1010110000000100, 5}, - {0b1010110000001000, 5}, {0b1010110000010000, 5}, - {0b1010110000100000, 5}, {0b1010110000110101, 4}, - {0b1010110000111010, 4}, {0b1010110001000000, 5}, - {0b1010110001010011, 4}, {0b1010110001011100, 4}, - {0b1010110001111111, 5}, {0b1010110010000000, 5}, - {0b1010110010100011, 4}, {0b1010110010101100, 4}, - {0b1010110010111111, 5}, {0b1010110011000101, 4}, - {0b1010110011001010, 4}, {0b1010110011011111, 5}, - {0b1010110011101111, 5}, {0b1010110011110111, 5}, - {0b1010110011111011, 5}, {0b1010110011111101, 5}, - {0b1010110011111110, 5}, {0b1010110011111111, 4}, - {0b1010110100111111, 5}, {0b1010110101011011, 3}, - {0b1010110101011110, 3}, {0b1010110101101111, 5}, - {0b1010110101110111, 5}, {0b1010110101111010, 3}, - {0b1010110101111101, 5}, {0b1010110101111111, 4}, - {0b1010110110011111, 5}, {0b1010110110100111, 3}, - {0b1010110110101101, 3}, {0b1010110110110101, 3}, - {0b1010110110111011, 5}, {0b1010110110111110, 5}, - {0b1010110110111111, 4}, {0b1010110111001111, 5}, - {0b1010110111010111, 5}, {0b1010110111011010, 3}, - {0b1010110111011101, 5}, {0b1010110111011111, 4}, - {0b1010110111100101, 3}, {0b1010110111101011, 5}, - {0b1010110111101110, 5}, {0b1010110111101111, 4}, - {0b1010110111110011, 5}, {0b1010110111110110, 5}, - {0b1010110111110111, 4}, {0b1010110111111001, 5}, - {0b1010110111111011, 4}, {0b1010110111111100, 5}, - {0b1010110111111101, 4}, {0b1010110111111110, 4}, - {0b1010110111111111, 5}, {0b1010111000111111, 5}, - {0b1010111001010111, 3}, {0b1010111001011101, 3}, - {0b1010111001101111, 5}, {0b1010111001110101, 3}, - {0b1010111001111011, 5}, {0b1010111001111110, 5}, - {0b1010111001111111, 4}, {0b1010111010011111, 5}, - {0b1010111010101011, 3}, {0b1010111010101110, 3}, - {0b1010111010110111, 5}, {0b1010111010111010, 3}, - {0b1010111010111101, 5}, {0b1010111010111111, 4}, - {0b1010111011001111, 5}, {0b1010111011010101, 3}, - {0b1010111011011011, 5}, {0b1010111011011110, 5}, - {0b1010111011011111, 4}, {0b1010111011100111, 5}, - {0b1010111011101010, 3}, {0b1010111011101101, 5}, - {0b1010111011101111, 4}, {0b1010111011110011, 5}, - {0b1010111011110110, 5}, {0b1010111011110111, 4}, - {0b1010111011111001, 5}, {0b1010111011111011, 4}, - {0b1010111011111100, 5}, {0b1010111011111101, 4}, - {0b1010111011111110, 4}, {0b1010111011111111, 5}, - {0b1010111100000000, 3}, {0b1010111100000101, 4}, - {0b1010111100001010, 4}, {0b1010111100001111, 3}, - {0b1010111100110111, 5}, {0b1010111100111011, 5}, - {0b1010111100111101, 5}, {0b1010111100111110, 5}, - {0b1010111100111111, 4}, {0b1010111101010000, 4}, - {0b1010111101010101, 3}, {0b1010111101011010, 3}, - {0b1010111101011111, 2}, {0b1010111101100111, 5}, - {0b1010111101101011, 5}, {0b1010111101101101, 5}, - {0b1010111101101110, 5}, {0b1010111101101111, 4}, - {0b1010111101110011, 5}, {0b1010111101110110, 5}, - {0b1010111101110111, 4}, {0b1010111101111001, 5}, - {0b1010111101111011, 4}, {0b1010111101111100, 5}, - {0b1010111101111101, 4}, {0b1010111101111110, 4}, - {0b1010111101111111, 5}, {0b1010111110010111, 5}, - {0b1010111110011011, 5}, {0b1010111110011101, 5}, - {0b1010111110011110, 5}, {0b1010111110011111, 4}, - {0b1010111110100000, 4}, {0b1010111110100101, 3}, - {0b1010111110101010, 3}, {0b1010111110101111, 2}, - {0b1010111110110011, 5}, {0b1010111110110110, 5}, - {0b1010111110110111, 4}, {0b1010111110111001, 5}, - {0b1010111110111011, 4}, {0b1010111110111100, 5}, - {0b1010111110111101, 4}, {0b1010111110111110, 4}, - {0b1010111110111111, 5}, {0b1010111111000111, 5}, - {0b1010111111001011, 5}, {0b1010111111001101, 5}, - {0b1010111111001110, 5}, {0b1010111111001111, 4}, - {0b1010111111010011, 5}, {0b1010111111010110, 5}, - {0b1010111111010111, 4}, {0b1010111111011001, 5}, - {0b1010111111011011, 4}, {0b1010111111011100, 5}, - {0b1010111111011101, 4}, {0b1010111111011110, 4}, - {0b1010111111011111, 5}, {0b1010111111100011, 5}, - {0b1010111111100110, 5}, {0b1010111111100111, 4}, - {0b1010111111101001, 5}, {0b1010111111101011, 4}, - {0b1010111111101100, 5}, {0b1010111111101101, 4}, - {0b1010111111101110, 4}, {0b1010111111101111, 5}, - {0b1010111111110000, 3}, {0b1010111111110011, 4}, - {0b1010111111110101, 2}, {0b1010111111110110, 4}, - {0b1010111111110111, 5}, {0b1010111111111001, 4}, - {0b1010111111111010, 2}, {0b1010111111111011, 5}, - {0b1010111111111100, 4}, {0b1010111111111101, 5}, - {0b1010111111111110, 5}, {0b1010111111111111, 3}, - {0b1011000000000000, 5}, {0b1011000000000001, 4}, - {0b1011000000000010, 4}, {0b1011000000000100, 4}, - {0b1011000000000111, 3}, {0b1011000000001000, 4}, - {0b1011000000001011, 3}, {0b1011000000001101, 3}, - {0b1011000000001110, 3}, {0b1011000000010000, 4}, - {0b1011000000010001, 5}, {0b1011000000010010, 5}, - {0b1011000000010100, 5}, {0b1011000000011000, 5}, - {0b1011000000100000, 4}, {0b1011000000100001, 5}, - {0b1011000000100010, 5}, {0b1011000000100100, 5}, - {0b1011000000101000, 5}, {0b1011000001000000, 4}, - {0b1011000001000001, 5}, {0b1011000001000010, 5}, - {0b1011000001000100, 5}, {0b1011000001001000, 5}, - {0b1011000001110000, 3}, {0b1011000010000000, 4}, - {0b1011000010000001, 5}, {0b1011000010000010, 5}, - {0b1011000010000100, 5}, {0b1011000010001000, 5}, - {0b1011000010110000, 3}, {0b1011000011010000, 3}, - {0b1011000011100000, 3}, {0b1011000100000000, 4}, - {0b1011000100000001, 5}, {0b1011000100000010, 5}, - {0b1011000100000100, 5}, {0b1011000100001000, 5}, - {0b1011000100010000, 5}, {0b1011000100011011, 4}, - {0b1011000100100000, 5}, {0b1011000100100111, 4}, - {0b1011000101000000, 5}, {0b1011000101001110, 4}, - {0b1011000101110010, 4}, {0b1011000101111111, 5}, - {0b1011000110000000, 5}, {0b1011000110001101, 4}, - {0b1011000110110001, 4}, {0b1011000110111111, 5}, - {0b1011000111011000, 4}, {0b1011000111011111, 5}, - {0b1011000111100100, 4}, {0b1011000111101111, 5}, - {0b1011000111110111, 5}, {0b1011000111111011, 5}, - {0b1011000111111101, 5}, {0b1011000111111110, 5}, - {0b1011000111111111, 4}, {0b1011001000000000, 4}, - {0b1011001000000001, 5}, {0b1011001000000010, 5}, - {0b1011001000000100, 5}, {0b1011001000001000, 5}, - {0b1011001000010000, 5}, {0b1011001000010111, 4}, - {0b1011001000100000, 5}, {0b1011001000101011, 4}, - {0b1011001001000000, 5}, {0b1011001001001101, 4}, - {0b1011001001110001, 4}, {0b1011001001111111, 5}, - {0b1011001010000000, 5}, {0b1011001010001110, 4}, - {0b1011001010110010, 4}, {0b1011001010111111, 5}, - {0b1011001011010100, 4}, {0b1011001011011111, 5}, - {0b1011001011101000, 4}, {0b1011001011101111, 5}, - {0b1011001011110111, 5}, {0b1011001011111011, 5}, - {0b1011001011111101, 5}, {0b1011001011111110, 5}, - {0b1011001011111111, 4}, {0b1011001100110111, 3}, - {0b1011001100111011, 3}, {0b1011001101011111, 5}, - {0b1011001101101111, 5}, {0b1011001101110011, 3}, - {0b1011001101111101, 5}, {0b1011001101111110, 5}, - {0b1011001101111111, 4}, {0b1011001110011111, 5}, - {0b1011001110101111, 5}, {0b1011001110110011, 3}, - {0b1011001110111101, 5}, {0b1011001110111110, 5}, - {0b1011001110111111, 4}, {0b1011001111001101, 3}, - {0b1011001111001110, 3}, {0b1011001111010111, 5}, - {0b1011001111011011, 5}, {0b1011001111011100, 3}, - {0b1011001111011111, 4}, {0b1011001111100111, 5}, - {0b1011001111101011, 5}, {0b1011001111101100, 3}, - {0b1011001111101111, 4}, {0b1011001111110101, 5}, - {0b1011001111110110, 5}, {0b1011001111110111, 4}, - {0b1011001111111001, 5}, {0b1011001111111010, 5}, - {0b1011001111111011, 4}, {0b1011001111111101, 4}, - {0b1011001111111110, 4}, {0b1011001111111111, 5}, - {0b1011010000000000, 4}, {0b1011010000000001, 5}, - {0b1011010000000010, 5}, {0b1011010000000100, 5}, - {0b1011010000001000, 5}, {0b1011010000010000, 5}, - {0b1011010000011110, 4}, {0b1011010000100000, 5}, - {0b1011010000101101, 4}, {0b1011010001000000, 5}, - {0b1011010001001011, 4}, {0b1011010001111000, 4}, - {0b1011010001111111, 5}, {0b1011010010000000, 5}, - {0b1011010010000111, 4}, {0b1011010010110100, 4}, - {0b1011010010111111, 5}, {0b1011010011010010, 4}, - {0b1011010011011111, 5}, {0b1011010011100001, 4}, - {0b1011010011101111, 5}, {0b1011010011110111, 5}, - {0b1011010011111011, 5}, {0b1011010011111101, 5}, - {0b1011010011111110, 5}, {0b1011010011111111, 4}, - {0b1011010100111111, 5}, {0b1011010101011011, 3}, - {0b1011010101011110, 3}, {0b1011010101101111, 5}, - {0b1011010101110111, 5}, {0b1011010101111010, 3}, - {0b1011010101111101, 5}, {0b1011010101111111, 4}, - {0b1011010110011111, 5}, {0b1011010110100111, 3}, - {0b1011010110101101, 3}, {0b1011010110110101, 3}, - {0b1011010110111011, 5}, {0b1011010110111110, 5}, - {0b1011010110111111, 4}, {0b1011010111001111, 5}, - {0b1011010111010111, 5}, {0b1011010111011010, 3}, - {0b1011010111011101, 5}, {0b1011010111011111, 4}, - {0b1011010111100101, 3}, {0b1011010111101011, 5}, - {0b1011010111101110, 5}, {0b1011010111101111, 4}, - {0b1011010111110011, 5}, {0b1011010111110110, 5}, - {0b1011010111110111, 4}, {0b1011010111111001, 5}, - {0b1011010111111011, 4}, {0b1011010111111100, 5}, - {0b1011010111111101, 4}, {0b1011010111111110, 4}, - {0b1011010111111111, 5}, {0b1011011000111111, 5}, - {0b1011011001011111, 5}, {0b1011011001101011, 3}, - {0b1011011001101101, 3}, {0b1011011001110111, 5}, - {0b1011011001111001, 3}, {0b1011011001111110, 5}, - {0b1011011001111111, 4}, {0b1011011010010111, 3}, - {0b1011011010011110, 3}, {0b1011011010101111, 5}, - {0b1011011010110110, 3}, {0b1011011010111011, 5}, - {0b1011011010111101, 5}, {0b1011011010111111, 4}, - {0b1011011011001111, 5}, {0b1011011011010110, 3}, - {0b1011011011011011, 5}, {0b1011011011011101, 5}, - {0b1011011011011111, 4}, {0b1011011011100111, 5}, - {0b1011011011101001, 3}, {0b1011011011101110, 5}, - {0b1011011011101111, 4}, {0b1011011011110011, 5}, - {0b1011011011110101, 5}, {0b1011011011110111, 4}, - {0b1011011011111010, 5}, {0b1011011011111011, 4}, - {0b1011011011111100, 5}, {0b1011011011111101, 4}, - {0b1011011011111110, 4}, {0b1011011011111111, 5}, - {0b1011011100000000, 3}, {0b1011011100010010, 4}, - {0b1011011100011111, 5}, {0b1011011100100001, 4}, - {0b1011011100101111, 5}, {0b1011011100110011, 3}, - {0b1011011100111101, 5}, {0b1011011100111110, 5}, - {0b1011011100111111, 4}, {0b1011011101001000, 4}, - {0b1011011101001111, 5}, {0b1011011101010111, 5}, - {0b1011011101011010, 3}, {0b1011011101011101, 5}, - {0b1011011101011111, 4}, {0b1011011101100111, 5}, - {0b1011011101101001, 3}, {0b1011011101101110, 5}, - {0b1011011101101111, 4}, {0b1011011101110101, 5}, - {0b1011011101110110, 5}, {0b1011011101110111, 4}, - {0b1011011101111011, 2}, {0b1011011101111100, 5}, - {0b1011011101111101, 4}, {0b1011011101111110, 4}, - {0b1011011101111111, 5}, {0b1011011110000100, 4}, - {0b1011011110001111, 5}, {0b1011011110010110, 3}, - {0b1011011110011011, 5}, {0b1011011110011101, 5}, - {0b1011011110011111, 4}, {0b1011011110100101, 3}, - {0b1011011110101011, 5}, {0b1011011110101110, 5}, - {0b1011011110101111, 4}, {0b1011011110110111, 2}, - {0b1011011110111001, 5}, {0b1011011110111010, 5}, - {0b1011011110111011, 4}, {0b1011011110111100, 5}, - {0b1011011110111101, 4}, {0b1011011110111110, 4}, - {0b1011011110111111, 5}, {0b1011011111000111, 5}, - {0b1011011111001011, 5}, {0b1011011111001100, 3}, - {0b1011011111001111, 4}, {0b1011011111010011, 5}, - {0b1011011111010101, 5}, {0b1011011111010111, 4}, - {0b1011011111011001, 5}, {0b1011011111011011, 4}, - {0b1011011111011101, 4}, {0b1011011111011110, 2}, - {0b1011011111011111, 5}, {0b1011011111100011, 5}, - {0b1011011111100110, 5}, {0b1011011111100111, 4}, - {0b1011011111101010, 5}, {0b1011011111101011, 4}, - {0b1011011111101101, 2}, {0b1011011111101110, 4}, - {0b1011011111101111, 5}, {0b1011011111110001, 5}, - {0b1011011111110010, 5}, {0b1011011111110011, 4}, - {0b1011011111110100, 5}, {0b1011011111110101, 4}, - {0b1011011111110110, 4}, {0b1011011111110111, 5}, - {0b1011011111111000, 5}, {0b1011011111111001, 4}, - {0b1011011111111010, 4}, {0b1011011111111011, 5}, - {0b1011011111111100, 4}, {0b1011011111111101, 5}, - {0b1011011111111110, 5}, {0b1011011111111111, 3}, - {0b1011100000000000, 4}, {0b1011100000000001, 5}, - {0b1011100000000010, 5}, {0b1011100000000100, 5}, - {0b1011100000001000, 5}, {0b1011100000010000, 5}, - {0b1011100000011101, 4}, {0b1011100000100000, 5}, - {0b1011100000101110, 4}, {0b1011100001000000, 5}, - {0b1011100001000111, 4}, {0b1011100001110100, 4}, - {0b1011100001111111, 5}, {0b1011100010000000, 5}, - {0b1011100010001011, 4}, {0b1011100010111000, 4}, - {0b1011100010111111, 5}, {0b1011100011010001, 4}, - {0b1011100011011111, 5}, {0b1011100011100010, 4}, - {0b1011100011101111, 5}, {0b1011100011110111, 5}, - {0b1011100011111011, 5}, {0b1011100011111101, 5}, - {0b1011100011111110, 5}, {0b1011100011111111, 4}, - {0b1011100100111111, 5}, {0b1011100101011111, 5}, - {0b1011100101100111, 3}, {0b1011100101101110, 3}, - {0b1011100101110110, 3}, {0b1011100101111011, 5}, - {0b1011100101111101, 5}, {0b1011100101111111, 4}, - {0b1011100110011011, 3}, {0b1011100110011101, 3}, - {0b1011100110101111, 5}, {0b1011100110110111, 5}, - {0b1011100110111001, 3}, {0b1011100110111110, 5}, - {0b1011100110111111, 4}, {0b1011100111001111, 5}, - {0b1011100111010111, 5}, {0b1011100111011001, 3}, - {0b1011100111011110, 5}, {0b1011100111011111, 4}, - {0b1011100111100110, 3}, {0b1011100111101011, 5}, - {0b1011100111101101, 5}, {0b1011100111101111, 4}, - {0b1011100111110011, 5}, {0b1011100111110101, 5}, - {0b1011100111110111, 4}, {0b1011100111111010, 5}, - {0b1011100111111011, 4}, {0b1011100111111100, 5}, - {0b1011100111111101, 4}, {0b1011100111111110, 4}, - {0b1011100111111111, 5}, {0b1011101000111111, 5}, - {0b1011101001010111, 3}, {0b1011101001011101, 3}, - {0b1011101001101111, 5}, {0b1011101001110101, 3}, - {0b1011101001111011, 5}, {0b1011101001111110, 5}, - {0b1011101001111111, 4}, {0b1011101010011111, 5}, - {0b1011101010101011, 3}, {0b1011101010101110, 3}, - {0b1011101010110111, 5}, {0b1011101010111010, 3}, - {0b1011101010111101, 5}, {0b1011101010111111, 4}, - {0b1011101011001111, 5}, {0b1011101011010101, 3}, - {0b1011101011011011, 5}, {0b1011101011011110, 5}, - {0b1011101011011111, 4}, {0b1011101011100111, 5}, - {0b1011101011101010, 3}, {0b1011101011101101, 5}, - {0b1011101011101111, 4}, {0b1011101011110011, 5}, - {0b1011101011110110, 5}, {0b1011101011110111, 4}, - {0b1011101011111001, 5}, {0b1011101011111011, 4}, - {0b1011101011111100, 5}, {0b1011101011111101, 4}, - {0b1011101011111110, 4}, {0b1011101011111111, 5}, - {0b1011101100000000, 3}, {0b1011101100010001, 4}, - {0b1011101100011111, 5}, {0b1011101100100010, 4}, - {0b1011101100101111, 5}, {0b1011101100110011, 3}, - {0b1011101100111101, 5}, {0b1011101100111110, 5}, - {0b1011101100111111, 4}, {0b1011101101000100, 4}, - {0b1011101101001111, 5}, {0b1011101101010101, 3}, - {0b1011101101011011, 5}, {0b1011101101011110, 5}, - {0b1011101101011111, 4}, {0b1011101101100110, 3}, - {0b1011101101101011, 5}, {0b1011101101101101, 5}, - {0b1011101101101111, 4}, {0b1011101101110111, 2}, - {0b1011101101111001, 5}, {0b1011101101111010, 5}, - {0b1011101101111011, 4}, {0b1011101101111100, 5}, - {0b1011101101111101, 4}, {0b1011101101111110, 4}, - {0b1011101101111111, 5}, {0b1011101110001000, 4}, - {0b1011101110001111, 5}, {0b1011101110010111, 5}, - {0b1011101110011001, 3}, {0b1011101110011110, 5}, - {0b1011101110011111, 4}, {0b1011101110100111, 5}, - {0b1011101110101010, 3}, {0b1011101110101101, 5}, - {0b1011101110101111, 4}, {0b1011101110110101, 5}, - {0b1011101110110110, 5}, {0b1011101110110111, 4}, - {0b1011101110111011, 2}, {0b1011101110111100, 5}, - {0b1011101110111101, 4}, {0b1011101110111110, 4}, - {0b1011101110111111, 5}, {0b1011101111000111, 5}, - {0b1011101111001011, 5}, {0b1011101111001100, 3}, - {0b1011101111001111, 4}, {0b1011101111010011, 5}, - {0b1011101111010110, 5}, {0b1011101111010111, 4}, - {0b1011101111011010, 5}, {0b1011101111011011, 4}, - {0b1011101111011101, 2}, {0b1011101111011110, 4}, - {0b1011101111011111, 5}, {0b1011101111100011, 5}, - {0b1011101111100101, 5}, {0b1011101111100111, 4}, - {0b1011101111101001, 5}, {0b1011101111101011, 4}, - {0b1011101111101101, 4}, {0b1011101111101110, 2}, - {0b1011101111101111, 5}, {0b1011101111110001, 5}, - {0b1011101111110010, 5}, {0b1011101111110011, 4}, - {0b1011101111110100, 5}, {0b1011101111110101, 4}, - {0b1011101111110110, 4}, {0b1011101111110111, 5}, - {0b1011101111111000, 5}, {0b1011101111111001, 4}, - {0b1011101111111010, 4}, {0b1011101111111011, 5}, - {0b1011101111111100, 4}, {0b1011101111111101, 5}, - {0b1011101111111110, 5}, {0b1011101111111111, 3}, - {0b1011110000111101, 3}, {0b1011110000111110, 3}, - {0b1011110001011111, 5}, {0b1011110001101111, 5}, - {0b1011110001110111, 5}, {0b1011110001111011, 5}, - {0b1011110001111100, 3}, {0b1011110001111111, 4}, - {0b1011110010011111, 5}, {0b1011110010101111, 5}, - {0b1011110010110111, 5}, {0b1011110010111011, 5}, - {0b1011110010111100, 3}, {0b1011110010111111, 4}, - {0b1011110011000111, 3}, {0b1011110011001011, 3}, - {0b1011110011010011, 3}, {0b1011110011011101, 5}, - {0b1011110011011110, 5}, {0b1011110011011111, 4}, - {0b1011110011100011, 3}, {0b1011110011101101, 5}, - {0b1011110011101110, 5}, {0b1011110011101111, 4}, - {0b1011110011110101, 5}, {0b1011110011110110, 5}, - {0b1011110011110111, 4}, {0b1011110011111001, 5}, - {0b1011110011111010, 5}, {0b1011110011111011, 4}, - {0b1011110011111101, 4}, {0b1011110011111110, 4}, - {0b1011110011111111, 5}, {0b1011110100000000, 3}, - {0b1011110100011000, 4}, {0b1011110100011111, 5}, - {0b1011110100100100, 4}, {0b1011110100101111, 5}, - {0b1011110100110111, 5}, {0b1011110100111011, 5}, - {0b1011110100111100, 3}, {0b1011110100111111, 4}, - {0b1011110101000010, 4}, {0b1011110101001111, 5}, - {0b1011110101010111, 5}, {0b1011110101011010, 3}, - {0b1011110101011101, 5}, {0b1011110101011111, 4}, - {0b1011110101100110, 3}, {0b1011110101101011, 5}, - {0b1011110101101101, 5}, {0b1011110101101111, 4}, - {0b1011110101110011, 5}, {0b1011110101110101, 5}, - {0b1011110101110111, 4}, {0b1011110101111001, 5}, - {0b1011110101111011, 4}, {0b1011110101111101, 4}, - {0b1011110101111110, 2}, {0b1011110101111111, 5}, - {0b1011110110000001, 4}, {0b1011110110001111, 5}, - {0b1011110110010111, 5}, {0b1011110110011001, 3}, - {0b1011110110011110, 5}, {0b1011110110011111, 4}, - {0b1011110110100101, 3}, {0b1011110110101011, 5}, - {0b1011110110101110, 5}, {0b1011110110101111, 4}, - {0b1011110110110011, 5}, {0b1011110110110110, 5}, - {0b1011110110110111, 4}, {0b1011110110111010, 5}, - {0b1011110110111011, 4}, {0b1011110110111101, 2}, - {0b1011110110111110, 4}, {0b1011110110111111, 5}, - {0b1011110111000011, 3}, {0b1011110111001101, 5}, - {0b1011110111001110, 5}, {0b1011110111001111, 4}, - {0b1011110111010101, 5}, {0b1011110111010110, 5}, - {0b1011110111010111, 4}, {0b1011110111011011, 2}, - {0b1011110111011100, 5}, {0b1011110111011101, 4}, - {0b1011110111011110, 4}, {0b1011110111011111, 5}, - {0b1011110111100111, 2}, {0b1011110111101001, 5}, - {0b1011110111101010, 5}, {0b1011110111101011, 4}, - {0b1011110111101100, 5}, {0b1011110111101101, 4}, - {0b1011110111101110, 4}, {0b1011110111101111, 5}, - {0b1011110111110001, 5}, {0b1011110111110010, 5}, - {0b1011110111110011, 4}, {0b1011110111110100, 5}, - {0b1011110111110101, 4}, {0b1011110111110110, 4}, - {0b1011110111110111, 5}, {0b1011110111111000, 5}, - {0b1011110111111001, 4}, {0b1011110111111010, 4}, - {0b1011110111111011, 5}, {0b1011110111111100, 4}, - {0b1011110111111101, 5}, {0b1011110111111110, 5}, - {0b1011110111111111, 3}, {0b1011111000000000, 3}, - {0b1011111000010100, 4}, {0b1011111000011111, 5}, - {0b1011111000101000, 4}, {0b1011111000101111, 5}, - {0b1011111000110111, 5}, {0b1011111000111011, 5}, - {0b1011111000111100, 3}, {0b1011111000111111, 4}, - {0b1011111001000001, 4}, {0b1011111001001111, 5}, - {0b1011111001010101, 3}, {0b1011111001011011, 5}, - {0b1011111001011110, 5}, {0b1011111001011111, 4}, - {0b1011111001100111, 5}, {0b1011111001101001, 3}, - {0b1011111001101110, 5}, {0b1011111001101111, 4}, - {0b1011111001110011, 5}, {0b1011111001110110, 5}, - {0b1011111001110111, 4}, {0b1011111001111010, 5}, - {0b1011111001111011, 4}, {0b1011111001111101, 2}, - {0b1011111001111110, 4}, {0b1011111001111111, 5}, - {0b1011111010000010, 4}, {0b1011111010001111, 5}, - {0b1011111010010110, 3}, {0b1011111010011011, 5}, - {0b1011111010011101, 5}, {0b1011111010011111, 4}, - {0b1011111010100111, 5}, {0b1011111010101010, 3}, - {0b1011111010101101, 5}, {0b1011111010101111, 4}, - {0b1011111010110011, 5}, {0b1011111010110101, 5}, - {0b1011111010110111, 4}, {0b1011111010111001, 5}, - {0b1011111010111011, 4}, {0b1011111010111101, 4}, - {0b1011111010111110, 2}, {0b1011111010111111, 5}, - {0b1011111011000011, 3}, {0b1011111011001101, 5}, - {0b1011111011001110, 5}, {0b1011111011001111, 4}, - {0b1011111011010111, 2}, {0b1011111011011001, 5}, - {0b1011111011011010, 5}, {0b1011111011011011, 4}, - {0b1011111011011100, 5}, {0b1011111011011101, 4}, - {0b1011111011011110, 4}, {0b1011111011011111, 5}, - {0b1011111011100101, 5}, {0b1011111011100110, 5}, - {0b1011111011100111, 4}, {0b1011111011101011, 2}, - {0b1011111011101100, 5}, {0b1011111011101101, 4}, - {0b1011111011101110, 4}, {0b1011111011101111, 5}, - {0b1011111011110001, 5}, {0b1011111011110010, 5}, - {0b1011111011110011, 4}, {0b1011111011110100, 5}, - {0b1011111011110101, 4}, {0b1011111011110110, 4}, - {0b1011111011110111, 5}, {0b1011111011111000, 5}, - {0b1011111011111001, 4}, {0b1011111011111010, 4}, - {0b1011111011111011, 5}, {0b1011111011111100, 4}, - {0b1011111011111101, 5}, {0b1011111011111110, 5}, - {0b1011111011111111, 3}, {0b1011111100010111, 5}, - {0b1011111100011011, 5}, {0b1011111100011101, 5}, - {0b1011111100011110, 5}, {0b1011111100011111, 4}, - {0b1011111100100111, 5}, {0b1011111100101011, 5}, - {0b1011111100101101, 5}, {0b1011111100101110, 5}, - {0b1011111100101111, 4}, {0b1011111100110101, 5}, - {0b1011111100110110, 5}, {0b1011111100110111, 4}, - {0b1011111100111001, 5}, {0b1011111100111010, 5}, - {0b1011111100111011, 4}, {0b1011111100111101, 4}, - {0b1011111100111110, 4}, {0b1011111100111111, 5}, - {0b1011111101000111, 5}, {0b1011111101001011, 5}, - {0b1011111101001101, 5}, {0b1011111101001110, 5}, - {0b1011111101001111, 4}, {0b1011111101010011, 5}, - {0b1011111101010110, 5}, {0b1011111101010111, 4}, - {0b1011111101011001, 5}, {0b1011111101011011, 4}, - {0b1011111101011100, 5}, {0b1011111101011101, 4}, - {0b1011111101011110, 4}, {0b1011111101011111, 5}, - {0b1011111101100011, 5}, {0b1011111101100101, 5}, - {0b1011111101100111, 4}, {0b1011111101101010, 5}, - {0b1011111101101011, 4}, {0b1011111101101100, 5}, - {0b1011111101101101, 4}, {0b1011111101101110, 4}, - {0b1011111101101111, 5}, {0b1011111101110001, 5}, - {0b1011111101110010, 5}, {0b1011111101110011, 4}, - {0b1011111101110100, 5}, {0b1011111101110101, 4}, - {0b1011111101110110, 4}, {0b1011111101110111, 5}, - {0b1011111101111000, 5}, {0b1011111101111001, 4}, - {0b1011111101111010, 4}, {0b1011111101111011, 5}, - {0b1011111101111100, 4}, {0b1011111101111101, 5}, - {0b1011111101111110, 5}, {0b1011111101111111, 3}, - {0b1011111110000111, 5}, {0b1011111110001011, 5}, - {0b1011111110001101, 5}, {0b1011111110001110, 5}, - {0b1011111110001111, 4}, {0b1011111110010011, 5}, - {0b1011111110010101, 5}, {0b1011111110010111, 4}, - {0b1011111110011010, 5}, {0b1011111110011011, 4}, - {0b1011111110011100, 5}, {0b1011111110011101, 4}, - {0b1011111110011110, 4}, {0b1011111110011111, 5}, - {0b1011111110100011, 5}, {0b1011111110100110, 5}, - {0b1011111110100111, 4}, {0b1011111110101001, 5}, - {0b1011111110101011, 4}, {0b1011111110101100, 5}, - {0b1011111110101101, 4}, {0b1011111110101110, 4}, - {0b1011111110101111, 5}, {0b1011111110110001, 5}, - {0b1011111110110010, 5}, {0b1011111110110011, 4}, - {0b1011111110110100, 5}, {0b1011111110110101, 4}, - {0b1011111110110110, 4}, {0b1011111110110111, 5}, - {0b1011111110111000, 5}, {0b1011111110111001, 4}, - {0b1011111110111010, 4}, {0b1011111110111011, 5}, - {0b1011111110111100, 4}, {0b1011111110111101, 5}, - {0b1011111110111110, 5}, {0b1011111110111111, 3}, - {0b1011111111000101, 5}, {0b1011111111000110, 5}, - {0b1011111111000111, 4}, {0b1011111111001001, 5}, - {0b1011111111001010, 5}, {0b1011111111001011, 4}, - {0b1011111111001101, 4}, {0b1011111111001110, 4}, - {0b1011111111001111, 5}, {0b1011111111010001, 5}, - {0b1011111111010010, 5}, {0b1011111111010011, 4}, - {0b1011111111010100, 5}, {0b1011111111010101, 4}, - {0b1011111111010110, 4}, {0b1011111111010111, 5}, - {0b1011111111011000, 5}, {0b1011111111011001, 4}, - {0b1011111111011010, 4}, {0b1011111111011011, 5}, - {0b1011111111011100, 4}, {0b1011111111011101, 5}, - {0b1011111111011110, 5}, {0b1011111111011111, 3}, - {0b1011111111100001, 5}, {0b1011111111100010, 5}, - {0b1011111111100011, 4}, {0b1011111111100100, 5}, - {0b1011111111100101, 4}, {0b1011111111100110, 4}, - {0b1011111111100111, 5}, {0b1011111111101000, 5}, - {0b1011111111101001, 4}, {0b1011111111101010, 4}, - {0b1011111111101011, 5}, {0b1011111111101100, 4}, - {0b1011111111101101, 5}, {0b1011111111101110, 5}, - {0b1011111111101111, 3}, {0b1011111111110001, 4}, - {0b1011111111110010, 4}, {0b1011111111110011, 5}, - {0b1011111111110100, 4}, {0b1011111111110101, 5}, - {0b1011111111110110, 5}, {0b1011111111110111, 3}, - {0b1011111111111000, 4}, {0b1011111111111001, 5}, - {0b1011111111111010, 5}, {0b1011111111111011, 3}, - {0b1011111111111100, 5}, {0b1011111111111101, 3}, - {0b1011111111111110, 3}, {0b1011111111111111, 4}, - {0b1100000000000000, 3}, {0b1100000000000001, 5}, - {0b1100000000000010, 5}, {0b1100000000000011, 2}, - {0b1100000000000100, 5}, {0b1100000000000101, 4}, - {0b1100000000000110, 4}, {0b1100000000001000, 5}, - {0b1100000000001001, 4}, {0b1100000000001010, 4}, - {0b1100000000001100, 2}, {0b1100000000001111, 3}, - {0b1100000000010000, 5}, {0b1100000000010001, 4}, - {0b1100000000010010, 4}, {0b1100000000010100, 4}, - {0b1100000000010101, 5}, {0b1100000000010110, 5}, - {0b1100000000011000, 4}, {0b1100000000011001, 5}, - {0b1100000000011010, 5}, {0b1100000000100000, 5}, - {0b1100000000100001, 4}, {0b1100000000100010, 4}, - {0b1100000000100100, 4}, {0b1100000000100101, 5}, - {0b1100000000100110, 5}, {0b1100000000101000, 4}, - {0b1100000000101001, 5}, {0b1100000000101010, 5}, - {0b1100000000110000, 2}, {0b1100000000110011, 3}, - {0b1100000000111100, 3}, {0b1100000000111111, 4}, - {0b1100000001000000, 5}, {0b1100000001000001, 4}, - {0b1100000001000010, 4}, {0b1100000001000100, 4}, - {0b1100000001000101, 5}, {0b1100000001000110, 5}, - {0b1100000001001000, 4}, {0b1100000001001001, 5}, - {0b1100000001001010, 5}, {0b1100000001010000, 4}, - {0b1100000001010001, 5}, {0b1100000001010010, 5}, - {0b1100000001010100, 5}, {0b1100000001011000, 5}, - {0b1100000001100000, 4}, {0b1100000001100001, 5}, - {0b1100000001100010, 5}, {0b1100000001100100, 5}, - {0b1100000001101000, 5}, {0b1100000010000000, 5}, - {0b1100000010000001, 4}, {0b1100000010000010, 4}, - {0b1100000010000100, 4}, {0b1100000010000101, 5}, - {0b1100000010000110, 5}, {0b1100000010001000, 4}, - {0b1100000010001001, 5}, {0b1100000010001010, 5}, - {0b1100000010010000, 4}, {0b1100000010010001, 5}, - {0b1100000010010010, 5}, {0b1100000010010100, 5}, - {0b1100000010011000, 5}, {0b1100000010100000, 4}, - {0b1100000010100001, 5}, {0b1100000010100010, 5}, - {0b1100000010100100, 5}, {0b1100000010101000, 5}, - {0b1100000011000000, 2}, {0b1100000011000011, 3}, - {0b1100000011001100, 3}, {0b1100000011001111, 4}, - {0b1100000011110000, 3}, {0b1100000011110011, 4}, - {0b1100000011111100, 4}, {0b1100000011111111, 3}, - {0b1100000100000000, 5}, {0b1100000100000001, 4}, - {0b1100000100000010, 4}, {0b1100000100000100, 4}, - {0b1100000100000101, 5}, {0b1100000100000110, 5}, - {0b1100000100001000, 4}, {0b1100000100001001, 5}, - {0b1100000100001010, 5}, {0b1100000100010000, 4}, - {0b1100000100010001, 5}, {0b1100000100010010, 5}, - {0b1100000100011100, 3}, {0b1100000100100000, 4}, - {0b1100000100100001, 5}, {0b1100000100100010, 5}, - {0b1100000100101100, 3}, {0b1100000100110100, 3}, - {0b1100000100111000, 3}, {0b1100000101000000, 4}, - {0b1100000101000011, 3}, {0b1100000101000100, 5}, - {0b1100000101001000, 5}, {0b1100000101010000, 5}, - {0b1100000101100000, 5}, {0b1100000110000000, 4}, - {0b1100000110000011, 3}, {0b1100000110000100, 5}, - {0b1100000110001000, 5}, {0b1100000110010000, 5}, - {0b1100000110100000, 5}, {0b1100000111000001, 3}, - {0b1100000111000010, 3}, {0b1100001000000000, 5}, - {0b1100001000000001, 4}, {0b1100001000000010, 4}, - {0b1100001000000100, 4}, {0b1100001000000101, 5}, - {0b1100001000000110, 5}, {0b1100001000001000, 4}, - {0b1100001000001001, 5}, {0b1100001000001010, 5}, - {0b1100001000010000, 4}, {0b1100001000010001, 5}, - {0b1100001000010010, 5}, {0b1100001000011100, 3}, - {0b1100001000100000, 4}, {0b1100001000100001, 5}, - {0b1100001000100010, 5}, {0b1100001000101100, 3}, - {0b1100001000110100, 3}, {0b1100001000111000, 3}, - {0b1100001001000000, 4}, {0b1100001001000011, 3}, - {0b1100001001000100, 5}, {0b1100001001001000, 5}, - {0b1100001001010000, 5}, {0b1100001001100000, 5}, - {0b1100001010000000, 4}, {0b1100001010000011, 3}, - {0b1100001010000100, 5}, {0b1100001010001000, 5}, - {0b1100001010010000, 5}, {0b1100001010100000, 5}, - {0b1100001011000001, 3}, {0b1100001011000010, 3}, - {0b1100001100000000, 2}, {0b1100001100000011, 3}, - {0b1100001100001100, 3}, {0b1100001100001111, 4}, - {0b1100001100010100, 3}, {0b1100001100011000, 3}, - {0b1100001100100100, 3}, {0b1100001100101000, 3}, - {0b1100001100110000, 3}, {0b1100001100110011, 4}, - {0b1100001100111100, 1}, {0b1100001100111111, 3}, - {0b1100001101000001, 3}, {0b1100001101000010, 3}, - {0b1100001101010101, 4}, {0b1100001101011010, 4}, - {0b1100001101100110, 4}, {0b1100001101101001, 4}, - {0b1100001101111101, 3}, {0b1100001101111110, 3}, - {0b1100001110000001, 3}, {0b1100001110000010, 3}, - {0b1100001110010110, 4}, {0b1100001110011001, 4}, - {0b1100001110100101, 4}, {0b1100001110101010, 4}, - {0b1100001110111101, 3}, {0b1100001110111110, 3}, - {0b1100001111000000, 3}, {0b1100001111000011, 1}, - {0b1100001111001100, 4}, {0b1100001111001111, 3}, - {0b1100001111010111, 3}, {0b1100001111011011, 3}, - {0b1100001111100111, 3}, {0b1100001111101011, 3}, - {0b1100001111110000, 4}, {0b1100001111110011, 3}, - {0b1100001111111100, 3}, {0b1100001111111111, 2}, - {0b1100010000000000, 5}, {0b1100010000000001, 4}, - {0b1100010000000010, 4}, {0b1100010000000100, 4}, - {0b1100010000000101, 5}, {0b1100010000000110, 5}, - {0b1100010000001000, 4}, {0b1100010000001001, 5}, - {0b1100010000001010, 5}, {0b1100010000010000, 4}, - {0b1100010000010011, 3}, {0b1100010000010100, 5}, - {0b1100010000011000, 5}, {0b1100010000100000, 4}, - {0b1100010000100011, 3}, {0b1100010000100100, 5}, - {0b1100010000101000, 5}, {0b1100010000110001, 3}, - {0b1100010000110010, 3}, {0b1100010001000000, 4}, - {0b1100010001000001, 5}, {0b1100010001000010, 5}, - {0b1100010001001100, 3}, {0b1100010001010000, 5}, - {0b1100010001100000, 5}, {0b1100010010000000, 4}, - {0b1100010010000001, 5}, {0b1100010010000010, 5}, - {0b1100010010001100, 3}, {0b1100010010010000, 5}, - {0b1100010010100000, 5}, {0b1100010011000100, 3}, - {0b1100010011001000, 3}, {0b1100010100000000, 4}, - {0b1100010100000001, 5}, {0b1100010100000010, 5}, - {0b1100010100000100, 5}, {0b1100010100001000, 5}, - {0b1100010100010000, 5}, {0b1100010100100000, 5}, - {0b1100010100110101, 4}, {0b1100010100111010, 4}, - {0b1100010101000000, 5}, {0b1100010101010011, 4}, - {0b1100010101011100, 4}, {0b1100010101111111, 5}, - {0b1100010110000000, 5}, {0b1100010110100011, 4}, - {0b1100010110101100, 4}, {0b1100010110111111, 5}, - {0b1100010111000101, 4}, {0b1100010111001010, 4}, - {0b1100010111011111, 5}, {0b1100010111101111, 5}, - {0b1100010111110111, 5}, {0b1100010111111011, 5}, - {0b1100010111111101, 5}, {0b1100010111111110, 5}, - {0b1100010111111111, 4}, {0b1100011000000000, 4}, - {0b1100011000000001, 5}, {0b1100011000000010, 5}, - {0b1100011000000100, 5}, {0b1100011000001000, 5}, - {0b1100011000010000, 5}, {0b1100011000100000, 5}, - {0b1100011000110110, 4}, {0b1100011000111001, 4}, - {0b1100011001000000, 5}, {0b1100011001100011, 4}, - {0b1100011001101100, 4}, {0b1100011001111111, 5}, - {0b1100011010000000, 5}, {0b1100011010010011, 4}, - {0b1100011010011100, 4}, {0b1100011010111111, 5}, - {0b1100011011000110, 4}, {0b1100011011001001, 4}, - {0b1100011011011111, 5}, {0b1100011011101111, 5}, - {0b1100011011110111, 5}, {0b1100011011111011, 5}, - {0b1100011011111101, 5}, {0b1100011011111110, 5}, - {0b1100011011111111, 4}, {0b1100011100111101, 3}, - {0b1100011100111110, 3}, {0b1100011101011111, 5}, - {0b1100011101101111, 5}, {0b1100011101110111, 5}, - {0b1100011101111011, 5}, {0b1100011101111100, 3}, - {0b1100011101111111, 4}, {0b1100011110011111, 5}, - {0b1100011110101111, 5}, {0b1100011110110111, 5}, - {0b1100011110111011, 5}, {0b1100011110111100, 3}, - {0b1100011110111111, 4}, {0b1100011111000111, 3}, - {0b1100011111001011, 3}, {0b1100011111010011, 3}, - {0b1100011111011101, 5}, {0b1100011111011110, 5}, - {0b1100011111011111, 4}, {0b1100011111100011, 3}, - {0b1100011111101101, 5}, {0b1100011111101110, 5}, - {0b1100011111101111, 4}, {0b1100011111110101, 5}, - {0b1100011111110110, 5}, {0b1100011111110111, 4}, - {0b1100011111111001, 5}, {0b1100011111111010, 5}, - {0b1100011111111011, 4}, {0b1100011111111101, 4}, - {0b1100011111111110, 4}, {0b1100011111111111, 5}, - {0b1100100000000000, 5}, {0b1100100000000001, 4}, - {0b1100100000000010, 4}, {0b1100100000000100, 4}, - {0b1100100000000101, 5}, {0b1100100000000110, 5}, - {0b1100100000001000, 4}, {0b1100100000001001, 5}, - {0b1100100000001010, 5}, {0b1100100000010000, 4}, - {0b1100100000010011, 3}, {0b1100100000010100, 5}, - {0b1100100000011000, 5}, {0b1100100000100000, 4}, - {0b1100100000100011, 3}, {0b1100100000100100, 5}, - {0b1100100000101000, 5}, {0b1100100000110001, 3}, - {0b1100100000110010, 3}, {0b1100100001000000, 4}, - {0b1100100001000001, 5}, {0b1100100001000010, 5}, - {0b1100100001001100, 3}, {0b1100100001010000, 5}, - {0b1100100001100000, 5}, {0b1100100010000000, 4}, - {0b1100100010000001, 5}, {0b1100100010000010, 5}, - {0b1100100010001100, 3}, {0b1100100010010000, 5}, - {0b1100100010100000, 5}, {0b1100100011000100, 3}, - {0b1100100011001000, 3}, {0b1100100100000000, 4}, - {0b1100100100000001, 5}, {0b1100100100000010, 5}, - {0b1100100100000100, 5}, {0b1100100100001000, 5}, - {0b1100100100010000, 5}, {0b1100100100100000, 5}, - {0b1100100100110110, 4}, {0b1100100100111001, 4}, - {0b1100100101000000, 5}, {0b1100100101100011, 4}, - {0b1100100101101100, 4}, {0b1100100101111111, 5}, - {0b1100100110000000, 5}, {0b1100100110010011, 4}, - {0b1100100110011100, 4}, {0b1100100110111111, 5}, - {0b1100100111000110, 4}, {0b1100100111001001, 4}, - {0b1100100111011111, 5}, {0b1100100111101111, 5}, - {0b1100100111110111, 5}, {0b1100100111111011, 5}, - {0b1100100111111101, 5}, {0b1100100111111110, 5}, - {0b1100100111111111, 4}, {0b1100101000000000, 4}, - {0b1100101000000001, 5}, {0b1100101000000010, 5}, - {0b1100101000000100, 5}, {0b1100101000001000, 5}, - {0b1100101000010000, 5}, {0b1100101000100000, 5}, - {0b1100101000110101, 4}, {0b1100101000111010, 4}, - {0b1100101001000000, 5}, {0b1100101001010011, 4}, - {0b1100101001011100, 4}, {0b1100101001111111, 5}, - {0b1100101010000000, 5}, {0b1100101010100011, 4}, - {0b1100101010101100, 4}, {0b1100101010111111, 5}, - {0b1100101011000101, 4}, {0b1100101011001010, 4}, - {0b1100101011011111, 5}, {0b1100101011101111, 5}, - {0b1100101011110111, 5}, {0b1100101011111011, 5}, - {0b1100101011111101, 5}, {0b1100101011111110, 5}, - {0b1100101011111111, 4}, {0b1100101100111101, 3}, - {0b1100101100111110, 3}, {0b1100101101011111, 5}, - {0b1100101101101111, 5}, {0b1100101101110111, 5}, - {0b1100101101111011, 5}, {0b1100101101111100, 3}, - {0b1100101101111111, 4}, {0b1100101110011111, 5}, - {0b1100101110101111, 5}, {0b1100101110110111, 5}, - {0b1100101110111011, 5}, {0b1100101110111100, 3}, - {0b1100101110111111, 4}, {0b1100101111000111, 3}, - {0b1100101111001011, 3}, {0b1100101111010011, 3}, - {0b1100101111011101, 5}, {0b1100101111011110, 5}, - {0b1100101111011111, 4}, {0b1100101111100011, 3}, - {0b1100101111101101, 5}, {0b1100101111101110, 5}, - {0b1100101111101111, 4}, {0b1100101111110101, 5}, - {0b1100101111110110, 5}, {0b1100101111110111, 4}, - {0b1100101111111001, 5}, {0b1100101111111010, 5}, - {0b1100101111111011, 4}, {0b1100101111111101, 4}, - {0b1100101111111110, 4}, {0b1100101111111111, 5}, - {0b1100110000000000, 2}, {0b1100110000000011, 3}, - {0b1100110000001100, 3}, {0b1100110000001111, 4}, - {0b1100110000010001, 3}, {0b1100110000010010, 3}, - {0b1100110000100001, 3}, {0b1100110000100010, 3}, - {0b1100110000110000, 3}, {0b1100110000110011, 1}, - {0b1100110000111100, 4}, {0b1100110000111111, 3}, - {0b1100110001000100, 3}, {0b1100110001001000, 3}, - {0b1100110001010101, 4}, {0b1100110001011010, 4}, - {0b1100110001100110, 4}, {0b1100110001101001, 4}, - {0b1100110001110111, 3}, {0b1100110001111011, 3}, - {0b1100110010000100, 3}, {0b1100110010001000, 3}, - {0b1100110010010110, 4}, {0b1100110010011001, 4}, - {0b1100110010100101, 4}, {0b1100110010101010, 4}, - {0b1100110010110111, 3}, {0b1100110010111011, 3}, - {0b1100110011000000, 3}, {0b1100110011000011, 4}, - {0b1100110011001100, 1}, {0b1100110011001111, 3}, - {0b1100110011011101, 3}, {0b1100110011011110, 3}, - {0b1100110011101101, 3}, {0b1100110011101110, 3}, - {0b1100110011110000, 4}, {0b1100110011110011, 3}, - {0b1100110011111100, 3}, {0b1100110011111111, 2}, - {0b1100110100110111, 3}, {0b1100110100111011, 3}, - {0b1100110101011111, 5}, {0b1100110101101111, 5}, - {0b1100110101110011, 3}, {0b1100110101111101, 5}, - {0b1100110101111110, 5}, {0b1100110101111111, 4}, - {0b1100110110011111, 5}, {0b1100110110101111, 5}, - {0b1100110110110011, 3}, {0b1100110110111101, 5}, - {0b1100110110111110, 5}, {0b1100110110111111, 4}, - {0b1100110111001101, 3}, {0b1100110111001110, 3}, - {0b1100110111010111, 5}, {0b1100110111011011, 5}, - {0b1100110111011100, 3}, {0b1100110111011111, 4}, - {0b1100110111100111, 5}, {0b1100110111101011, 5}, - {0b1100110111101100, 3}, {0b1100110111101111, 4}, - {0b1100110111110101, 5}, {0b1100110111110110, 5}, - {0b1100110111110111, 4}, {0b1100110111111001, 5}, - {0b1100110111111010, 5}, {0b1100110111111011, 4}, - {0b1100110111111101, 4}, {0b1100110111111110, 4}, - {0b1100110111111111, 5}, {0b1100111000110111, 3}, - {0b1100111000111011, 3}, {0b1100111001011111, 5}, - {0b1100111001101111, 5}, {0b1100111001110011, 3}, - {0b1100111001111101, 5}, {0b1100111001111110, 5}, - {0b1100111001111111, 4}, {0b1100111010011111, 5}, - {0b1100111010101111, 5}, {0b1100111010110011, 3}, - {0b1100111010111101, 5}, {0b1100111010111110, 5}, - {0b1100111010111111, 4}, {0b1100111011001101, 3}, - {0b1100111011001110, 3}, {0b1100111011010111, 5}, - {0b1100111011011011, 5}, {0b1100111011011100, 3}, - {0b1100111011011111, 4}, {0b1100111011100111, 5}, - {0b1100111011101011, 5}, {0b1100111011101100, 3}, - {0b1100111011101111, 4}, {0b1100111011110101, 5}, - {0b1100111011110110, 5}, {0b1100111011110111, 4}, - {0b1100111011111001, 5}, {0b1100111011111010, 5}, - {0b1100111011111011, 4}, {0b1100111011111101, 4}, - {0b1100111011111110, 4}, {0b1100111011111111, 5}, - {0b1100111100000000, 3}, {0b1100111100000011, 4}, - {0b1100111100001100, 4}, {0b1100111100001111, 3}, - {0b1100111100110000, 4}, {0b1100111100110011, 3}, - {0b1100111100111100, 3}, {0b1100111100111111, 2}, - {0b1100111101010111, 5}, {0b1100111101011011, 5}, - {0b1100111101011101, 5}, {0b1100111101011110, 5}, - {0b1100111101011111, 4}, {0b1100111101100111, 5}, - {0b1100111101101011, 5}, {0b1100111101101101, 5}, - {0b1100111101101110, 5}, {0b1100111101101111, 4}, - {0b1100111101110101, 5}, {0b1100111101110110, 5}, - {0b1100111101110111, 4}, {0b1100111101111001, 5}, - {0b1100111101111010, 5}, {0b1100111101111011, 4}, - {0b1100111101111101, 4}, {0b1100111101111110, 4}, - {0b1100111101111111, 5}, {0b1100111110010111, 5}, - {0b1100111110011011, 5}, {0b1100111110011101, 5}, - {0b1100111110011110, 5}, {0b1100111110011111, 4}, - {0b1100111110100111, 5}, {0b1100111110101011, 5}, - {0b1100111110101101, 5}, {0b1100111110101110, 5}, - {0b1100111110101111, 4}, {0b1100111110110101, 5}, - {0b1100111110110110, 5}, {0b1100111110110111, 4}, - {0b1100111110111001, 5}, {0b1100111110111010, 5}, - {0b1100111110111011, 4}, {0b1100111110111101, 4}, - {0b1100111110111110, 4}, {0b1100111110111111, 5}, - {0b1100111111000000, 4}, {0b1100111111000011, 3}, - {0b1100111111001100, 3}, {0b1100111111001111, 2}, - {0b1100111111010101, 5}, {0b1100111111010110, 5}, - {0b1100111111010111, 4}, {0b1100111111011001, 5}, - {0b1100111111011010, 5}, {0b1100111111011011, 4}, - {0b1100111111011101, 4}, {0b1100111111011110, 4}, - {0b1100111111011111, 5}, {0b1100111111100101, 5}, - {0b1100111111100110, 5}, {0b1100111111100111, 4}, - {0b1100111111101001, 5}, {0b1100111111101010, 5}, - {0b1100111111101011, 4}, {0b1100111111101101, 4}, - {0b1100111111101110, 4}, {0b1100111111101111, 5}, - {0b1100111111110000, 3}, {0b1100111111110011, 2}, - {0b1100111111110101, 4}, {0b1100111111110110, 4}, - {0b1100111111110111, 5}, {0b1100111111111001, 4}, - {0b1100111111111010, 4}, {0b1100111111111011, 5}, - {0b1100111111111100, 2}, {0b1100111111111101, 5}, - {0b1100111111111110, 5}, {0b1100111111111111, 3}, - {0b1101000000000000, 5}, {0b1101000000000001, 4}, - {0b1101000000000010, 4}, {0b1101000000000100, 4}, - {0b1101000000000111, 3}, {0b1101000000001000, 4}, - {0b1101000000001011, 3}, {0b1101000000001101, 3}, - {0b1101000000001110, 3}, {0b1101000000010000, 4}, - {0b1101000000010001, 5}, {0b1101000000010010, 5}, - {0b1101000000010100, 5}, {0b1101000000011000, 5}, - {0b1101000000100000, 4}, {0b1101000000100001, 5}, - {0b1101000000100010, 5}, {0b1101000000100100, 5}, - {0b1101000000101000, 5}, {0b1101000001000000, 4}, - {0b1101000001000001, 5}, {0b1101000001000010, 5}, - {0b1101000001000100, 5}, {0b1101000001001000, 5}, - {0b1101000001110000, 3}, {0b1101000010000000, 4}, - {0b1101000010000001, 5}, {0b1101000010000010, 5}, - {0b1101000010000100, 5}, {0b1101000010001000, 5}, - {0b1101000010110000, 3}, {0b1101000011010000, 3}, - {0b1101000011100000, 3}, {0b1101000100000000, 4}, - {0b1101000100000001, 5}, {0b1101000100000010, 5}, - {0b1101000100000100, 5}, {0b1101000100001000, 5}, - {0b1101000100010000, 5}, {0b1101000100011101, 4}, - {0b1101000100100000, 5}, {0b1101000100101110, 4}, - {0b1101000101000000, 5}, {0b1101000101000111, 4}, - {0b1101000101110100, 4}, {0b1101000101111111, 5}, - {0b1101000110000000, 5}, {0b1101000110001011, 4}, - {0b1101000110111000, 4}, {0b1101000110111111, 5}, - {0b1101000111010001, 4}, {0b1101000111011111, 5}, - {0b1101000111100010, 4}, {0b1101000111101111, 5}, - {0b1101000111110111, 5}, {0b1101000111111011, 5}, - {0b1101000111111101, 5}, {0b1101000111111110, 5}, - {0b1101000111111111, 4}, {0b1101001000000000, 4}, - {0b1101001000000001, 5}, {0b1101001000000010, 5}, - {0b1101001000000100, 5}, {0b1101001000001000, 5}, - {0b1101001000010000, 5}, {0b1101001000011110, 4}, - {0b1101001000100000, 5}, {0b1101001000101101, 4}, - {0b1101001001000000, 5}, {0b1101001001001011, 4}, - {0b1101001001111000, 4}, {0b1101001001111111, 5}, - {0b1101001010000000, 5}, {0b1101001010000111, 4}, - {0b1101001010110100, 4}, {0b1101001010111111, 5}, - {0b1101001011010010, 4}, {0b1101001011011111, 5}, - {0b1101001011100001, 4}, {0b1101001011101111, 5}, - {0b1101001011110111, 5}, {0b1101001011111011, 5}, - {0b1101001011111101, 5}, {0b1101001011111110, 5}, - {0b1101001011111111, 4}, {0b1101001100111101, 3}, - {0b1101001100111110, 3}, {0b1101001101011111, 5}, - {0b1101001101101111, 5}, {0b1101001101110111, 5}, - {0b1101001101111011, 5}, {0b1101001101111100, 3}, - {0b1101001101111111, 4}, {0b1101001110011111, 5}, - {0b1101001110101111, 5}, {0b1101001110110111, 5}, - {0b1101001110111011, 5}, {0b1101001110111100, 3}, - {0b1101001110111111, 4}, {0b1101001111000111, 3}, - {0b1101001111001011, 3}, {0b1101001111010011, 3}, - {0b1101001111011101, 5}, {0b1101001111011110, 5}, - {0b1101001111011111, 4}, {0b1101001111100011, 3}, - {0b1101001111101101, 5}, {0b1101001111101110, 5}, - {0b1101001111101111, 4}, {0b1101001111110101, 5}, - {0b1101001111110110, 5}, {0b1101001111110111, 4}, - {0b1101001111111001, 5}, {0b1101001111111010, 5}, - {0b1101001111111011, 4}, {0b1101001111111101, 4}, - {0b1101001111111110, 4}, {0b1101001111111111, 5}, - {0b1101010000000000, 4}, {0b1101010000000001, 5}, - {0b1101010000000010, 5}, {0b1101010000000100, 5}, - {0b1101010000001000, 5}, {0b1101010000010000, 5}, - {0b1101010000010111, 4}, {0b1101010000100000, 5}, - {0b1101010000101011, 4}, {0b1101010001000000, 5}, - {0b1101010001001101, 4}, {0b1101010001110001, 4}, - {0b1101010001111111, 5}, {0b1101010010000000, 5}, - {0b1101010010001110, 4}, {0b1101010010110010, 4}, - {0b1101010010111111, 5}, {0b1101010011010100, 4}, - {0b1101010011011111, 5}, {0b1101010011101000, 4}, - {0b1101010011101111, 5}, {0b1101010011110111, 5}, - {0b1101010011111011, 5}, {0b1101010011111101, 5}, - {0b1101010011111110, 5}, {0b1101010011111111, 4}, - {0b1101010100111111, 5}, {0b1101010101010111, 3}, - {0b1101010101011101, 3}, {0b1101010101101111, 5}, - {0b1101010101110101, 3}, {0b1101010101111011, 5}, - {0b1101010101111110, 5}, {0b1101010101111111, 4}, - {0b1101010110011111, 5}, {0b1101010110101011, 3}, - {0b1101010110101110, 3}, {0b1101010110110111, 5}, - {0b1101010110111010, 3}, {0b1101010110111101, 5}, - {0b1101010110111111, 4}, {0b1101010111001111, 5}, - {0b1101010111010101, 3}, {0b1101010111011011, 5}, - {0b1101010111011110, 5}, {0b1101010111011111, 4}, - {0b1101010111100111, 5}, {0b1101010111101010, 3}, - {0b1101010111101101, 5}, {0b1101010111101111, 4}, - {0b1101010111110011, 5}, {0b1101010111110110, 5}, - {0b1101010111110111, 4}, {0b1101010111111001, 5}, - {0b1101010111111011, 4}, {0b1101010111111100, 5}, - {0b1101010111111101, 4}, {0b1101010111111110, 4}, - {0b1101010111111111, 5}, {0b1101011000111111, 5}, - {0b1101011001011111, 5}, {0b1101011001101011, 3}, - {0b1101011001101101, 3}, {0b1101011001110111, 5}, - {0b1101011001111001, 3}, {0b1101011001111110, 5}, - {0b1101011001111111, 4}, {0b1101011010010111, 3}, - {0b1101011010011110, 3}, {0b1101011010101111, 5}, - {0b1101011010110110, 3}, {0b1101011010111011, 5}, - {0b1101011010111101, 5}, {0b1101011010111111, 4}, - {0b1101011011001111, 5}, {0b1101011011010110, 3}, - {0b1101011011011011, 5}, {0b1101011011011101, 5}, - {0b1101011011011111, 4}, {0b1101011011100111, 5}, - {0b1101011011101001, 3}, {0b1101011011101110, 5}, - {0b1101011011101111, 4}, {0b1101011011110011, 5}, - {0b1101011011110101, 5}, {0b1101011011110111, 4}, - {0b1101011011111010, 5}, {0b1101011011111011, 4}, - {0b1101011011111100, 5}, {0b1101011011111101, 4}, - {0b1101011011111110, 4}, {0b1101011011111111, 5}, - {0b1101011100000000, 3}, {0b1101011100010100, 4}, - {0b1101011100011111, 5}, {0b1101011100101000, 4}, - {0b1101011100101111, 5}, {0b1101011100110111, 5}, - {0b1101011100111011, 5}, {0b1101011100111100, 3}, - {0b1101011100111111, 4}, {0b1101011101000001, 4}, - {0b1101011101001111, 5}, {0b1101011101010101, 3}, - {0b1101011101011011, 5}, {0b1101011101011110, 5}, - {0b1101011101011111, 4}, {0b1101011101100111, 5}, - {0b1101011101101001, 3}, {0b1101011101101110, 5}, - {0b1101011101101111, 4}, {0b1101011101110011, 5}, - {0b1101011101110110, 5}, {0b1101011101110111, 4}, - {0b1101011101111010, 5}, {0b1101011101111011, 4}, - {0b1101011101111101, 2}, {0b1101011101111110, 4}, - {0b1101011101111111, 5}, {0b1101011110000010, 4}, - {0b1101011110001111, 5}, {0b1101011110010110, 3}, - {0b1101011110011011, 5}, {0b1101011110011101, 5}, - {0b1101011110011111, 4}, {0b1101011110100111, 5}, - {0b1101011110101010, 3}, {0b1101011110101101, 5}, - {0b1101011110101111, 4}, {0b1101011110110011, 5}, - {0b1101011110110101, 5}, {0b1101011110110111, 4}, - {0b1101011110111001, 5}, {0b1101011110111011, 4}, - {0b1101011110111101, 4}, {0b1101011110111110, 2}, - {0b1101011110111111, 5}, {0b1101011111000011, 3}, - {0b1101011111001101, 5}, {0b1101011111001110, 5}, - {0b1101011111001111, 4}, {0b1101011111010111, 2}, - {0b1101011111011001, 5}, {0b1101011111011010, 5}, - {0b1101011111011011, 4}, {0b1101011111011100, 5}, - {0b1101011111011101, 4}, {0b1101011111011110, 4}, - {0b1101011111011111, 5}, {0b1101011111100101, 5}, - {0b1101011111100110, 5}, {0b1101011111100111, 4}, - {0b1101011111101011, 2}, {0b1101011111101100, 5}, - {0b1101011111101101, 4}, {0b1101011111101110, 4}, - {0b1101011111101111, 5}, {0b1101011111110001, 5}, - {0b1101011111110010, 5}, {0b1101011111110011, 4}, - {0b1101011111110100, 5}, {0b1101011111110101, 4}, - {0b1101011111110110, 4}, {0b1101011111110111, 5}, - {0b1101011111111000, 5}, {0b1101011111111001, 4}, - {0b1101011111111010, 4}, {0b1101011111111011, 5}, - {0b1101011111111100, 4}, {0b1101011111111101, 5}, - {0b1101011111111110, 5}, {0b1101011111111111, 3}, - {0b1101100000000000, 4}, {0b1101100000000001, 5}, - {0b1101100000000010, 5}, {0b1101100000000100, 5}, - {0b1101100000001000, 5}, {0b1101100000010000, 5}, - {0b1101100000011011, 4}, {0b1101100000100000, 5}, - {0b1101100000100111, 4}, {0b1101100001000000, 5}, - {0b1101100001001110, 4}, {0b1101100001110010, 4}, - {0b1101100001111111, 5}, {0b1101100010000000, 5}, - {0b1101100010001101, 4}, {0b1101100010110001, 4}, - {0b1101100010111111, 5}, {0b1101100011011000, 4}, - {0b1101100011011111, 5}, {0b1101100011100100, 4}, - {0b1101100011101111, 5}, {0b1101100011110111, 5}, - {0b1101100011111011, 5}, {0b1101100011111101, 5}, - {0b1101100011111110, 5}, {0b1101100011111111, 4}, - {0b1101100100111111, 5}, {0b1101100101011111, 5}, - {0b1101100101100111, 3}, {0b1101100101101110, 3}, - {0b1101100101110110, 3}, {0b1101100101111011, 5}, - {0b1101100101111101, 5}, {0b1101100101111111, 4}, - {0b1101100110011011, 3}, {0b1101100110011101, 3}, - {0b1101100110101111, 5}, {0b1101100110110111, 5}, - {0b1101100110111001, 3}, {0b1101100110111110, 5}, - {0b1101100110111111, 4}, {0b1101100111001111, 5}, - {0b1101100111010111, 5}, {0b1101100111011001, 3}, - {0b1101100111011110, 5}, {0b1101100111011111, 4}, - {0b1101100111100110, 3}, {0b1101100111101011, 5}, - {0b1101100111101101, 5}, {0b1101100111101111, 4}, - {0b1101100111110011, 5}, {0b1101100111110101, 5}, - {0b1101100111110111, 4}, {0b1101100111111010, 5}, - {0b1101100111111011, 4}, {0b1101100111111100, 5}, - {0b1101100111111101, 4}, {0b1101100111111110, 4}, - {0b1101100111111111, 5}, {0b1101101000111111, 5}, - {0b1101101001011011, 3}, {0b1101101001011110, 3}, - {0b1101101001101111, 5}, {0b1101101001110111, 5}, - {0b1101101001111010, 3}, {0b1101101001111101, 5}, - {0b1101101001111111, 4}, {0b1101101010011111, 5}, - {0b1101101010100111, 3}, {0b1101101010101101, 3}, - {0b1101101010110101, 3}, {0b1101101010111011, 5}, - {0b1101101010111110, 5}, {0b1101101010111111, 4}, - {0b1101101011001111, 5}, {0b1101101011010111, 5}, - {0b1101101011011010, 3}, {0b1101101011011101, 5}, - {0b1101101011011111, 4}, {0b1101101011100101, 3}, - {0b1101101011101011, 5}, {0b1101101011101110, 5}, - {0b1101101011101111, 4}, {0b1101101011110011, 5}, - {0b1101101011110110, 5}, {0b1101101011110111, 4}, - {0b1101101011111001, 5}, {0b1101101011111011, 4}, - {0b1101101011111100, 5}, {0b1101101011111101, 4}, - {0b1101101011111110, 4}, {0b1101101011111111, 5}, - {0b1101101100000000, 3}, {0b1101101100011000, 4}, - {0b1101101100011111, 5}, {0b1101101100100100, 4}, - {0b1101101100101111, 5}, {0b1101101100110111, 5}, - {0b1101101100111011, 5}, {0b1101101100111100, 3}, - {0b1101101100111111, 4}, {0b1101101101000010, 4}, - {0b1101101101001111, 5}, {0b1101101101010111, 5}, - {0b1101101101011010, 3}, {0b1101101101011101, 5}, - {0b1101101101011111, 4}, {0b1101101101100110, 3}, - {0b1101101101101011, 5}, {0b1101101101101101, 5}, - {0b1101101101101111, 4}, {0b1101101101110011, 5}, - {0b1101101101110101, 5}, {0b1101101101110111, 4}, - {0b1101101101111001, 5}, {0b1101101101111011, 4}, - {0b1101101101111101, 4}, {0b1101101101111110, 2}, - {0b1101101101111111, 5}, {0b1101101110000001, 4}, - {0b1101101110001111, 5}, {0b1101101110010111, 5}, - {0b1101101110011001, 3}, {0b1101101110011110, 5}, - {0b1101101110011111, 4}, {0b1101101110100101, 3}, - {0b1101101110101011, 5}, {0b1101101110101110, 5}, - {0b1101101110101111, 4}, {0b1101101110110011, 5}, - {0b1101101110110110, 5}, {0b1101101110110111, 4}, - {0b1101101110111010, 5}, {0b1101101110111011, 4}, - {0b1101101110111101, 2}, {0b1101101110111110, 4}, - {0b1101101110111111, 5}, {0b1101101111000011, 3}, - {0b1101101111001101, 5}, {0b1101101111001110, 5}, - {0b1101101111001111, 4}, {0b1101101111010101, 5}, - {0b1101101111010110, 5}, {0b1101101111010111, 4}, - {0b1101101111011011, 2}, {0b1101101111011100, 5}, - {0b1101101111011101, 4}, {0b1101101111011110, 4}, - {0b1101101111011111, 5}, {0b1101101111100111, 2}, - {0b1101101111101001, 5}, {0b1101101111101010, 5}, - {0b1101101111101011, 4}, {0b1101101111101100, 5}, - {0b1101101111101101, 4}, {0b1101101111101110, 4}, - {0b1101101111101111, 5}, {0b1101101111110001, 5}, - {0b1101101111110010, 5}, {0b1101101111110011, 4}, - {0b1101101111110100, 5}, {0b1101101111110101, 4}, - {0b1101101111110110, 4}, {0b1101101111110111, 5}, - {0b1101101111111000, 5}, {0b1101101111111001, 4}, - {0b1101101111111010, 4}, {0b1101101111111011, 5}, - {0b1101101111111100, 4}, {0b1101101111111101, 5}, - {0b1101101111111110, 5}, {0b1101101111111111, 3}, - {0b1101110000110111, 3}, {0b1101110000111011, 3}, - {0b1101110001011111, 5}, {0b1101110001101111, 5}, - {0b1101110001110011, 3}, {0b1101110001111101, 5}, - {0b1101110001111110, 5}, {0b1101110001111111, 4}, - {0b1101110010011111, 5}, {0b1101110010101111, 5}, - {0b1101110010110011, 3}, {0b1101110010111101, 5}, - {0b1101110010111110, 5}, {0b1101110010111111, 4}, - {0b1101110011001101, 3}, {0b1101110011001110, 3}, - {0b1101110011010111, 5}, {0b1101110011011011, 5}, - {0b1101110011011100, 3}, {0b1101110011011111, 4}, - {0b1101110011100111, 5}, {0b1101110011101011, 5}, - {0b1101110011101100, 3}, {0b1101110011101111, 4}, - {0b1101110011110101, 5}, {0b1101110011110110, 5}, - {0b1101110011110111, 4}, {0b1101110011111001, 5}, - {0b1101110011111010, 5}, {0b1101110011111011, 4}, - {0b1101110011111101, 4}, {0b1101110011111110, 4}, - {0b1101110011111111, 5}, {0b1101110100000000, 3}, - {0b1101110100010001, 4}, {0b1101110100011111, 5}, - {0b1101110100100010, 4}, {0b1101110100101111, 5}, - {0b1101110100110011, 3}, {0b1101110100111101, 5}, - {0b1101110100111110, 5}, {0b1101110100111111, 4}, - {0b1101110101000100, 4}, {0b1101110101001111, 5}, - {0b1101110101010101, 3}, {0b1101110101011011, 5}, - {0b1101110101011110, 5}, {0b1101110101011111, 4}, - {0b1101110101100110, 3}, {0b1101110101101011, 5}, - {0b1101110101101101, 5}, {0b1101110101101111, 4}, - {0b1101110101110111, 2}, {0b1101110101111001, 5}, - {0b1101110101111010, 5}, {0b1101110101111011, 4}, - {0b1101110101111100, 5}, {0b1101110101111101, 4}, - {0b1101110101111110, 4}, {0b1101110101111111, 5}, - {0b1101110110001000, 4}, {0b1101110110001111, 5}, - {0b1101110110010111, 5}, {0b1101110110011001, 3}, - {0b1101110110011110, 5}, {0b1101110110011111, 4}, - {0b1101110110100111, 5}, {0b1101110110101010, 3}, - {0b1101110110101101, 5}, {0b1101110110101111, 4}, - {0b1101110110110101, 5}, {0b1101110110110110, 5}, - {0b1101110110110111, 4}, {0b1101110110111011, 2}, - {0b1101110110111100, 5}, {0b1101110110111101, 4}, - {0b1101110110111110, 4}, {0b1101110110111111, 5}, - {0b1101110111000111, 5}, {0b1101110111001011, 5}, - {0b1101110111001100, 3}, {0b1101110111001111, 4}, - {0b1101110111010011, 5}, {0b1101110111010110, 5}, - {0b1101110111010111, 4}, {0b1101110111011010, 5}, - {0b1101110111011011, 4}, {0b1101110111011101, 2}, - {0b1101110111011110, 4}, {0b1101110111011111, 5}, - {0b1101110111100011, 5}, {0b1101110111100101, 5}, - {0b1101110111100111, 4}, {0b1101110111101001, 5}, - {0b1101110111101011, 4}, {0b1101110111101101, 4}, - {0b1101110111101110, 2}, {0b1101110111101111, 5}, - {0b1101110111110001, 5}, {0b1101110111110010, 5}, - {0b1101110111110011, 4}, {0b1101110111110100, 5}, - {0b1101110111110101, 4}, {0b1101110111110110, 4}, - {0b1101110111110111, 5}, {0b1101110111111000, 5}, - {0b1101110111111001, 4}, {0b1101110111111010, 4}, - {0b1101110111111011, 5}, {0b1101110111111100, 4}, - {0b1101110111111101, 5}, {0b1101110111111110, 5}, - {0b1101110111111111, 3}, {0b1101111000000000, 3}, - {0b1101111000010010, 4}, {0b1101111000011111, 5}, - {0b1101111000100001, 4}, {0b1101111000101111, 5}, - {0b1101111000110011, 3}, {0b1101111000111101, 5}, - {0b1101111000111110, 5}, {0b1101111000111111, 4}, - {0b1101111001001000, 4}, {0b1101111001001111, 5}, - {0b1101111001010111, 5}, {0b1101111001011010, 3}, - {0b1101111001011101, 5}, {0b1101111001011111, 4}, - {0b1101111001100111, 5}, {0b1101111001101001, 3}, - {0b1101111001101110, 5}, {0b1101111001101111, 4}, - {0b1101111001110101, 5}, {0b1101111001110110, 5}, - {0b1101111001110111, 4}, {0b1101111001111011, 2}, - {0b1101111001111100, 5}, {0b1101111001111101, 4}, - {0b1101111001111110, 4}, {0b1101111001111111, 5}, - {0b1101111010000100, 4}, {0b1101111010001111, 5}, - {0b1101111010010110, 3}, {0b1101111010011011, 5}, - {0b1101111010011101, 5}, {0b1101111010011111, 4}, - {0b1101111010100101, 3}, {0b1101111010101011, 5}, - {0b1101111010101110, 5}, {0b1101111010101111, 4}, - {0b1101111010110111, 2}, {0b1101111010111001, 5}, - {0b1101111010111010, 5}, {0b1101111010111011, 4}, - {0b1101111010111100, 5}, {0b1101111010111101, 4}, - {0b1101111010111110, 4}, {0b1101111010111111, 5}, - {0b1101111011000111, 5}, {0b1101111011001011, 5}, - {0b1101111011001100, 3}, {0b1101111011001111, 4}, - {0b1101111011010011, 5}, {0b1101111011010101, 5}, - {0b1101111011010111, 4}, {0b1101111011011001, 5}, - {0b1101111011011011, 4}, {0b1101111011011101, 4}, - {0b1101111011011110, 2}, {0b1101111011011111, 5}, - {0b1101111011100011, 5}, {0b1101111011100110, 5}, - {0b1101111011100111, 4}, {0b1101111011101010, 5}, - {0b1101111011101011, 4}, {0b1101111011101101, 2}, - {0b1101111011101110, 4}, {0b1101111011101111, 5}, - {0b1101111011110001, 5}, {0b1101111011110010, 5}, - {0b1101111011110011, 4}, {0b1101111011110100, 5}, - {0b1101111011110101, 4}, {0b1101111011110110, 4}, - {0b1101111011110111, 5}, {0b1101111011111000, 5}, - {0b1101111011111001, 4}, {0b1101111011111010, 4}, - {0b1101111011111011, 5}, {0b1101111011111100, 4}, - {0b1101111011111101, 5}, {0b1101111011111110, 5}, - {0b1101111011111111, 3}, {0b1101111100010111, 5}, - {0b1101111100011011, 5}, {0b1101111100011101, 5}, - {0b1101111100011110, 5}, {0b1101111100011111, 4}, - {0b1101111100100111, 5}, {0b1101111100101011, 5}, - {0b1101111100101101, 5}, {0b1101111100101110, 5}, - {0b1101111100101111, 4}, {0b1101111100110101, 5}, - {0b1101111100110110, 5}, {0b1101111100110111, 4}, - {0b1101111100111001, 5}, {0b1101111100111010, 5}, - {0b1101111100111011, 4}, {0b1101111100111101, 4}, - {0b1101111100111110, 4}, {0b1101111100111111, 5}, - {0b1101111101000111, 5}, {0b1101111101001011, 5}, - {0b1101111101001101, 5}, {0b1101111101001110, 5}, - {0b1101111101001111, 4}, {0b1101111101010011, 5}, - {0b1101111101010110, 5}, {0b1101111101010111, 4}, - {0b1101111101011001, 5}, {0b1101111101011011, 4}, - {0b1101111101011100, 5}, {0b1101111101011101, 4}, - {0b1101111101011110, 4}, {0b1101111101011111, 5}, - {0b1101111101100011, 5}, {0b1101111101100101, 5}, - {0b1101111101100111, 4}, {0b1101111101101010, 5}, - {0b1101111101101011, 4}, {0b1101111101101100, 5}, - {0b1101111101101101, 4}, {0b1101111101101110, 4}, - {0b1101111101101111, 5}, {0b1101111101110001, 5}, - {0b1101111101110010, 5}, {0b1101111101110011, 4}, - {0b1101111101110100, 5}, {0b1101111101110101, 4}, - {0b1101111101110110, 4}, {0b1101111101110111, 5}, - {0b1101111101111000, 5}, {0b1101111101111001, 4}, - {0b1101111101111010, 4}, {0b1101111101111011, 5}, - {0b1101111101111100, 4}, {0b1101111101111101, 5}, - {0b1101111101111110, 5}, {0b1101111101111111, 3}, - {0b1101111110000111, 5}, {0b1101111110001011, 5}, - {0b1101111110001101, 5}, {0b1101111110001110, 5}, - {0b1101111110001111, 4}, {0b1101111110010011, 5}, - {0b1101111110010101, 5}, {0b1101111110010111, 4}, - {0b1101111110011010, 5}, {0b1101111110011011, 4}, - {0b1101111110011100, 5}, {0b1101111110011101, 4}, - {0b1101111110011110, 4}, {0b1101111110011111, 5}, - {0b1101111110100011, 5}, {0b1101111110100110, 5}, - {0b1101111110100111, 4}, {0b1101111110101001, 5}, - {0b1101111110101011, 4}, {0b1101111110101100, 5}, - {0b1101111110101101, 4}, {0b1101111110101110, 4}, - {0b1101111110101111, 5}, {0b1101111110110001, 5}, - {0b1101111110110010, 5}, {0b1101111110110011, 4}, - {0b1101111110110100, 5}, {0b1101111110110101, 4}, - {0b1101111110110110, 4}, {0b1101111110110111, 5}, - {0b1101111110111000, 5}, {0b1101111110111001, 4}, - {0b1101111110111010, 4}, {0b1101111110111011, 5}, - {0b1101111110111100, 4}, {0b1101111110111101, 5}, - {0b1101111110111110, 5}, {0b1101111110111111, 3}, - {0b1101111111000101, 5}, {0b1101111111000110, 5}, - {0b1101111111000111, 4}, {0b1101111111001001, 5}, - {0b1101111111001010, 5}, {0b1101111111001011, 4}, - {0b1101111111001101, 4}, {0b1101111111001110, 4}, - {0b1101111111001111, 5}, {0b1101111111010001, 5}, - {0b1101111111010010, 5}, {0b1101111111010011, 4}, - {0b1101111111010100, 5}, {0b1101111111010101, 4}, - {0b1101111111010110, 4}, {0b1101111111010111, 5}, - {0b1101111111011000, 5}, {0b1101111111011001, 4}, - {0b1101111111011010, 4}, {0b1101111111011011, 5}, - {0b1101111111011100, 4}, {0b1101111111011101, 5}, - {0b1101111111011110, 5}, {0b1101111111011111, 3}, - {0b1101111111100001, 5}, {0b1101111111100010, 5}, - {0b1101111111100011, 4}, {0b1101111111100100, 5}, - {0b1101111111100101, 4}, {0b1101111111100110, 4}, - {0b1101111111100111, 5}, {0b1101111111101000, 5}, - {0b1101111111101001, 4}, {0b1101111111101010, 4}, - {0b1101111111101011, 5}, {0b1101111111101100, 4}, - {0b1101111111101101, 5}, {0b1101111111101110, 5}, - {0b1101111111101111, 3}, {0b1101111111110001, 4}, - {0b1101111111110010, 4}, {0b1101111111110011, 5}, - {0b1101111111110100, 4}, {0b1101111111110101, 5}, - {0b1101111111110110, 5}, {0b1101111111110111, 3}, - {0b1101111111111000, 4}, {0b1101111111111001, 5}, - {0b1101111111111010, 5}, {0b1101111111111011, 3}, - {0b1101111111111100, 5}, {0b1101111111111101, 3}, - {0b1101111111111110, 3}, {0b1101111111111111, 4}, - {0b1110000000000000, 5}, {0b1110000000000001, 4}, - {0b1110000000000010, 4}, {0b1110000000000100, 4}, - {0b1110000000000111, 3}, {0b1110000000001000, 4}, - {0b1110000000001011, 3}, {0b1110000000001101, 3}, - {0b1110000000001110, 3}, {0b1110000000010000, 4}, - {0b1110000000010001, 5}, {0b1110000000010010, 5}, - {0b1110000000010100, 5}, {0b1110000000011000, 5}, - {0b1110000000100000, 4}, {0b1110000000100001, 5}, - {0b1110000000100010, 5}, {0b1110000000100100, 5}, - {0b1110000000101000, 5}, {0b1110000001000000, 4}, - {0b1110000001000001, 5}, {0b1110000001000010, 5}, - {0b1110000001000100, 5}, {0b1110000001001000, 5}, - {0b1110000001110000, 3}, {0b1110000010000000, 4}, - {0b1110000010000001, 5}, {0b1110000010000010, 5}, - {0b1110000010000100, 5}, {0b1110000010001000, 5}, - {0b1110000010110000, 3}, {0b1110000011010000, 3}, - {0b1110000011100000, 3}, {0b1110000100000000, 4}, - {0b1110000100000001, 5}, {0b1110000100000010, 5}, - {0b1110000100000100, 5}, {0b1110000100001000, 5}, - {0b1110000100010000, 5}, {0b1110000100011110, 4}, - {0b1110000100100000, 5}, {0b1110000100101101, 4}, - {0b1110000101000000, 5}, {0b1110000101001011, 4}, - {0b1110000101111000, 4}, {0b1110000101111111, 5}, - {0b1110000110000000, 5}, {0b1110000110000111, 4}, - {0b1110000110110100, 4}, {0b1110000110111111, 5}, - {0b1110000111010010, 4}, {0b1110000111011111, 5}, - {0b1110000111100001, 4}, {0b1110000111101111, 5}, - {0b1110000111110111, 5}, {0b1110000111111011, 5}, - {0b1110000111111101, 5}, {0b1110000111111110, 5}, - {0b1110000111111111, 4}, {0b1110001000000000, 4}, - {0b1110001000000001, 5}, {0b1110001000000010, 5}, - {0b1110001000000100, 5}, {0b1110001000001000, 5}, - {0b1110001000010000, 5}, {0b1110001000011101, 4}, - {0b1110001000100000, 5}, {0b1110001000101110, 4}, - {0b1110001001000000, 5}, {0b1110001001000111, 4}, - {0b1110001001110100, 4}, {0b1110001001111111, 5}, - {0b1110001010000000, 5}, {0b1110001010001011, 4}, - {0b1110001010111000, 4}, {0b1110001010111111, 5}, - {0b1110001011010001, 4}, {0b1110001011011111, 5}, - {0b1110001011100010, 4}, {0b1110001011101111, 5}, - {0b1110001011110111, 5}, {0b1110001011111011, 5}, - {0b1110001011111101, 5}, {0b1110001011111110, 5}, - {0b1110001011111111, 4}, {0b1110001100111101, 3}, - {0b1110001100111110, 3}, {0b1110001101011111, 5}, - {0b1110001101101111, 5}, {0b1110001101110111, 5}, - {0b1110001101111011, 5}, {0b1110001101111100, 3}, - {0b1110001101111111, 4}, {0b1110001110011111, 5}, - {0b1110001110101111, 5}, {0b1110001110110111, 5}, - {0b1110001110111011, 5}, {0b1110001110111100, 3}, - {0b1110001110111111, 4}, {0b1110001111000111, 3}, - {0b1110001111001011, 3}, {0b1110001111010011, 3}, - {0b1110001111011101, 5}, {0b1110001111011110, 5}, - {0b1110001111011111, 4}, {0b1110001111100011, 3}, - {0b1110001111101101, 5}, {0b1110001111101110, 5}, - {0b1110001111101111, 4}, {0b1110001111110101, 5}, - {0b1110001111110110, 5}, {0b1110001111110111, 4}, - {0b1110001111111001, 5}, {0b1110001111111010, 5}, - {0b1110001111111011, 4}, {0b1110001111111101, 4}, - {0b1110001111111110, 4}, {0b1110001111111111, 5}, - {0b1110010000000000, 4}, {0b1110010000000001, 5}, - {0b1110010000000010, 5}, {0b1110010000000100, 5}, - {0b1110010000001000, 5}, {0b1110010000010000, 5}, - {0b1110010000011011, 4}, {0b1110010000100000, 5}, - {0b1110010000100111, 4}, {0b1110010001000000, 5}, - {0b1110010001001110, 4}, {0b1110010001110010, 4}, - {0b1110010001111111, 5}, {0b1110010010000000, 5}, - {0b1110010010001101, 4}, {0b1110010010110001, 4}, - {0b1110010010111111, 5}, {0b1110010011011000, 4}, - {0b1110010011011111, 5}, {0b1110010011100100, 4}, - {0b1110010011101111, 5}, {0b1110010011110111, 5}, - {0b1110010011111011, 5}, {0b1110010011111101, 5}, - {0b1110010011111110, 5}, {0b1110010011111111, 4}, - {0b1110010100111111, 5}, {0b1110010101011011, 3}, - {0b1110010101011110, 3}, {0b1110010101101111, 5}, - {0b1110010101110111, 5}, {0b1110010101111010, 3}, - {0b1110010101111101, 5}, {0b1110010101111111, 4}, - {0b1110010110011111, 5}, {0b1110010110100111, 3}, - {0b1110010110101101, 3}, {0b1110010110110101, 3}, - {0b1110010110111011, 5}, {0b1110010110111110, 5}, - {0b1110010110111111, 4}, {0b1110010111001111, 5}, - {0b1110010111010111, 5}, {0b1110010111011010, 3}, - {0b1110010111011101, 5}, {0b1110010111011111, 4}, - {0b1110010111100101, 3}, {0b1110010111101011, 5}, - {0b1110010111101110, 5}, {0b1110010111101111, 4}, - {0b1110010111110011, 5}, {0b1110010111110110, 5}, - {0b1110010111110111, 4}, {0b1110010111111001, 5}, - {0b1110010111111011, 4}, {0b1110010111111100, 5}, - {0b1110010111111101, 4}, {0b1110010111111110, 4}, - {0b1110010111111111, 5}, {0b1110011000111111, 5}, - {0b1110011001011111, 5}, {0b1110011001100111, 3}, - {0b1110011001101110, 3}, {0b1110011001110110, 3}, - {0b1110011001111011, 5}, {0b1110011001111101, 5}, - {0b1110011001111111, 4}, {0b1110011010011011, 3}, - {0b1110011010011101, 3}, {0b1110011010101111, 5}, - {0b1110011010110111, 5}, {0b1110011010111001, 3}, - {0b1110011010111110, 5}, {0b1110011010111111, 4}, - {0b1110011011001111, 5}, {0b1110011011010111, 5}, - {0b1110011011011001, 3}, {0b1110011011011110, 5}, - {0b1110011011011111, 4}, {0b1110011011100110, 3}, - {0b1110011011101011, 5}, {0b1110011011101101, 5}, - {0b1110011011101111, 4}, {0b1110011011110011, 5}, - {0b1110011011110101, 5}, {0b1110011011110111, 4}, - {0b1110011011111010, 5}, {0b1110011011111011, 4}, - {0b1110011011111100, 5}, {0b1110011011111101, 4}, - {0b1110011011111110, 4}, {0b1110011011111111, 5}, - {0b1110011100000000, 3}, {0b1110011100011000, 4}, - {0b1110011100011111, 5}, {0b1110011100100100, 4}, - {0b1110011100101111, 5}, {0b1110011100110111, 5}, - {0b1110011100111011, 5}, {0b1110011100111100, 3}, - {0b1110011100111111, 4}, {0b1110011101000010, 4}, - {0b1110011101001111, 5}, {0b1110011101010111, 5}, - {0b1110011101011010, 3}, {0b1110011101011101, 5}, - {0b1110011101011111, 4}, {0b1110011101100110, 3}, - {0b1110011101101011, 5}, {0b1110011101101101, 5}, - {0b1110011101101111, 4}, {0b1110011101110011, 5}, - {0b1110011101110101, 5}, {0b1110011101110111, 4}, - {0b1110011101111001, 5}, {0b1110011101111011, 4}, - {0b1110011101111101, 4}, {0b1110011101111110, 2}, - {0b1110011101111111, 5}, {0b1110011110000001, 4}, - {0b1110011110001111, 5}, {0b1110011110010111, 5}, - {0b1110011110011001, 3}, {0b1110011110011110, 5}, - {0b1110011110011111, 4}, {0b1110011110100101, 3}, - {0b1110011110101011, 5}, {0b1110011110101110, 5}, - {0b1110011110101111, 4}, {0b1110011110110011, 5}, - {0b1110011110110110, 5}, {0b1110011110110111, 4}, - {0b1110011110111010, 5}, {0b1110011110111011, 4}, - {0b1110011110111101, 2}, {0b1110011110111110, 4}, - {0b1110011110111111, 5}, {0b1110011111000011, 3}, - {0b1110011111001101, 5}, {0b1110011111001110, 5}, - {0b1110011111001111, 4}, {0b1110011111010101, 5}, - {0b1110011111010110, 5}, {0b1110011111010111, 4}, - {0b1110011111011011, 2}, {0b1110011111011100, 5}, - {0b1110011111011101, 4}, {0b1110011111011110, 4}, - {0b1110011111011111, 5}, {0b1110011111100111, 2}, - {0b1110011111101001, 5}, {0b1110011111101010, 5}, - {0b1110011111101011, 4}, {0b1110011111101100, 5}, - {0b1110011111101101, 4}, {0b1110011111101110, 4}, - {0b1110011111101111, 5}, {0b1110011111110001, 5}, - {0b1110011111110010, 5}, {0b1110011111110011, 4}, - {0b1110011111110100, 5}, {0b1110011111110101, 4}, - {0b1110011111110110, 4}, {0b1110011111110111, 5}, - {0b1110011111111000, 5}, {0b1110011111111001, 4}, - {0b1110011111111010, 4}, {0b1110011111111011, 5}, - {0b1110011111111100, 4}, {0b1110011111111101, 5}, - {0b1110011111111110, 5}, {0b1110011111111111, 3}, - {0b1110100000000000, 4}, {0b1110100000000001, 5}, - {0b1110100000000010, 5}, {0b1110100000000100, 5}, - {0b1110100000001000, 5}, {0b1110100000010000, 5}, - {0b1110100000010111, 4}, {0b1110100000100000, 5}, - {0b1110100000101011, 4}, {0b1110100001000000, 5}, - {0b1110100001001101, 4}, {0b1110100001110001, 4}, - {0b1110100001111111, 5}, {0b1110100010000000, 5}, - {0b1110100010001110, 4}, {0b1110100010110010, 4}, - {0b1110100010111111, 5}, {0b1110100011010100, 4}, - {0b1110100011011111, 5}, {0b1110100011101000, 4}, - {0b1110100011101111, 5}, {0b1110100011110111, 5}, - {0b1110100011111011, 5}, {0b1110100011111101, 5}, - {0b1110100011111110, 5}, {0b1110100011111111, 4}, - {0b1110100100111111, 5}, {0b1110100101011111, 5}, - {0b1110100101101011, 3}, {0b1110100101101101, 3}, - {0b1110100101110111, 5}, {0b1110100101111001, 3}, - {0b1110100101111110, 5}, {0b1110100101111111, 4}, - {0b1110100110010111, 3}, {0b1110100110011110, 3}, - {0b1110100110101111, 5}, {0b1110100110110110, 3}, - {0b1110100110111011, 5}, {0b1110100110111101, 5}, - {0b1110100110111111, 4}, {0b1110100111001111, 5}, - {0b1110100111010110, 3}, {0b1110100111011011, 5}, - {0b1110100111011101, 5}, {0b1110100111011111, 4}, - {0b1110100111100111, 5}, {0b1110100111101001, 3}, - {0b1110100111101110, 5}, {0b1110100111101111, 4}, - {0b1110100111110011, 5}, {0b1110100111110101, 5}, - {0b1110100111110111, 4}, {0b1110100111111010, 5}, - {0b1110100111111011, 4}, {0b1110100111111100, 5}, - {0b1110100111111101, 4}, {0b1110100111111110, 4}, - {0b1110100111111111, 5}, {0b1110101000111111, 5}, - {0b1110101001010111, 3}, {0b1110101001011101, 3}, - {0b1110101001101111, 5}, {0b1110101001110101, 3}, - {0b1110101001111011, 5}, {0b1110101001111110, 5}, - {0b1110101001111111, 4}, {0b1110101010011111, 5}, - {0b1110101010101011, 3}, {0b1110101010101110, 3}, - {0b1110101010110111, 5}, {0b1110101010111010, 3}, - {0b1110101010111101, 5}, {0b1110101010111111, 4}, - {0b1110101011001111, 5}, {0b1110101011010101, 3}, - {0b1110101011011011, 5}, {0b1110101011011110, 5}, - {0b1110101011011111, 4}, {0b1110101011100111, 5}, - {0b1110101011101010, 3}, {0b1110101011101101, 5}, - {0b1110101011101111, 4}, {0b1110101011110011, 5}, - {0b1110101011110110, 5}, {0b1110101011110111, 4}, - {0b1110101011111001, 5}, {0b1110101011111011, 4}, - {0b1110101011111100, 5}, {0b1110101011111101, 4}, - {0b1110101011111110, 4}, {0b1110101011111111, 5}, - {0b1110101100000000, 3}, {0b1110101100010100, 4}, - {0b1110101100011111, 5}, {0b1110101100101000, 4}, - {0b1110101100101111, 5}, {0b1110101100110111, 5}, - {0b1110101100111011, 5}, {0b1110101100111100, 3}, - {0b1110101100111111, 4}, {0b1110101101000001, 4}, - {0b1110101101001111, 5}, {0b1110101101010101, 3}, - {0b1110101101011011, 5}, {0b1110101101011110, 5}, - {0b1110101101011111, 4}, {0b1110101101100111, 5}, - {0b1110101101101001, 3}, {0b1110101101101110, 5}, - {0b1110101101101111, 4}, {0b1110101101110011, 5}, - {0b1110101101110110, 5}, {0b1110101101110111, 4}, - {0b1110101101111010, 5}, {0b1110101101111011, 4}, - {0b1110101101111101, 2}, {0b1110101101111110, 4}, - {0b1110101101111111, 5}, {0b1110101110000010, 4}, - {0b1110101110001111, 5}, {0b1110101110010110, 3}, - {0b1110101110011011, 5}, {0b1110101110011101, 5}, - {0b1110101110011111, 4}, {0b1110101110100111, 5}, - {0b1110101110101010, 3}, {0b1110101110101101, 5}, - {0b1110101110101111, 4}, {0b1110101110110011, 5}, - {0b1110101110110101, 5}, {0b1110101110110111, 4}, - {0b1110101110111001, 5}, {0b1110101110111011, 4}, - {0b1110101110111101, 4}, {0b1110101110111110, 2}, - {0b1110101110111111, 5}, {0b1110101111000011, 3}, - {0b1110101111001101, 5}, {0b1110101111001110, 5}, - {0b1110101111001111, 4}, {0b1110101111010111, 2}, - {0b1110101111011001, 5}, {0b1110101111011010, 5}, - {0b1110101111011011, 4}, {0b1110101111011100, 5}, - {0b1110101111011101, 4}, {0b1110101111011110, 4}, - {0b1110101111011111, 5}, {0b1110101111100101, 5}, - {0b1110101111100110, 5}, {0b1110101111100111, 4}, - {0b1110101111101011, 2}, {0b1110101111101100, 5}, - {0b1110101111101101, 4}, {0b1110101111101110, 4}, - {0b1110101111101111, 5}, {0b1110101111110001, 5}, - {0b1110101111110010, 5}, {0b1110101111110011, 4}, - {0b1110101111110100, 5}, {0b1110101111110101, 4}, - {0b1110101111110110, 4}, {0b1110101111110111, 5}, - {0b1110101111111000, 5}, {0b1110101111111001, 4}, - {0b1110101111111010, 4}, {0b1110101111111011, 5}, - {0b1110101111111100, 4}, {0b1110101111111101, 5}, - {0b1110101111111110, 5}, {0b1110101111111111, 3}, - {0b1110110000110111, 3}, {0b1110110000111011, 3}, - {0b1110110001011111, 5}, {0b1110110001101111, 5}, - {0b1110110001110011, 3}, {0b1110110001111101, 5}, - {0b1110110001111110, 5}, {0b1110110001111111, 4}, - {0b1110110010011111, 5}, {0b1110110010101111, 5}, - {0b1110110010110011, 3}, {0b1110110010111101, 5}, - {0b1110110010111110, 5}, {0b1110110010111111, 4}, - {0b1110110011001101, 3}, {0b1110110011001110, 3}, - {0b1110110011010111, 5}, {0b1110110011011011, 5}, - {0b1110110011011100, 3}, {0b1110110011011111, 4}, - {0b1110110011100111, 5}, {0b1110110011101011, 5}, - {0b1110110011101100, 3}, {0b1110110011101111, 4}, - {0b1110110011110101, 5}, {0b1110110011110110, 5}, - {0b1110110011110111, 4}, {0b1110110011111001, 5}, - {0b1110110011111010, 5}, {0b1110110011111011, 4}, - {0b1110110011111101, 4}, {0b1110110011111110, 4}, - {0b1110110011111111, 5}, {0b1110110100000000, 3}, - {0b1110110100010010, 4}, {0b1110110100011111, 5}, - {0b1110110100100001, 4}, {0b1110110100101111, 5}, - {0b1110110100110011, 3}, {0b1110110100111101, 5}, - {0b1110110100111110, 5}, {0b1110110100111111, 4}, - {0b1110110101001000, 4}, {0b1110110101001111, 5}, - {0b1110110101010111, 5}, {0b1110110101011010, 3}, - {0b1110110101011101, 5}, {0b1110110101011111, 4}, - {0b1110110101100111, 5}, {0b1110110101101001, 3}, - {0b1110110101101110, 5}, {0b1110110101101111, 4}, - {0b1110110101110101, 5}, {0b1110110101110110, 5}, - {0b1110110101110111, 4}, {0b1110110101111011, 2}, - {0b1110110101111100, 5}, {0b1110110101111101, 4}, - {0b1110110101111110, 4}, {0b1110110101111111, 5}, - {0b1110110110000100, 4}, {0b1110110110001111, 5}, - {0b1110110110010110, 3}, {0b1110110110011011, 5}, - {0b1110110110011101, 5}, {0b1110110110011111, 4}, - {0b1110110110100101, 3}, {0b1110110110101011, 5}, - {0b1110110110101110, 5}, {0b1110110110101111, 4}, - {0b1110110110110111, 2}, {0b1110110110111001, 5}, - {0b1110110110111010, 5}, {0b1110110110111011, 4}, - {0b1110110110111100, 5}, {0b1110110110111101, 4}, - {0b1110110110111110, 4}, {0b1110110110111111, 5}, - {0b1110110111000111, 5}, {0b1110110111001011, 5}, - {0b1110110111001100, 3}, {0b1110110111001111, 4}, - {0b1110110111010011, 5}, {0b1110110111010101, 5}, - {0b1110110111010111, 4}, {0b1110110111011001, 5}, - {0b1110110111011011, 4}, {0b1110110111011101, 4}, - {0b1110110111011110, 2}, {0b1110110111011111, 5}, - {0b1110110111100011, 5}, {0b1110110111100110, 5}, - {0b1110110111100111, 4}, {0b1110110111101010, 5}, - {0b1110110111101011, 4}, {0b1110110111101101, 2}, - {0b1110110111101110, 4}, {0b1110110111101111, 5}, - {0b1110110111110001, 5}, {0b1110110111110010, 5}, - {0b1110110111110011, 4}, {0b1110110111110100, 5}, - {0b1110110111110101, 4}, {0b1110110111110110, 4}, - {0b1110110111110111, 5}, {0b1110110111111000, 5}, - {0b1110110111111001, 4}, {0b1110110111111010, 4}, - {0b1110110111111011, 5}, {0b1110110111111100, 4}, - {0b1110110111111101, 5}, {0b1110110111111110, 5}, - {0b1110110111111111, 3}, {0b1110111000000000, 3}, - {0b1110111000010001, 4}, {0b1110111000011111, 5}, - {0b1110111000100010, 4}, {0b1110111000101111, 5}, - {0b1110111000110011, 3}, {0b1110111000111101, 5}, - {0b1110111000111110, 5}, {0b1110111000111111, 4}, - {0b1110111001000100, 4}, {0b1110111001001111, 5}, - {0b1110111001010101, 3}, {0b1110111001011011, 5}, - {0b1110111001011110, 5}, {0b1110111001011111, 4}, - {0b1110111001100110, 3}, {0b1110111001101011, 5}, - {0b1110111001101101, 5}, {0b1110111001101111, 4}, - {0b1110111001110111, 2}, {0b1110111001111001, 5}, - {0b1110111001111010, 5}, {0b1110111001111011, 4}, - {0b1110111001111100, 5}, {0b1110111001111101, 4}, - {0b1110111001111110, 4}, {0b1110111001111111, 5}, - {0b1110111010001000, 4}, {0b1110111010001111, 5}, - {0b1110111010010111, 5}, {0b1110111010011001, 3}, - {0b1110111010011110, 5}, {0b1110111010011111, 4}, - {0b1110111010100111, 5}, {0b1110111010101010, 3}, - {0b1110111010101101, 5}, {0b1110111010101111, 4}, - {0b1110111010110101, 5}, {0b1110111010110110, 5}, - {0b1110111010110111, 4}, {0b1110111010111011, 2}, - {0b1110111010111100, 5}, {0b1110111010111101, 4}, - {0b1110111010111110, 4}, {0b1110111010111111, 5}, - {0b1110111011000111, 5}, {0b1110111011001011, 5}, - {0b1110111011001100, 3}, {0b1110111011001111, 4}, - {0b1110111011010011, 5}, {0b1110111011010110, 5}, - {0b1110111011010111, 4}, {0b1110111011011010, 5}, - {0b1110111011011011, 4}, {0b1110111011011101, 2}, - {0b1110111011011110, 4}, {0b1110111011011111, 5}, - {0b1110111011100011, 5}, {0b1110111011100101, 5}, - {0b1110111011100111, 4}, {0b1110111011101001, 5}, - {0b1110111011101011, 4}, {0b1110111011101101, 4}, - {0b1110111011101110, 2}, {0b1110111011101111, 5}, - {0b1110111011110001, 5}, {0b1110111011110010, 5}, - {0b1110111011110011, 4}, {0b1110111011110100, 5}, - {0b1110111011110101, 4}, {0b1110111011110110, 4}, - {0b1110111011110111, 5}, {0b1110111011111000, 5}, - {0b1110111011111001, 4}, {0b1110111011111010, 4}, - {0b1110111011111011, 5}, {0b1110111011111100, 4}, - {0b1110111011111101, 5}, {0b1110111011111110, 5}, - {0b1110111011111111, 3}, {0b1110111100010111, 5}, - {0b1110111100011011, 5}, {0b1110111100011101, 5}, - {0b1110111100011110, 5}, {0b1110111100011111, 4}, - {0b1110111100100111, 5}, {0b1110111100101011, 5}, - {0b1110111100101101, 5}, {0b1110111100101110, 5}, - {0b1110111100101111, 4}, {0b1110111100110101, 5}, - {0b1110111100110110, 5}, {0b1110111100110111, 4}, - {0b1110111100111001, 5}, {0b1110111100111010, 5}, - {0b1110111100111011, 4}, {0b1110111100111101, 4}, - {0b1110111100111110, 4}, {0b1110111100111111, 5}, - {0b1110111101000111, 5}, {0b1110111101001011, 5}, - {0b1110111101001101, 5}, {0b1110111101001110, 5}, - {0b1110111101001111, 4}, {0b1110111101010011, 5}, - {0b1110111101010110, 5}, {0b1110111101010111, 4}, - {0b1110111101011001, 5}, {0b1110111101011011, 4}, - {0b1110111101011100, 5}, {0b1110111101011101, 4}, - {0b1110111101011110, 4}, {0b1110111101011111, 5}, - {0b1110111101100011, 5}, {0b1110111101100101, 5}, - {0b1110111101100111, 4}, {0b1110111101101010, 5}, - {0b1110111101101011, 4}, {0b1110111101101100, 5}, - {0b1110111101101101, 4}, {0b1110111101101110, 4}, - {0b1110111101101111, 5}, {0b1110111101110001, 5}, - {0b1110111101110010, 5}, {0b1110111101110011, 4}, - {0b1110111101110100, 5}, {0b1110111101110101, 4}, - {0b1110111101110110, 4}, {0b1110111101110111, 5}, - {0b1110111101111000, 5}, {0b1110111101111001, 4}, - {0b1110111101111010, 4}, {0b1110111101111011, 5}, - {0b1110111101111100, 4}, {0b1110111101111101, 5}, - {0b1110111101111110, 5}, {0b1110111101111111, 3}, - {0b1110111110000111, 5}, {0b1110111110001011, 5}, - {0b1110111110001101, 5}, {0b1110111110001110, 5}, - {0b1110111110001111, 4}, {0b1110111110010011, 5}, - {0b1110111110010101, 5}, {0b1110111110010111, 4}, - {0b1110111110011010, 5}, {0b1110111110011011, 4}, - {0b1110111110011100, 5}, {0b1110111110011101, 4}, - {0b1110111110011110, 4}, {0b1110111110011111, 5}, - {0b1110111110100011, 5}, {0b1110111110100110, 5}, - {0b1110111110100111, 4}, {0b1110111110101001, 5}, - {0b1110111110101011, 4}, {0b1110111110101100, 5}, - {0b1110111110101101, 4}, {0b1110111110101110, 4}, - {0b1110111110101111, 5}, {0b1110111110110001, 5}, - {0b1110111110110010, 5}, {0b1110111110110011, 4}, - {0b1110111110110100, 5}, {0b1110111110110101, 4}, - {0b1110111110110110, 4}, {0b1110111110110111, 5}, - {0b1110111110111000, 5}, {0b1110111110111001, 4}, - {0b1110111110111010, 4}, {0b1110111110111011, 5}, - {0b1110111110111100, 4}, {0b1110111110111101, 5}, - {0b1110111110111110, 5}, {0b1110111110111111, 3}, - {0b1110111111000101, 5}, {0b1110111111000110, 5}, - {0b1110111111000111, 4}, {0b1110111111001001, 5}, - {0b1110111111001010, 5}, {0b1110111111001011, 4}, - {0b1110111111001101, 4}, {0b1110111111001110, 4}, - {0b1110111111001111, 5}, {0b1110111111010001, 5}, - {0b1110111111010010, 5}, {0b1110111111010011, 4}, - {0b1110111111010100, 5}, {0b1110111111010101, 4}, - {0b1110111111010110, 4}, {0b1110111111010111, 5}, - {0b1110111111011000, 5}, {0b1110111111011001, 4}, - {0b1110111111011010, 4}, {0b1110111111011011, 5}, - {0b1110111111011100, 4}, {0b1110111111011101, 5}, - {0b1110111111011110, 5}, {0b1110111111011111, 3}, - {0b1110111111100001, 5}, {0b1110111111100010, 5}, - {0b1110111111100011, 4}, {0b1110111111100100, 5}, - {0b1110111111100101, 4}, {0b1110111111100110, 4}, - {0b1110111111100111, 5}, {0b1110111111101000, 5}, - {0b1110111111101001, 4}, {0b1110111111101010, 4}, - {0b1110111111101011, 5}, {0b1110111111101100, 4}, - {0b1110111111101101, 5}, {0b1110111111101110, 5}, - {0b1110111111101111, 3}, {0b1110111111110001, 4}, - {0b1110111111110010, 4}, {0b1110111111110011, 5}, - {0b1110111111110100, 4}, {0b1110111111110101, 5}, - {0b1110111111110110, 5}, {0b1110111111110111, 3}, - {0b1110111111111000, 4}, {0b1110111111111001, 5}, - {0b1110111111111010, 5}, {0b1110111111111011, 3}, - {0b1110111111111100, 5}, {0b1110111111111101, 3}, - {0b1110111111111110, 3}, {0b1110111111111111, 4}, - {0b1111000000000000, 2}, {0b1111000000000011, 3}, - {0b1111000000000101, 3}, {0b1111000000000110, 3}, - {0b1111000000001001, 3}, {0b1111000000001010, 3}, - {0b1111000000001100, 3}, {0b1111000000001111, 1}, - {0b1111000000110000, 3}, {0b1111000000110011, 4}, - {0b1111000000111100, 4}, {0b1111000000111111, 3}, - {0b1111000001010000, 3}, {0b1111000001010101, 4}, - {0b1111000001011010, 4}, {0b1111000001011111, 3}, - {0b1111000001100000, 3}, {0b1111000001100110, 4}, - {0b1111000001101001, 4}, {0b1111000001101111, 3}, - {0b1111000010010000, 3}, {0b1111000010010110, 4}, - {0b1111000010011001, 4}, {0b1111000010011111, 3}, - {0b1111000010100000, 3}, {0b1111000010100101, 4}, - {0b1111000010101010, 4}, {0b1111000010101111, 3}, - {0b1111000011000000, 3}, {0b1111000011000011, 4}, - {0b1111000011001100, 4}, {0b1111000011001111, 3}, - {0b1111000011110000, 1}, {0b1111000011110011, 3}, - {0b1111000011110101, 3}, {0b1111000011110110, 3}, - {0b1111000011111001, 3}, {0b1111000011111010, 3}, - {0b1111000011111100, 3}, {0b1111000011111111, 2}, - {0b1111000100011111, 3}, {0b1111000100101111, 3}, - {0b1111000101001111, 3}, {0b1111000101110111, 5}, - {0b1111000101111011, 5}, {0b1111000101111101, 5}, - {0b1111000101111110, 5}, {0b1111000101111111, 4}, - {0b1111000110001111, 3}, {0b1111000110110111, 5}, - {0b1111000110111011, 5}, {0b1111000110111101, 5}, - {0b1111000110111110, 5}, {0b1111000110111111, 4}, - {0b1111000111010111, 5}, {0b1111000111011011, 5}, - {0b1111000111011101, 5}, {0b1111000111011110, 5}, - {0b1111000111011111, 4}, {0b1111000111100111, 5}, - {0b1111000111101011, 5}, {0b1111000111101101, 5}, - {0b1111000111101110, 5}, {0b1111000111101111, 4}, - {0b1111000111110001, 3}, {0b1111000111110010, 3}, - {0b1111000111110100, 3}, {0b1111000111110111, 4}, - {0b1111000111111000, 3}, {0b1111000111111011, 4}, - {0b1111000111111101, 4}, {0b1111000111111110, 4}, - {0b1111000111111111, 5}, {0b1111001000011111, 3}, - {0b1111001000101111, 3}, {0b1111001001001111, 3}, - {0b1111001001110111, 5}, {0b1111001001111011, 5}, - {0b1111001001111101, 5}, {0b1111001001111110, 5}, - {0b1111001001111111, 4}, {0b1111001010001111, 3}, - {0b1111001010110111, 5}, {0b1111001010111011, 5}, - {0b1111001010111101, 5}, {0b1111001010111110, 5}, - {0b1111001010111111, 4}, {0b1111001011010111, 5}, - {0b1111001011011011, 5}, {0b1111001011011101, 5}, - {0b1111001011011110, 5}, {0b1111001011011111, 4}, - {0b1111001011100111, 5}, {0b1111001011101011, 5}, - {0b1111001011101101, 5}, {0b1111001011101110, 5}, - {0b1111001011101111, 4}, {0b1111001011110001, 3}, - {0b1111001011110010, 3}, {0b1111001011110100, 3}, - {0b1111001011110111, 4}, {0b1111001011111000, 3}, - {0b1111001011111011, 4}, {0b1111001011111101, 4}, - {0b1111001011111110, 4}, {0b1111001011111111, 5}, - {0b1111001100000000, 3}, {0b1111001100000011, 4}, - {0b1111001100001100, 4}, {0b1111001100001111, 3}, - {0b1111001100110000, 4}, {0b1111001100110011, 3}, - {0b1111001100111100, 3}, {0b1111001100111111, 2}, - {0b1111001101010111, 5}, {0b1111001101011011, 5}, - {0b1111001101011101, 5}, {0b1111001101011110, 5}, - {0b1111001101011111, 4}, {0b1111001101100111, 5}, - {0b1111001101101011, 5}, {0b1111001101101101, 5}, - {0b1111001101101110, 5}, {0b1111001101101111, 4}, - {0b1111001101110101, 5}, {0b1111001101110110, 5}, - {0b1111001101110111, 4}, {0b1111001101111001, 5}, - {0b1111001101111010, 5}, {0b1111001101111011, 4}, - {0b1111001101111101, 4}, {0b1111001101111110, 4}, - {0b1111001101111111, 5}, {0b1111001110010111, 5}, - {0b1111001110011011, 5}, {0b1111001110011101, 5}, - {0b1111001110011110, 5}, {0b1111001110011111, 4}, - {0b1111001110100111, 5}, {0b1111001110101011, 5}, - {0b1111001110101101, 5}, {0b1111001110101110, 5}, - {0b1111001110101111, 4}, {0b1111001110110101, 5}, - {0b1111001110110110, 5}, {0b1111001110110111, 4}, - {0b1111001110111001, 5}, {0b1111001110111010, 5}, - {0b1111001110111011, 4}, {0b1111001110111101, 4}, - {0b1111001110111110, 4}, {0b1111001110111111, 5}, - {0b1111001111000000, 4}, {0b1111001111000011, 3}, - {0b1111001111001100, 3}, {0b1111001111001111, 2}, - {0b1111001111010101, 5}, {0b1111001111010110, 5}, - {0b1111001111010111, 4}, {0b1111001111011001, 5}, - {0b1111001111011010, 5}, {0b1111001111011011, 4}, - {0b1111001111011101, 4}, {0b1111001111011110, 4}, - {0b1111001111011111, 5}, {0b1111001111100101, 5}, - {0b1111001111100110, 5}, {0b1111001111100111, 4}, - {0b1111001111101001, 5}, {0b1111001111101010, 5}, - {0b1111001111101011, 4}, {0b1111001111101101, 4}, - {0b1111001111101110, 4}, {0b1111001111101111, 5}, - {0b1111001111110000, 3}, {0b1111001111110011, 2}, - {0b1111001111110101, 4}, {0b1111001111110110, 4}, - {0b1111001111110111, 5}, {0b1111001111111001, 4}, - {0b1111001111111010, 4}, {0b1111001111111011, 5}, - {0b1111001111111100, 2}, {0b1111001111111101, 5}, - {0b1111001111111110, 5}, {0b1111001111111111, 3}, - {0b1111010000011111, 3}, {0b1111010000101111, 3}, - {0b1111010001001111, 3}, {0b1111010001110111, 5}, - {0b1111010001111011, 5}, {0b1111010001111101, 5}, - {0b1111010001111110, 5}, {0b1111010001111111, 4}, - {0b1111010010001111, 3}, {0b1111010010110111, 5}, - {0b1111010010111011, 5}, {0b1111010010111101, 5}, - {0b1111010010111110, 5}, {0b1111010010111111, 4}, - {0b1111010011010111, 5}, {0b1111010011011011, 5}, - {0b1111010011011101, 5}, {0b1111010011011110, 5}, - {0b1111010011011111, 4}, {0b1111010011100111, 5}, - {0b1111010011101011, 5}, {0b1111010011101101, 5}, - {0b1111010011101110, 5}, {0b1111010011101111, 4}, - {0b1111010011110001, 3}, {0b1111010011110010, 3}, - {0b1111010011110100, 3}, {0b1111010011110111, 4}, - {0b1111010011111000, 3}, {0b1111010011111011, 4}, - {0b1111010011111101, 4}, {0b1111010011111110, 4}, - {0b1111010011111111, 5}, {0b1111010100000000, 3}, - {0b1111010100000101, 4}, {0b1111010100001010, 4}, - {0b1111010100001111, 3}, {0b1111010100110111, 5}, - {0b1111010100111011, 5}, {0b1111010100111101, 5}, - {0b1111010100111110, 5}, {0b1111010100111111, 4}, - {0b1111010101010000, 4}, {0b1111010101010101, 3}, - {0b1111010101011010, 3}, {0b1111010101011111, 2}, - {0b1111010101100111, 5}, {0b1111010101101011, 5}, - {0b1111010101101101, 5}, {0b1111010101101110, 5}, - {0b1111010101101111, 4}, {0b1111010101110011, 5}, - {0b1111010101110110, 5}, {0b1111010101110111, 4}, - {0b1111010101111001, 5}, {0b1111010101111011, 4}, - {0b1111010101111100, 5}, {0b1111010101111101, 4}, - {0b1111010101111110, 4}, {0b1111010101111111, 5}, - {0b1111010110010111, 5}, {0b1111010110011011, 5}, - {0b1111010110011101, 5}, {0b1111010110011110, 5}, - {0b1111010110011111, 4}, {0b1111010110100000, 4}, - {0b1111010110100101, 3}, {0b1111010110101010, 3}, - {0b1111010110101111, 2}, {0b1111010110110011, 5}, - {0b1111010110110110, 5}, {0b1111010110110111, 4}, - {0b1111010110111001, 5}, {0b1111010110111011, 4}, - {0b1111010110111100, 5}, {0b1111010110111101, 4}, - {0b1111010110111110, 4}, {0b1111010110111111, 5}, - {0b1111010111000111, 5}, {0b1111010111001011, 5}, - {0b1111010111001101, 5}, {0b1111010111001110, 5}, - {0b1111010111001111, 4}, {0b1111010111010011, 5}, - {0b1111010111010110, 5}, {0b1111010111010111, 4}, - {0b1111010111011001, 5}, {0b1111010111011011, 4}, - {0b1111010111011100, 5}, {0b1111010111011101, 4}, - {0b1111010111011110, 4}, {0b1111010111011111, 5}, - {0b1111010111100011, 5}, {0b1111010111100110, 5}, - {0b1111010111100111, 4}, {0b1111010111101001, 5}, - {0b1111010111101011, 4}, {0b1111010111101100, 5}, - {0b1111010111101101, 4}, {0b1111010111101110, 4}, - {0b1111010111101111, 5}, {0b1111010111110000, 3}, - {0b1111010111110011, 4}, {0b1111010111110101, 2}, - {0b1111010111110110, 4}, {0b1111010111110111, 5}, - {0b1111010111111001, 4}, {0b1111010111111010, 2}, - {0b1111010111111011, 5}, {0b1111010111111100, 4}, - {0b1111010111111101, 5}, {0b1111010111111110, 5}, - {0b1111010111111111, 3}, {0b1111011000000000, 3}, - {0b1111011000000110, 4}, {0b1111011000001001, 4}, - {0b1111011000001111, 3}, {0b1111011000110111, 5}, - {0b1111011000111011, 5}, {0b1111011000111101, 5}, - {0b1111011000111110, 5}, {0b1111011000111111, 4}, - {0b1111011001010111, 5}, {0b1111011001011011, 5}, - {0b1111011001011101, 5}, {0b1111011001011110, 5}, - {0b1111011001011111, 4}, {0b1111011001100000, 4}, - {0b1111011001100110, 3}, {0b1111011001101001, 3}, - {0b1111011001101111, 2}, {0b1111011001110011, 5}, - {0b1111011001110101, 5}, {0b1111011001110111, 4}, - {0b1111011001111010, 5}, {0b1111011001111011, 4}, - {0b1111011001111100, 5}, {0b1111011001111101, 4}, - {0b1111011001111110, 4}, {0b1111011001111111, 5}, - {0b1111011010010000, 4}, {0b1111011010010110, 3}, - {0b1111011010011001, 3}, {0b1111011010011111, 2}, - {0b1111011010100111, 5}, {0b1111011010101011, 5}, - {0b1111011010101101, 5}, {0b1111011010101110, 5}, - {0b1111011010101111, 4}, {0b1111011010110011, 5}, - {0b1111011010110101, 5}, {0b1111011010110111, 4}, - {0b1111011010111010, 5}, {0b1111011010111011, 4}, - {0b1111011010111100, 5}, {0b1111011010111101, 4}, - {0b1111011010111110, 4}, {0b1111011010111111, 5}, - {0b1111011011000111, 5}, {0b1111011011001011, 5}, - {0b1111011011001101, 5}, {0b1111011011001110, 5}, - {0b1111011011001111, 4}, {0b1111011011010011, 5}, - {0b1111011011010101, 5}, {0b1111011011010111, 4}, - {0b1111011011011010, 5}, {0b1111011011011011, 4}, - {0b1111011011011100, 5}, {0b1111011011011101, 4}, - {0b1111011011011110, 4}, {0b1111011011011111, 5}, - {0b1111011011100011, 5}, {0b1111011011100101, 5}, - {0b1111011011100111, 4}, {0b1111011011101010, 5}, - {0b1111011011101011, 4}, {0b1111011011101100, 5}, - {0b1111011011101101, 4}, {0b1111011011101110, 4}, - {0b1111011011101111, 5}, {0b1111011011110000, 3}, - {0b1111011011110011, 4}, {0b1111011011110101, 4}, - {0b1111011011110110, 2}, {0b1111011011110111, 5}, - {0b1111011011111001, 2}, {0b1111011011111010, 4}, - {0b1111011011111011, 5}, {0b1111011011111100, 4}, - {0b1111011011111101, 5}, {0b1111011011111110, 5}, - {0b1111011011111111, 3}, {0b1111011100010111, 5}, - {0b1111011100011011, 5}, {0b1111011100011101, 5}, - {0b1111011100011110, 5}, {0b1111011100011111, 4}, - {0b1111011100100111, 5}, {0b1111011100101011, 5}, - {0b1111011100101101, 5}, {0b1111011100101110, 5}, - {0b1111011100101111, 4}, {0b1111011100110101, 5}, - {0b1111011100110110, 5}, {0b1111011100110111, 4}, - {0b1111011100111001, 5}, {0b1111011100111010, 5}, - {0b1111011100111011, 4}, {0b1111011100111101, 4}, - {0b1111011100111110, 4}, {0b1111011100111111, 5}, - {0b1111011101000111, 5}, {0b1111011101001011, 5}, - {0b1111011101001101, 5}, {0b1111011101001110, 5}, - {0b1111011101001111, 4}, {0b1111011101010011, 5}, - {0b1111011101010110, 5}, {0b1111011101010111, 4}, - {0b1111011101011001, 5}, {0b1111011101011011, 4}, - {0b1111011101011100, 5}, {0b1111011101011101, 4}, - {0b1111011101011110, 4}, {0b1111011101011111, 5}, - {0b1111011101100011, 5}, {0b1111011101100101, 5}, - {0b1111011101100111, 4}, {0b1111011101101010, 5}, - {0b1111011101101011, 4}, {0b1111011101101100, 5}, - {0b1111011101101101, 4}, {0b1111011101101110, 4}, - {0b1111011101101111, 5}, {0b1111011101110001, 5}, - {0b1111011101110010, 5}, {0b1111011101110011, 4}, - {0b1111011101110100, 5}, {0b1111011101110101, 4}, - {0b1111011101110110, 4}, {0b1111011101110111, 5}, - {0b1111011101111000, 5}, {0b1111011101111001, 4}, - {0b1111011101111010, 4}, {0b1111011101111011, 5}, - {0b1111011101111100, 4}, {0b1111011101111101, 5}, - {0b1111011101111110, 5}, {0b1111011101111111, 3}, - {0b1111011110000111, 5}, {0b1111011110001011, 5}, - {0b1111011110001101, 5}, {0b1111011110001110, 5}, - {0b1111011110001111, 4}, {0b1111011110010011, 5}, - {0b1111011110010101, 5}, {0b1111011110010111, 4}, - {0b1111011110011010, 5}, {0b1111011110011011, 4}, - {0b1111011110011100, 5}, {0b1111011110011101, 4}, - {0b1111011110011110, 4}, {0b1111011110011111, 5}, - {0b1111011110100011, 5}, {0b1111011110100110, 5}, - {0b1111011110100111, 4}, {0b1111011110101001, 5}, - {0b1111011110101011, 4}, {0b1111011110101100, 5}, - {0b1111011110101101, 4}, {0b1111011110101110, 4}, - {0b1111011110101111, 5}, {0b1111011110110001, 5}, - {0b1111011110110010, 5}, {0b1111011110110011, 4}, - {0b1111011110110100, 5}, {0b1111011110110101, 4}, - {0b1111011110110110, 4}, {0b1111011110110111, 5}, - {0b1111011110111000, 5}, {0b1111011110111001, 4}, - {0b1111011110111010, 4}, {0b1111011110111011, 5}, - {0b1111011110111100, 4}, {0b1111011110111101, 5}, - {0b1111011110111110, 5}, {0b1111011110111111, 3}, - {0b1111011111000101, 5}, {0b1111011111000110, 5}, - {0b1111011111000111, 4}, {0b1111011111001001, 5}, - {0b1111011111001010, 5}, {0b1111011111001011, 4}, - {0b1111011111001101, 4}, {0b1111011111001110, 4}, - {0b1111011111001111, 5}, {0b1111011111010001, 5}, - {0b1111011111010010, 5}, {0b1111011111010011, 4}, - {0b1111011111010100, 5}, {0b1111011111010101, 4}, - {0b1111011111010110, 4}, {0b1111011111010111, 5}, - {0b1111011111011000, 5}, {0b1111011111011001, 4}, - {0b1111011111011010, 4}, {0b1111011111011011, 5}, - {0b1111011111011100, 4}, {0b1111011111011101, 5}, - {0b1111011111011110, 5}, {0b1111011111011111, 3}, - {0b1111011111100001, 5}, {0b1111011111100010, 5}, - {0b1111011111100011, 4}, {0b1111011111100100, 5}, - {0b1111011111100101, 4}, {0b1111011111100110, 4}, - {0b1111011111100111, 5}, {0b1111011111101000, 5}, - {0b1111011111101001, 4}, {0b1111011111101010, 4}, - {0b1111011111101011, 5}, {0b1111011111101100, 4}, - {0b1111011111101101, 5}, {0b1111011111101110, 5}, - {0b1111011111101111, 3}, {0b1111011111110001, 4}, - {0b1111011111110010, 4}, {0b1111011111110011, 5}, - {0b1111011111110100, 4}, {0b1111011111110101, 5}, - {0b1111011111110110, 5}, {0b1111011111110111, 3}, - {0b1111011111111000, 4}, {0b1111011111111001, 5}, - {0b1111011111111010, 5}, {0b1111011111111011, 3}, - {0b1111011111111100, 5}, {0b1111011111111101, 3}, - {0b1111011111111110, 3}, {0b1111011111111111, 4}, - {0b1111100000011111, 3}, {0b1111100000101111, 3}, - {0b1111100001001111, 3}, {0b1111100001110111, 5}, - {0b1111100001111011, 5}, {0b1111100001111101, 5}, - {0b1111100001111110, 5}, {0b1111100001111111, 4}, - {0b1111100010001111, 3}, {0b1111100010110111, 5}, - {0b1111100010111011, 5}, {0b1111100010111101, 5}, - {0b1111100010111110, 5}, {0b1111100010111111, 4}, - {0b1111100011010111, 5}, {0b1111100011011011, 5}, - {0b1111100011011101, 5}, {0b1111100011011110, 5}, - {0b1111100011011111, 4}, {0b1111100011100111, 5}, - {0b1111100011101011, 5}, {0b1111100011101101, 5}, - {0b1111100011101110, 5}, {0b1111100011101111, 4}, - {0b1111100011110001, 3}, {0b1111100011110010, 3}, - {0b1111100011110100, 3}, {0b1111100011110111, 4}, - {0b1111100011111000, 3}, {0b1111100011111011, 4}, - {0b1111100011111101, 4}, {0b1111100011111110, 4}, - {0b1111100011111111, 5}, {0b1111100100000000, 3}, - {0b1111100100000110, 4}, {0b1111100100001001, 4}, - {0b1111100100001111, 3}, {0b1111100100110111, 5}, - {0b1111100100111011, 5}, {0b1111100100111101, 5}, - {0b1111100100111110, 5}, {0b1111100100111111, 4}, - {0b1111100101010111, 5}, {0b1111100101011011, 5}, - {0b1111100101011101, 5}, {0b1111100101011110, 5}, - {0b1111100101011111, 4}, {0b1111100101100000, 4}, - {0b1111100101100110, 3}, {0b1111100101101001, 3}, - {0b1111100101101111, 2}, {0b1111100101110011, 5}, - {0b1111100101110101, 5}, {0b1111100101110111, 4}, - {0b1111100101111010, 5}, {0b1111100101111011, 4}, - {0b1111100101111100, 5}, {0b1111100101111101, 4}, - {0b1111100101111110, 4}, {0b1111100101111111, 5}, - {0b1111100110010000, 4}, {0b1111100110010110, 3}, - {0b1111100110011001, 3}, {0b1111100110011111, 2}, - {0b1111100110100111, 5}, {0b1111100110101011, 5}, - {0b1111100110101101, 5}, {0b1111100110101110, 5}, - {0b1111100110101111, 4}, {0b1111100110110011, 5}, - {0b1111100110110101, 5}, {0b1111100110110111, 4}, - {0b1111100110111010, 5}, {0b1111100110111011, 4}, - {0b1111100110111100, 5}, {0b1111100110111101, 4}, - {0b1111100110111110, 4}, {0b1111100110111111, 5}, - {0b1111100111000111, 5}, {0b1111100111001011, 5}, - {0b1111100111001101, 5}, {0b1111100111001110, 5}, - {0b1111100111001111, 4}, {0b1111100111010011, 5}, - {0b1111100111010101, 5}, {0b1111100111010111, 4}, - {0b1111100111011010, 5}, {0b1111100111011011, 4}, - {0b1111100111011100, 5}, {0b1111100111011101, 4}, - {0b1111100111011110, 4}, {0b1111100111011111, 5}, - {0b1111100111100011, 5}, {0b1111100111100101, 5}, - {0b1111100111100111, 4}, {0b1111100111101010, 5}, - {0b1111100111101011, 4}, {0b1111100111101100, 5}, - {0b1111100111101101, 4}, {0b1111100111101110, 4}, - {0b1111100111101111, 5}, {0b1111100111110000, 3}, - {0b1111100111110011, 4}, {0b1111100111110101, 4}, - {0b1111100111110110, 2}, {0b1111100111110111, 5}, - {0b1111100111111001, 2}, {0b1111100111111010, 4}, - {0b1111100111111011, 5}, {0b1111100111111100, 4}, - {0b1111100111111101, 5}, {0b1111100111111110, 5}, - {0b1111100111111111, 3}, {0b1111101000000000, 3}, - {0b1111101000000101, 4}, {0b1111101000001010, 4}, - {0b1111101000001111, 3}, {0b1111101000110111, 5}, - {0b1111101000111011, 5}, {0b1111101000111101, 5}, - {0b1111101000111110, 5}, {0b1111101000111111, 4}, - {0b1111101001010000, 4}, {0b1111101001010101, 3}, - {0b1111101001011010, 3}, {0b1111101001011111, 2}, - {0b1111101001100111, 5}, {0b1111101001101011, 5}, - {0b1111101001101101, 5}, {0b1111101001101110, 5}, - {0b1111101001101111, 4}, {0b1111101001110011, 5}, - {0b1111101001110110, 5}, {0b1111101001110111, 4}, - {0b1111101001111001, 5}, {0b1111101001111011, 4}, - {0b1111101001111100, 5}, {0b1111101001111101, 4}, - {0b1111101001111110, 4}, {0b1111101001111111, 5}, - {0b1111101010010111, 5}, {0b1111101010011011, 5}, - {0b1111101010011101, 5}, {0b1111101010011110, 5}, - {0b1111101010011111, 4}, {0b1111101010100000, 4}, - {0b1111101010100101, 3}, {0b1111101010101010, 3}, - {0b1111101010101111, 2}, {0b1111101010110011, 5}, - {0b1111101010110110, 5}, {0b1111101010110111, 4}, - {0b1111101010111001, 5}, {0b1111101010111011, 4}, - {0b1111101010111100, 5}, {0b1111101010111101, 4}, - {0b1111101010111110, 4}, {0b1111101010111111, 5}, - {0b1111101011000111, 5}, {0b1111101011001011, 5}, - {0b1111101011001101, 5}, {0b1111101011001110, 5}, - {0b1111101011001111, 4}, {0b1111101011010011, 5}, - {0b1111101011010110, 5}, {0b1111101011010111, 4}, - {0b1111101011011001, 5}, {0b1111101011011011, 4}, - {0b1111101011011100, 5}, {0b1111101011011101, 4}, - {0b1111101011011110, 4}, {0b1111101011011111, 5}, - {0b1111101011100011, 5}, {0b1111101011100110, 5}, - {0b1111101011100111, 4}, {0b1111101011101001, 5}, - {0b1111101011101011, 4}, {0b1111101011101100, 5}, - {0b1111101011101101, 4}, {0b1111101011101110, 4}, - {0b1111101011101111, 5}, {0b1111101011110000, 3}, - {0b1111101011110011, 4}, {0b1111101011110101, 2}, - {0b1111101011110110, 4}, {0b1111101011110111, 5}, - {0b1111101011111001, 4}, {0b1111101011111010, 2}, - {0b1111101011111011, 5}, {0b1111101011111100, 4}, - {0b1111101011111101, 5}, {0b1111101011111110, 5}, - {0b1111101011111111, 3}, {0b1111101100010111, 5}, - {0b1111101100011011, 5}, {0b1111101100011101, 5}, - {0b1111101100011110, 5}, {0b1111101100011111, 4}, - {0b1111101100100111, 5}, {0b1111101100101011, 5}, - {0b1111101100101101, 5}, {0b1111101100101110, 5}, - {0b1111101100101111, 4}, {0b1111101100110101, 5}, - {0b1111101100110110, 5}, {0b1111101100110111, 4}, - {0b1111101100111001, 5}, {0b1111101100111010, 5}, - {0b1111101100111011, 4}, {0b1111101100111101, 4}, - {0b1111101100111110, 4}, {0b1111101100111111, 5}, - {0b1111101101000111, 5}, {0b1111101101001011, 5}, - {0b1111101101001101, 5}, {0b1111101101001110, 5}, - {0b1111101101001111, 4}, {0b1111101101010011, 5}, - {0b1111101101010110, 5}, {0b1111101101010111, 4}, - {0b1111101101011001, 5}, {0b1111101101011011, 4}, - {0b1111101101011100, 5}, {0b1111101101011101, 4}, - {0b1111101101011110, 4}, {0b1111101101011111, 5}, - {0b1111101101100011, 5}, {0b1111101101100101, 5}, - {0b1111101101100111, 4}, {0b1111101101101010, 5}, - {0b1111101101101011, 4}, {0b1111101101101100, 5}, - {0b1111101101101101, 4}, {0b1111101101101110, 4}, - {0b1111101101101111, 5}, {0b1111101101110001, 5}, - {0b1111101101110010, 5}, {0b1111101101110011, 4}, - {0b1111101101110100, 5}, {0b1111101101110101, 4}, - {0b1111101101110110, 4}, {0b1111101101110111, 5}, - {0b1111101101111000, 5}, {0b1111101101111001, 4}, - {0b1111101101111010, 4}, {0b1111101101111011, 5}, - {0b1111101101111100, 4}, {0b1111101101111101, 5}, - {0b1111101101111110, 5}, {0b1111101101111111, 3}, - {0b1111101110000111, 5}, {0b1111101110001011, 5}, - {0b1111101110001101, 5}, {0b1111101110001110, 5}, - {0b1111101110001111, 4}, {0b1111101110010011, 5}, - {0b1111101110010101, 5}, {0b1111101110010111, 4}, - {0b1111101110011010, 5}, {0b1111101110011011, 4}, - {0b1111101110011100, 5}, {0b1111101110011101, 4}, - {0b1111101110011110, 4}, {0b1111101110011111, 5}, - {0b1111101110100011, 5}, {0b1111101110100110, 5}, - {0b1111101110100111, 4}, {0b1111101110101001, 5}, - {0b1111101110101011, 4}, {0b1111101110101100, 5}, - {0b1111101110101101, 4}, {0b1111101110101110, 4}, - {0b1111101110101111, 5}, {0b1111101110110001, 5}, - {0b1111101110110010, 5}, {0b1111101110110011, 4}, - {0b1111101110110100, 5}, {0b1111101110110101, 4}, - {0b1111101110110110, 4}, {0b1111101110110111, 5}, - {0b1111101110111000, 5}, {0b1111101110111001, 4}, - {0b1111101110111010, 4}, {0b1111101110111011, 5}, - {0b1111101110111100, 4}, {0b1111101110111101, 5}, - {0b1111101110111110, 5}, {0b1111101110111111, 3}, - {0b1111101111000101, 5}, {0b1111101111000110, 5}, - {0b1111101111000111, 4}, {0b1111101111001001, 5}, - {0b1111101111001010, 5}, {0b1111101111001011, 4}, - {0b1111101111001101, 4}, {0b1111101111001110, 4}, - {0b1111101111001111, 5}, {0b1111101111010001, 5}, - {0b1111101111010010, 5}, {0b1111101111010011, 4}, - {0b1111101111010100, 5}, {0b1111101111010101, 4}, - {0b1111101111010110, 4}, {0b1111101111010111, 5}, - {0b1111101111011000, 5}, {0b1111101111011001, 4}, - {0b1111101111011010, 4}, {0b1111101111011011, 5}, - {0b1111101111011100, 4}, {0b1111101111011101, 5}, - {0b1111101111011110, 5}, {0b1111101111011111, 3}, - {0b1111101111100001, 5}, {0b1111101111100010, 5}, - {0b1111101111100011, 4}, {0b1111101111100100, 5}, - {0b1111101111100101, 4}, {0b1111101111100110, 4}, - {0b1111101111100111, 5}, {0b1111101111101000, 5}, - {0b1111101111101001, 4}, {0b1111101111101010, 4}, - {0b1111101111101011, 5}, {0b1111101111101100, 4}, - {0b1111101111101101, 5}, {0b1111101111101110, 5}, - {0b1111101111101111, 3}, {0b1111101111110001, 4}, - {0b1111101111110010, 4}, {0b1111101111110011, 5}, - {0b1111101111110100, 4}, {0b1111101111110101, 5}, - {0b1111101111110110, 5}, {0b1111101111110111, 3}, - {0b1111101111111000, 4}, {0b1111101111111001, 5}, - {0b1111101111111010, 5}, {0b1111101111111011, 3}, - {0b1111101111111100, 5}, {0b1111101111111101, 3}, - {0b1111101111111110, 3}, {0b1111101111111111, 4}, - {0b1111110000000000, 3}, {0b1111110000000011, 4}, - {0b1111110000001100, 4}, {0b1111110000001111, 3}, - {0b1111110000110000, 4}, {0b1111110000110011, 3}, - {0b1111110000111100, 3}, {0b1111110000111111, 2}, - {0b1111110001010111, 5}, {0b1111110001011011, 5}, - {0b1111110001011101, 5}, {0b1111110001011110, 5}, - {0b1111110001011111, 4}, {0b1111110001100111, 5}, - {0b1111110001101011, 5}, {0b1111110001101101, 5}, - {0b1111110001101110, 5}, {0b1111110001101111, 4}, - {0b1111110001110101, 5}, {0b1111110001110110, 5}, - {0b1111110001110111, 4}, {0b1111110001111001, 5}, - {0b1111110001111010, 5}, {0b1111110001111011, 4}, - {0b1111110001111101, 4}, {0b1111110001111110, 4}, - {0b1111110001111111, 5}, {0b1111110010010111, 5}, - {0b1111110010011011, 5}, {0b1111110010011101, 5}, - {0b1111110010011110, 5}, {0b1111110010011111, 4}, - {0b1111110010100111, 5}, {0b1111110010101011, 5}, - {0b1111110010101101, 5}, {0b1111110010101110, 5}, - {0b1111110010101111, 4}, {0b1111110010110101, 5}, - {0b1111110010110110, 5}, {0b1111110010110111, 4}, - {0b1111110010111001, 5}, {0b1111110010111010, 5}, - {0b1111110010111011, 4}, {0b1111110010111101, 4}, - {0b1111110010111110, 4}, {0b1111110010111111, 5}, - {0b1111110011000000, 4}, {0b1111110011000011, 3}, - {0b1111110011001100, 3}, {0b1111110011001111, 2}, - {0b1111110011010101, 5}, {0b1111110011010110, 5}, - {0b1111110011010111, 4}, {0b1111110011011001, 5}, - {0b1111110011011010, 5}, {0b1111110011011011, 4}, - {0b1111110011011101, 4}, {0b1111110011011110, 4}, - {0b1111110011011111, 5}, {0b1111110011100101, 5}, - {0b1111110011100110, 5}, {0b1111110011100111, 4}, - {0b1111110011101001, 5}, {0b1111110011101010, 5}, - {0b1111110011101011, 4}, {0b1111110011101101, 4}, - {0b1111110011101110, 4}, {0b1111110011101111, 5}, - {0b1111110011110000, 3}, {0b1111110011110011, 2}, - {0b1111110011110101, 4}, {0b1111110011110110, 4}, - {0b1111110011110111, 5}, {0b1111110011111001, 4}, - {0b1111110011111010, 4}, {0b1111110011111011, 5}, - {0b1111110011111100, 2}, {0b1111110011111101, 5}, - {0b1111110011111110, 5}, {0b1111110011111111, 3}, - {0b1111110100010111, 5}, {0b1111110100011011, 5}, - {0b1111110100011101, 5}, {0b1111110100011110, 5}, - {0b1111110100011111, 4}, {0b1111110100100111, 5}, - {0b1111110100101011, 5}, {0b1111110100101101, 5}, - {0b1111110100101110, 5}, {0b1111110100101111, 4}, - {0b1111110100110101, 5}, {0b1111110100110110, 5}, - {0b1111110100110111, 4}, {0b1111110100111001, 5}, - {0b1111110100111010, 5}, {0b1111110100111011, 4}, - {0b1111110100111101, 4}, {0b1111110100111110, 4}, - {0b1111110100111111, 5}, {0b1111110101000111, 5}, - {0b1111110101001011, 5}, {0b1111110101001101, 5}, - {0b1111110101001110, 5}, {0b1111110101001111, 4}, - {0b1111110101010011, 5}, {0b1111110101010110, 5}, - {0b1111110101010111, 4}, {0b1111110101011001, 5}, - {0b1111110101011011, 4}, {0b1111110101011100, 5}, - {0b1111110101011101, 4}, {0b1111110101011110, 4}, - {0b1111110101011111, 5}, {0b1111110101100011, 5}, - {0b1111110101100101, 5}, {0b1111110101100111, 4}, - {0b1111110101101010, 5}, {0b1111110101101011, 4}, - {0b1111110101101100, 5}, {0b1111110101101101, 4}, - {0b1111110101101110, 4}, {0b1111110101101111, 5}, - {0b1111110101110001, 5}, {0b1111110101110010, 5}, - {0b1111110101110011, 4}, {0b1111110101110100, 5}, - {0b1111110101110101, 4}, {0b1111110101110110, 4}, - {0b1111110101110111, 5}, {0b1111110101111000, 5}, - {0b1111110101111001, 4}, {0b1111110101111010, 4}, - {0b1111110101111011, 5}, {0b1111110101111100, 4}, - {0b1111110101111101, 5}, {0b1111110101111110, 5}, - {0b1111110101111111, 3}, {0b1111110110000111, 5}, - {0b1111110110001011, 5}, {0b1111110110001101, 5}, - {0b1111110110001110, 5}, {0b1111110110001111, 4}, - {0b1111110110010011, 5}, {0b1111110110010101, 5}, - {0b1111110110010111, 4}, {0b1111110110011010, 5}, - {0b1111110110011011, 4}, {0b1111110110011100, 5}, - {0b1111110110011101, 4}, {0b1111110110011110, 4}, - {0b1111110110011111, 5}, {0b1111110110100011, 5}, - {0b1111110110100110, 5}, {0b1111110110100111, 4}, - {0b1111110110101001, 5}, {0b1111110110101011, 4}, - {0b1111110110101100, 5}, {0b1111110110101101, 4}, - {0b1111110110101110, 4}, {0b1111110110101111, 5}, - {0b1111110110110001, 5}, {0b1111110110110010, 5}, - {0b1111110110110011, 4}, {0b1111110110110100, 5}, - {0b1111110110110101, 4}, {0b1111110110110110, 4}, - {0b1111110110110111, 5}, {0b1111110110111000, 5}, - {0b1111110110111001, 4}, {0b1111110110111010, 4}, - {0b1111110110111011, 5}, {0b1111110110111100, 4}, - {0b1111110110111101, 5}, {0b1111110110111110, 5}, - {0b1111110110111111, 3}, {0b1111110111000101, 5}, - {0b1111110111000110, 5}, {0b1111110111000111, 4}, - {0b1111110111001001, 5}, {0b1111110111001010, 5}, - {0b1111110111001011, 4}, {0b1111110111001101, 4}, - {0b1111110111001110, 4}, {0b1111110111001111, 5}, - {0b1111110111010001, 5}, {0b1111110111010010, 5}, - {0b1111110111010011, 4}, {0b1111110111010100, 5}, - {0b1111110111010101, 4}, {0b1111110111010110, 4}, - {0b1111110111010111, 5}, {0b1111110111011000, 5}, - {0b1111110111011001, 4}, {0b1111110111011010, 4}, - {0b1111110111011011, 5}, {0b1111110111011100, 4}, - {0b1111110111011101, 5}, {0b1111110111011110, 5}, - {0b1111110111011111, 3}, {0b1111110111100001, 5}, - {0b1111110111100010, 5}, {0b1111110111100011, 4}, - {0b1111110111100100, 5}, {0b1111110111100101, 4}, - {0b1111110111100110, 4}, {0b1111110111100111, 5}, - {0b1111110111101000, 5}, {0b1111110111101001, 4}, - {0b1111110111101010, 4}, {0b1111110111101011, 5}, - {0b1111110111101100, 4}, {0b1111110111101101, 5}, - {0b1111110111101110, 5}, {0b1111110111101111, 3}, - {0b1111110111110001, 4}, {0b1111110111110010, 4}, - {0b1111110111110011, 5}, {0b1111110111110100, 4}, - {0b1111110111110101, 5}, {0b1111110111110110, 5}, - {0b1111110111110111, 3}, {0b1111110111111000, 4}, - {0b1111110111111001, 5}, {0b1111110111111010, 5}, - {0b1111110111111011, 3}, {0b1111110111111100, 5}, - {0b1111110111111101, 3}, {0b1111110111111110, 3}, - {0b1111110111111111, 4}, {0b1111111000010111, 5}, - {0b1111111000011011, 5}, {0b1111111000011101, 5}, - {0b1111111000011110, 5}, {0b1111111000011111, 4}, - {0b1111111000100111, 5}, {0b1111111000101011, 5}, - {0b1111111000101101, 5}, {0b1111111000101110, 5}, - {0b1111111000101111, 4}, {0b1111111000110101, 5}, - {0b1111111000110110, 5}, {0b1111111000110111, 4}, - {0b1111111000111001, 5}, {0b1111111000111010, 5}, - {0b1111111000111011, 4}, {0b1111111000111101, 4}, - {0b1111111000111110, 4}, {0b1111111000111111, 5}, - {0b1111111001000111, 5}, {0b1111111001001011, 5}, - {0b1111111001001101, 5}, {0b1111111001001110, 5}, - {0b1111111001001111, 4}, {0b1111111001010011, 5}, - {0b1111111001010110, 5}, {0b1111111001010111, 4}, - {0b1111111001011001, 5}, {0b1111111001011011, 4}, - {0b1111111001011100, 5}, {0b1111111001011101, 4}, - {0b1111111001011110, 4}, {0b1111111001011111, 5}, - {0b1111111001100011, 5}, {0b1111111001100101, 5}, - {0b1111111001100111, 4}, {0b1111111001101010, 5}, - {0b1111111001101011, 4}, {0b1111111001101100, 5}, - {0b1111111001101101, 4}, {0b1111111001101110, 4}, - {0b1111111001101111, 5}, {0b1111111001110001, 5}, - {0b1111111001110010, 5}, {0b1111111001110011, 4}, - {0b1111111001110100, 5}, {0b1111111001110101, 4}, - {0b1111111001110110, 4}, {0b1111111001110111, 5}, - {0b1111111001111000, 5}, {0b1111111001111001, 4}, - {0b1111111001111010, 4}, {0b1111111001111011, 5}, - {0b1111111001111100, 4}, {0b1111111001111101, 5}, - {0b1111111001111110, 5}, {0b1111111001111111, 3}, - {0b1111111010000111, 5}, {0b1111111010001011, 5}, - {0b1111111010001101, 5}, {0b1111111010001110, 5}, - {0b1111111010001111, 4}, {0b1111111010010011, 5}, - {0b1111111010010101, 5}, {0b1111111010010111, 4}, - {0b1111111010011010, 5}, {0b1111111010011011, 4}, - {0b1111111010011100, 5}, {0b1111111010011101, 4}, - {0b1111111010011110, 4}, {0b1111111010011111, 5}, - {0b1111111010100011, 5}, {0b1111111010100110, 5}, - {0b1111111010100111, 4}, {0b1111111010101001, 5}, - {0b1111111010101011, 4}, {0b1111111010101100, 5}, - {0b1111111010101101, 4}, {0b1111111010101110, 4}, - {0b1111111010101111, 5}, {0b1111111010110001, 5}, - {0b1111111010110010, 5}, {0b1111111010110011, 4}, - {0b1111111010110100, 5}, {0b1111111010110101, 4}, - {0b1111111010110110, 4}, {0b1111111010110111, 5}, - {0b1111111010111000, 5}, {0b1111111010111001, 4}, - {0b1111111010111010, 4}, {0b1111111010111011, 5}, - {0b1111111010111100, 4}, {0b1111111010111101, 5}, - {0b1111111010111110, 5}, {0b1111111010111111, 3}, - {0b1111111011000101, 5}, {0b1111111011000110, 5}, - {0b1111111011000111, 4}, {0b1111111011001001, 5}, - {0b1111111011001010, 5}, {0b1111111011001011, 4}, - {0b1111111011001101, 4}, {0b1111111011001110, 4}, - {0b1111111011001111, 5}, {0b1111111011010001, 5}, - {0b1111111011010010, 5}, {0b1111111011010011, 4}, - {0b1111111011010100, 5}, {0b1111111011010101, 4}, - {0b1111111011010110, 4}, {0b1111111011010111, 5}, - {0b1111111011011000, 5}, {0b1111111011011001, 4}, - {0b1111111011011010, 4}, {0b1111111011011011, 5}, - {0b1111111011011100, 4}, {0b1111111011011101, 5}, - {0b1111111011011110, 5}, {0b1111111011011111, 3}, - {0b1111111011100001, 5}, {0b1111111011100010, 5}, - {0b1111111011100011, 4}, {0b1111111011100100, 5}, - {0b1111111011100101, 4}, {0b1111111011100110, 4}, - {0b1111111011100111, 5}, {0b1111111011101000, 5}, - {0b1111111011101001, 4}, {0b1111111011101010, 4}, - {0b1111111011101011, 5}, {0b1111111011101100, 4}, - {0b1111111011101101, 5}, {0b1111111011101110, 5}, - {0b1111111011101111, 3}, {0b1111111011110001, 4}, - {0b1111111011110010, 4}, {0b1111111011110011, 5}, - {0b1111111011110100, 4}, {0b1111111011110101, 5}, - {0b1111111011110110, 5}, {0b1111111011110111, 3}, - {0b1111111011111000, 4}, {0b1111111011111001, 5}, - {0b1111111011111010, 5}, {0b1111111011111011, 3}, - {0b1111111011111100, 5}, {0b1111111011111101, 3}, - {0b1111111011111110, 3}, {0b1111111011111111, 4}, - {0b1111111100000000, 1}, {0b1111111100000011, 3}, - {0b1111111100000101, 3}, {0b1111111100000110, 3}, - {0b1111111100001001, 3}, {0b1111111100001010, 3}, - {0b1111111100001100, 3}, {0b1111111100001111, 2}, - {0b1111111100010001, 3}, {0b1111111100010010, 3}, - {0b1111111100010100, 3}, {0b1111111100010111, 4}, - {0b1111111100011000, 3}, {0b1111111100011011, 4}, - {0b1111111100011101, 4}, {0b1111111100011110, 4}, - {0b1111111100011111, 5}, {0b1111111100100001, 3}, - {0b1111111100100010, 3}, {0b1111111100100100, 3}, - {0b1111111100100111, 4}, {0b1111111100101000, 3}, - {0b1111111100101011, 4}, {0b1111111100101101, 4}, - {0b1111111100101110, 4}, {0b1111111100101111, 5}, - {0b1111111100110000, 3}, {0b1111111100110011, 2}, - {0b1111111100110101, 4}, {0b1111111100110110, 4}, - {0b1111111100110111, 5}, {0b1111111100111001, 4}, - {0b1111111100111010, 4}, {0b1111111100111011, 5}, - {0b1111111100111100, 2}, {0b1111111100111101, 5}, - {0b1111111100111110, 5}, {0b1111111100111111, 3}, - {0b1111111101000001, 3}, {0b1111111101000010, 3}, - {0b1111111101000100, 3}, {0b1111111101000111, 4}, - {0b1111111101001000, 3}, {0b1111111101001011, 4}, - {0b1111111101001101, 4}, {0b1111111101001110, 4}, - {0b1111111101001111, 5}, {0b1111111101010000, 3}, - {0b1111111101010011, 4}, {0b1111111101010101, 2}, - {0b1111111101010110, 4}, {0b1111111101010111, 5}, - {0b1111111101011001, 4}, {0b1111111101011010, 2}, - {0b1111111101011011, 5}, {0b1111111101011100, 4}, - {0b1111111101011101, 5}, {0b1111111101011110, 5}, - {0b1111111101011111, 3}, {0b1111111101100000, 3}, - {0b1111111101100011, 4}, {0b1111111101100101, 4}, - {0b1111111101100110, 2}, {0b1111111101100111, 5}, - {0b1111111101101001, 2}, {0b1111111101101010, 4}, - {0b1111111101101011, 5}, {0b1111111101101100, 4}, - {0b1111111101101101, 5}, {0b1111111101101110, 5}, - {0b1111111101101111, 3}, {0b1111111101110001, 4}, - {0b1111111101110010, 4}, {0b1111111101110011, 5}, - {0b1111111101110100, 4}, {0b1111111101110101, 5}, - {0b1111111101110110, 5}, {0b1111111101110111, 3}, - {0b1111111101111000, 4}, {0b1111111101111001, 5}, - {0b1111111101111010, 5}, {0b1111111101111011, 3}, - {0b1111111101111100, 5}, {0b1111111101111101, 3}, - {0b1111111101111110, 3}, {0b1111111101111111, 4}, - {0b1111111110000001, 3}, {0b1111111110000010, 3}, - {0b1111111110000100, 3}, {0b1111111110000111, 4}, - {0b1111111110001000, 3}, {0b1111111110001011, 4}, - {0b1111111110001101, 4}, {0b1111111110001110, 4}, - {0b1111111110001111, 5}, {0b1111111110010000, 3}, - {0b1111111110010011, 4}, {0b1111111110010101, 4}, - {0b1111111110010110, 2}, {0b1111111110010111, 5}, - {0b1111111110011001, 2}, {0b1111111110011010, 4}, - {0b1111111110011011, 5}, {0b1111111110011100, 4}, - {0b1111111110011101, 5}, {0b1111111110011110, 5}, - {0b1111111110011111, 3}, {0b1111111110100000, 3}, - {0b1111111110100011, 4}, {0b1111111110100101, 2}, - {0b1111111110100110, 4}, {0b1111111110100111, 5}, - {0b1111111110101001, 4}, {0b1111111110101010, 2}, - {0b1111111110101011, 5}, {0b1111111110101100, 4}, - {0b1111111110101101, 5}, {0b1111111110101110, 5}, - {0b1111111110101111, 3}, {0b1111111110110001, 4}, - {0b1111111110110010, 4}, {0b1111111110110011, 5}, - {0b1111111110110100, 4}, {0b1111111110110101, 5}, - {0b1111111110110110, 5}, {0b1111111110110111, 3}, - {0b1111111110111000, 4}, {0b1111111110111001, 5}, - {0b1111111110111010, 5}, {0b1111111110111011, 3}, - {0b1111111110111100, 5}, {0b1111111110111101, 3}, - {0b1111111110111110, 3}, {0b1111111110111111, 4}, - {0b1111111111000000, 3}, {0b1111111111000011, 2}, - {0b1111111111000101, 4}, {0b1111111111000110, 4}, - {0b1111111111000111, 5}, {0b1111111111001001, 4}, - {0b1111111111001010, 4}, {0b1111111111001011, 5}, - {0b1111111111001100, 2}, {0b1111111111001101, 5}, - {0b1111111111001110, 5}, {0b1111111111001111, 3}, - {0b1111111111010001, 4}, {0b1111111111010010, 4}, - {0b1111111111010011, 5}, {0b1111111111010100, 4}, - {0b1111111111010101, 5}, {0b1111111111010110, 5}, - {0b1111111111010111, 3}, {0b1111111111011000, 4}, - {0b1111111111011001, 5}, {0b1111111111011010, 5}, - {0b1111111111011011, 3}, {0b1111111111011100, 5}, - {0b1111111111011101, 3}, {0b1111111111011110, 3}, - {0b1111111111011111, 4}, {0b1111111111100001, 4}, - {0b1111111111100010, 4}, {0b1111111111100011, 5}, - {0b1111111111100100, 4}, {0b1111111111100101, 5}, - {0b1111111111100110, 5}, {0b1111111111100111, 3}, - {0b1111111111101000, 4}, {0b1111111111101001, 5}, - {0b1111111111101010, 5}, {0b1111111111101011, 3}, - {0b1111111111101100, 5}, {0b1111111111101101, 3}, - {0b1111111111101110, 3}, {0b1111111111101111, 4}, - {0b1111111111110000, 2}, {0b1111111111110001, 5}, - {0b1111111111110010, 5}, {0b1111111111110011, 3}, - {0b1111111111110100, 5}, {0b1111111111110101, 3}, - {0b1111111111110110, 3}, {0b1111111111110111, 4}, - {0b1111111111111000, 5}, {0b1111111111111001, 3}, - {0b1111111111111010, 3}, {0b1111111111111011, 4}, - {0b1111111111111100, 3}, {0b1111111111111101, 4}, - {0b1111111111111110, 4}, {0b1111111111111111, 1}}}; - -/** - * Tests if the matrix is invertible by checking the rows are linearly - * independent in GF(2). - * @param {number[]} rows - * @returns {boolean} - */ - -int total = 0; -__attribute__((noinline)) bool -isInvertible(const std::vector &matrix) { - uint16_t basis[16]{}; - auto curr = matrix.cbegin(); - do { - uint16_t v = *curr; - do { - uint16_t b = 15 - __builtin_clzs(v); - if (!basis[b]) { - basis[b] = v; - break; - } - v ^= basis[b]; - if (!v) - return false; - } while (true); - } while (++curr < matrix.cend()); - return true; -} - -__attribute__((noinline)) bool invertMatrix(const std::vector &matrix, - std::vector &scratch, - std::vector &output) { - for (size_t i = 0; i < matrix.size(); i++) { - scratch[i] = matrix[i] | (1 << (16 + i)); - } - uint32_t mask = 1; - for (auto currI = scratch.begin(); currI < scratch.end(); currI++) { - for (auto currJ = currI; currJ < scratch.end(); currJ++) { - if ((*currJ) & mask) { - std::swap(*currI, *currJ); - break; - } - } - for (auto currJ = currI + 1; currJ < scratch.end(); currJ++) { - if ((*currJ) & mask) { - *currJ ^= *currI; - } - } - mask <<= 1; - } - auto currI = scratch.end(); - while (currI-- != scratch.begin()) { - mask >>= 1; - auto currJ = currI; - while (currJ-- != scratch.begin()) { - if ((*currJ) & mask) { - *currJ ^= *currI; - } - } - } - for (size_t i = 0; i < scratch.size(); i++) { - output[i] = scratch[i] >> 16; - } - return true; -} - -std::vector transition(const std::vector &rows, - const std::vector &terms) { - std::vector new_terms = std::vector(terms.size()); - for (size_t i = 0; i < terms.size(); i++) { - uint16_t bitmask = 1; - for (size_t j = 0; j < terms.size(); j++) { - if (rows[i] & bitmask) { - new_terms[i] ^= terms[j]; - } - bitmask <<= 1; - } - } - return new_terms; -} - -std::vector transpose(const std::vector &matrix) { - std::vector result = std::vector(matrix.size()); - for (size_t i = 0; i < matrix.size(); i++) { - uint16_t beginning = (matrix[0] >> i) & 1; - for (size_t j = 1; j < matrix.size(); j++) { - beginning |= ((matrix[j] >> i) & 1) << j; - } - result[i] = beginning; - } - return result; -} - -/** - * @typedef {Map} TermMap - * @description Transitioned term as key, lamp count as value, ordered by lamp - * count - */ -/** - * @typedef {number[]} viableCombinations - * @description Array of solvable linear combinations, preserving order of - * TermMap - */ -/** - * Generates all viable linear combinations (encodings) of input terms - * @param {number[]} terms - * @param {number} mask - * @returns {[viableCombinations,TermMap]} Viable linear combinations array, and - * pruned map of terms. - */ - -struct Precursor { - uint8_t lampCount; - uint16_t precursor; - uint16_t combination; - Precursor(uint8_t lc, uint16_t p, uint16_t c) - : lampCount(lc), precursor(p), combination(c) {} -}; - -size_t sizes[] = {16, 256, 12960}; - -__attribute__((noinline)) -std::pair, std::unordered_map> -getGoodTerms(size_t varCount, const std::vector &terms, - uint16_t mask) { - const auto &dictionary = Dictionary[varCount - 2]; - size_t size = sizes[varCount - 2]; - std::unordered_map maskedDictionary; - for (size_t i = 0; i < size; i++) { - auto [term, complexity] = dictionary[i]; - auto [it, inserted] = maskedDictionary.try_emplace(term | mask, complexity); - if (!inserted) { - if (complexity < it->second) { - it->second = complexity; - } - } - } - - std::vector precursorTerms; - for (uint16_t combination = 1; combination < 1 << terms.size(); - combination++) { - uint16_t bitmask = 0b1; - uint16_t precursor = 0b0; - for (size_t i = 0; i < terms.size(); i++) { - if ((combination & bitmask)) { - precursor ^= terms[i]; - } - bitmask <<= 1; - } - - auto minIt = maskedDictionary.find(precursor | mask); - if (minIt != maskedDictionary.end()) { - precursorTerms.emplace_back(minIt->second, precursor, combination); - } - } - std::stable_sort(precursorTerms.begin(), precursorTerms.end(), - [](const Precursor &a, const Precursor &b) -> bool { - return a.lampCount < b.lampCount; - }); - - maskedDictionary.clear(); // We can reuse this dictionary. - - std::vector realPrecursorTerms; - for (size_t i = 0; i < precursorTerms.size(); i++) { - const auto &term = precursorTerms[i]; - - auto [it, inserted] = - maskedDictionary.try_emplace(term.precursor, term.lampCount); - if (inserted) { - realPrecursorTerms.emplace_back(term.combination); - } - } - return std::make_pair(std::move(realPrecursorTerms), - std::move(maskedDictionary)); -} - -struct Result { - uint8_t complexity; - std::vector rows; - std::vector transitioned; - uint16_t mask; -}; - -typedef std::vector::const_iterator cit_u16_t; - -__attribute__((noinline)) bool nextCombination(std::vector &arr, - std::vector &view, - cit_u16_t n, size_t m) { - for (size_t i = m; i-- > 0;) { - if (arr[i] < n - (m - i)) { - auto last = ++arr[i]; - view[i] = *last; - for (size_t j = i + 1; j < m; j++) { - arr[j] = ++last; - view[j] = *last; - } - return true; - } - } - return false; -} - -/** - * Generates all transition matrices for a given set of terms - * @param {number[]} terms - * @param {number} mask - * @returns {number[][]} Partially sorted transition matrices - */ -std::vector combinations(size_t varCount, - std::vector terms, uint16_t mask = 0, - size_t hardLimit = 20) { - const size_t terms_size = terms.size(); - - const auto [linCombs, goodTermsMap] = getGoodTerms(varCount, terms, mask); - - std::vector combination(terms_size); - - std::vector lin_combination(terms_size, linCombs[0]); - - std::vector BigRes; - std::vector invert_scratch = std::vector(terms_size); - std::vector invert_output = std::vector(terms_size); - - for (size_t i = 0; i < terms_size; i++) { - combination[i] = linCombs.cbegin() + i; - lin_combination[i] = *combination[i]; - } - - size_t tested = 0; - do { - // We want just... linearly independent matrixes. - bool hasInverse = isInvertible(lin_combination); - if (hasInverse) { - invertMatrix(lin_combination, invert_scratch, invert_output); - const auto transitioned = transition(lin_combination, terms); - const auto &inverse = invert_output; - const auto rows = transpose(inverse); - std::vector new_transitioned; - std::unordered_map transitionedMap; - - for (size_t i = 0; i < transitioned.size(); i++) { - uint16_t itransition = transitioned[i]; - auto itranIt = transitionedMap.find(itransition); - if (itranIt != transitionedMap.end()) { - itranIt->second ^= rows[i]; - } else { - transitionedMap.emplace(itransition, rows[i]); - new_transitioned.emplace_back(itransition); - } - } - - std::vector new_rows; - - uint8_t complexity_sum = 0; - - for (size_t i = 0; i < new_transitioned.size(); i++) { - complexity_sum += goodTermsMap.at(new_transitioned[i]); - new_rows.emplace_back(transitionedMap.at(new_transitioned[i])); - } - - BigRes.emplace_back(Result{complexity_sum, std::move(new_rows), - std::move(new_transitioned), mask}); - } - tested++; - if (BigRes.size() >= hardLimit) { - break; - } - } while (nextCombination(combination, lin_combination, linCombs.cend(), - terms_size)); - std::stable_sort(BigRes.begin(), BigRes.end(), - [](const auto &a, const auto &b) -> bool { - return a.complexity < b.complexity; - }); - return BigRes; -} - -EMSCRIPTEN_BINDINGS(my_module) { - emscripten::function("combinations", &combinations); - emscripten::value_object("_") - .field("complexity", &Result::complexity) - .field("rows", &Result::rows) - .field("transitioned", &Result::transitioned) - .field("mask", &Result::mask); -} - -namespace emscripten { -namespace internal { - -template -struct BindingType> { - using ValBinding = BindingType; - using WireType = ValBinding::WireType; - - static WireType toWireType(const std::vector &vec, - rvp::default_tag) { - return ValBinding::toWireType(val::array(vec), rvp::default_tag{}); - } - - static std::vector fromWireType(WireType value) { - return vecFromJSArray(ValBinding::fromWireType(value)); - } -}; - -template -struct TypeID< - T, - typename std::enable_if_t::type, - std::vector::type::value_type, - typename Canonicalized::type::allocator_type>>::value>> { - static constexpr TYPEID get() { return TypeID::get(); } -}; - -} // namespace internal -} // namespace emscripten diff --git a/js/worker/transmatrix.js b/js/worker/transmatrix.js index 687e5c7..7da286e 100644 --- a/js/worker/transmatrix.js +++ b/js/worker/transmatrix.js @@ -11,7 +11,6 @@ SOLUTION: prune linear combination set (what the getGoodTerms function does) at */ import { Dictionary } from "../data/dictionary.js"; -import Module from "./transmatrix_wasm.mjs" /** * tests if a number is a power of two @@ -62,22 +61,6 @@ function transition(rows, terms) { return newTerms; } -/** - * We are tasked with transposing an array of numbers as if the bits formed a matrix. - * We assume they are square, but that's fine for the uses we have. - */ -function transpose(arrayOfNums) { - let result = []; - for(let i = 0; i < arrayOfNums.length; i++) { - let beginning = (arrayOfNums[0] >> i) & 1; - for(let j = 1; j < arrayOfNums.length; j++) { - beginning |= ((arrayOfNums[j] >> i) & 1) << j; - } - result[i] = beginning; - } - return result; -} - /** * @typedef {Map} TermMap * @description Transitioned term as key, lamp count as value, ordered by lamp count @@ -163,32 +146,16 @@ function combinations({ varCount, terms, mask = 0, hardLimit = 20 }) { // Check the matrix and add it to possible solutions list. if (isInvertible(lin_combinations)) { const transitioned = transition(lin_combinations, terms); - const inverse = getInverseMatrix(lin_combinations); - let rows = transpose(inverse); - let new_transitioned = []; - let transitionedMap = new Map(); - for(let i = 0; i < transitioned.length; i++) { - let itransition = transitioned[i]; - if(transitionedMap.has(itransition)) { - // We XOR instead of OR here, even though they *should* be identical, but just in case the system decides to use the same term twice for some reason. - transitionedMap.set(itransition, transitionedMap.get(itransition) ^ rows[i]); - } else { - transitionedMap.set(itransition, rows[i]); - new_transitioned.push(itransition); - } - } - let new_rows = []; - for(let i = 0; i < new_transitioned.length; i++) { - new_rows.push(transitionedMap.get(new_transitioned[i])); - } - const lampSum = new_transitioned.reduce( + const lampSum = transitioned.reduce( (acc, term) => acc + goodTermsMap.get(term), 0 ); + const inverse = getInverseMatrix(lin_combinations); + BigRes.push({ complexity: lampSum, - rows: new_rows, - transitioned: new_transitioned, + rows: inverse, + transitioned: transitioned, mask: mask, }); } @@ -236,23 +203,19 @@ function getInverseMatrix(lin_combinations) { return inverse; } -let module = Module({}); - -async function wasmWorkerWrapper(varCount, terms, mask, hardLimit) { - return (await module).combinations(varCount, terms, mask, hardLimit); -} - -onmessage = async (e) => { +onmessage = (e) => { switch (e.data.action) { case "generate": - const matrices = await wasmWorkerWrapper(e.data.varCount, e.data.terms, e.data.mask, e.data.hardLimit); + const matrices = combinations({ + varCount: e.data.varCount, + terms: e.data.terms, + mask: e.data.mask, + hardLimit: e.data.hardLimit, + }); + matrices.sort((a, b) => a[0] - b[0]); postMessage({ action: "matrices", - results: { - varCount: e.data.varCount, - matrices, - outputs: e.data.terms.length - }, + results: matrices, }); break; default: diff --git a/js/worker/transmatrix_wasm.mjs b/js/worker/transmatrix_wasm.mjs deleted file mode 100644 index 8f49cc5..0000000 --- a/js/worker/transmatrix_wasm.mjs +++ /dev/null @@ -1,1744 +0,0 @@ -// This code implements the `-sMODULARIZE` settings by taking the generated -// JS program code (INNER_JS_CODE) and wrapping it in a factory function. - -// When targetting node and ES6 we use `await import ..` in the generated code -// so the outer function needs to be marked as async. -async function Module(moduleArg = {}) { - var moduleRtn; - -// include: shell.js -// The Module object: Our interface to the outside world. We import -// and export values on it. There are various ways Module can be used: -// 1. Not defined. We create it here -// 2. A function parameter, function(moduleArg) => Promise -// 3. pre-run appended it, var Module = {}; ..generated code.. -// 4. External script tag defines var Module. -// We need to check if Module already exists (e.g. case 3 above). -// Substitution will be replaced with actual code on later stage of the build, -// this way Closure Compiler will not mangle it (e.g. case 4. above). -// Note that if you want to run closure, and also to use Module -// after the generated code, you will need to define var Module = {}; -// before the code. Then that object will be used in the code, and you -// can continue to use Module afterwards as well. -var Module = moduleArg; - -// Determine the runtime environment we are in. You can customize this by -// setting the ENVIRONMENT setting at compile time (see settings.js). -// Attempt to auto-detect the environment -var ENVIRONMENT_IS_WEB = typeof window == "object"; - -var ENVIRONMENT_IS_WORKER = typeof WorkerGlobalScope != "undefined"; - -// N.b. Electron.js environment is simultaneously a NODE-environment, but -// also a web environment. -var ENVIRONMENT_IS_NODE = typeof process == "object" && process.versions?.node && process.type != "renderer"; - -if (ENVIRONMENT_IS_NODE) { - // When building an ES module `require` is not normally available. - // We need to use `createRequire()` to construct the require()` function. - const {createRequire} = await import("module"); - /** @suppress{duplicate} */ var require = createRequire(import.meta.url); -} - -// --pre-jses are emitted after the Module integration code, so that they can -// refer to Module (if they choose; they can also define Module) -var arguments_ = []; - -var thisProgram = "./this.program"; - -var quit_ = (status, toThrow) => { - throw toThrow; -}; - -var _scriptName = import.meta.url; - -// `/` should be present at the end if `scriptDirectory` is not empty -var scriptDirectory = ""; - -function locateFile(path) { - if (Module["locateFile"]) { - return Module["locateFile"](path, scriptDirectory); - } - return scriptDirectory + path; -} - -// Hooks that are implemented differently in different runtime environments. -var readAsync, readBinary; - -if (ENVIRONMENT_IS_NODE) { - // These modules will usually be used on Node.js. Load them eagerly to avoid - // the complexity of lazy-loading. - var fs = require("fs"); - if (_scriptName.startsWith("file:")) { - scriptDirectory = require("path").dirname(require("url").fileURLToPath(_scriptName)) + "/"; - } - // include: node_shell_read.js - readBinary = filename => { - // We need to re-wrap `file://` strings to URLs. - filename = isFileURI(filename) ? new URL(filename) : filename; - var ret = fs.readFileSync(filename); - return ret; - }; - readAsync = async (filename, binary = true) => { - // See the comment in the `readBinary` function. - filename = isFileURI(filename) ? new URL(filename) : filename; - var ret = fs.readFileSync(filename, binary ? undefined : "utf8"); - return ret; - }; - // end include: node_shell_read.js - if (process.argv.length > 1) { - thisProgram = process.argv[1].replace(/\\/g, "/"); - } - arguments_ = process.argv.slice(2); - quit_ = (status, toThrow) => { - process.exitCode = status; - throw toThrow; - }; -} else // Note that this includes Node.js workers when relevant (pthreads is enabled). -// Node.js workers are detected as a combination of ENVIRONMENT_IS_WORKER and -// ENVIRONMENT_IS_NODE. -if (ENVIRONMENT_IS_WEB || ENVIRONMENT_IS_WORKER) { - try { - scriptDirectory = new URL(".", _scriptName).href; - } catch {} - { - // include: web_or_worker_shell_read.js - if (ENVIRONMENT_IS_WORKER) { - readBinary = url => { - var xhr = new XMLHttpRequest; - xhr.open("GET", url, false); - xhr.responseType = "arraybuffer"; - xhr.send(null); - return new Uint8Array(/** @type{!ArrayBuffer} */ (xhr.response)); - }; - } - readAsync = async url => { - // Fetch has some additional restrictions over XHR, like it can't be used on a file:// url. - // See https://github.com/github/fetch/pull/92#issuecomment-140665932 - // Cordova or Electron apps are typically loaded from a file:// url. - // So use XHR on webview if URL is a file URL. - if (isFileURI(url)) { - return new Promise((resolve, reject) => { - var xhr = new XMLHttpRequest; - xhr.open("GET", url, true); - xhr.responseType = "arraybuffer"; - xhr.onload = () => { - if (xhr.status == 200 || (xhr.status == 0 && xhr.response)) { - // file URLs can return 0 - resolve(xhr.response); - return; - } - reject(xhr.status); - }; - xhr.onerror = reject; - xhr.send(null); - }); - } - var response = await fetch(url, { - credentials: "same-origin" - }); - if (response.ok) { - return response.arrayBuffer(); - } - throw new Error(response.status + " : " + response.url); - }; - } -} else {} - -var out = console.log.bind(console); - -var err = console.error.bind(console); - -// end include: shell.js -// include: preamble.js -// === Preamble library stuff === -// Documentation for the public APIs defined in this file must be updated in: -// site/source/docs/api_reference/preamble.js.rst -// A prebuilt local version of the documentation is available at: -// site/build/text/docs/api_reference/preamble.js.txt -// You can also build docs locally as HTML or other formats in site/ -// An online HTML version (which may be of a different version of Emscripten) -// is up at http://kripken.github.io/emscripten-site/docs/api_reference/preamble.js.html -var wasmBinary; - -// Wasm globals -//======================================== -// Runtime essentials -//======================================== -// whether we are quitting the application. no code should run after this. -// set in exit() and abort() -var ABORT = false; - -/** - * Indicates whether filename is delivered via file protocol (as opposed to http/https) - * @noinline - */ var isFileURI = filename => filename.startsWith("file://"); - -// include: runtime_common.js -// include: runtime_stack_check.js -// end include: runtime_stack_check.js -// include: runtime_exceptions.js -// end include: runtime_exceptions.js -// include: runtime_debug.js -// end include: runtime_debug.js -var readyPromiseResolve, readyPromiseReject; - -// Memory management -var wasmMemory; - -var /** @type {!Int8Array} */ HEAP8, /** @type {!Uint8Array} */ HEAPU8, /** @type {!Int16Array} */ HEAP16, /** @type {!Uint16Array} */ HEAPU16, /** @type {!Int32Array} */ HEAP32, /** @type {!Uint32Array} */ HEAPU32, /** @type {!Float32Array} */ HEAPF32, /** @type {!Float64Array} */ HEAPF64; - -// BigInt64Array type is not correctly defined in closure -var /** not-@type {!BigInt64Array} */ HEAP64, /* BigUint64Array type is not correctly defined in closure -/** not-@type {!BigUint64Array} */ HEAPU64; - -var runtimeInitialized = false; - -function updateMemoryViews() { - var b = wasmMemory.buffer; - HEAP8 = new Int8Array(b); - HEAP16 = new Int16Array(b); - HEAPU8 = new Uint8Array(b); - HEAPU16 = new Uint16Array(b); - HEAP32 = new Int32Array(b); - HEAPU32 = new Uint32Array(b); - HEAPF32 = new Float32Array(b); - HEAPF64 = new Float64Array(b); - HEAP64 = new BigInt64Array(b); - HEAPU64 = new BigUint64Array(b); -} - -// include: memoryprofiler.js -// end include: memoryprofiler.js -// end include: runtime_common.js -function preRun() { - if (Module["preRun"]) { - if (typeof Module["preRun"] == "function") Module["preRun"] = [ Module["preRun"] ]; - while (Module["preRun"].length) { - addOnPreRun(Module["preRun"].shift()); - } - } - // Begin ATPRERUNS hooks - callRuntimeCallbacks(onPreRuns); -} - -function initRuntime() { - runtimeInitialized = true; - // No ATINITS hooks - wasmExports["A"](); -} - -function postRun() { - // PThreads reuse the runtime from the main thread. - if (Module["postRun"]) { - if (typeof Module["postRun"] == "function") Module["postRun"] = [ Module["postRun"] ]; - while (Module["postRun"].length) { - addOnPostRun(Module["postRun"].shift()); - } - } - // Begin ATPOSTRUNS hooks - callRuntimeCallbacks(onPostRuns); -} - -// A counter of dependencies for calling run(). If we need to -// do asynchronous work before running, increment this and -// decrement it. Incrementing must happen in a place like -// Module.preRun (used by emcc to add file preloading). -// Note that you can add dependencies in preRun, even though -// it happens right before run - run will be postponed until -// the dependencies are met. -var runDependencies = 0; - -var dependenciesFulfilled = null; - -// overridden to take different actions when all run dependencies are fulfilled -function addRunDependency(id) { - runDependencies++; - Module["monitorRunDependencies"]?.(runDependencies); -} - -function removeRunDependency(id) { - runDependencies--; - Module["monitorRunDependencies"]?.(runDependencies); - if (runDependencies == 0) { - if (dependenciesFulfilled) { - var callback = dependenciesFulfilled; - dependenciesFulfilled = null; - callback(); - } - } -} - -/** @param {string|number=} what */ function abort(what) { - Module["onAbort"]?.(what); - what = "Aborted(" + what + ")"; - // TODO(sbc): Should we remove printing and leave it up to whoever - // catches the exception? - err(what); - ABORT = true; - what += ". Build with -sASSERTIONS for more info."; - // Use a wasm runtime error, because a JS error might be seen as a foreign - // exception, which means we'd run destructors on it. We need the error to - // simply make the program stop. - // FIXME This approach does not work in Wasm EH because it currently does not assume - // all RuntimeErrors are from traps; it decides whether a RuntimeError is from - // a trap or not based on a hidden field within the object. So at the moment - // we don't have a way of throwing a wasm trap from JS. TODO Make a JS API that - // allows this in the wasm spec. - // Suppress closure compiler warning here. Closure compiler's builtin extern - // definition for WebAssembly.RuntimeError claims it takes no arguments even - // though it can. - // TODO(https://github.com/google/closure-compiler/pull/3913): Remove if/when upstream closure gets fixed. - /** @suppress {checkTypes} */ var e = new WebAssembly.RuntimeError(what); - readyPromiseReject?.(e); - // Throw the error whether or not MODULARIZE is set because abort is used - // in code paths apart from instantiation where an exception is expected - // to be thrown when abort is called. - throw e; -} - -var wasmBinaryFile; - -function findWasmBinary() { - if (Module["locateFile"]) { - return locateFile("transmatrix_wasm.wasm"); - } - // Use bundler-friendly `new URL(..., import.meta.url)` pattern; works in browsers too. - return new URL("transmatrix_wasm.wasm", import.meta.url).href; -} - -function getBinarySync(file) { - if (file == wasmBinaryFile && wasmBinary) { - return new Uint8Array(wasmBinary); - } - if (readBinary) { - return readBinary(file); - } - throw "both async and sync fetching of the wasm failed"; -} - -async function getWasmBinary(binaryFile) { - // If we don't have the binary yet, load it asynchronously using readAsync. - if (!wasmBinary) { - // Fetch the binary using readAsync - try { - var response = await readAsync(binaryFile); - return new Uint8Array(response); - } catch {} - } - // Otherwise, getBinarySync should be able to get it synchronously - return getBinarySync(binaryFile); -} - -async function instantiateArrayBuffer(binaryFile, imports) { - try { - var binary = await getWasmBinary(binaryFile); - var instance = await WebAssembly.instantiate(binary, imports); - return instance; - } catch (reason) { - err(`failed to asynchronously prepare wasm: ${reason}`); - abort(reason); - } -} - -async function instantiateAsync(binary, binaryFile, imports) { - if (!binary && typeof WebAssembly.instantiateStreaming == "function" && !isFileURI(binaryFile) && !ENVIRONMENT_IS_NODE) { - try { - var response = fetch(binaryFile, { - credentials: "same-origin" - }); - var instantiationResult = await WebAssembly.instantiateStreaming(response, imports); - return instantiationResult; - } catch (reason) { - // We expect the most common failure cause to be a bad MIME type for the binary, - // in which case falling back to ArrayBuffer instantiation should work. - err(`wasm streaming compile failed: ${reason}`); - err("falling back to ArrayBuffer instantiation"); - } - } - return instantiateArrayBuffer(binaryFile, imports); -} - -function getWasmImports() { - // prepare imports - return { - "a": wasmImports - }; -} - -// Create the wasm instance. -// Receives the wasm imports, returns the exports. -async function createWasm() { - // Load the wasm module and create an instance of using native support in the JS engine. - // handle a generated wasm instance, receiving its exports and - // performing other necessary setup - /** @param {WebAssembly.Module=} module*/ function receiveInstance(instance, module) { - wasmExports = instance.exports; - wasmMemory = wasmExports["z"]; - updateMemoryViews(); - wasmTable = wasmExports["B"]; - assignWasmExports(wasmExports); - removeRunDependency("wasm-instantiate"); - return wasmExports; - } - // wait for the pthread pool (if any) - addRunDependency("wasm-instantiate"); - // Prefer streaming instantiation if available. - function receiveInstantiationResult(result) { - // 'result' is a ResultObject object which has both the module and instance. - // receiveInstance() will swap in the exports (to Module.asm) so they can be called - // TODO: Due to Closure regression https://github.com/google/closure-compiler/issues/3193, the above line no longer optimizes out down to the following line. - // When the regression is fixed, can restore the above PTHREADS-enabled path. - return receiveInstance(result["instance"]); - } - var info = getWasmImports(); - // User shell pages can write their own Module.instantiateWasm = function(imports, successCallback) callback - // to manually instantiate the Wasm module themselves. This allows pages to - // run the instantiation parallel to any other async startup actions they are - // performing. - // Also pthreads and wasm workers initialize the wasm instance through this - // path. - if (Module["instantiateWasm"]) { - return new Promise((resolve, reject) => { - Module["instantiateWasm"](info, (mod, inst) => { - resolve(receiveInstance(mod, inst)); - }); - }); - } - wasmBinaryFile ??= findWasmBinary(); - var result = await instantiateAsync(wasmBinary, wasmBinaryFile, info); - var exports = receiveInstantiationResult(result); - return exports; -} - -// end include: preamble.js -// Begin JS library code -class ExitStatus { - name="ExitStatus"; - constructor(status) { - this.message = `Program terminated with exit(${status})`; - this.status = status; - } -} - -var callRuntimeCallbacks = callbacks => { - while (callbacks.length > 0) { - // Pass the module as the first argument. - callbacks.shift()(Module); - } -}; - -var onPostRuns = []; - -var addOnPostRun = cb => onPostRuns.push(cb); - -var onPreRuns = []; - -var addOnPreRun = cb => onPreRuns.push(cb); - -var noExitRuntime = true; - -class ExceptionInfo { - // excPtr - Thrown object pointer to wrap. Metadata pointer is calculated from it. - constructor(excPtr) { - this.excPtr = excPtr; - this.ptr = excPtr - 24; - } - set_type(type) { - HEAPU32[(((this.ptr) + (4)) >> 2)] = type; - } - get_type() { - return HEAPU32[(((this.ptr) + (4)) >> 2)]; - } - set_destructor(destructor) { - HEAPU32[(((this.ptr) + (8)) >> 2)] = destructor; - } - get_destructor() { - return HEAPU32[(((this.ptr) + (8)) >> 2)]; - } - set_caught(caught) { - caught = caught ? 1 : 0; - HEAP8[(this.ptr) + (12)] = caught; - } - get_caught() { - return HEAP8[(this.ptr) + (12)] != 0; - } - set_rethrown(rethrown) { - rethrown = rethrown ? 1 : 0; - HEAP8[(this.ptr) + (13)] = rethrown; - } - get_rethrown() { - return HEAP8[(this.ptr) + (13)] != 0; - } - // Initialize native structure fields. Should be called once after allocated. - init(type, destructor) { - this.set_adjusted_ptr(0); - this.set_type(type); - this.set_destructor(destructor); - } - set_adjusted_ptr(adjustedPtr) { - HEAPU32[(((this.ptr) + (16)) >> 2)] = adjustedPtr; - } - get_adjusted_ptr() { - return HEAPU32[(((this.ptr) + (16)) >> 2)]; - } -} - -var exceptionLast = 0; - -var uncaughtExceptionCount = 0; - -var ___cxa_throw = (ptr, type, destructor) => { - var info = new ExceptionInfo(ptr); - // Initialize ExceptionInfo content after it was allocated in __cxa_allocate_exception. - info.init(type, destructor); - exceptionLast = ptr; - uncaughtExceptionCount++; - throw exceptionLast; -}; - -var __abort_js = () => abort(""); - -var structRegistrations = {}; - -var runDestructors = destructors => { - while (destructors.length) { - var ptr = destructors.pop(); - var del = destructors.pop(); - del(ptr); - } -}; - -/** @suppress {globalThis} */ function readPointer(pointer) { - return this.fromWireType(HEAPU32[((pointer) >> 2)]); -} - -var awaitingDependencies = {}; - -var registeredTypes = {}; - -var typeDependencies = {}; - -var InternalError = class InternalError extends Error { - constructor(message) { - super(message); - this.name = "InternalError"; - } -}; - -var throwInternalError = message => { - throw new InternalError(message); -}; - -var whenDependentTypesAreResolved = (myTypes, dependentTypes, getTypeConverters) => { - myTypes.forEach(type => typeDependencies[type] = dependentTypes); - function onComplete(typeConverters) { - var myTypeConverters = getTypeConverters(typeConverters); - if (myTypeConverters.length !== myTypes.length) { - throwInternalError("Mismatched type converter count"); - } - for (var i = 0; i < myTypes.length; ++i) { - registerType(myTypes[i], myTypeConverters[i]); - } - } - var typeConverters = new Array(dependentTypes.length); - var unregisteredTypes = []; - var registered = 0; - dependentTypes.forEach((dt, i) => { - if (registeredTypes.hasOwnProperty(dt)) { - typeConverters[i] = registeredTypes[dt]; - } else { - unregisteredTypes.push(dt); - if (!awaitingDependencies.hasOwnProperty(dt)) { - awaitingDependencies[dt] = []; - } - awaitingDependencies[dt].push(() => { - typeConverters[i] = registeredTypes[dt]; - ++registered; - if (registered === unregisteredTypes.length) { - onComplete(typeConverters); - } - }); - } - }); - if (0 === unregisteredTypes.length) { - onComplete(typeConverters); - } -}; - -var __embind_finalize_value_object = structType => { - var reg = structRegistrations[structType]; - delete structRegistrations[structType]; - var rawConstructor = reg.rawConstructor; - var rawDestructor = reg.rawDestructor; - var fieldRecords = reg.fields; - var fieldTypes = fieldRecords.map(field => field.getterReturnType).concat(fieldRecords.map(field => field.setterArgumentType)); - whenDependentTypesAreResolved([ structType ], fieldTypes, fieldTypes => { - var fields = {}; - fieldRecords.forEach((field, i) => { - var fieldName = field.fieldName; - var getterReturnType = fieldTypes[i]; - var optional = fieldTypes[i].optional; - var getter = field.getter; - var getterContext = field.getterContext; - var setterArgumentType = fieldTypes[i + fieldRecords.length]; - var setter = field.setter; - var setterContext = field.setterContext; - fields[fieldName] = { - read: ptr => getterReturnType.fromWireType(getter(getterContext, ptr)), - write: (ptr, o) => { - var destructors = []; - setter(setterContext, ptr, setterArgumentType.toWireType(destructors, o)); - runDestructors(destructors); - }, - optional - }; - }); - return [ { - name: reg.name, - fromWireType: ptr => { - var rv = {}; - for (var i in fields) { - rv[i] = fields[i].read(ptr); - } - rawDestructor(ptr); - return rv; - }, - toWireType: (destructors, o) => { - // todo: Here we have an opportunity for -O3 level "unsafe" optimizations: - // assume all fields are present without checking. - for (var fieldName in fields) { - if (!(fieldName in o) && !fields[fieldName].optional) { - throw new TypeError(`Missing field: "${fieldName}"`); - } - } - var ptr = rawConstructor(); - for (fieldName in fields) { - fields[fieldName].write(ptr, o[fieldName]); - } - if (destructors !== null) { - destructors.push(rawDestructor, ptr); - } - return ptr; - }, - readValueFromPointer: readPointer, - destructorFunction: rawDestructor - } ]; - }); -}; - -var AsciiToString = ptr => { - var str = ""; - while (1) { - var ch = HEAPU8[ptr++]; - if (!ch) return str; - str += String.fromCharCode(ch); - } -}; - -var BindingError = class BindingError extends Error { - constructor(message) { - super(message); - this.name = "BindingError"; - } -}; - -var throwBindingError = message => { - throw new BindingError(message); -}; - -/** @param {Object=} options */ function sharedRegisterType(rawType, registeredInstance, options = {}) { - var name = registeredInstance.name; - if (!rawType) { - throwBindingError(`type "${name}" must have a positive integer typeid pointer`); - } - if (registeredTypes.hasOwnProperty(rawType)) { - if (options.ignoreDuplicateRegistrations) { - return; - } else { - throwBindingError(`Cannot register type '${name}' twice`); - } - } - registeredTypes[rawType] = registeredInstance; - delete typeDependencies[rawType]; - if (awaitingDependencies.hasOwnProperty(rawType)) { - var callbacks = awaitingDependencies[rawType]; - delete awaitingDependencies[rawType]; - callbacks.forEach(cb => cb()); - } -} - -/** @param {Object=} options */ function registerType(rawType, registeredInstance, options = {}) { - return sharedRegisterType(rawType, registeredInstance, options); -} - -var integerReadValueFromPointer = (name, width, signed) => { - // integers are quite common, so generate very specialized functions - switch (width) { - case 1: - return signed ? pointer => HEAP8[pointer] : pointer => HEAPU8[pointer]; - - case 2: - return signed ? pointer => HEAP16[((pointer) >> 1)] : pointer => HEAPU16[((pointer) >> 1)]; - - case 4: - return signed ? pointer => HEAP32[((pointer) >> 2)] : pointer => HEAPU32[((pointer) >> 2)]; - - case 8: - return signed ? pointer => HEAP64[((pointer) >> 3)] : pointer => HEAPU64[((pointer) >> 3)]; - - default: - throw new TypeError(`invalid integer width (${width}): ${name}`); - } -}; - -/** @suppress {globalThis} */ var __embind_register_bigint = (primitiveType, name, size, minRange, maxRange) => { - name = AsciiToString(name); - const isUnsignedType = minRange === 0n; - let fromWireType = value => value; - if (isUnsignedType) { - // uint64 get converted to int64 in ABI, fix them up like we do for 32-bit integers. - const bitSize = size * 8; - fromWireType = value => BigInt.asUintN(bitSize, value); - maxRange = fromWireType(maxRange); - } - registerType(primitiveType, { - name, - fromWireType, - toWireType: (destructors, value) => { - if (typeof value == "number") { - value = BigInt(value); - } - return value; - }, - readValueFromPointer: integerReadValueFromPointer(name, size, !isUnsignedType), - destructorFunction: null - }); -}; - -/** @suppress {globalThis} */ var __embind_register_bool = (rawType, name, trueValue, falseValue) => { - name = AsciiToString(name); - registerType(rawType, { - name, - fromWireType: function(wt) { - // ambiguous emscripten ABI: sometimes return values are - // true or false, and sometimes integers (0 or 1) - return !!wt; - }, - toWireType: function(destructors, o) { - return o ? trueValue : falseValue; - }, - readValueFromPointer: function(pointer) { - return this.fromWireType(HEAPU8[pointer]); - }, - destructorFunction: null - }); -}; - -var emval_freelist = []; - -var emval_handles = [ 0, 1, , 1, null, 1, true, 1, false, 1 ]; - -var __emval_decref = handle => { - if (handle > 9 && 0 === --emval_handles[handle + 1]) { - emval_handles[handle] = undefined; - emval_freelist.push(handle); - } -}; - -var Emval = { - toValue: handle => { - if (!handle) { - throwBindingError(`Cannot use deleted val. handle = ${handle}`); - } - return emval_handles[handle]; - }, - toHandle: value => { - switch (value) { - case undefined: - return 2; - - case null: - return 4; - - case true: - return 6; - - case false: - return 8; - - default: - { - const handle = emval_freelist.pop() || emval_handles.length; - emval_handles[handle] = value; - emval_handles[handle + 1] = 1; - return handle; - } - } - } -}; - -var EmValType = { - name: "emscripten::val", - fromWireType: handle => { - var rv = Emval.toValue(handle); - __emval_decref(handle); - return rv; - }, - toWireType: (destructors, value) => Emval.toHandle(value), - readValueFromPointer: readPointer, - destructorFunction: null -}; - -var __embind_register_emval = rawType => registerType(rawType, EmValType); - -var floatReadValueFromPointer = (name, width) => { - switch (width) { - case 4: - return function(pointer) { - return this.fromWireType(HEAPF32[((pointer) >> 2)]); - }; - - case 8: - return function(pointer) { - return this.fromWireType(HEAPF64[((pointer) >> 3)]); - }; - - default: - throw new TypeError(`invalid float width (${width}): ${name}`); - } -}; - -var __embind_register_float = (rawType, name, size) => { - name = AsciiToString(name); - registerType(rawType, { - name, - fromWireType: value => value, - toWireType: (destructors, value) => value, - readValueFromPointer: floatReadValueFromPointer(name, size), - destructorFunction: null - }); -}; - -var createNamedFunction = (name, func) => Object.defineProperty(func, "name", { - value: name -}); - -function usesDestructorStack(argTypes) { - // Skip return value at index 0 - it's not deleted here. - for (var i = 1; i < argTypes.length; ++i) { - // The type does not define a destructor function - must use dynamic stack - if (argTypes[i] !== null && argTypes[i].destructorFunction === undefined) { - return true; - } - } - return false; -} - -function createJsInvoker(argTypes, isClassMethodFunc, returns, isAsync) { - var needsDestructorStack = usesDestructorStack(argTypes); - var argCount = argTypes.length - 2; - var argsList = []; - var argsListWired = [ "fn" ]; - if (isClassMethodFunc) { - argsListWired.push("thisWired"); - } - for (var i = 0; i < argCount; ++i) { - argsList.push(`arg${i}`); - argsListWired.push(`arg${i}Wired`); - } - argsList = argsList.join(","); - argsListWired = argsListWired.join(","); - var invokerFnBody = `return function (${argsList}) {\n`; - if (needsDestructorStack) { - invokerFnBody += "var destructors = [];\n"; - } - var dtorStack = needsDestructorStack ? "destructors" : "null"; - var args1 = [ "humanName", "throwBindingError", "invoker", "fn", "runDestructors", "fromRetWire", "toClassParamWire" ]; - if (isClassMethodFunc) { - invokerFnBody += `var thisWired = toClassParamWire(${dtorStack}, this);\n`; - } - for (var i = 0; i < argCount; ++i) { - var argName = `toArg${i}Wire`; - invokerFnBody += `var arg${i}Wired = ${argName}(${dtorStack}, arg${i});\n`; - args1.push(argName); - } - invokerFnBody += (returns || isAsync ? "var rv = " : "") + `invoker(${argsListWired});\n`; - if (needsDestructorStack) { - invokerFnBody += "runDestructors(destructors);\n"; - } else { - for (var i = isClassMethodFunc ? 1 : 2; i < argTypes.length; ++i) { - // Skip return value at index 0 - it's not deleted here. Also skip class type if not a method. - var paramName = (i === 1 ? "thisWired" : ("arg" + (i - 2) + "Wired")); - if (argTypes[i].destructorFunction !== null) { - invokerFnBody += `${paramName}_dtor(${paramName});\n`; - args1.push(`${paramName}_dtor`); - } - } - } - if (returns) { - invokerFnBody += "var ret = fromRetWire(rv);\n" + "return ret;\n"; - } else {} - invokerFnBody += "}\n"; - return new Function(args1, invokerFnBody); -} - -function craftInvokerFunction(humanName, argTypes, classType, cppInvokerFunc, cppTargetFunc, /** boolean= */ isAsync) { - // humanName: a human-readable string name for the function to be generated. - // argTypes: An array that contains the embind type objects for all types in the function signature. - // argTypes[0] is the type object for the function return value. - // argTypes[1] is the type object for function this object/class type, or null if not crafting an invoker for a class method. - // argTypes[2...] are the actual function parameters. - // classType: The embind type object for the class to be bound, or null if this is not a method of a class. - // cppInvokerFunc: JS Function object to the C++-side function that interops into C++ code. - // cppTargetFunc: Function pointer (an integer to FUNCTION_TABLE) to the target C++ function the cppInvokerFunc will end up calling. - // isAsync: Optional. If true, returns an async function. Async bindings are only supported with JSPI. - var argCount = argTypes.length; - if (argCount < 2) { - throwBindingError("argTypes array size mismatch! Must at least get return value and 'this' types!"); - } - var isClassMethodFunc = (argTypes[1] !== null && classType !== null); - // Free functions with signature "void function()" do not need an invoker that marshalls between wire types. - // TODO: This omits argument count check - enable only at -O3 or similar. - // if (ENABLE_UNSAFE_OPTS && argCount == 2 && argTypes[0].name == "void" && !isClassMethodFunc) { - // return FUNCTION_TABLE[fn]; - // } - // Determine if we need to use a dynamic stack to store the destructors for the function parameters. - // TODO: Remove this completely once all function invokers are being dynamically generated. - var needsDestructorStack = usesDestructorStack(argTypes); - var returns = !argTypes[0].isVoid; - // Builld the arguments that will be passed into the closure around the invoker - // function. - var retType = argTypes[0]; - var instType = argTypes[1]; - var closureArgs = [ humanName, throwBindingError, cppInvokerFunc, cppTargetFunc, runDestructors, retType.fromWireType.bind(retType), instType?.toWireType.bind(instType) ]; - for (var i = 2; i < argCount; ++i) { - var argType = argTypes[i]; - closureArgs.push(argType.toWireType.bind(argType)); - } - if (!needsDestructorStack) { - // Skip return value at index 0 - it's not deleted here. Also skip class type if not a method. - for (var i = isClassMethodFunc ? 1 : 2; i < argTypes.length; ++i) { - if (argTypes[i].destructorFunction !== null) { - closureArgs.push(argTypes[i].destructorFunction); - } - } - } - let invokerFactory = createJsInvoker(argTypes, isClassMethodFunc, returns, isAsync); - var invokerFn = invokerFactory(...closureArgs); - return createNamedFunction(humanName, invokerFn); -} - -var ensureOverloadTable = (proto, methodName, humanName) => { - if (undefined === proto[methodName].overloadTable) { - var prevFunc = proto[methodName]; - // Inject an overload resolver function that routes to the appropriate overload based on the number of arguments. - proto[methodName] = function(...args) { - // TODO This check can be removed in -O3 level "unsafe" optimizations. - if (!proto[methodName].overloadTable.hasOwnProperty(args.length)) { - throwBindingError(`Function '${humanName}' called with an invalid number of arguments (${args.length}) - expects one of (${proto[methodName].overloadTable})!`); - } - return proto[methodName].overloadTable[args.length].apply(this, args); - }; - // Move the previous function into the overload table. - proto[methodName].overloadTable = []; - proto[methodName].overloadTable[prevFunc.argCount] = prevFunc; - } -}; - -/** @param {number=} numArguments */ var exposePublicSymbol = (name, value, numArguments) => { - if (Module.hasOwnProperty(name)) { - if (undefined === numArguments || (undefined !== Module[name].overloadTable && undefined !== Module[name].overloadTable[numArguments])) { - throwBindingError(`Cannot register public name '${name}' twice`); - } - // We are exposing a function with the same name as an existing function. Create an overload table and a function selector - // that routes between the two. - ensureOverloadTable(Module, name, name); - if (Module[name].overloadTable.hasOwnProperty(numArguments)) { - throwBindingError(`Cannot register multiple overloads of a function with the same number of arguments (${numArguments})!`); - } - // Add the new function into the overload table. - Module[name].overloadTable[numArguments] = value; - } else { - Module[name] = value; - Module[name].argCount = numArguments; - } -}; - -var heap32VectorToArray = (count, firstElement) => { - var array = []; - for (var i = 0; i < count; i++) { - // TODO(https://github.com/emscripten-core/emscripten/issues/17310): - // Find a way to hoist the `>> 2` or `>> 3` out of this loop. - array.push(HEAPU32[(((firstElement) + (i * 4)) >> 2)]); - } - return array; -}; - -/** @param {number=} numArguments */ var replacePublicSymbol = (name, value, numArguments) => { - if (!Module.hasOwnProperty(name)) { - throwInternalError("Replacing nonexistent public symbol"); - } - // If there's an overload table for this symbol, replace the symbol in the overload table instead. - if (undefined !== Module[name].overloadTable && undefined !== numArguments) { - Module[name].overloadTable[numArguments] = value; - } else { - Module[name] = value; - Module[name].argCount = numArguments; - } -}; - -var wasmTableMirror = []; - -/** @type {WebAssembly.Table} */ var wasmTable; - -var getWasmTableEntry = funcPtr => { - var func = wasmTableMirror[funcPtr]; - if (!func) { - /** @suppress {checkTypes} */ wasmTableMirror[funcPtr] = func = wasmTable.get(funcPtr); - } - return func; -}; - -var embind__requireFunction = (signature, rawFunction, isAsync = false) => { - signature = AsciiToString(signature); - function makeDynCaller() { - var rtn = getWasmTableEntry(rawFunction); - return rtn; - } - var fp = makeDynCaller(); - if (typeof fp != "function") { - throwBindingError(`unknown function pointer with signature ${signature}: ${rawFunction}`); - } - return fp; -}; - -class UnboundTypeError extends Error {} - -var getTypeName = type => { - var ptr = ___getTypeName(type); - var rv = AsciiToString(ptr); - _free(ptr); - return rv; -}; - -var throwUnboundTypeError = (message, types) => { - var unboundTypes = []; - var seen = {}; - function visit(type) { - if (seen[type]) { - return; - } - if (registeredTypes[type]) { - return; - } - if (typeDependencies[type]) { - typeDependencies[type].forEach(visit); - return; - } - unboundTypes.push(type); - seen[type] = true; - } - types.forEach(visit); - throw new UnboundTypeError(`${message}: ` + unboundTypes.map(getTypeName).join([ ", " ])); -}; - -var getFunctionName = signature => { - signature = signature.trim(); - const argsIndex = signature.indexOf("("); - if (argsIndex === -1) return signature; - return signature.slice(0, argsIndex); -}; - -var __embind_register_function = (name, argCount, rawArgTypesAddr, signature, rawInvoker, fn, isAsync, isNonnullReturn) => { - var argTypes = heap32VectorToArray(argCount, rawArgTypesAddr); - name = AsciiToString(name); - name = getFunctionName(name); - rawInvoker = embind__requireFunction(signature, rawInvoker, isAsync); - exposePublicSymbol(name, function() { - throwUnboundTypeError(`Cannot call ${name} due to unbound types`, argTypes); - }, argCount - 1); - whenDependentTypesAreResolved([], argTypes, argTypes => { - var invokerArgsArray = [ argTypes[0], null ].concat(argTypes.slice(1)); - replacePublicSymbol(name, craftInvokerFunction(name, invokerArgsArray, null, rawInvoker, fn, isAsync), argCount - 1); - return []; - }); -}; - -/** @suppress {globalThis} */ var __embind_register_integer = (primitiveType, name, size, minRange, maxRange) => { - name = AsciiToString(name); - const isUnsignedType = minRange === 0; - let fromWireType = value => value; - if (isUnsignedType) { - var bitshift = 32 - 8 * size; - fromWireType = value => (value << bitshift) >>> bitshift; - maxRange = fromWireType(maxRange); - } - registerType(primitiveType, { - name, - fromWireType, - toWireType: (destructors, value) => value, - readValueFromPointer: integerReadValueFromPointer(name, size, minRange !== 0), - destructorFunction: null - }); -}; - -var __embind_register_memory_view = (rawType, dataTypeIndex, name) => { - var typeMapping = [ Int8Array, Uint8Array, Int16Array, Uint16Array, Int32Array, Uint32Array, Float32Array, Float64Array, BigInt64Array, BigUint64Array ]; - var TA = typeMapping[dataTypeIndex]; - function decodeMemoryView(handle) { - var size = HEAPU32[((handle) >> 2)]; - var data = HEAPU32[(((handle) + (4)) >> 2)]; - return new TA(HEAP8.buffer, data, size); - } - name = AsciiToString(name); - registerType(rawType, { - name, - fromWireType: decodeMemoryView, - readValueFromPointer: decodeMemoryView - }, { - ignoreDuplicateRegistrations: true - }); -}; - -var stringToUTF8Array = (str, heap, outIdx, maxBytesToWrite) => { - // Parameter maxBytesToWrite is not optional. Negative values, 0, null, - // undefined and false each don't write out any bytes. - if (!(maxBytesToWrite > 0)) return 0; - var startIdx = outIdx; - var endIdx = outIdx + maxBytesToWrite - 1; - // -1 for string null terminator. - for (var i = 0; i < str.length; ++i) { - // For UTF8 byte structure, see http://en.wikipedia.org/wiki/UTF-8#Description - // and https://www.ietf.org/rfc/rfc2279.txt - // and https://tools.ietf.org/html/rfc3629 - var u = str.codePointAt(i); - if (u <= 127) { - if (outIdx >= endIdx) break; - heap[outIdx++] = u; - } else if (u <= 2047) { - if (outIdx + 1 >= endIdx) break; - heap[outIdx++] = 192 | (u >> 6); - heap[outIdx++] = 128 | (u & 63); - } else if (u <= 65535) { - if (outIdx + 2 >= endIdx) break; - heap[outIdx++] = 224 | (u >> 12); - heap[outIdx++] = 128 | ((u >> 6) & 63); - heap[outIdx++] = 128 | (u & 63); - } else { - if (outIdx + 3 >= endIdx) break; - heap[outIdx++] = 240 | (u >> 18); - heap[outIdx++] = 128 | ((u >> 12) & 63); - heap[outIdx++] = 128 | ((u >> 6) & 63); - heap[outIdx++] = 128 | (u & 63); - // Gotcha: if codePoint is over 0xFFFF, it is represented as a surrogate pair in UTF-16. - // We need to manually skip over the second code unit for correct iteration. - i++; - } - } - // Null-terminate the pointer to the buffer. - heap[outIdx] = 0; - return outIdx - startIdx; -}; - -var stringToUTF8 = (str, outPtr, maxBytesToWrite) => stringToUTF8Array(str, HEAPU8, outPtr, maxBytesToWrite); - -var lengthBytesUTF8 = str => { - var len = 0; - for (var i = 0; i < str.length; ++i) { - // Gotcha: charCodeAt returns a 16-bit word that is a UTF-16 encoded code - // unit, not a Unicode code point of the character! So decode - // UTF16->UTF32->UTF8. - // See http://unicode.org/faq/utf_bom.html#utf16-3 - var c = str.charCodeAt(i); - // possibly a lead surrogate - if (c <= 127) { - len++; - } else if (c <= 2047) { - len += 2; - } else if (c >= 55296 && c <= 57343) { - len += 4; - ++i; - } else { - len += 3; - } - } - return len; -}; - -var UTF8Decoder = typeof TextDecoder != "undefined" ? new TextDecoder : undefined; - -var findStringEnd = (heapOrArray, idx, maxBytesToRead, ignoreNul) => { - var maxIdx = idx + maxBytesToRead; - if (ignoreNul) return maxIdx; - // TextDecoder needs to know the byte length in advance, it doesn't stop on - // null terminator by itself. - // As a tiny code save trick, compare idx against maxIdx using a negation, - // so that maxBytesToRead=undefined/NaN means Infinity. - while (heapOrArray[idx] && !(idx >= maxIdx)) ++idx; - return idx; -}; - -/** - * Given a pointer 'idx' to a null-terminated UTF8-encoded string in the given - * array that contains uint8 values, returns a copy of that string as a - * Javascript String object. - * heapOrArray is either a regular array, or a JavaScript typed array view. - * @param {number=} idx - * @param {number=} maxBytesToRead - * @param {boolean=} ignoreNul - If true, the function will not stop on a NUL character. - * @return {string} - */ var UTF8ArrayToString = (heapOrArray, idx = 0, maxBytesToRead, ignoreNul) => { - var endPtr = findStringEnd(heapOrArray, idx, maxBytesToRead, ignoreNul); - // When using conditional TextDecoder, skip it for short strings as the overhead of the native call is not worth it. - if (endPtr - idx > 16 && heapOrArray.buffer && UTF8Decoder) { - return UTF8Decoder.decode(heapOrArray.subarray(idx, endPtr)); - } - var str = ""; - // If building with TextDecoder, we have already computed the string length - // above, so test loop end condition against that - while (idx < endPtr) { - // For UTF8 byte structure, see: - // http://en.wikipedia.org/wiki/UTF-8#Description - // https://www.ietf.org/rfc/rfc2279.txt - // https://tools.ietf.org/html/rfc3629 - var u0 = heapOrArray[idx++]; - if (!(u0 & 128)) { - str += String.fromCharCode(u0); - continue; - } - var u1 = heapOrArray[idx++] & 63; - if ((u0 & 224) == 192) { - str += String.fromCharCode(((u0 & 31) << 6) | u1); - continue; - } - var u2 = heapOrArray[idx++] & 63; - if ((u0 & 240) == 224) { - u0 = ((u0 & 15) << 12) | (u1 << 6) | u2; - } else { - u0 = ((u0 & 7) << 18) | (u1 << 12) | (u2 << 6) | (heapOrArray[idx++] & 63); - } - if (u0 < 65536) { - str += String.fromCharCode(u0); - } else { - var ch = u0 - 65536; - str += String.fromCharCode(55296 | (ch >> 10), 56320 | (ch & 1023)); - } - } - return str; -}; - -/** - * Given a pointer 'ptr' to a null-terminated UTF8-encoded string in the - * emscripten HEAP, returns a copy of that string as a Javascript String object. - * - * @param {number} ptr - * @param {number=} maxBytesToRead - An optional length that specifies the - * maximum number of bytes to read. You can omit this parameter to scan the - * string until the first 0 byte. If maxBytesToRead is passed, and the string - * at [ptr, ptr+maxBytesToReadr[ contains a null byte in the middle, then the - * string will cut short at that byte index. - * @param {boolean=} ignoreNul - If true, the function will not stop on a NUL character. - * @return {string} - */ var UTF8ToString = (ptr, maxBytesToRead, ignoreNul) => ptr ? UTF8ArrayToString(HEAPU8, ptr, maxBytesToRead, ignoreNul) : ""; - -var __embind_register_std_string = (rawType, name) => { - name = AsciiToString(name); - var stdStringIsUTF8 = true; - registerType(rawType, { - name, - // For some method names we use string keys here since they are part of - // the public/external API and/or used by the runtime-generated code. - fromWireType(value) { - var length = HEAPU32[((value) >> 2)]; - var payload = value + 4; - var str; - if (stdStringIsUTF8) { - str = UTF8ToString(payload, length, true); - } else { - str = ""; - for (var i = 0; i < length; ++i) { - str += String.fromCharCode(HEAPU8[payload + i]); - } - } - _free(value); - return str; - }, - toWireType(destructors, value) { - if (value instanceof ArrayBuffer) { - value = new Uint8Array(value); - } - var length; - var valueIsOfTypeString = (typeof value == "string"); - // We accept `string` or array views with single byte elements - if (!(valueIsOfTypeString || (ArrayBuffer.isView(value) && value.BYTES_PER_ELEMENT == 1))) { - throwBindingError("Cannot pass non-string to std::string"); - } - if (stdStringIsUTF8 && valueIsOfTypeString) { - length = lengthBytesUTF8(value); - } else { - length = value.length; - } - // assumes POINTER_SIZE alignment - var base = _malloc(4 + length + 1); - var ptr = base + 4; - HEAPU32[((base) >> 2)] = length; - if (valueIsOfTypeString) { - if (stdStringIsUTF8) { - stringToUTF8(value, ptr, length + 1); - } else { - for (var i = 0; i < length; ++i) { - var charCode = value.charCodeAt(i); - if (charCode > 255) { - _free(base); - throwBindingError("String has UTF-16 code units that do not fit in 8 bits"); - } - HEAPU8[ptr + i] = charCode; - } - } - } else { - HEAPU8.set(value, ptr); - } - if (destructors !== null) { - destructors.push(_free, base); - } - return base; - }, - readValueFromPointer: readPointer, - destructorFunction(ptr) { - _free(ptr); - } - }); -}; - -var UTF16Decoder = typeof TextDecoder != "undefined" ? new TextDecoder("utf-16le") : undefined; - -var UTF16ToString = (ptr, maxBytesToRead, ignoreNul) => { - var idx = ((ptr) >> 1); - var endIdx = findStringEnd(HEAPU16, idx, maxBytesToRead / 2, ignoreNul); - // When using conditional TextDecoder, skip it for short strings as the overhead of the native call is not worth it. - if (endIdx - idx > 16 && UTF16Decoder) return UTF16Decoder.decode(HEAPU16.subarray(idx, endIdx)); - // Fallback: decode without UTF16Decoder - var str = ""; - // If maxBytesToRead is not passed explicitly, it will be undefined, and the - // for-loop's condition will always evaluate to true. The loop is then - // terminated on the first null char. - for (var i = idx; // If building with TextDecoder, we have already computed the string length - // above, so test loop end condition against that - i < endIdx; ++i) { - var codeUnit = HEAPU16[i]; - // fromCharCode constructs a character from a UTF-16 code unit, so we can - // pass the UTF16 string right through. - str += String.fromCharCode(codeUnit); - } - return str; -}; - -var stringToUTF16 = (str, outPtr, maxBytesToWrite) => { - // Backwards compatibility: if max bytes is not specified, assume unsafe unbounded write is allowed. - maxBytesToWrite ??= 2147483647; - if (maxBytesToWrite < 2) return 0; - maxBytesToWrite -= 2; - // Null terminator. - var startPtr = outPtr; - var numCharsToWrite = (maxBytesToWrite < str.length * 2) ? (maxBytesToWrite / 2) : str.length; - for (var i = 0; i < numCharsToWrite; ++i) { - // charCodeAt returns a UTF-16 encoded code unit, so it can be directly written to the HEAP. - var codeUnit = str.charCodeAt(i); - // possibly a lead surrogate - HEAP16[((outPtr) >> 1)] = codeUnit; - outPtr += 2; - } - // Null-terminate the pointer to the HEAP. - HEAP16[((outPtr) >> 1)] = 0; - return outPtr - startPtr; -}; - -var lengthBytesUTF16 = str => str.length * 2; - -var UTF32ToString = (ptr, maxBytesToRead, ignoreNul) => { - var str = ""; - var startIdx = ((ptr) >> 2); - // If maxBytesToRead is not passed explicitly, it will be undefined, and this - // will always evaluate to true. This saves on code size. - for (var i = 0; !(i >= maxBytesToRead / 4); i++) { - var utf32 = HEAPU32[startIdx + i]; - if (!utf32 && !ignoreNul) break; - str += String.fromCodePoint(utf32); - } - return str; -}; - -var stringToUTF32 = (str, outPtr, maxBytesToWrite) => { - // Backwards compatibility: if max bytes is not specified, assume unsafe unbounded write is allowed. - maxBytesToWrite ??= 2147483647; - if (maxBytesToWrite < 4) return 0; - var startPtr = outPtr; - var endPtr = startPtr + maxBytesToWrite - 4; - for (var i = 0; i < str.length; ++i) { - var codePoint = str.codePointAt(i); - // Gotcha: if codePoint is over 0xFFFF, it is represented as a surrogate pair in UTF-16. - // We need to manually skip over the second code unit for correct iteration. - if (codePoint > 65535) { - i++; - } - HEAP32[((outPtr) >> 2)] = codePoint; - outPtr += 4; - if (outPtr + 4 > endPtr) break; - } - // Null-terminate the pointer to the HEAP. - HEAP32[((outPtr) >> 2)] = 0; - return outPtr - startPtr; -}; - -var lengthBytesUTF32 = str => { - var len = 0; - for (var i = 0; i < str.length; ++i) { - var codePoint = str.codePointAt(i); - // Gotcha: if codePoint is over 0xFFFF, it is represented as a surrogate pair in UTF-16. - // We need to manually skip over the second code unit for correct iteration. - if (codePoint > 65535) { - i++; - } - len += 4; - } - return len; -}; - -var __embind_register_std_wstring = (rawType, charSize, name) => { - name = AsciiToString(name); - var decodeString, encodeString, lengthBytesUTF; - if (charSize === 2) { - decodeString = UTF16ToString; - encodeString = stringToUTF16; - lengthBytesUTF = lengthBytesUTF16; - } else { - decodeString = UTF32ToString; - encodeString = stringToUTF32; - lengthBytesUTF = lengthBytesUTF32; - } - registerType(rawType, { - name, - fromWireType: value => { - // Code mostly taken from _embind_register_std_string fromWireType - var length = HEAPU32[((value) >> 2)]; - var str = decodeString(value + 4, length * charSize, true); - _free(value); - return str; - }, - toWireType: (destructors, value) => { - if (!(typeof value == "string")) { - throwBindingError(`Cannot pass non-string to C++ string type ${name}`); - } - // assumes POINTER_SIZE alignment - var length = lengthBytesUTF(value); - var ptr = _malloc(4 + length + charSize); - HEAPU32[((ptr) >> 2)] = length / charSize; - encodeString(value, ptr + 4, length + charSize); - if (destructors !== null) { - destructors.push(_free, ptr); - } - return ptr; - }, - readValueFromPointer: readPointer, - destructorFunction(ptr) { - _free(ptr); - } - }); -}; - -var __embind_register_value_object = (rawType, name, constructorSignature, rawConstructor, destructorSignature, rawDestructor) => { - structRegistrations[rawType] = { - name: AsciiToString(name), - rawConstructor: embind__requireFunction(constructorSignature, rawConstructor), - rawDestructor: embind__requireFunction(destructorSignature, rawDestructor), - fields: [] - }; -}; - -var __embind_register_value_object_field = (structType, fieldName, getterReturnType, getterSignature, getter, getterContext, setterArgumentType, setterSignature, setter, setterContext) => { - structRegistrations[structType].fields.push({ - fieldName: AsciiToString(fieldName), - getterReturnType, - getter: embind__requireFunction(getterSignature, getter), - getterContext, - setterArgumentType, - setter: embind__requireFunction(setterSignature, setter), - setterContext - }); -}; - -var __embind_register_void = (rawType, name) => { - name = AsciiToString(name); - registerType(rawType, { - isVoid: true, - // void return values can be optimized out sometimes - name, - fromWireType: () => undefined, - // TODO: assert if anything else is given? - toWireType: (destructors, o) => undefined - }); -}; - -var emval_methodCallers = []; - -var emval_addMethodCaller = caller => { - var id = emval_methodCallers.length; - emval_methodCallers.push(caller); - return id; -}; - -var requireRegisteredType = (rawType, humanName) => { - var impl = registeredTypes[rawType]; - if (undefined === impl) { - throwBindingError(`${humanName} has unknown type ${getTypeName(rawType)}`); - } - return impl; -}; - -var emval_lookupTypes = (argCount, argTypes) => { - var a = new Array(argCount); - for (var i = 0; i < argCount; ++i) { - a[i] = requireRegisteredType(HEAPU32[(((argTypes) + (i * 4)) >> 2)], `parameter ${i}`); - } - return a; -}; - -var emval_returnValue = (toReturnWire, destructorsRef, handle) => { - var destructors = []; - var result = toReturnWire(destructors, handle); - if (destructors.length) { - // void, primitives and any other types w/o destructors don't need to allocate a handle - HEAPU32[((destructorsRef) >> 2)] = Emval.toHandle(destructors); - } - return result; -}; - -var emval_symbols = {}; - -var getStringOrSymbol = address => { - var symbol = emval_symbols[address]; - if (symbol === undefined) { - return AsciiToString(address); - } - return symbol; -}; - -var __emval_create_invoker = (argCount, argTypesPtr, kind) => { - var GenericWireTypeSize = 8; - var [retType, ...argTypes] = emval_lookupTypes(argCount, argTypesPtr); - var toReturnWire = retType.toWireType.bind(retType); - var argFromPtr = argTypes.map(type => type.readValueFromPointer.bind(type)); - argCount--; - // remove the extracted return type - var captures = { - "toValue": Emval.toValue - }; - var args = argFromPtr.map((argFromPtr, i) => { - var captureName = `argFromPtr${i}`; - captures[captureName] = argFromPtr; - return `${captureName}(args${i ? "+" + i * GenericWireTypeSize : ""})`; - }); - var functionBody; - switch (kind) { - case 0: - functionBody = "toValue(handle)"; - break; - - case 2: - functionBody = "new (toValue(handle))"; - break; - - case 3: - functionBody = ""; - break; - - case 1: - captures["getStringOrSymbol"] = getStringOrSymbol; - functionBody = "toValue(handle)[getStringOrSymbol(methodName)]"; - break; - } - functionBody += `(${args})`; - if (!retType.isVoid) { - captures["toReturnWire"] = toReturnWire; - captures["emval_returnValue"] = emval_returnValue; - functionBody = `return emval_returnValue(toReturnWire, destructorsRef, ${functionBody})`; - } - functionBody = `return function (handle, methodName, destructorsRef, args) {\n ${functionBody}\n }`; - var invokerFunction = new Function(Object.keys(captures), functionBody)(...Object.values(captures)); - var functionName = `methodCaller<(${argTypes.map(t => t.name)}) => ${retType.name}>`; - return emval_addMethodCaller(createNamedFunction(functionName, invokerFunction)); -}; - -var __emval_get_property = (handle, key) => { - handle = Emval.toValue(handle); - key = Emval.toValue(key); - return Emval.toHandle(handle[key]); -}; - -var __emval_incref = handle => { - if (handle > 9) { - emval_handles[handle + 1] += 1; - } -}; - -var __emval_invoke = (caller, handle, methodName, destructorsRef, args) => emval_methodCallers[caller](handle, methodName, destructorsRef, args); - -var __emval_new_array = () => Emval.toHandle([]); - -var __emval_new_array_from_memory_view = view => { - view = Emval.toValue(view); - // using for..loop is faster than Array.from - var a = new Array(view.length); - for (var i = 0; i < view.length; i++) a[i] = view[i]; - return Emval.toHandle(a); -}; - -var __emval_new_cstring = v => Emval.toHandle(getStringOrSymbol(v)); - -var __emval_run_destructors = handle => { - var destructors = Emval.toValue(handle); - runDestructors(destructors); - __emval_decref(handle); -}; - -var abortOnCannotGrowMemory = requestedSize => { - abort("OOM"); -}; - -var _emscripten_resize_heap = requestedSize => { - var oldSize = HEAPU8.length; - // With CAN_ADDRESS_2GB or MEMORY64, pointers are already unsigned. - requestedSize >>>= 0; - abortOnCannotGrowMemory(requestedSize); -}; - -// End JS library code -// include: postlibrary.js -// This file is included after the automatically-generated JS library code -// but before the wasm module is created. -{ - // Begin ATMODULES hooks - if (Module["noExitRuntime"]) noExitRuntime = Module["noExitRuntime"]; - if (Module["print"]) out = Module["print"]; - if (Module["printErr"]) err = Module["printErr"]; - if (Module["wasmBinary"]) wasmBinary = Module["wasmBinary"]; - // End ATMODULES hooks - if (Module["arguments"]) arguments_ = Module["arguments"]; - if (Module["thisProgram"]) thisProgram = Module["thisProgram"]; -} - -// Begin runtime exports -// End runtime exports -// Begin JS library exports -// End JS library exports -// end include: postlibrary.js -// Imports from the Wasm binary. -var ___getTypeName, _malloc, _free; - -function assignWasmExports(wasmExports) { - ___getTypeName = wasmExports["C"]; - _malloc = wasmExports["D"]; - _free = wasmExports["E"]; -} - -var wasmImports = { - /** @export */ i: ___cxa_throw, - /** @export */ y: __abort_js, - /** @export */ x: __embind_finalize_value_object, - /** @export */ m: __embind_register_bigint, - /** @export */ w: __embind_register_bool, - /** @export */ v: __embind_register_emval, - /** @export */ l: __embind_register_float, - /** @export */ u: __embind_register_function, - /** @export */ b: __embind_register_integer, - /** @export */ a: __embind_register_memory_view, - /** @export */ t: __embind_register_std_string, - /** @export */ h: __embind_register_std_wstring, - /** @export */ s: __embind_register_value_object, - /** @export */ g: __embind_register_value_object_field, - /** @export */ r: __embind_register_void, - /** @export */ f: __emval_create_invoker, - /** @export */ c: __emval_decref, - /** @export */ k: __emval_get_property, - /** @export */ j: __emval_incref, - /** @export */ e: __emval_invoke, - /** @export */ q: __emval_new_array, - /** @export */ p: __emval_new_array_from_memory_view, - /** @export */ o: __emval_new_cstring, - /** @export */ d: __emval_run_destructors, - /** @export */ n: _emscripten_resize_heap -}; - -var wasmExports = await createWasm(); - -// include: postamble.js -// === Auto-generated postamble setup entry stuff === -function run() { - if (runDependencies > 0) { - dependenciesFulfilled = run; - return; - } - preRun(); - // a preRun added a dependency, run will be called later - if (runDependencies > 0) { - dependenciesFulfilled = run; - return; - } - function doRun() { - // run may have just been called through dependencies being fulfilled just in this very frame, - // or while the async setStatus time below was happening - Module["calledRun"] = true; - if (ABORT) return; - initRuntime(); - readyPromiseResolve?.(Module); - Module["onRuntimeInitialized"]?.(); - postRun(); - } - if (Module["setStatus"]) { - Module["setStatus"]("Running..."); - setTimeout(() => { - setTimeout(() => Module["setStatus"](""), 1); - doRun(); - }, 1); - } else { - doRun(); - } -} - -function preInit() { - if (Module["preInit"]) { - if (typeof Module["preInit"] == "function") Module["preInit"] = [ Module["preInit"] ]; - while (Module["preInit"].length > 0) { - Module["preInit"].shift()(); - } - } -} - -preInit(); - -run(); - -// end include: postamble.js -// include: postamble_modularize.js -// In MODULARIZE mode we wrap the generated code in a factory function -// and return either the Module itself, or a promise of the module. -// We assign to the `moduleRtn` global here and configure closure to see -// this as and extern so it won't get minified. -if (runtimeInitialized) { - moduleRtn = Module; -} else { - // Set up the promise that indicates the Module is initialized - moduleRtn = new Promise((resolve, reject) => { - readyPromiseResolve = resolve; - readyPromiseReject = reject; - }); -} - - - return moduleRtn; -} - -// Export using a UMD style export, or ES6 exports if selected -export default Module; - diff --git a/js/worker/transmatrix_wasm.wasm b/js/worker/transmatrix_wasm.wasm deleted file mode 100644 index 3ab5bac9f61e2dc9170d46c20ba779eefac809bb..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 100275 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%0A>0XH0p9|)A@_lgAwLG5Kz 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 kHD< -#include -#include -#include -#include -#include -#include - -constexpr const uint16_t Terms[][32] = { - { - 0b0000, - 0b1111, - 0b1100, - 0b1010, - 0b0011, - 0b0101, - 0b0110, - 0b1001 - }, - { - 0b00000000, - 0b11111111, - 0b11110000, - 0b11001100, - 0b10101010, - 0b00001111, - 0b00110011, - 0b01010101, - 0b00111100, - 0b01011010, - 0b01100110, - 0b11000011, - 0b10100101, - 0b10011001, - 0b10010110, - 0b01101001 - }, - { - 0b0000000000000000, - 0b1111111111111111, - 0b1111111100000000, - 0b1111000011110000, - 0b1100110011001100, - 0b1010101010101010, - 0b0000000011111111, - 0b0000111100001111, - 0b0011001100110011, - 0b0101010101010101, - 0b0000111111110000, - 0b0011001111001100, - 0b0101010110101010, - 0b0011110000111100, - 0b0101101001011010, - 0b0110011001100110, - 0b1111000000001111, - 0b1100110000110011, - 0b1010101001010101, - 0b1100001111000011, - 0b1010010110100101, - 0b1001100110011001, - 0b1100001100111100, - 0b1010010101011010, - 0b1001100101100110, - 0b1001011010010110, - 0b0011110011000011, - 0b0101101010100101, - 0b0110011010011001, - 0b0110100101101001, - 0b0110100110010110, - 0b1001011001101001 - } -}; - -constexpr const std::pair Symbols[][32] = { - { - {"0", 0b00000}, - {"1", 0b00001}, - {"a", 0b00010}, - {"b", 0b00100}, - {"¬a", 0b00011}, - {"¬b", 0b00101}, - {"ab", 0b00111}, - {"¬ab", 0b00111} - }, - { - {"0", 0b00000}, - {"1", 0b00001}, - {"a", 0b00010}, - {"b", 0b00100}, - {"c", 0b01000}, - {"¬a", 0b00011}, - {"¬b", 0b00101}, - {"¬c", 0b01001}, - {"ab", 0b00110}, - {"ac", 0b01010}, - {"bc", 0b01100}, - {"¬ab", 0b00111}, - {"¬ac", 0b01011}, - {"¬bc", 0b01101}, - {"abc", 0b01110}, - {"¬abc", 0b01111} - }, - { - {"0", 0b00000}, - {"1", 0b00001}, - {"a", 0b00010}, - {"b", 0b00100}, - {"c", 0b01000}, - {"d", 0b10000}, - {"¬a", 0b00011}, - {"¬b", 0b00101}, - {"¬c", 0b01001}, - {"¬d", 0b10001}, - {"ab", 0b00110}, - {"ac", 0b01010}, - {"ad", 0b10010}, - {"bc", 0b01100}, - {"bd", 0b10100}, - {"cd", 0b11000}, - {"¬ab", 0b00111}, - {"¬ac", 0b01011}, - {"¬ad", 0b10011}, - {"¬bc", 0b01101}, - {"¬bd", 0b10101}, - {"¬cd", 0b11001}, - {"abc", 0b01110}, - {"abd", 0b10110}, - {"acd", 0b11010}, - {"bcd", 0b11100}, - {"¬abc", 0b01111}, - {"¬abd", 0b10111}, - {"¬acd", 0b11011}, - {"¬bcd", 0b11101}, - {"abcd", 0b11110}, - {"¬abcd", 0b11111} - } -}; - -uint16_t negate(uint16_t term, size_t var_count) { - return ~term & ((1 << (1 << var_count)) - 1); -} - -struct Chain { - const Chain* prev; - size_t idx; - uint16_t CACHE_0; - uint16_t CACHE_1; -}; - -uint16_t OR_GATE(Chain* numbers, uint16_t mask) { - if(numbers->prev) { - return numbers->CACHE_0 = numbers->prev->CACHE_0 | mask; - } - return numbers->CACHE_0 = mask; -} - -uint16_t XOR_GATE(Chain* numbers, uint16_t mask) { - if(numbers->prev) { - uint16_t over = numbers->prev->CACHE_1 | (mask & numbers->prev->CACHE_0); - uint16_t encountered = numbers->CACHE_0; - numbers->CACHE_1 = over; - return ~over & encountered; - } - return mask; -} - - - -template -struct inplace_vector { - using value_type = T; - constexpr static size_t size = S; - std::array backing; - size_t _size; - void resize(size_t size) {this->_size = size;} - auto end() {return backing.begin() + this->_size;} - auto cend() const {return backing.cbegin() + this->_size;} - auto begin() {return backing.begin();} - auto cbegin() const {return backing.cbegin();} - T& operator[](std::size_t idx) { return backing[idx]; } - const T& operator[](std::size_t idx) const { return backing[idx]; } -}; - - -struct Solution { - std::string symbol_string; - inplace_vector wire_lamps; -}; - -void identity(const uint16_t* legalTerms, Chain* val, size_t count, std::vector& solutions, uint16_t term, uint16_t neg_term, const std::pair* symbols) { - auto vterm = legalTerms[val->idx]; - if(count == 1) { - if(vterm == term) { - const auto& symbol_pair = symbols[val->idx]; - solutions.emplace_back(Solution { std::string {std::get<0>(symbol_pair) }, { std::get<1>(symbol_pair) } }); - } - } else { - { - auto t = OR_GATE(val, vterm); - if(t == term || t == neg_term) { - Solution& solution = solutions.emplace_back(); - - std::string& symbol_string = solution.symbol_string; - auto& wire_lamps = solution.wire_lamps; - wire_lamps.resize(count); - symbol_string = std::get<0>(symbols[val->idx]); - symbol_string.push_back(')'); - const Chain* current = val->prev; - auto index = count; - wire_lamps[index--] = std::get<1>(symbols[val->idx]); - while(current != nullptr) { - const auto& cterm = symbols[current->idx]; - symbol_string.insert(0, ", "); - symbol_string.insert(0, std::get<0>(cterm)); - wire_lamps[--index] = std::get<1>(cterm); - current = current->prev; - } - symbol_string.insert(0, t == term ? "∨(" : "¬∨("); - } - } - { - auto t = XOR_GATE(val, vterm); - if(t == term || t == neg_term) { - Solution& solution = solutions.emplace_back(); - - std::string& symbol_string = solution.symbol_string; - auto& wire_lamps = solution.wire_lamps; - wire_lamps.resize(count); - symbol_string = std::get<0>(symbols[val->idx]); - symbol_string.push_back(')'); - const Chain* current = val->prev; - auto index = count; - wire_lamps[index--] = std::get<1>(symbols[val->idx]); - while(current != nullptr) { - const auto& cterm = symbols[current->idx]; - symbol_string.insert(0, ", "); - symbol_string.insert(0, std::get<0>(cterm)); - wire_lamps[--index] = std::get<1>(cterm); - current = current->prev; - } - symbol_string.insert(0, t == term ? "⊕(" : "¬⊕("); - } - } - } -} - -Chain chains[242824]; -uint16_t real_legal_terms[32]; - -std::vector makeExpressionsBFS(size_t varCount, size_t maxDepth, uint16_t term, uint16_t mask) { - uint16_t neg_term = negate(term, varCount); - term = term & ~mask; - const auto& legalTerms = Terms[varCount - 2]; - const auto& legalSymbols = Symbols[varCount - 2]; - const size_t num_terms = 2 << varCount; - - Chain* queueTail = chains; - - for (size_t i = 0; i < num_terms; i++) { - real_legal_terms[i] = legalTerms[i] & ~mask; - queueTail->CACHE_0 = real_legal_terms[i]; - queueTail->CACHE_1 = 0; - queueTail->idx = i; - queueTail->prev = nullptr; - queueTail++; - } - - Chain* queueEnd = queueTail; - Chain* queueHead = chains; - - std::vector solutions; - - size_t count = 0; - queueEnd = queueTail; - while (queueHead != queueEnd) { - count++; - while(queueHead != queueEnd) { - Chain* val = queueHead++; - - identity(real_legal_terms, val, count, solutions, term, neg_term, legalSymbols); - - if (count < maxDepth) { - if((val->CACHE_1 & term) && (val->CACHE_1 & neg_term)) { - continue; - } - for (size_t i = val->idx + 1; i < num_terms; i++) { - queueTail->prev = val; - queueTail->idx = i; - queueTail++; - } - } - } - queueEnd = queueTail; - } - return solutions; -} - -EMSCRIPTEN_BINDINGS(my_module) { - emscripten::function("makeExpressionsBFS", &makeExpressionsBFS); - emscripten::value_array("Solution") - .element(&Solution::symbol_string) - .element(&Solution::wire_lamps); -} - -template -inplace_vector inplacevecFromJSArray(const emscripten::val& v, Policies... policies) { - const uint32_t l = v["length"].as(); - - inplace_vector rv; - rv.resize(l); - for (uint32_t i = 0; i < l; ++i) { - rv[i] = v[i].as(std::forward(policies)...); - } - - return rv; -} - -namespace emscripten { -namespace internal { - -template -struct BindingType> { - using ValBinding = BindingType; - using WireType = ValBinding::WireType; - - static WireType toWireType(const std::vector &vec, rvp::default_tag) { - return ValBinding::toWireType(val::array(vec), rvp::default_tag{}); - } - - static std::vector fromWireType(WireType value) { - return vecFromJSArray(ValBinding::fromWireType(value)); - } -}; - -template -struct BindingType> { - using ValBinding = BindingType; - using WireType = ValBinding::WireType; - - static WireType toWireType(const inplace_vector &vec, rvp::default_tag) { - return ValBinding::toWireType(val::array(vec.cbegin(), vec.cend()), rvp::default_tag{}); - } - - static inplace_vector fromWireType(WireType value) { - return inplacevecFromJSArray(ValBinding::fromWireType(value)); - } -}; - -template -struct TypeID< - T, - typename std::enable_if_t::type, - std::vector::type::value_type, - typename Canonicalized::type::allocator_type>>::value>> { - static constexpr TYPEID get() { return TypeID::get(); } -}; - -template -struct TypeID< - T, - typename std::enable_if_t::type, - inplace_vector::type::value_type, Canonicalized::type::size>>::value>> { - static constexpr TYPEID get() { return TypeID::get(); } -}; - -} // namespace internal -} // namespace emscripten \ No newline at end of file diff --git a/js/worker/worker.js b/js/worker/worker.js index 9b2185c..7d8386e 100644 --- a/js/worker/worker.js +++ b/js/worker/worker.js @@ -1,4 +1,3 @@ -import Module from "./worker_wasm.mjs" import { Terms } from "../data/terms.js"; import { Gates, negate } from "../data/gates.js"; import { Dictionary } from "../data/dictionary.js"; @@ -35,31 +34,29 @@ const testfunc = (terms, varCount, val, count, solutions) => { * @param {number} neg_term: The complement of the desired term to reach, in case we can reach it using a negated output * @param {number} mask: a mask taking care of don't cares */ -const identity = (terms, val, count, solutions, term, neg_term, mask, symbols) => { +const identity = (terms, val, count, solutions, term, neg_term, mask) => { let vterm = terms[val.idx]; if (count === 1) { - for(let i = 0; i < Gates.length; i++) { - let gate = Gates[i]; - gate.combine(val, vterm); + for (let gate of Gates) { + gate.combine(terms, val); } - if (vterm == term) { - solutions.push([symbols[val.idx][0], [symbols[val.idx][1]]]); + if ((vterm[1] | mask) == term) { + solutions.push([vterm[0], vterm[2]]); } } else { - for(let i = 0; i < Gates.length; i++) { - let gate = Gates[i]; - const t = gate.combine(val, vterm); - const t_m = t; + for (let gate of Gates) { + const t = gate.combine(terms, val); + const t_m = t | mask; if (t_m == term || t_m == neg_term) { - let symbol_string = symbols[val.idx][0]; + let symbol_string = vterm[0]; let current = val.prev; let wire_lamps = new Array(count); let index = count; - wire_lamps[--index] = symbols[val.idx][1]; + do { - let cterm = symbols[current.idx]; + let cterm = terms[current.idx]; symbol_string = cterm[0] + ", " + symbol_string; - wire_lamps[--index] = cterm[1]; + wire_lamps[--index] = cterm[2]; current = current.prev; } while(current != null); @@ -90,23 +87,18 @@ function makeExpressionsBFS({ mask, callback = identity, }) { - let legalTerms = Terms[varCount]; - let neg_term; - let symbols; - if(callback == identity) { - neg_term = negate(term, varCount); - term = term ^ mask; - symbols = legalTerms.map(term => [term[0], term[2]]); - legalTerms = legalTerms.map(term => term[1] & ~mask); - } + const neg_term = negate(term ^ mask, varCount) | mask; + const legalTerms = Terms[varCount]; + // Initialize the queue with the individual terms. let queue = new Queue(); let next_queue = new Queue(); for(let i = 0; i < legalTerms.length; i++) { next_queue.enqueue({ - CACHE_0: 0, - CACHE_1: 0, + XOR_CACHE_O: 0, + XOR_CACHE_E: 0, + AND_CACHE: 0, prev: null, next: null, idx: i, @@ -125,15 +117,13 @@ function makeExpressionsBFS({ while (!queue.empty()) { let val = queue.dequeue(); - callback(legalTerms, val, count, solutions, term, neg_term, mask, symbols); + callback(legalTerms, val, count, solutions, term, neg_term, mask); if (count < maxDepth) { - if((val.CACHE_1 & term) && (val.CACHE_1 & neg_term)) { - continue; - } for (let i = val.idx + 1; i < legalTerms.length; i++) { next_queue.enqueue({ - CACHE_0: 0, - CACHE_1: 0, + XOR_CACHE_O: 0, + XOR_CACHE_E: 0, + AND_CACHE: 0, prev: val, next: null, idx: i, @@ -146,48 +136,43 @@ function makeExpressionsBFS({ return solutions.length > 0 ? solutions : undefined; } -let module = Module({}); -async function wasmWorkerWrapper(varCount, maxDepth, term, mask) { - let results = (await module).makeExpressionsBFS(varCount, maxDepth, term, mask); - if (results.length == 0) { - return undefined; - } - console.log(results); - return results; -} - -onmessage = async (e) => { +onmessage = (e) => { switch (e.data.action) { case "search": + const maskedDictionary = Dictionary[e.data.varCount - 2].map((a) => [ + a[0] | e.data.mask, + a[1], + ]); - let results = await wasmWorkerWrapper( - e.data.varCount, e.data.maxDepth, e.data.term, e.data.mask - ); - - if(results != undefined) { - postMessage({ action: "result", results }); + if (maskedDictionary.find((a) => a[0] == e.data.term)) { + const results = makeExpressionsBFS({ + varCount: e.data.varCount, + maxDepth: e.data.maxDepth, + term: e.data.term, + mask: e.data.mask, + }); + postMessage({ action: "result", results: results }); } else { - let dictionary = Dictionary[e.data.varCount - 2]; - let maskedDictionary = new Map(); - for(let i = 0; i < dictionary.length; i++) { - let dict = dictionary[i]; - let maskedTerm = dict[0] | e.data.mask; - let complexity = dict[1]; - if(maskedDictionary.has(maskedTerm)) { - if(complexity < maskedDictionary.get(maskedTerm)) { - maskedDictionary.set(maskedTerm, complexity); + // Preprocessing... + let maskedDictionaryMap = new Map(); + for(let i = 0; i < maskedDictionary.length; i++) { + let [term, complexity] = maskedDictionary[i]; + if(maskedDictionaryMap.has(term)) { + if(complexity < maskedDictionaryMap.get(term)) { + maskedDictionaryMap.set(term, complexity); } } else { - maskedDictionary.set(maskedTerm, complexity); + maskedDictionaryMap.set(term, complexity); } } // find the two terms of the shortest combined complexity that, when XOR'ed together, give the searched term let pair = [], min = Infinity; - for (let term0 of maskedDictionary) { + for (let i = 0; i < maskedDictionary.length; i++) { + let term0 = maskedDictionary[i]; let complementary = (e.data.term ^ term0[0]) | e.data.mask; - if(maskedDictionary.has(complementary)) { - let term1Complexity = maskedDictionary.get(complementary); + if(maskedDictionaryMap.has(complementary)) { + let term1Complexity = maskedDictionaryMap.get(complementary); if (term1Complexity + term0[1] < min) { pair = [complementary, term0[0]]; min = term1Complexity + term0[1]; diff --git a/js/worker/worker_wasm.mjs b/js/worker/worker_wasm.mjs deleted file mode 100644 index ccf9d0b..0000000 --- a/js/worker/worker_wasm.mjs +++ /dev/null @@ -1,1788 +0,0 @@ -// This code implements the `-sMODULARIZE` settings by taking the generated -// JS program code (INNER_JS_CODE) and wrapping it in a factory function. - -// When targetting node and ES6 we use `await import ..` in the generated code -// so the outer function needs to be marked as async. -async function Module(moduleArg = {}) { - var moduleRtn; - -// include: shell.js -// The Module object: Our interface to the outside world. We import -// and export values on it. There are various ways Module can be used: -// 1. Not defined. We create it here -// 2. A function parameter, function(moduleArg) => Promise -// 3. pre-run appended it, var Module = {}; ..generated code.. -// 4. External script tag defines var Module. -// We need to check if Module already exists (e.g. case 3 above). -// Substitution will be replaced with actual code on later stage of the build, -// this way Closure Compiler will not mangle it (e.g. case 4. above). -// Note that if you want to run closure, and also to use Module -// after the generated code, you will need to define var Module = {}; -// before the code. Then that object will be used in the code, and you -// can continue to use Module afterwards as well. -var Module = moduleArg; - -// Determine the runtime environment we are in. You can customize this by -// setting the ENVIRONMENT setting at compile time (see settings.js). -// Attempt to auto-detect the environment -var ENVIRONMENT_IS_WEB = typeof window == "object"; - -var ENVIRONMENT_IS_WORKER = typeof WorkerGlobalScope != "undefined"; - -// N.b. Electron.js environment is simultaneously a NODE-environment, but -// also a web environment. -var ENVIRONMENT_IS_NODE = typeof process == "object" && process.versions?.node && process.type != "renderer"; - -if (ENVIRONMENT_IS_NODE) { - // When building an ES module `require` is not normally available. - // We need to use `createRequire()` to construct the require()` function. - const {createRequire} = await import("module"); - /** @suppress{duplicate} */ var require = createRequire(import.meta.url); -} - -// --pre-jses are emitted after the Module integration code, so that they can -// refer to Module (if they choose; they can also define Module) -var arguments_ = []; - -var thisProgram = "./this.program"; - -var quit_ = (status, toThrow) => { - throw toThrow; -}; - -var _scriptName = import.meta.url; - -// `/` should be present at the end if `scriptDirectory` is not empty -var scriptDirectory = ""; - -function locateFile(path) { - if (Module["locateFile"]) { - return Module["locateFile"](path, scriptDirectory); - } - return scriptDirectory + path; -} - -// Hooks that are implemented differently in different runtime environments. -var readAsync, readBinary; - -if (ENVIRONMENT_IS_NODE) { - // These modules will usually be used on Node.js. Load them eagerly to avoid - // the complexity of lazy-loading. - var fs = require("fs"); - if (_scriptName.startsWith("file:")) { - scriptDirectory = require("path").dirname(require("url").fileURLToPath(_scriptName)) + "/"; - } - // include: node_shell_read.js - readBinary = filename => { - // We need to re-wrap `file://` strings to URLs. - filename = isFileURI(filename) ? new URL(filename) : filename; - var ret = fs.readFileSync(filename); - return ret; - }; - readAsync = async (filename, binary = true) => { - // See the comment in the `readBinary` function. - filename = isFileURI(filename) ? new URL(filename) : filename; - var ret = fs.readFileSync(filename, binary ? undefined : "utf8"); - return ret; - }; - // end include: node_shell_read.js - if (process.argv.length > 1) { - thisProgram = process.argv[1].replace(/\\/g, "/"); - } - arguments_ = process.argv.slice(2); - quit_ = (status, toThrow) => { - process.exitCode = status; - throw toThrow; - }; -} else // Note that this includes Node.js workers when relevant (pthreads is enabled). -// Node.js workers are detected as a combination of ENVIRONMENT_IS_WORKER and -// ENVIRONMENT_IS_NODE. -if (ENVIRONMENT_IS_WEB || ENVIRONMENT_IS_WORKER) { - try { - scriptDirectory = new URL(".", _scriptName).href; - } catch {} - { - // include: web_or_worker_shell_read.js - if (ENVIRONMENT_IS_WORKER) { - readBinary = url => { - var xhr = new XMLHttpRequest; - xhr.open("GET", url, false); - xhr.responseType = "arraybuffer"; - xhr.send(null); - return new Uint8Array(/** @type{!ArrayBuffer} */ (xhr.response)); - }; - } - readAsync = async url => { - // Fetch has some additional restrictions over XHR, like it can't be used on a file:// url. - // See https://github.com/github/fetch/pull/92#issuecomment-140665932 - // Cordova or Electron apps are typically loaded from a file:// url. - // So use XHR on webview if URL is a file URL. - if (isFileURI(url)) { - return new Promise((resolve, reject) => { - var xhr = new XMLHttpRequest; - xhr.open("GET", url, true); - xhr.responseType = "arraybuffer"; - xhr.onload = () => { - if (xhr.status == 200 || (xhr.status == 0 && xhr.response)) { - // file URLs can return 0 - resolve(xhr.response); - return; - } - reject(xhr.status); - }; - xhr.onerror = reject; - xhr.send(null); - }); - } - var response = await fetch(url, { - credentials: "same-origin" - }); - if (response.ok) { - return response.arrayBuffer(); - } - throw new Error(response.status + " : " + response.url); - }; - } -} else {} - -var out = console.log.bind(console); - -var err = console.error.bind(console); - -// end include: shell.js -// include: preamble.js -// === Preamble library stuff === -// Documentation for the public APIs defined in this file must be updated in: -// site/source/docs/api_reference/preamble.js.rst -// A prebuilt local version of the documentation is available at: -// site/build/text/docs/api_reference/preamble.js.txt -// You can also build docs locally as HTML or other formats in site/ -// An online HTML version (which may be of a different version of Emscripten) -// is up at http://kripken.github.io/emscripten-site/docs/api_reference/preamble.js.html -var wasmBinary; - -// Wasm globals -//======================================== -// Runtime essentials -//======================================== -// whether we are quitting the application. no code should run after this. -// set in exit() and abort() -var ABORT = false; - -/** - * Indicates whether filename is delivered via file protocol (as opposed to http/https) - * @noinline - */ var isFileURI = filename => filename.startsWith("file://"); - -// include: runtime_common.js -// include: runtime_stack_check.js -// end include: runtime_stack_check.js -// include: runtime_exceptions.js -// end include: runtime_exceptions.js -// include: runtime_debug.js -// end include: runtime_debug.js -var readyPromiseResolve, readyPromiseReject; - -// Memory management -var wasmMemory; - -var /** @type {!Int8Array} */ HEAP8, /** @type {!Uint8Array} */ HEAPU8, /** @type {!Int16Array} */ HEAP16, /** @type {!Uint16Array} */ HEAPU16, /** @type {!Int32Array} */ HEAP32, /** @type {!Uint32Array} */ HEAPU32, /** @type {!Float32Array} */ HEAPF32, /** @type {!Float64Array} */ HEAPF64; - -// BigInt64Array type is not correctly defined in closure -var /** not-@type {!BigInt64Array} */ HEAP64, /* BigUint64Array type is not correctly defined in closure -/** not-@type {!BigUint64Array} */ HEAPU64; - -var runtimeInitialized = false; - -function updateMemoryViews() { - var b = wasmMemory.buffer; - HEAP8 = new Int8Array(b); - HEAP16 = new Int16Array(b); - HEAPU8 = new Uint8Array(b); - HEAPU16 = new Uint16Array(b); - HEAP32 = new Int32Array(b); - HEAPU32 = new Uint32Array(b); - HEAPF32 = new Float32Array(b); - HEAPF64 = new Float64Array(b); - HEAP64 = new BigInt64Array(b); - HEAPU64 = new BigUint64Array(b); -} - -// include: memoryprofiler.js -// end include: memoryprofiler.js -// end include: runtime_common.js -function preRun() { - if (Module["preRun"]) { - if (typeof Module["preRun"] == "function") Module["preRun"] = [ Module["preRun"] ]; - while (Module["preRun"].length) { - addOnPreRun(Module["preRun"].shift()); - } - } - // Begin ATPRERUNS hooks - callRuntimeCallbacks(onPreRuns); -} - -function initRuntime() { - runtimeInitialized = true; - // No ATINITS hooks - wasmExports["A"](); -} - -function postRun() { - // PThreads reuse the runtime from the main thread. - if (Module["postRun"]) { - if (typeof Module["postRun"] == "function") Module["postRun"] = [ Module["postRun"] ]; - while (Module["postRun"].length) { - addOnPostRun(Module["postRun"].shift()); - } - } - // Begin ATPOSTRUNS hooks - callRuntimeCallbacks(onPostRuns); -} - -// A counter of dependencies for calling run(). If we need to -// do asynchronous work before running, increment this and -// decrement it. Incrementing must happen in a place like -// Module.preRun (used by emcc to add file preloading). -// Note that you can add dependencies in preRun, even though -// it happens right before run - run will be postponed until -// the dependencies are met. -var runDependencies = 0; - -var dependenciesFulfilled = null; - -// overridden to take different actions when all run dependencies are fulfilled -function addRunDependency(id) { - runDependencies++; - Module["monitorRunDependencies"]?.(runDependencies); -} - -function removeRunDependency(id) { - runDependencies--; - Module["monitorRunDependencies"]?.(runDependencies); - if (runDependencies == 0) { - if (dependenciesFulfilled) { - var callback = dependenciesFulfilled; - dependenciesFulfilled = null; - callback(); - } - } -} - -/** @param {string|number=} what */ function abort(what) { - Module["onAbort"]?.(what); - what = "Aborted(" + what + ")"; - // TODO(sbc): Should we remove printing and leave it up to whoever - // catches the exception? - err(what); - ABORT = true; - what += ". Build with -sASSERTIONS for more info."; - // Use a wasm runtime error, because a JS error might be seen as a foreign - // exception, which means we'd run destructors on it. We need the error to - // simply make the program stop. - // FIXME This approach does not work in Wasm EH because it currently does not assume - // all RuntimeErrors are from traps; it decides whether a RuntimeError is from - // a trap or not based on a hidden field within the object. So at the moment - // we don't have a way of throwing a wasm trap from JS. TODO Make a JS API that - // allows this in the wasm spec. - // Suppress closure compiler warning here. Closure compiler's builtin extern - // definition for WebAssembly.RuntimeError claims it takes no arguments even - // though it can. - // TODO(https://github.com/google/closure-compiler/pull/3913): Remove if/when upstream closure gets fixed. - /** @suppress {checkTypes} */ var e = new WebAssembly.RuntimeError(what); - readyPromiseReject?.(e); - // Throw the error whether or not MODULARIZE is set because abort is used - // in code paths apart from instantiation where an exception is expected - // to be thrown when abort is called. - throw e; -} - -var wasmBinaryFile; - -function findWasmBinary() { - if (Module["locateFile"]) { - return locateFile("worker_wasm.wasm"); - } - // Use bundler-friendly `new URL(..., import.meta.url)` pattern; works in browsers too. - return new URL("worker_wasm.wasm", import.meta.url).href; -} - -function getBinarySync(file) { - if (file == wasmBinaryFile && wasmBinary) { - return new Uint8Array(wasmBinary); - } - if (readBinary) { - return readBinary(file); - } - throw "both async and sync fetching of the wasm failed"; -} - -async function getWasmBinary(binaryFile) { - // If we don't have the binary yet, load it asynchronously using readAsync. - if (!wasmBinary) { - // Fetch the binary using readAsync - try { - var response = await readAsync(binaryFile); - return new Uint8Array(response); - } catch {} - } - // Otherwise, getBinarySync should be able to get it synchronously - return getBinarySync(binaryFile); -} - -async function instantiateArrayBuffer(binaryFile, imports) { - try { - var binary = await getWasmBinary(binaryFile); - var instance = await WebAssembly.instantiate(binary, imports); - return instance; - } catch (reason) { - err(`failed to asynchronously prepare wasm: ${reason}`); - abort(reason); - } -} - -async function instantiateAsync(binary, binaryFile, imports) { - if (!binary && typeof WebAssembly.instantiateStreaming == "function" && !isFileURI(binaryFile) && !ENVIRONMENT_IS_NODE) { - try { - var response = fetch(binaryFile, { - credentials: "same-origin" - }); - var instantiationResult = await WebAssembly.instantiateStreaming(response, imports); - return instantiationResult; - } catch (reason) { - // We expect the most common failure cause to be a bad MIME type for the binary, - // in which case falling back to ArrayBuffer instantiation should work. - err(`wasm streaming compile failed: ${reason}`); - err("falling back to ArrayBuffer instantiation"); - } - } - return instantiateArrayBuffer(binaryFile, imports); -} - -function getWasmImports() { - // prepare imports - return { - "a": wasmImports - }; -} - -// Create the wasm instance. -// Receives the wasm imports, returns the exports. -async function createWasm() { - // Load the wasm module and create an instance of using native support in the JS engine. - // handle a generated wasm instance, receiving its exports and - // performing other necessary setup - /** @param {WebAssembly.Module=} module*/ function receiveInstance(instance, module) { - wasmExports = instance.exports; - wasmMemory = wasmExports["z"]; - updateMemoryViews(); - wasmTable = wasmExports["B"]; - assignWasmExports(wasmExports); - removeRunDependency("wasm-instantiate"); - return wasmExports; - } - // wait for the pthread pool (if any) - addRunDependency("wasm-instantiate"); - // Prefer streaming instantiation if available. - function receiveInstantiationResult(result) { - // 'result' is a ResultObject object which has both the module and instance. - // receiveInstance() will swap in the exports (to Module.asm) so they can be called - // TODO: Due to Closure regression https://github.com/google/closure-compiler/issues/3193, the above line no longer optimizes out down to the following line. - // When the regression is fixed, can restore the above PTHREADS-enabled path. - return receiveInstance(result["instance"]); - } - var info = getWasmImports(); - // User shell pages can write their own Module.instantiateWasm = function(imports, successCallback) callback - // to manually instantiate the Wasm module themselves. This allows pages to - // run the instantiation parallel to any other async startup actions they are - // performing. - // Also pthreads and wasm workers initialize the wasm instance through this - // path. - if (Module["instantiateWasm"]) { - return new Promise((resolve, reject) => { - Module["instantiateWasm"](info, (mod, inst) => { - resolve(receiveInstance(mod, inst)); - }); - }); - } - wasmBinaryFile ??= findWasmBinary(); - var result = await instantiateAsync(wasmBinary, wasmBinaryFile, info); - var exports = receiveInstantiationResult(result); - return exports; -} - -// end include: preamble.js -// Begin JS library code -class ExitStatus { - name="ExitStatus"; - constructor(status) { - this.message = `Program terminated with exit(${status})`; - this.status = status; - } -} - -var callRuntimeCallbacks = callbacks => { - while (callbacks.length > 0) { - // Pass the module as the first argument. - callbacks.shift()(Module); - } -}; - -var onPostRuns = []; - -var addOnPostRun = cb => onPostRuns.push(cb); - -var onPreRuns = []; - -var addOnPreRun = cb => onPreRuns.push(cb); - -var noExitRuntime = true; - -class ExceptionInfo { - // excPtr - Thrown object pointer to wrap. Metadata pointer is calculated from it. - constructor(excPtr) { - this.excPtr = excPtr; - this.ptr = excPtr - 24; - } - set_type(type) { - HEAPU32[(((this.ptr) + (4)) >> 2)] = type; - } - get_type() { - return HEAPU32[(((this.ptr) + (4)) >> 2)]; - } - set_destructor(destructor) { - HEAPU32[(((this.ptr) + (8)) >> 2)] = destructor; - } - get_destructor() { - return HEAPU32[(((this.ptr) + (8)) >> 2)]; - } - set_caught(caught) { - caught = caught ? 1 : 0; - HEAP8[(this.ptr) + (12)] = caught; - } - get_caught() { - return HEAP8[(this.ptr) + (12)] != 0; - } - set_rethrown(rethrown) { - rethrown = rethrown ? 1 : 0; - HEAP8[(this.ptr) + (13)] = rethrown; - } - get_rethrown() { - return HEAP8[(this.ptr) + (13)] != 0; - } - // Initialize native structure fields. Should be called once after allocated. - init(type, destructor) { - this.set_adjusted_ptr(0); - this.set_type(type); - this.set_destructor(destructor); - } - set_adjusted_ptr(adjustedPtr) { - HEAPU32[(((this.ptr) + (16)) >> 2)] = adjustedPtr; - } - get_adjusted_ptr() { - return HEAPU32[(((this.ptr) + (16)) >> 2)]; - } -} - -var exceptionLast = 0; - -var uncaughtExceptionCount = 0; - -var ___cxa_throw = (ptr, type, destructor) => { - var info = new ExceptionInfo(ptr); - // Initialize ExceptionInfo content after it was allocated in __cxa_allocate_exception. - info.init(type, destructor); - exceptionLast = ptr; - uncaughtExceptionCount++; - throw exceptionLast; -}; - -var __abort_js = () => abort(""); - -var tupleRegistrations = {}; - -var runDestructors = destructors => { - while (destructors.length) { - var ptr = destructors.pop(); - var del = destructors.pop(); - del(ptr); - } -}; - -/** @suppress {globalThis} */ function readPointer(pointer) { - return this.fromWireType(HEAPU32[((pointer) >> 2)]); -} - -var awaitingDependencies = {}; - -var registeredTypes = {}; - -var typeDependencies = {}; - -var InternalError = class InternalError extends Error { - constructor(message) { - super(message); - this.name = "InternalError"; - } -}; - -var throwInternalError = message => { - throw new InternalError(message); -}; - -var whenDependentTypesAreResolved = (myTypes, dependentTypes, getTypeConverters) => { - myTypes.forEach(type => typeDependencies[type] = dependentTypes); - function onComplete(typeConverters) { - var myTypeConverters = getTypeConverters(typeConverters); - if (myTypeConverters.length !== myTypes.length) { - throwInternalError("Mismatched type converter count"); - } - for (var i = 0; i < myTypes.length; ++i) { - registerType(myTypes[i], myTypeConverters[i]); - } - } - var typeConverters = new Array(dependentTypes.length); - var unregisteredTypes = []; - var registered = 0; - dependentTypes.forEach((dt, i) => { - if (registeredTypes.hasOwnProperty(dt)) { - typeConverters[i] = registeredTypes[dt]; - } else { - unregisteredTypes.push(dt); - if (!awaitingDependencies.hasOwnProperty(dt)) { - awaitingDependencies[dt] = []; - } - awaitingDependencies[dt].push(() => { - typeConverters[i] = registeredTypes[dt]; - ++registered; - if (registered === unregisteredTypes.length) { - onComplete(typeConverters); - } - }); - } - }); - if (0 === unregisteredTypes.length) { - onComplete(typeConverters); - } -}; - -var __embind_finalize_value_array = rawTupleType => { - var reg = tupleRegistrations[rawTupleType]; - delete tupleRegistrations[rawTupleType]; - var elements = reg.elements; - var elementsLength = elements.length; - var elementTypes = elements.map(elt => elt.getterReturnType).concat(elements.map(elt => elt.setterArgumentType)); - var rawConstructor = reg.rawConstructor; - var rawDestructor = reg.rawDestructor; - whenDependentTypesAreResolved([ rawTupleType ], elementTypes, elementTypes => { - elements.forEach((elt, i) => { - var getterReturnType = elementTypes[i]; - var getter = elt.getter; - var getterContext = elt.getterContext; - var setterArgumentType = elementTypes[i + elementsLength]; - var setter = elt.setter; - var setterContext = elt.setterContext; - elt.read = ptr => getterReturnType.fromWireType(getter(getterContext, ptr)); - elt.write = (ptr, o) => { - var destructors = []; - setter(setterContext, ptr, setterArgumentType.toWireType(destructors, o)); - runDestructors(destructors); - }; - }); - return [ { - name: reg.name, - fromWireType: ptr => { - var rv = new Array(elementsLength); - for (var i = 0; i < elementsLength; ++i) { - rv[i] = elements[i].read(ptr); - } - rawDestructor(ptr); - return rv; - }, - toWireType: (destructors, o) => { - if (elementsLength !== o.length) { - throw new TypeError(`Incorrect number of tuple elements for ${reg.name}: expected=${elementsLength}, actual=${o.length}`); - } - var ptr = rawConstructor(); - for (var i = 0; i < elementsLength; ++i) { - elements[i].write(ptr, o[i]); - } - if (destructors !== null) { - destructors.push(rawDestructor, ptr); - } - return ptr; - }, - readValueFromPointer: readPointer, - destructorFunction: rawDestructor - } ]; - }); -}; - -var AsciiToString = ptr => { - var str = ""; - while (1) { - var ch = HEAPU8[ptr++]; - if (!ch) return str; - str += String.fromCharCode(ch); - } -}; - -var BindingError = class BindingError extends Error { - constructor(message) { - super(message); - this.name = "BindingError"; - } -}; - -var throwBindingError = message => { - throw new BindingError(message); -}; - -/** @param {Object=} options */ function sharedRegisterType(rawType, registeredInstance, options = {}) { - var name = registeredInstance.name; - if (!rawType) { - throwBindingError(`type "${name}" must have a positive integer typeid pointer`); - } - if (registeredTypes.hasOwnProperty(rawType)) { - if (options.ignoreDuplicateRegistrations) { - return; - } else { - throwBindingError(`Cannot register type '${name}' twice`); - } - } - registeredTypes[rawType] = registeredInstance; - delete typeDependencies[rawType]; - if (awaitingDependencies.hasOwnProperty(rawType)) { - var callbacks = awaitingDependencies[rawType]; - delete awaitingDependencies[rawType]; - callbacks.forEach(cb => cb()); - } -} - -/** @param {Object=} options */ function registerType(rawType, registeredInstance, options = {}) { - return sharedRegisterType(rawType, registeredInstance, options); -} - -var integerReadValueFromPointer = (name, width, signed) => { - // integers are quite common, so generate very specialized functions - switch (width) { - case 1: - return signed ? pointer => HEAP8[pointer] : pointer => HEAPU8[pointer]; - - case 2: - return signed ? pointer => HEAP16[((pointer) >> 1)] : pointer => HEAPU16[((pointer) >> 1)]; - - case 4: - return signed ? pointer => HEAP32[((pointer) >> 2)] : pointer => HEAPU32[((pointer) >> 2)]; - - case 8: - return signed ? pointer => HEAP64[((pointer) >> 3)] : pointer => HEAPU64[((pointer) >> 3)]; - - default: - throw new TypeError(`invalid integer width (${width}): ${name}`); - } -}; - -/** @suppress {globalThis} */ var __embind_register_bigint = (primitiveType, name, size, minRange, maxRange) => { - name = AsciiToString(name); - const isUnsignedType = minRange === 0n; - let fromWireType = value => value; - if (isUnsignedType) { - // uint64 get converted to int64 in ABI, fix them up like we do for 32-bit integers. - const bitSize = size * 8; - fromWireType = value => BigInt.asUintN(bitSize, value); - maxRange = fromWireType(maxRange); - } - registerType(primitiveType, { - name, - fromWireType, - toWireType: (destructors, value) => { - if (typeof value == "number") { - value = BigInt(value); - } - return value; - }, - readValueFromPointer: integerReadValueFromPointer(name, size, !isUnsignedType), - destructorFunction: null - }); -}; - -/** @suppress {globalThis} */ var __embind_register_bool = (rawType, name, trueValue, falseValue) => { - name = AsciiToString(name); - registerType(rawType, { - name, - fromWireType: function(wt) { - // ambiguous emscripten ABI: sometimes return values are - // true or false, and sometimes integers (0 or 1) - return !!wt; - }, - toWireType: function(destructors, o) { - return o ? trueValue : falseValue; - }, - readValueFromPointer: function(pointer) { - return this.fromWireType(HEAPU8[pointer]); - }, - destructorFunction: null - }); -}; - -var emval_freelist = []; - -var emval_handles = [ 0, 1, , 1, null, 1, true, 1, false, 1 ]; - -var __emval_decref = handle => { - if (handle > 9 && 0 === --emval_handles[handle + 1]) { - emval_handles[handle] = undefined; - emval_freelist.push(handle); - } -}; - -var Emval = { - toValue: handle => { - if (!handle) { - throwBindingError(`Cannot use deleted val. handle = ${handle}`); - } - return emval_handles[handle]; - }, - toHandle: value => { - switch (value) { - case undefined: - return 2; - - case null: - return 4; - - case true: - return 6; - - case false: - return 8; - - default: - { - const handle = emval_freelist.pop() || emval_handles.length; - emval_handles[handle] = value; - emval_handles[handle + 1] = 1; - return handle; - } - } - } -}; - -var EmValType = { - name: "emscripten::val", - fromWireType: handle => { - var rv = Emval.toValue(handle); - __emval_decref(handle); - return rv; - }, - toWireType: (destructors, value) => Emval.toHandle(value), - readValueFromPointer: readPointer, - destructorFunction: null -}; - -var __embind_register_emval = rawType => registerType(rawType, EmValType); - -var floatReadValueFromPointer = (name, width) => { - switch (width) { - case 4: - return function(pointer) { - return this.fromWireType(HEAPF32[((pointer) >> 2)]); - }; - - case 8: - return function(pointer) { - return this.fromWireType(HEAPF64[((pointer) >> 3)]); - }; - - default: - throw new TypeError(`invalid float width (${width}): ${name}`); - } -}; - -var __embind_register_float = (rawType, name, size) => { - name = AsciiToString(name); - registerType(rawType, { - name, - fromWireType: value => value, - toWireType: (destructors, value) => value, - readValueFromPointer: floatReadValueFromPointer(name, size), - destructorFunction: null - }); -}; - -var createNamedFunction = (name, func) => Object.defineProperty(func, "name", { - value: name -}); - -function usesDestructorStack(argTypes) { - // Skip return value at index 0 - it's not deleted here. - for (var i = 1; i < argTypes.length; ++i) { - // The type does not define a destructor function - must use dynamic stack - if (argTypes[i] !== null && argTypes[i].destructorFunction === undefined) { - return true; - } - } - return false; -} - -function createJsInvoker(argTypes, isClassMethodFunc, returns, isAsync) { - var needsDestructorStack = usesDestructorStack(argTypes); - var argCount = argTypes.length - 2; - var argsList = []; - var argsListWired = [ "fn" ]; - if (isClassMethodFunc) { - argsListWired.push("thisWired"); - } - for (var i = 0; i < argCount; ++i) { - argsList.push(`arg${i}`); - argsListWired.push(`arg${i}Wired`); - } - argsList = argsList.join(","); - argsListWired = argsListWired.join(","); - var invokerFnBody = `return function (${argsList}) {\n`; - if (needsDestructorStack) { - invokerFnBody += "var destructors = [];\n"; - } - var dtorStack = needsDestructorStack ? "destructors" : "null"; - var args1 = [ "humanName", "throwBindingError", "invoker", "fn", "runDestructors", "fromRetWire", "toClassParamWire" ]; - if (isClassMethodFunc) { - invokerFnBody += `var thisWired = toClassParamWire(${dtorStack}, this);\n`; - } - for (var i = 0; i < argCount; ++i) { - var argName = `toArg${i}Wire`; - invokerFnBody += `var arg${i}Wired = ${argName}(${dtorStack}, arg${i});\n`; - args1.push(argName); - } - invokerFnBody += (returns || isAsync ? "var rv = " : "") + `invoker(${argsListWired});\n`; - if (needsDestructorStack) { - invokerFnBody += "runDestructors(destructors);\n"; - } else { - for (var i = isClassMethodFunc ? 1 : 2; i < argTypes.length; ++i) { - // Skip return value at index 0 - it's not deleted here. Also skip class type if not a method. - var paramName = (i === 1 ? "thisWired" : ("arg" + (i - 2) + "Wired")); - if (argTypes[i].destructorFunction !== null) { - invokerFnBody += `${paramName}_dtor(${paramName});\n`; - args1.push(`${paramName}_dtor`); - } - } - } - if (returns) { - invokerFnBody += "var ret = fromRetWire(rv);\n" + "return ret;\n"; - } else {} - invokerFnBody += "}\n"; - return new Function(args1, invokerFnBody); -} - -function craftInvokerFunction(humanName, argTypes, classType, cppInvokerFunc, cppTargetFunc, /** boolean= */ isAsync) { - // humanName: a human-readable string name for the function to be generated. - // argTypes: An array that contains the embind type objects for all types in the function signature. - // argTypes[0] is the type object for the function return value. - // argTypes[1] is the type object for function this object/class type, or null if not crafting an invoker for a class method. - // argTypes[2...] are the actual function parameters. - // classType: The embind type object for the class to be bound, or null if this is not a method of a class. - // cppInvokerFunc: JS Function object to the C++-side function that interops into C++ code. - // cppTargetFunc: Function pointer (an integer to FUNCTION_TABLE) to the target C++ function the cppInvokerFunc will end up calling. - // isAsync: Optional. If true, returns an async function. Async bindings are only supported with JSPI. - var argCount = argTypes.length; - if (argCount < 2) { - throwBindingError("argTypes array size mismatch! Must at least get return value and 'this' types!"); - } - var isClassMethodFunc = (argTypes[1] !== null && classType !== null); - // Free functions with signature "void function()" do not need an invoker that marshalls between wire types. - // TODO: This omits argument count check - enable only at -O3 or similar. - // if (ENABLE_UNSAFE_OPTS && argCount == 2 && argTypes[0].name == "void" && !isClassMethodFunc) { - // return FUNCTION_TABLE[fn]; - // } - // Determine if we need to use a dynamic stack to store the destructors for the function parameters. - // TODO: Remove this completely once all function invokers are being dynamically generated. - var needsDestructorStack = usesDestructorStack(argTypes); - var returns = !argTypes[0].isVoid; - // Builld the arguments that will be passed into the closure around the invoker - // function. - var retType = argTypes[0]; - var instType = argTypes[1]; - var closureArgs = [ humanName, throwBindingError, cppInvokerFunc, cppTargetFunc, runDestructors, retType.fromWireType.bind(retType), instType?.toWireType.bind(instType) ]; - for (var i = 2; i < argCount; ++i) { - var argType = argTypes[i]; - closureArgs.push(argType.toWireType.bind(argType)); - } - if (!needsDestructorStack) { - // Skip return value at index 0 - it's not deleted here. Also skip class type if not a method. - for (var i = isClassMethodFunc ? 1 : 2; i < argTypes.length; ++i) { - if (argTypes[i].destructorFunction !== null) { - closureArgs.push(argTypes[i].destructorFunction); - } - } - } - let invokerFactory = createJsInvoker(argTypes, isClassMethodFunc, returns, isAsync); - var invokerFn = invokerFactory(...closureArgs); - return createNamedFunction(humanName, invokerFn); -} - -var ensureOverloadTable = (proto, methodName, humanName) => { - if (undefined === proto[methodName].overloadTable) { - var prevFunc = proto[methodName]; - // Inject an overload resolver function that routes to the appropriate overload based on the number of arguments. - proto[methodName] = function(...args) { - // TODO This check can be removed in -O3 level "unsafe" optimizations. - if (!proto[methodName].overloadTable.hasOwnProperty(args.length)) { - throwBindingError(`Function '${humanName}' called with an invalid number of arguments (${args.length}) - expects one of (${proto[methodName].overloadTable})!`); - } - return proto[methodName].overloadTable[args.length].apply(this, args); - }; - // Move the previous function into the overload table. - proto[methodName].overloadTable = []; - proto[methodName].overloadTable[prevFunc.argCount] = prevFunc; - } -}; - -/** @param {number=} numArguments */ var exposePublicSymbol = (name, value, numArguments) => { - if (Module.hasOwnProperty(name)) { - if (undefined === numArguments || (undefined !== Module[name].overloadTable && undefined !== Module[name].overloadTable[numArguments])) { - throwBindingError(`Cannot register public name '${name}' twice`); - } - // We are exposing a function with the same name as an existing function. Create an overload table and a function selector - // that routes between the two. - ensureOverloadTable(Module, name, name); - if (Module[name].overloadTable.hasOwnProperty(numArguments)) { - throwBindingError(`Cannot register multiple overloads of a function with the same number of arguments (${numArguments})!`); - } - // Add the new function into the overload table. - Module[name].overloadTable[numArguments] = value; - } else { - Module[name] = value; - Module[name].argCount = numArguments; - } -}; - -var heap32VectorToArray = (count, firstElement) => { - var array = []; - for (var i = 0; i < count; i++) { - // TODO(https://github.com/emscripten-core/emscripten/issues/17310): - // Find a way to hoist the `>> 2` or `>> 3` out of this loop. - array.push(HEAPU32[(((firstElement) + (i * 4)) >> 2)]); - } - return array; -}; - -/** @param {number=} numArguments */ var replacePublicSymbol = (name, value, numArguments) => { - if (!Module.hasOwnProperty(name)) { - throwInternalError("Replacing nonexistent public symbol"); - } - // If there's an overload table for this symbol, replace the symbol in the overload table instead. - if (undefined !== Module[name].overloadTable && undefined !== numArguments) { - Module[name].overloadTable[numArguments] = value; - } else { - Module[name] = value; - Module[name].argCount = numArguments; - } -}; - -var wasmTableMirror = []; - -/** @type {WebAssembly.Table} */ var wasmTable; - -var getWasmTableEntry = funcPtr => { - var func = wasmTableMirror[funcPtr]; - if (!func) { - /** @suppress {checkTypes} */ wasmTableMirror[funcPtr] = func = wasmTable.get(funcPtr); - } - return func; -}; - -var embind__requireFunction = (signature, rawFunction, isAsync = false) => { - signature = AsciiToString(signature); - function makeDynCaller() { - var rtn = getWasmTableEntry(rawFunction); - return rtn; - } - var fp = makeDynCaller(); - if (typeof fp != "function") { - throwBindingError(`unknown function pointer with signature ${signature}: ${rawFunction}`); - } - return fp; -}; - -class UnboundTypeError extends Error {} - -var getTypeName = type => { - var ptr = ___getTypeName(type); - var rv = AsciiToString(ptr); - _free(ptr); - return rv; -}; - -var throwUnboundTypeError = (message, types) => { - var unboundTypes = []; - var seen = {}; - function visit(type) { - if (seen[type]) { - return; - } - if (registeredTypes[type]) { - return; - } - if (typeDependencies[type]) { - typeDependencies[type].forEach(visit); - return; - } - unboundTypes.push(type); - seen[type] = true; - } - types.forEach(visit); - throw new UnboundTypeError(`${message}: ` + unboundTypes.map(getTypeName).join([ ", " ])); -}; - -var getFunctionName = signature => { - signature = signature.trim(); - const argsIndex = signature.indexOf("("); - if (argsIndex === -1) return signature; - return signature.slice(0, argsIndex); -}; - -var __embind_register_function = (name, argCount, rawArgTypesAddr, signature, rawInvoker, fn, isAsync, isNonnullReturn) => { - var argTypes = heap32VectorToArray(argCount, rawArgTypesAddr); - name = AsciiToString(name); - name = getFunctionName(name); - rawInvoker = embind__requireFunction(signature, rawInvoker, isAsync); - exposePublicSymbol(name, function() { - throwUnboundTypeError(`Cannot call ${name} due to unbound types`, argTypes); - }, argCount - 1); - whenDependentTypesAreResolved([], argTypes, argTypes => { - var invokerArgsArray = [ argTypes[0], null ].concat(argTypes.slice(1)); - replacePublicSymbol(name, craftInvokerFunction(name, invokerArgsArray, null, rawInvoker, fn, isAsync), argCount - 1); - return []; - }); -}; - -/** @suppress {globalThis} */ var __embind_register_integer = (primitiveType, name, size, minRange, maxRange) => { - name = AsciiToString(name); - const isUnsignedType = minRange === 0; - let fromWireType = value => value; - if (isUnsignedType) { - var bitshift = 32 - 8 * size; - fromWireType = value => (value << bitshift) >>> bitshift; - maxRange = fromWireType(maxRange); - } - registerType(primitiveType, { - name, - fromWireType, - toWireType: (destructors, value) => value, - readValueFromPointer: integerReadValueFromPointer(name, size, minRange !== 0), - destructorFunction: null - }); -}; - -var __embind_register_memory_view = (rawType, dataTypeIndex, name) => { - var typeMapping = [ Int8Array, Uint8Array, Int16Array, Uint16Array, Int32Array, Uint32Array, Float32Array, Float64Array, BigInt64Array, BigUint64Array ]; - var TA = typeMapping[dataTypeIndex]; - function decodeMemoryView(handle) { - var size = HEAPU32[((handle) >> 2)]; - var data = HEAPU32[(((handle) + (4)) >> 2)]; - return new TA(HEAP8.buffer, data, size); - } - name = AsciiToString(name); - registerType(rawType, { - name, - fromWireType: decodeMemoryView, - readValueFromPointer: decodeMemoryView - }, { - ignoreDuplicateRegistrations: true - }); -}; - -var stringToUTF8Array = (str, heap, outIdx, maxBytesToWrite) => { - // Parameter maxBytesToWrite is not optional. Negative values, 0, null, - // undefined and false each don't write out any bytes. - if (!(maxBytesToWrite > 0)) return 0; - var startIdx = outIdx; - var endIdx = outIdx + maxBytesToWrite - 1; - // -1 for string null terminator. - for (var i = 0; i < str.length; ++i) { - // For UTF8 byte structure, see http://en.wikipedia.org/wiki/UTF-8#Description - // and https://www.ietf.org/rfc/rfc2279.txt - // and https://tools.ietf.org/html/rfc3629 - var u = str.codePointAt(i); - if (u <= 127) { - if (outIdx >= endIdx) break; - heap[outIdx++] = u; - } else if (u <= 2047) { - if (outIdx + 1 >= endIdx) break; - heap[outIdx++] = 192 | (u >> 6); - heap[outIdx++] = 128 | (u & 63); - } else if (u <= 65535) { - if (outIdx + 2 >= endIdx) break; - heap[outIdx++] = 224 | (u >> 12); - heap[outIdx++] = 128 | ((u >> 6) & 63); - heap[outIdx++] = 128 | (u & 63); - } else { - if (outIdx + 3 >= endIdx) break; - heap[outIdx++] = 240 | (u >> 18); - heap[outIdx++] = 128 | ((u >> 12) & 63); - heap[outIdx++] = 128 | ((u >> 6) & 63); - heap[outIdx++] = 128 | (u & 63); - // Gotcha: if codePoint is over 0xFFFF, it is represented as a surrogate pair in UTF-16. - // We need to manually skip over the second code unit for correct iteration. - i++; - } - } - // Null-terminate the pointer to the buffer. - heap[outIdx] = 0; - return outIdx - startIdx; -}; - -var stringToUTF8 = (str, outPtr, maxBytesToWrite) => stringToUTF8Array(str, HEAPU8, outPtr, maxBytesToWrite); - -var lengthBytesUTF8 = str => { - var len = 0; - for (var i = 0; i < str.length; ++i) { - // Gotcha: charCodeAt returns a 16-bit word that is a UTF-16 encoded code - // unit, not a Unicode code point of the character! So decode - // UTF16->UTF32->UTF8. - // See http://unicode.org/faq/utf_bom.html#utf16-3 - var c = str.charCodeAt(i); - // possibly a lead surrogate - if (c <= 127) { - len++; - } else if (c <= 2047) { - len += 2; - } else if (c >= 55296 && c <= 57343) { - len += 4; - ++i; - } else { - len += 3; - } - } - return len; -}; - -var UTF8Decoder = typeof TextDecoder != "undefined" ? new TextDecoder : undefined; - -var findStringEnd = (heapOrArray, idx, maxBytesToRead, ignoreNul) => { - var maxIdx = idx + maxBytesToRead; - if (ignoreNul) return maxIdx; - // TextDecoder needs to know the byte length in advance, it doesn't stop on - // null terminator by itself. - // As a tiny code save trick, compare idx against maxIdx using a negation, - // so that maxBytesToRead=undefined/NaN means Infinity. - while (heapOrArray[idx] && !(idx >= maxIdx)) ++idx; - return idx; -}; - -/** - * Given a pointer 'idx' to a null-terminated UTF8-encoded string in the given - * array that contains uint8 values, returns a copy of that string as a - * Javascript String object. - * heapOrArray is either a regular array, or a JavaScript typed array view. - * @param {number=} idx - * @param {number=} maxBytesToRead - * @param {boolean=} ignoreNul - If true, the function will not stop on a NUL character. - * @return {string} - */ var UTF8ArrayToString = (heapOrArray, idx = 0, maxBytesToRead, ignoreNul) => { - var endPtr = findStringEnd(heapOrArray, idx, maxBytesToRead, ignoreNul); - // When using conditional TextDecoder, skip it for short strings as the overhead of the native call is not worth it. - if (endPtr - idx > 16 && heapOrArray.buffer && UTF8Decoder) { - return UTF8Decoder.decode(heapOrArray.subarray(idx, endPtr)); - } - var str = ""; - // If building with TextDecoder, we have already computed the string length - // above, so test loop end condition against that - while (idx < endPtr) { - // For UTF8 byte structure, see: - // http://en.wikipedia.org/wiki/UTF-8#Description - // https://www.ietf.org/rfc/rfc2279.txt - // https://tools.ietf.org/html/rfc3629 - var u0 = heapOrArray[idx++]; - if (!(u0 & 128)) { - str += String.fromCharCode(u0); - continue; - } - var u1 = heapOrArray[idx++] & 63; - if ((u0 & 224) == 192) { - str += String.fromCharCode(((u0 & 31) << 6) | u1); - continue; - } - var u2 = heapOrArray[idx++] & 63; - if ((u0 & 240) == 224) { - u0 = ((u0 & 15) << 12) | (u1 << 6) | u2; - } else { - u0 = ((u0 & 7) << 18) | (u1 << 12) | (u2 << 6) | (heapOrArray[idx++] & 63); - } - if (u0 < 65536) { - str += String.fromCharCode(u0); - } else { - var ch = u0 - 65536; - str += String.fromCharCode(55296 | (ch >> 10), 56320 | (ch & 1023)); - } - } - return str; -}; - -/** - * Given a pointer 'ptr' to a null-terminated UTF8-encoded string in the - * emscripten HEAP, returns a copy of that string as a Javascript String object. - * - * @param {number} ptr - * @param {number=} maxBytesToRead - An optional length that specifies the - * maximum number of bytes to read. You can omit this parameter to scan the - * string until the first 0 byte. If maxBytesToRead is passed, and the string - * at [ptr, ptr+maxBytesToReadr[ contains a null byte in the middle, then the - * string will cut short at that byte index. - * @param {boolean=} ignoreNul - If true, the function will not stop on a NUL character. - * @return {string} - */ var UTF8ToString = (ptr, maxBytesToRead, ignoreNul) => ptr ? UTF8ArrayToString(HEAPU8, ptr, maxBytesToRead, ignoreNul) : ""; - -var __embind_register_std_string = (rawType, name) => { - name = AsciiToString(name); - var stdStringIsUTF8 = true; - registerType(rawType, { - name, - // For some method names we use string keys here since they are part of - // the public/external API and/or used by the runtime-generated code. - fromWireType(value) { - var length = HEAPU32[((value) >> 2)]; - var payload = value + 4; - var str; - if (stdStringIsUTF8) { - str = UTF8ToString(payload, length, true); - } else { - str = ""; - for (var i = 0; i < length; ++i) { - str += String.fromCharCode(HEAPU8[payload + i]); - } - } - _free(value); - return str; - }, - toWireType(destructors, value) { - if (value instanceof ArrayBuffer) { - value = new Uint8Array(value); - } - var length; - var valueIsOfTypeString = (typeof value == "string"); - // We accept `string` or array views with single byte elements - if (!(valueIsOfTypeString || (ArrayBuffer.isView(value) && value.BYTES_PER_ELEMENT == 1))) { - throwBindingError("Cannot pass non-string to std::string"); - } - if (stdStringIsUTF8 && valueIsOfTypeString) { - length = lengthBytesUTF8(value); - } else { - length = value.length; - } - // assumes POINTER_SIZE alignment - var base = _malloc(4 + length + 1); - var ptr = base + 4; - HEAPU32[((base) >> 2)] = length; - if (valueIsOfTypeString) { - if (stdStringIsUTF8) { - stringToUTF8(value, ptr, length + 1); - } else { - for (var i = 0; i < length; ++i) { - var charCode = value.charCodeAt(i); - if (charCode > 255) { - _free(base); - throwBindingError("String has UTF-16 code units that do not fit in 8 bits"); - } - HEAPU8[ptr + i] = charCode; - } - } - } else { - HEAPU8.set(value, ptr); - } - if (destructors !== null) { - destructors.push(_free, base); - } - return base; - }, - readValueFromPointer: readPointer, - destructorFunction(ptr) { - _free(ptr); - } - }); -}; - -var UTF16Decoder = typeof TextDecoder != "undefined" ? new TextDecoder("utf-16le") : undefined; - -var UTF16ToString = (ptr, maxBytesToRead, ignoreNul) => { - var idx = ((ptr) >> 1); - var endIdx = findStringEnd(HEAPU16, idx, maxBytesToRead / 2, ignoreNul); - // When using conditional TextDecoder, skip it for short strings as the overhead of the native call is not worth it. - if (endIdx - idx > 16 && UTF16Decoder) return UTF16Decoder.decode(HEAPU16.subarray(idx, endIdx)); - // Fallback: decode without UTF16Decoder - var str = ""; - // If maxBytesToRead is not passed explicitly, it will be undefined, and the - // for-loop's condition will always evaluate to true. The loop is then - // terminated on the first null char. - for (var i = idx; // If building with TextDecoder, we have already computed the string length - // above, so test loop end condition against that - i < endIdx; ++i) { - var codeUnit = HEAPU16[i]; - // fromCharCode constructs a character from a UTF-16 code unit, so we can - // pass the UTF16 string right through. - str += String.fromCharCode(codeUnit); - } - return str; -}; - -var stringToUTF16 = (str, outPtr, maxBytesToWrite) => { - // Backwards compatibility: if max bytes is not specified, assume unsafe unbounded write is allowed. - maxBytesToWrite ??= 2147483647; - if (maxBytesToWrite < 2) return 0; - maxBytesToWrite -= 2; - // Null terminator. - var startPtr = outPtr; - var numCharsToWrite = (maxBytesToWrite < str.length * 2) ? (maxBytesToWrite / 2) : str.length; - for (var i = 0; i < numCharsToWrite; ++i) { - // charCodeAt returns a UTF-16 encoded code unit, so it can be directly written to the HEAP. - var codeUnit = str.charCodeAt(i); - // possibly a lead surrogate - HEAP16[((outPtr) >> 1)] = codeUnit; - outPtr += 2; - } - // Null-terminate the pointer to the HEAP. - HEAP16[((outPtr) >> 1)] = 0; - return outPtr - startPtr; -}; - -var lengthBytesUTF16 = str => str.length * 2; - -var UTF32ToString = (ptr, maxBytesToRead, ignoreNul) => { - var str = ""; - var startIdx = ((ptr) >> 2); - // If maxBytesToRead is not passed explicitly, it will be undefined, and this - // will always evaluate to true. This saves on code size. - for (var i = 0; !(i >= maxBytesToRead / 4); i++) { - var utf32 = HEAPU32[startIdx + i]; - if (!utf32 && !ignoreNul) break; - str += String.fromCodePoint(utf32); - } - return str; -}; - -var stringToUTF32 = (str, outPtr, maxBytesToWrite) => { - // Backwards compatibility: if max bytes is not specified, assume unsafe unbounded write is allowed. - maxBytesToWrite ??= 2147483647; - if (maxBytesToWrite < 4) return 0; - var startPtr = outPtr; - var endPtr = startPtr + maxBytesToWrite - 4; - for (var i = 0; i < str.length; ++i) { - var codePoint = str.codePointAt(i); - // Gotcha: if codePoint is over 0xFFFF, it is represented as a surrogate pair in UTF-16. - // We need to manually skip over the second code unit for correct iteration. - if (codePoint > 65535) { - i++; - } - HEAP32[((outPtr) >> 2)] = codePoint; - outPtr += 4; - if (outPtr + 4 > endPtr) break; - } - // Null-terminate the pointer to the HEAP. - HEAP32[((outPtr) >> 2)] = 0; - return outPtr - startPtr; -}; - -var lengthBytesUTF32 = str => { - var len = 0; - for (var i = 0; i < str.length; ++i) { - var codePoint = str.codePointAt(i); - // Gotcha: if codePoint is over 0xFFFF, it is represented as a surrogate pair in UTF-16. - // We need to manually skip over the second code unit for correct iteration. - if (codePoint > 65535) { - i++; - } - len += 4; - } - return len; -}; - -var __embind_register_std_wstring = (rawType, charSize, name) => { - name = AsciiToString(name); - var decodeString, encodeString, lengthBytesUTF; - if (charSize === 2) { - decodeString = UTF16ToString; - encodeString = stringToUTF16; - lengthBytesUTF = lengthBytesUTF16; - } else { - decodeString = UTF32ToString; - encodeString = stringToUTF32; - lengthBytesUTF = lengthBytesUTF32; - } - registerType(rawType, { - name, - fromWireType: value => { - // Code mostly taken from _embind_register_std_string fromWireType - var length = HEAPU32[((value) >> 2)]; - var str = decodeString(value + 4, length * charSize, true); - _free(value); - return str; - }, - toWireType: (destructors, value) => { - if (!(typeof value == "string")) { - throwBindingError(`Cannot pass non-string to C++ string type ${name}`); - } - // assumes POINTER_SIZE alignment - var length = lengthBytesUTF(value); - var ptr = _malloc(4 + length + charSize); - HEAPU32[((ptr) >> 2)] = length / charSize; - encodeString(value, ptr + 4, length + charSize); - if (destructors !== null) { - destructors.push(_free, ptr); - } - return ptr; - }, - readValueFromPointer: readPointer, - destructorFunction(ptr) { - _free(ptr); - } - }); -}; - -var __embind_register_value_array = (rawType, name, constructorSignature, rawConstructor, destructorSignature, rawDestructor) => { - tupleRegistrations[rawType] = { - name: AsciiToString(name), - rawConstructor: embind__requireFunction(constructorSignature, rawConstructor), - rawDestructor: embind__requireFunction(destructorSignature, rawDestructor), - elements: [] - }; -}; - -var __embind_register_value_array_element = (rawTupleType, getterReturnType, getterSignature, getter, getterContext, setterArgumentType, setterSignature, setter, setterContext) => { - tupleRegistrations[rawTupleType].elements.push({ - getterReturnType, - getter: embind__requireFunction(getterSignature, getter), - getterContext, - setterArgumentType, - setter: embind__requireFunction(setterSignature, setter), - setterContext - }); -}; - -var __embind_register_void = (rawType, name) => { - name = AsciiToString(name); - registerType(rawType, { - isVoid: true, - // void return values can be optimized out sometimes - name, - fromWireType: () => undefined, - // TODO: assert if anything else is given? - toWireType: (destructors, o) => undefined - }); -}; - -var emval_methodCallers = []; - -var emval_addMethodCaller = caller => { - var id = emval_methodCallers.length; - emval_methodCallers.push(caller); - return id; -}; - -var requireRegisteredType = (rawType, humanName) => { - var impl = registeredTypes[rawType]; - if (undefined === impl) { - throwBindingError(`${humanName} has unknown type ${getTypeName(rawType)}`); - } - return impl; -}; - -var emval_lookupTypes = (argCount, argTypes) => { - var a = new Array(argCount); - for (var i = 0; i < argCount; ++i) { - a[i] = requireRegisteredType(HEAPU32[(((argTypes) + (i * 4)) >> 2)], `parameter ${i}`); - } - return a; -}; - -var emval_returnValue = (toReturnWire, destructorsRef, handle) => { - var destructors = []; - var result = toReturnWire(destructors, handle); - if (destructors.length) { - // void, primitives and any other types w/o destructors don't need to allocate a handle - HEAPU32[((destructorsRef) >> 2)] = Emval.toHandle(destructors); - } - return result; -}; - -var emval_symbols = {}; - -var getStringOrSymbol = address => { - var symbol = emval_symbols[address]; - if (symbol === undefined) { - return AsciiToString(address); - } - return symbol; -}; - -var __emval_create_invoker = (argCount, argTypesPtr, kind) => { - var GenericWireTypeSize = 8; - var [retType, ...argTypes] = emval_lookupTypes(argCount, argTypesPtr); - var toReturnWire = retType.toWireType.bind(retType); - var argFromPtr = argTypes.map(type => type.readValueFromPointer.bind(type)); - argCount--; - // remove the extracted return type - var captures = { - "toValue": Emval.toValue - }; - var args = argFromPtr.map((argFromPtr, i) => { - var captureName = `argFromPtr${i}`; - captures[captureName] = argFromPtr; - return `${captureName}(args${i ? "+" + i * GenericWireTypeSize : ""})`; - }); - var functionBody; - switch (kind) { - case 0: - functionBody = "toValue(handle)"; - break; - - case 2: - functionBody = "new (toValue(handle))"; - break; - - case 3: - functionBody = ""; - break; - - case 1: - captures["getStringOrSymbol"] = getStringOrSymbol; - functionBody = "toValue(handle)[getStringOrSymbol(methodName)]"; - break; - } - functionBody += `(${args})`; - if (!retType.isVoid) { - captures["toReturnWire"] = toReturnWire; - captures["emval_returnValue"] = emval_returnValue; - functionBody = `return emval_returnValue(toReturnWire, destructorsRef, ${functionBody})`; - } - functionBody = `return function (handle, methodName, destructorsRef, args) {\n ${functionBody}\n }`; - var invokerFunction = new Function(Object.keys(captures), functionBody)(...Object.values(captures)); - var functionName = `methodCaller<(${argTypes.map(t => t.name)}) => ${retType.name}>`; - return emval_addMethodCaller(createNamedFunction(functionName, invokerFunction)); -}; - -var __emval_get_property = (handle, key) => { - handle = Emval.toValue(handle); - key = Emval.toValue(key); - return Emval.toHandle(handle[key]); -}; - -var __emval_incref = handle => { - if (handle > 9) { - emval_handles[handle + 1] += 1; - } -}; - -var __emval_invoke = (caller, handle, methodName, destructorsRef, args) => emval_methodCallers[caller](handle, methodName, destructorsRef, args); - -var __emval_new_array = () => Emval.toHandle([]); - -var __emval_new_array_from_memory_view = view => { - view = Emval.toValue(view); - // using for..loop is faster than Array.from - var a = new Array(view.length); - for (var i = 0; i < view.length; i++) a[i] = view[i]; - return Emval.toHandle(a); -}; - -var __emval_new_cstring = v => Emval.toHandle(getStringOrSymbol(v)); - -var __emval_run_destructors = handle => { - var destructors = Emval.toValue(handle); - runDestructors(destructors); - __emval_decref(handle); -}; - -var getHeapMax = () => // Stay one Wasm page short of 4GB: while e.g. Chrome is able to allocate -// full 4GB Wasm memories, the size will wrap back to 0 bytes in Wasm side -// for any code that deals with heap sizes, which would require special -// casing all heap size related code to treat 0 specially. -2147483648; - -var alignMemory = (size, alignment) => Math.ceil(size / alignment) * alignment; - -var growMemory = size => { - var oldHeapSize = wasmMemory.buffer.byteLength; - var pages = ((size - oldHeapSize + 65535) / 65536) | 0; - try { - // round size grow request up to wasm page size (fixed 64KB per spec) - wasmMemory.grow(pages); - // .grow() takes a delta compared to the previous size - updateMemoryViews(); - return 1; - } catch (e) {} -}; - -var _emscripten_resize_heap = requestedSize => { - var oldSize = HEAPU8.length; - // With CAN_ADDRESS_2GB or MEMORY64, pointers are already unsigned. - requestedSize >>>= 0; - // With multithreaded builds, races can happen (another thread might increase the size - // in between), so return a failure, and let the caller retry. - // Memory resize rules: - // 1. Always increase heap size to at least the requested size, rounded up - // to next page multiple. - // 2a. If MEMORY_GROWTH_LINEAR_STEP == -1, excessively resize the heap - // geometrically: increase the heap size according to - // MEMORY_GROWTH_GEOMETRIC_STEP factor (default +20%), At most - // overreserve by MEMORY_GROWTH_GEOMETRIC_CAP bytes (default 96MB). - // 2b. If MEMORY_GROWTH_LINEAR_STEP != -1, excessively resize the heap - // linearly: increase the heap size by at least - // MEMORY_GROWTH_LINEAR_STEP bytes. - // 3. Max size for the heap is capped at 2048MB-WASM_PAGE_SIZE, or by - // MAXIMUM_MEMORY, or by ASAN limit, depending on which is smallest - // 4. If we were unable to allocate as much memory, it may be due to - // over-eager decision to excessively reserve due to (3) above. - // Hence if an allocation fails, cut down on the amount of excess - // growth, in an attempt to succeed to perform a smaller allocation. - // A limit is set for how much we can grow. We should not exceed that - // (the wasm binary specifies it, so if we tried, we'd fail anyhow). - var maxHeapSize = getHeapMax(); - if (requestedSize > maxHeapSize) { - return false; - } - // Loop through potential heap size increases. If we attempt a too eager - // reservation that fails, cut down on the attempted size and reserve a - // smaller bump instead. (max 3 times, chosen somewhat arbitrarily) - for (var cutDown = 1; cutDown <= 4; cutDown *= 2) { - var overGrownHeapSize = oldSize * (1 + .2 / cutDown); - // ensure geometric growth - // but limit overreserving (default to capping at +96MB overgrowth at most) - overGrownHeapSize = Math.min(overGrownHeapSize, requestedSize + 100663296); - var newSize = Math.min(maxHeapSize, alignMemory(Math.max(requestedSize, overGrownHeapSize), 65536)); - var replacement = growMemory(newSize); - if (replacement) { - return true; - } - } - return false; -}; - -// End JS library code -// include: postlibrary.js -// This file is included after the automatically-generated JS library code -// but before the wasm module is created. -{ - // Begin ATMODULES hooks - if (Module["noExitRuntime"]) noExitRuntime = Module["noExitRuntime"]; - if (Module["print"]) out = Module["print"]; - if (Module["printErr"]) err = Module["printErr"]; - if (Module["wasmBinary"]) wasmBinary = Module["wasmBinary"]; - // End ATMODULES hooks - if (Module["arguments"]) arguments_ = Module["arguments"]; - if (Module["thisProgram"]) thisProgram = Module["thisProgram"]; -} - -// Begin runtime exports -// End runtime exports -// Begin JS library exports -// End JS library exports -// end include: postlibrary.js -// Imports from the Wasm binary. -var _malloc, ___getTypeName, _free; - -function assignWasmExports(wasmExports) { - _malloc = wasmExports["C"]; - ___getTypeName = wasmExports["D"]; - _free = wasmExports["E"]; -} - -var wasmImports = { - /** @export */ m: ___cxa_throw, - /** @export */ y: __abort_js, - /** @export */ x: __embind_finalize_value_array, - /** @export */ l: __embind_register_bigint, - /** @export */ w: __embind_register_bool, - /** @export */ v: __embind_register_emval, - /** @export */ k: __embind_register_float, - /** @export */ u: __embind_register_function, - /** @export */ b: __embind_register_integer, - /** @export */ a: __embind_register_memory_view, - /** @export */ t: __embind_register_std_string, - /** @export */ g: __embind_register_std_wstring, - /** @export */ s: __embind_register_value_array, - /** @export */ j: __embind_register_value_array_element, - /** @export */ r: __embind_register_void, - /** @export */ f: __emval_create_invoker, - /** @export */ c: __emval_decref, - /** @export */ i: __emval_get_property, - /** @export */ h: __emval_incref, - /** @export */ e: __emval_invoke, - /** @export */ q: __emval_new_array, - /** @export */ p: __emval_new_array_from_memory_view, - /** @export */ o: __emval_new_cstring, - /** @export */ d: __emval_run_destructors, - /** @export */ n: _emscripten_resize_heap -}; - -var wasmExports = await createWasm(); - -// include: postamble.js -// === Auto-generated postamble setup entry stuff === -function run() { - if (runDependencies > 0) { - dependenciesFulfilled = run; - return; - } - preRun(); - // a preRun added a dependency, run will be called later - if (runDependencies > 0) { - dependenciesFulfilled = run; - return; - } - function doRun() { - // run may have just been called through dependencies being fulfilled just in this very frame, - // or while the async setStatus time below was happening - Module["calledRun"] = true; - if (ABORT) return; - initRuntime(); - readyPromiseResolve?.(Module); - Module["onRuntimeInitialized"]?.(); - postRun(); - } - if (Module["setStatus"]) { - Module["setStatus"]("Running..."); - setTimeout(() => { - setTimeout(() => Module["setStatus"](""), 1); - doRun(); - }, 1); - } else { - doRun(); - } -} - -function preInit() { - if (Module["preInit"]) { - if (typeof Module["preInit"] == "function") Module["preInit"] = [ Module["preInit"] ]; - while (Module["preInit"].length > 0) { - Module["preInit"].shift()(); - } - } -} - -preInit(); - -run(); - -// end include: postamble.js -// include: postamble_modularize.js -// In MODULARIZE mode we wrap the generated code in a factory function -// and return either the Module itself, or a promise of the module. -// We assign to the `moduleRtn` global here and configure closure to see -// this as and extern so it won't get minified. -if (runtimeInitialized) { - moduleRtn = Module; -} else { - // Set up the promise that indicates the Module is initialized - moduleRtn = new Promise((resolve, reject) => { - readyPromiseResolve = resolve; - readyPromiseReject = reject; - }); -} - - - return moduleRtn; -} - -// Export using a UMD style export, or ES6 exports if selected -export default Module; - diff --git a/js/worker/worker_wasm.wasm b/js/worker/worker_wasm.wasm deleted file mode 100644 index 55a68a16c862d2fc33ca980320107da8ac497852..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 26346 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