結果
| 問題 | No.3433 [Cherry 8th Tune A] ADD OIL! |
| コンテスト | |
| ユーザー |
 occhan
|
| 提出日時 | 2026-01-23 22:00:05 |
| 言語 | JavaScript (node v25.2.1) |
| 結果 |
WA
|
| 実行時間 | - |
| コード長 | 27,593 bytes |
| 記録 | |
| コンパイル時間 | 202 ms |
| コンパイル使用メモリ | 7,972 KB |
| 実行使用メモリ | 59,348 KB |
| 最終ジャッジ日時 | 2026-01-23 22:00:50 |
| 合計ジャッジ時間 | 2,902 ms |
|
ジャッジサーバーID （参考情報） |
judge2 / judge1 |
（要ログイン）
| ファイルパターン | 結果 |
|---|---|
| other | WA * 12 |
ソースコード
"use strict";
// start
var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
if (k2 === undefined) k2 = k;
var desc = Object.getOwnPropertyDescriptor(m, k);
if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
desc = { enumerable: true, get: function() { return m[k]; } };
}
Object.defineProperty(o, k2, desc);
}) : (function(o, m, k, k2) {
if (k2 === undefined) k2 = k;
o[k2] = m[k];
}));
var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
Object.defineProperty(o, "default", { enumerable: true, value: v });
}) : function(o, v) {
o["default"] = v;
});
var __importStar = (this && this.__importStar) || (function () {
var ownKeys = function(o) {
ownKeys = Object.getOwnPropertyNames || function (o) {
var ar = [];
for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
return ar;
};
return ownKeys(o);
};
return function (mod) {
if (mod && mod.__esModule) return mod;
var result = {};
if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
__setModuleDefault(result, mod);
return result;
};
})();
Object.defineProperty(exports, "__esModule", { value: true });
const readline_1 = require("readline");
const fs = __importStar(require("fs"));
function main() {
// ここに処理を記述して
let T = nextNum();
while (T--) {
let [N, K] = nextNums(2);
let A = nextBigInts(N);
let ans = 10n ** 18n;
for (let i = 0; i < N; i++) {
let sum = 1n;
for (let j = 0; j < N; j++) {
if (i == j) {
sum *= (A[j] - BigInt(K));
}
else {
sum *= A[j];
}
}
ans = bigIntMin(ans, sum);
}
println(ans);
}
// 処理終了
}
Array.prototype.last = function () {
return this.length === 0 ? undefined : this[this.length - 1];
};
Array.prototype.isEmpty = function () {
return this.length === 0;
};
const less = (a, b) => (a == b ? 0 : a < b ? -1 : 1);
const greater = (a, b) => (a == b ? 0 : a < b ? 1 : -1);
const bigIntMax = (...args) => args.reduce((m, e) => (e > m ? e : m));
const bigIntMin = (...args) => args.reduce((m, e) => (e < m ? e : m));
const bigIntAbs = (arg) => (arg < 0 ? -arg : arg);
const bigIntSqrt = (n) => {
if (n == 0n) {
return 0n;
}
let x = n;
let y = (x + 1n) / 2n;
while (x !== y) {
x = y;
y = (x + n / x) / 2n;
}
return x;
};
let inputs = "";
let inputArray;
let currentIndex = 0;
let outputBuffer = "";
let yes = "Yes";
let no = "No";
let MOD998244353 = 998244353;
let dxy4 = [[-1, 0], [0, 1], [1, 0], [0, -1]];
let dxy8 = [[-1, 0], [-1, 1], [0, 1], [1, 1], [1, 0], [1, -1], [0, -1], [-1, -1]];
// // インタラクティブ用
// // お決まりのインプットはコメントアウト、main関数にasync、最後にrl.close()を忘れない
// // 詳しくはABC244-Cをチェック
// const rl = createInterface({
// input: process.stdin,
// output: process.stdout,
// });
// const input: string[] = [];
// rl.on("line", (line: string) => {
// input.push(line);
// });
// const gl = async (): Promise<string> => {
// while (!input.length) {
// await new Promise((resolve) => setTimeout(resolve, 0));
// }
// return input.shift()!.trim();
// };
function next() {
return inputArray[currentIndex++];
}
function nextNum() {
return +next();
}
function nextBigInt() {
return BigInt(next());
}
function nexts(length) {
const arr = [];
for (let i = 0; i < length; ++i)
arr[i] = next();
return arr;
}
function nextNums(length) {
const arr = [];
for (let i = 0; i < length; ++i)
arr[i] = nextNum();
return arr;
}
function nextBigInts(length) {
const arr = [];
for (let i = 0; i < length; ++i)
arr[i] = nextBigInt();
return arr;
}
function print(out, separator) {
if (Array.isArray(out)) {
outputBuffer += out.join(separator);
}
else {
outputBuffer += out;
}
}
function println(out, separator) {
if (Array.isArray(out)) {
print(out, separator || "");
}
else {
print(out);
}
print("\n");
}
function flush() {
console.log(outputBuffer);
}
function intDiv(a, b) {
return Math.trunc(a / b);
}
function lowerBound(list, value, less = (l, r) => l < r) {
let count = list.length;
let first = 0;
while (0 < count) {
const count2 = count / 2 | 0;
const mid = first + count2;
if (less(list[mid], value)) {
first = mid + 1;
count -= count2 + 1;
}
else {
count = count2;
}
}
return first;
}
function upperBound(list, value, less = (l, r) => l < r) {
return lowerBound(list, value, (l, r) => !less(r, l));
}
function nextPermutation(arr) {
const len = arr.length;
let left = len - 2;
while (left >= 0 && arr[left] >= arr[left + 1]) {
left--;
}
if (left < 0) {
return false;
}
let right = len - 1;
while (arr[left] >= arr[right]) {
right--;
}
const t = arr[left];
arr[left] = arr[right];
arr[right] = t;
left++;
right = len - 1;
while (left < right) {
const t = arr[left];
arr[left] = arr[right];
arr[right] = t;
left++;
right--;
}
return true;
}
function gcd(a, b) {
if (b == 0 || b == BigInt(0)) {
return a;
}
if (typeof a === 'number' && typeof b === 'number') {
const r = a % b;
return gcd(b, r);
}
else if (typeof a === 'bigint' && typeof b === 'bigint') {
const r = a % b;
return gcd(b, r);
}
return 0;
}
function lcm(a, b) {
try {
return a / gcd(a, b) * b;
}
catch (e) {
return -1n;
}
}
function eratosthenesPrime(N = 10 ** 6) {
let b = Array(N + 1).fill(true);
b[0] = false;
b[1] = false;
let prime = [2];
for (let i = 4; i <= N; i += 2) {
b[i] = false;
}
for (let i = 3; i <= N; i += 2) {
if (b[i]) {
prime.push(i);
for (let j = i * 3; j <= N; j += i * 2) {
b[j] = false;
}
}
}
return prime;
}
function enumDiv(n) {
let set = new Set();
for (let i = 1; i * i <= n; i++) {
if (n % i == 0) {
set.add(i);
set.add(intDiv(n, i));
}
}
return [...set];
}
function useModint(M) {
Number.prototype.add = function (a) {
const t = (+this + a) % M;
return t < 0 ? t + M : t;
};
Number.prototype.sub = function (a) {
const t = (+this - a) % M;
return t < 0 ? t + M : t;
};
Number.prototype.mul = function (a) {
const s = +this;
const t = s * a;
return t <= Number.MAX_SAFE_INTEGER
? t % M
: ((((s >> 16) * a) % M) * 65536 + (s & 65535) * a) % M;
};
Number.prototype.pow = function (n) {
let x = +this;
if (x % M === 0)
return 0;
let r = 1;
for (; n; x = x.mul(x), n >>>= 1)
if (n & 1)
r = r.mul(x);
return r;
};
Number.prototype.div = function (a) {
return this.mul(a.pow(M - 2));
};
}
function bigint_mod_pow(x, n, p) {
if (x % p === 0n)
return 0n;
let r = 1n;
for (x %= p; n; x = (x * x) % p, n >>= 1n) {
if (n & 1n)
r = (r * x) % p;
}
return r;
}
function z_algorithm(S) {
let A = Array(S.length).fill(0);
A[0] = S.length;
let i = 1, j = 0;
while (i < S.length) {
while (i + j < S.length && S[j] == S[i + j])
j++;
A[i] = j;
if (j == 0) {
i++;
continue;
}
let k = 1;
while (i + k < S.length && k + A[k] < j) {
A[i + k] = A[k];
k++;
}
i += k;
j -= k;
}
return A;
}
// 最長増加部分列（長さを返す）
function LIS(arr) {
let dp = [];
for (let num of arr) {
let lb = lowerBound(dp, num);
if (lb == dp.length) {
dp.push(num);
}
else {
dp[lb] = num;
}
}
return dp.length;
}
function combinations(arr, k) {
const result = [];
const combo = [];
function dfs(start) {
if (combo.length === k) {
result.push([...combo]);
return;
}
for (let i = start; i < arr.length; i++) {
combo.push(arr[i]);
dfs(i + 1);
combo.pop();
}
}
dfs(0);
return result;
}
function builtin_popcount(n) {
n |= 0;
let count = 0;
while (n != 0) {
n &= (n - 1);
count++;
}
return count;
}
class UnionFind {
constructor(edge) {
this.Parent = Array(edge).fill(-1);
}
root(node) {
if (this.Parent[node] < 0)
return node;
return this.Parent[node] = this.root(this.Parent[node]);
}
size(node) {
return -this.Parent[this.root(node)];
}
same(A, B) {
A = this.root(A);
B = this.root(B);
return A == B;
}
connect(A, B) {
A = this.root(A);
B = this.root(B);
if (A == B) {
return false;
}
if (this.size(A) < this.size(B)) {
let tmp = A;
A = B;
B = tmp;
}
this.Parent[A] += this.Parent[B];
this.Parent[B] = A;
return true;
}
}
class PriorityQueue {
constructor(compare) {
this.compare = compare;
this.list = new Array();
}
push(v) {
this.list.push(v);
const back = this.list.length - 1;
this.against(back);
}
against(child) {
if (child === 0)
return;
const parent = Math.ceil(child / 2) - 1;
const childValue = this.list[child];
const parentValue = this.list[parent];
if (this.compare(childValue, parentValue)) {
this.swap(child, parent);
this.against(parent);
}
}
swap(a, b) {
const tmp = this.list[a];
this.list[a] = this.list[b];
this.list[b] = tmp;
}
top() {
if (this.list.length === 0)
throw new Error("empty");
return this.list[0];
}
pop() {
if (this.list.length === 0)
throw new Error("empty");
if (this.list.length === 1) {
const ans = this.top();
this.list.pop();
return ans;
}
const ans = this.top();
this.list[0] = this.list.pop();
this.flow(0);
return ans;
}
flow(parent) {
const parentValue = this.list[parent];
const left = parent * 2 + 1;
const right = parent * 2 + 2;
if (!this.inRange(left)) {
return;
}
if (!this.inRange(right)) {
// 左子はいるが右子はいない
const leftValue = this.list[left];
if (this.compare(leftValue, parentValue)) {
this.swap(parent, left);
}
return;
}
const leftValue = this.list[left];
const rightValue = this.list[right];
const target = this.compare(leftValue, rightValue) ? left : right;
const targetValue = this.list[target];
if (this.compare(targetValue, parentValue)) {
this.swap(parent, target);
this.flow(target);
}
}
inRange(index) {
return index < this.list.length;
}
size() {
return this.list.length;
}
}
// 01-bfsのときは無理にdequeを使わず、2つの配列を使う方が速い（ABC431-E）
class Deque {
constructor(capacity = 1 << 20) {
this.capacity = capacity;
this.data = new Array(capacity);
this.head = capacity >> 1;
this.tail = capacity >> 1;
}
push(value) {
this.data[this.tail++] = value;
}
unshift(value) {
this.data[--this.head] = value;
}
shift() {
return this.head < this.tail ? this.data[this.head++] : undefined;
}
pop() {
return this.head < this.tail ? this.data[--this.tail] : undefined;
}
peekHead() {
return this.head < this.tail ? this.data[this.head] : undefined;
}
peekHeadIdx(idx) {
return this.head + idx < this.tail ? this.data[this.head + idx] : undefined;
}
peekTail() {
return this.head < this.tail ? this.data[this.tail - 1] : undefined;
}
peekTailIdx(idx) {
return this.head < this.tail - idx ? this.data[this.tail - idx - 1] : undefined;
}
getLength() {
return this.tail - this.head;
}
}
// オイラーツアーのメモ
// let E;
// let L = Array.from({length: 101010},() => 0);
// let R = Array.from({length: 101010},() => 0);
// let idx = 0;
// function euler(cu, pa = -1) {
// L[cu] = idx;
// idx++;
// for (let to of E[cu]) if (to != pa) euler(to, cu);
// R[cu] = idx;
// }
// https://atcoder.jp/users/nanana1o
class SegmentTree {
constructor(lenOrArray) {
this.len = typeof lenOrArray === 'number' ? lenOrArray : lenOrArray.length;
this.n = 1;
while (this.n < this.len) {
this.n *= 2;
}
const bufsize = this.n * 2;
this.tree = Array(bufsize);
this.tree[0] = this.getDefaultValue();
if (Array.isArray(lenOrArray)) {
for (let i = 0; i < this.len; i++)
this.tree[this.n + i] = lenOrArray[i];
for (let i = this.len; i < this.n; i++)
this.tree[this.n + i] = this.getDefaultValue();
for (let i = this.n - 1; i >= 1; i--)
this.tree[i] = this.merger(this.tree[i * 2], this.tree[i * 2 + 1]);
}
else {
for (let i = 1; i < bufsize; i++)
this.tree[i] = this.getDefaultValue();
}
}
get length() {
return this.len;
}
update(index, value) {
let k = index + this.n;
this.tree[k] = this.updater(this.tree[k], value);
while (k > 1) {
k >>= 1;
this.tree[k] = this.merger(this.tree[2 * k], this.tree[2 * k + 1]);
}
}
get(left, right) {
let res = this.getDefaultValue();
for (left += this.n, right += this.n; left < right; left >>= 1, right >>= 1) {
if (left & 1) {
res = this.merger(res, this.tree[left++]);
}
if (right & 1) {
res = this.merger(res, this.tree[--right]);
}
}
return res;
}
}
class MaxSegmentTree2 extends SegmentTree {
getDefaultValue() {
return -Infinity;
}
merger(a, b) {
return Math.max(a, b);
}
updater(oldV, newV) {
return newV;
}
}
class MinSegmentTree2 extends SegmentTree {
getDefaultValue() {
return Infinity;
}
merger(a, b) {
return Math.min(a, b);
}
updater(oldV, newV) {
return newV;
}
}
class SumSegmentTree2 extends SegmentTree {
getDefaultValue() {
return 0;
}
merger(a, b) {
return a + b;
}
updater(oldV, newV) {
return newV;
}
}
class XorSegmentTree2 extends SegmentTree {
getDefaultValue() {
return 0;
}
merger(a, b) {
return a ^ b;
}
updater(oldV, newV) {
return oldV ^ newV;
}
}
class ArraySegmentTree2 extends SegmentTree {
getDefaultValue() {
return [];
}
merger(a, b) {
return a[0] > b[0] ? a : b;
}
updater(oldV, newV) {
return newV;
}
}
class LazySegmentTree {
constructor(size) {
this.size = 1;
while (this.size < size) {
this.size *= 2;
}
this.tree = Array(2 * this.size - 1).fill(0);
this.lazy = Array(2 * this.size - 1).fill(0);
}
query(left, right) {
return this.querySub(left, right, 0, 0, this.size);
}
update(left, right, value) {
this.updateSub(left, right, value, 0, 0, this.size);
}
querySub(queryLeft, queryRight, index, nodeLeft, nodeRight) {
if (nodeRight <= queryLeft || queryRight <= nodeLeft) {
return 0;
}
this.applyLazyUpdate(index);
if (queryLeft <= nodeLeft && nodeRight <= queryRight) {
return this.tree[index];
}
const mid = Math.floor((nodeLeft + nodeRight) / 2);
const leftValue = this.querySub(queryLeft, queryRight, index * 2 + 1, nodeLeft, mid);
const rightValue = this.querySub(queryLeft, queryRight, index * 2 + 2, mid, nodeRight);
return Math.max(leftValue, rightValue);
}
updateSub(queryLeft, queryRight, value, index, nodeLeft, nodeRight) {
if (nodeRight <= queryLeft || queryRight <= nodeLeft) {
return;
}
if (queryLeft <= nodeLeft && nodeRight <= queryRight) {
this.lazy[index] = value;
this.applyLazyUpdate(index);
return;
}
const mid = Math.floor((nodeLeft + nodeRight) / 2);
this.updateSub(queryLeft, queryRight, value, index * 2 + 1, nodeLeft, mid);
this.updateSub(queryLeft, queryRight, value, index * 2 + 2, mid, nodeRight);
this.tree[index] = Math.max(this.tree[index * 2 + 1], this.tree[index * 2 + 2]);
}
applyLazyUpdate(index) {
if (this.lazy[index] === 0) {
return;
}
this.tree[index] = this.lazy[index];
if (index < this.size - 1) {
this.lazy[index * 2 + 1] = this.lazy[index];
this.lazy[index * 2 + 2] = this.lazy[index];
}
this.lazy[index] = 0;
}
}
class Trie {
constructor() {
this.next = new Map();
this.nextSet = new TreeMultiSet();
this.idx = [];
}
}
// https://atcoder.jp/users/mst40
class TreeSetNode {
constructor(n) {
this.value = n;
this.left = null;
this.right = null;
this.height = 1;
this.count = 1;
}
incCnt() {
this.count++;
}
decCnt() {
this.count--;
}
}
class TreeMultiSet {
constructor() {
this.root = null;
}
add(val) {
this.root = this._addHelper(this.root, val);
}
delete(val) {
const newTree = this._deleteHelper(this.root, val);
this.root = newTree;
if (!newTree) {
return false;
}
return true;
}
count(value) {
return this._getCountHelper(this.root, value);
}
min() {
if (!this.root) {
return undefined;
}
return this._findMin(this.root).value;
}
max() {
if (!this.root) {
return undefined;
}
return this._findMax(this.root).value;
}
lower_bound(val) {
return this._lower_boundHelper(this.root, val);
}
upper_bound(val) {
return this._upper_boundHelper(this.root, val);
}
prev(val) {
return this._prevHelper(this.root, val);
}
next(val) {
return this._nextHelper(this.root, val);
}
/** private */
_addHelper(node, val) {
if (!node) {
return new TreeSetNode(val);
}
if (val < node.value) {
node.left = this._addHelper(node.left, val);
}
else if (node.value < val) {
node.right = this._addHelper(node.right, val);
}
else {
node.incCnt();
return node;
}
node.height = this._newHeight(node);
return this._balancing(node, val);
}
_getBalanceFactor(node) {
return this._getHeight(node.right) - this._getHeight(node.left);
}
_getHeight(node) {
return node ? node.height : 0;
}
_newHeight(node) {
return Math.max(this._getHeight(node.left), this._getHeight(node.right)) + 1;
}
_balancing(node, val) {
const factor = this._getBalanceFactor(node);
if (factor < -1) {
if (val < node.left.value) {
return this._rightRotate(node);
}
else {
node.left = this._leftRotate(node.left);
return this._rightRotate(node);
}
}
else if (1 < factor) {
if (val > node.right.value) {
return this._leftRotate(node);
}
else {
node.right = this._rightRotate(node.right);
return this._leftRotate(node);
}
}
return node;
}
_leftRotate(node) {
const pivot = node.right;
node.right = pivot ? pivot.left : null;
if (pivot)
pivot.left = node;
node.height = this._newHeight(node);
if (pivot)
pivot.height = this._newHeight(pivot);
return pivot || node;
}
_rightRotate(node) {
const pivot = node.left;
node.left = pivot ? pivot.right : null;
if (pivot)
pivot.right = node;
node.height = this._newHeight(node);
if (pivot)
pivot.height = this._newHeight(pivot);
return pivot || node;
}
_getCountHelper(node, value) {
// value is not exsists.
if (!node) {
return 0;
}
// binary search(recursive)
if (value < node.value) {
return this._getCountHelper(node.left, value);
}
else if (value > node.value) {
return this._getCountHelper(node.right, value);
}
else {
return node.count;
}
}
_deleteHelper(node, val) {
if (!node) {
return null;
}
if (val < node.value) {
node.left = this._deleteHelper(node.left, val);
}
else if (val > node.value) {
node.right = this._deleteHelper(node.right, val);
}
else {
if (1 < node.count) {
node.decCnt();
return node;
}
if (!node.left) {
node = node.right;
}
else if (!node.right) {
node = node.left;
}
else {
const min = this._findMin(node.right);
node.value = min.value;
node.right = this._deleteHelper(node.right, min.value);
}
if (node) {
node.height = this._newHeight(node);
return this._balancing(node, val);
}
}
return node;
}
_findMin(node) {
let curr = node;
while (curr.left) {
curr = curr.left;
}
return curr;
}
_findMax(node) {
let curr = node;
while (curr.right) {
curr = curr.right;
}
return curr;
}
_lower_boundHelper(node, val) {
if (!node) {
return undefined;
}
if (val <= node.value) {
const left = this._lower_boundHelper(node.left, val);
return left !== undefined ? left : node.value;
}
else {
return this._lower_boundHelper(node.right, val);
}
}
_upper_boundHelper(node, val) {
if (!node) {
return undefined;
}
if (val < node.value) {
const left = this._upper_boundHelper(node.left, val);
return left !== undefined ? left : node.value;
}
else {
return this._upper_boundHelper(node.right, val);
}
}
_prevHelper(node, val) {
if (!node) {
return undefined;
}
if (val <= node.value) {
return this._prevHelper(node.left, val);
}
else {
const right = this._prevHelper(node.right, val);
return right !== undefined ? right : node.value;
}
}
_nextHelper(node, val) {
if (!node) {
return undefined;
}
if (val >= node.value) {
return this._nextHelper(node.right, val);
}
else {
const left = this._nextHelper(node.left, val);
return left !== undefined ? left : node.value;
}
}
}
class FenwickTree {
constructor(arraySize) {
this.arraySize = arraySize;
// Fill tree array with zeros.
this.treeArray = Array(this.arraySize + 1).fill(0);
}
increase(position, value) {
if (position < 0 || position > this.arraySize) {
throw new Error('Position is out of allowed range');
}
for (let i = position; i <= this.arraySize; i += (i & -i)) {
this.treeArray[i] += value;
}
return this;
}
query(position) {
if (position < 0 || position > this.arraySize) {
throw new Error('Position is out of allowed range');
}
let sum = 0;
for (let i = position; i >= 0; i -= (i & -i)) {
sum += this.treeArray[i];
}
return sum;
}
queryRange(leftIndex, rightIndex) {
if (leftIndex > rightIndex) {
throw new Error('Left index can not be greater than right one');
}
if (leftIndex === 0) {
return this.query(rightIndex);
}
return this.query(rightIndex) - this.query(leftIndex - 1);
}
}
class FenwickTreeMod {
constructor(arraySize) {
this.arraySize = arraySize;
// Fill tree array with zeros.
this.treeArray = Array(this.arraySize + 1).fill(0);
}
increase(position, value) {
if (position < 0 || position > this.arraySize) {
throw new Error('Position is out of allowed range');
}
for (let i = position; i <= this.arraySize; i += (i & -i)) {
this.treeArray[i] = this.treeArray[i].add(value);
}
return this;
}
query(position) {
if (position < 0 || position > this.arraySize) {
throw new Error('Position is out of allowed range');
}
let sum = 0;
for (let i = position; i >= 0; i -= (i & -i)) {
sum = sum.add(this.treeArray[i]);
}
return sum;
}
queryRange(leftIndex, rightIndex) {
if (leftIndex > rightIndex) {
throw new Error('Left index can not be greater than right one');
}
if (leftIndex === 0) {
return this.query(rightIndex);
}
return this.query(rightIndex).sub(this.query(leftIndex - 1));
}
}
// end
// デバッグ環境がWindowsであれば条件分岐する
if (process.env.OS == "Windows_NT") {
const stream = (0, readline_1.createInterface)({
input: process.stdin,
output: process.stdout,
});
stream.on("line", (line) => {
inputs += line;
inputs += "\n";
});
stream.on("close", () => {
inputArray = inputs.split(/\s/);
main();
flush();
});
}
else {
inputs = fs.readFileSync("/dev/stdin", "utf8");
inputArray = inputs.split(/\s/);
main();
flush();
}
//# sourceMappingURL=main.js.map