function solution(dots) {
  let width = 0;
  let height = 0;

  for (let i = 1; i < 4; i++) {
    if (dots[i][0] === dots[0][0]) {
      height = Math.abs(dots[i][1] - dots[0][1]);
      continue;
    }

    if (dots[i][1] === dots[0][1]) {
      width = Math.abs(dots[i][0] - dots[0][0]);
    }
  }

  return width * height;
}

function solution(dots) {
  let width = 0;
  let height = 0;

  for (let i = 1; i < 4; i++) {
    if (dots[i][0] === dots[0][0]) {
      height = Math.abs(dots[i][1] - dots[0][1]);
      continue;
    }

    if (dots[i][1] === dots[0][1]) {
      width = Math.abs(dots[i][0] - dots[0][0]);
    }
  }

  return width * height;
}

function solution(dots) {
  const [benchmarkX, benchmarkY] = dots[0];
  let width = 0;
  let height = 0;

  dots.forEach(([x, y], index) => {
    if (index === 0) return;
    if (!height && x === benchmarkX) height = Math.abs(benchmarkY - y);
    if (!width && y === benchmarkY) width = Math.abs(benchmarkX - x);
  });

  return width * height;
}

function solution(polynomial) {
  const answer = [0, 0];
  const splitted = polynomial.split(" + ");

  if (splitted.length === 1) return polynomial;

  splitted.forEach((term) => {
    if (term[term.length - 1] !== "x") {
      answer[1] += term * 1;
      return;
    }

    answer[0] += term === "x" ? 1 : term.slice(0, term.length - 1) * 1;
  });

  if (answer[0] === 1) answer[0] = "";
  answer[0] += "x";
  if (answer[0] === "0x") answer.shift();
  if (answer[1] === 0) answer.pop();

  return answer.join(" + ");
}

const filterPolynomial = (polynomialStr) => {
  const validTerm = new RegExp("[0-9]*x|[0-9]+", "g");
  return polynomialStr.match(validTerm);
};

const getPolynomialResult = (polynomialArr) => {
  const result = [0, 0];
  polynomialArr.forEach((term) => {
    if (term[term.length - 1] !== "x") {
      result[1] += parseInt(term);
      return;
    }

    result[0] += term === "x" ? 1 : parseInt(term);
  });

  return result;
};

const formatPolynomial = (xNumber, constant) => {
  if (!xNumber) return [constant];

  const result = [];
  xNumber === 1 ? result.push("x") : result.push(`${xNumber}x`);
  if (constant) result.push(constant);

  return result;
};

function solution(polynomial) {
  const filtered = filterPolynomial(polynomial);
  const [x, constant] = getPolynomialResult(filtered);
  const answer = formatPolynomial(x, constant);

  return answer.join(" + ");
}

function solution(polynomial) {
  const answer = [0, 0];
  const splitted = polynomial.split(" + ");

  if (splitted.length === 1) return polynomial;

  splitted.forEach((term) => {
    let index = 0;
    if (term[term.length - 1] !== "x") index = 1;

    answer[index] += term === "x" ? 1 : parseInt(term);
  });

  if (!answer[0]) return `${answer[1]}`;
  if (!answer[1]) answer.pop();
  answer[0] === 1 ? (answer[0] = "x") : (answer[0] += "x");

  return answer.join(" + ");
}

function solution(array) {
  let answer = 0;
  array.forEach((num) => {
    while (num) {
      if (num % 10 === 7) answer++;
      num = Math.floor(num / 10);
    }
  });
  return answer;
}

function solution(numbers) {
  let max = -Infinity;
  for (let i = 0; i < numbers.length; i++) {
    for (let j = i + 1; j < numbers.length; j++) {
      if (max < numbers[i] * numbers[j]) max = numbers[i] * numbers[j];
    }
  }
  return max;
}

function solution(my_str, n) {
  const answer = [];
  let index = 0;
  while (index < my_str.length) {
    answer.push(my_str.slice(index, index + n));
    index += n;
  }
  return answer;
}

function solution(keyinput, board) {
  const character = [0, 0];
  const halfWidth = (board[0] - 1) / 2;
  const halfHeigth = (board[1] - 1) / 2;
  keyinput.forEach((key) => {
    switch (key) {
      case "left":
        if (character[0] > -halfWidth) character[0]--;
        break;
      case "right":
        if (character[0] < halfWidth) character[0]++;
        break;
      case "down":
        if (character[1] > -halfHeigth) character[1]--;
        break;
      case "up":
        if (character[1] < halfHeigth) character[1]++;
        break;
    }
  });
  return character;
}

function solution(str1, str2) {
  const strRegExp = new RegExp(str2);
  return strRegExp.test(str1) ? 1 : 2;
}

function solution(my_string) {
  return my_string.toLowerCase().split("").sort().join("");
}

const getExpressionResult = (expression) => {
  const [X, operator, Y, _, Z] = expression.split(" ");
  let result = X * 1;
  result += operator === "+" ? Y * 1 : Y * -1;
  return result === Z * 1 ? "O" : "X";
};

const solution = (quiz) => {
  const answer = quiz.map((expression) => getExpressionResult(expression));
  return answer;
};

function solution(n, numlist) {
  return numlist.filter((num) => !(num % n));
}

function solution(n, numlist) {
  return numlist.filter((num) => {
    if (num % n === 0) return true;
    return false;
  });
}

function solution(num, k) {
  const numArr = num.toString().split("");
  const strK = k.toString();
  if (numArr.includes(strK)) return numArr.indexOf(strK) + 1;
  return -1;
}

function solution(num, k) {
  let index = 0;
  const length = num.toString().length;
  let answer = -1;
  while (num) {
    if (num % 10 === k) answer = length - index;
    num = Math.floor(num / 10);
    index++;
  }
  return answer;
}

function solution(n, t) {
  return n * Math.pow(2, t);
}

function solution(s) {
  let answer = "";
  const countArray = new Array(32).fill(0);
  for (let i = 0; i < s.length; i++) {
    countArray[s.charCodeAt(i) - 97]++;
  }
  countArray.forEach((count, index) => {
    if (count === 1) answer += String.fromCharCode(index + 97);
  });
  return answer;
}

function solution(array) {
  const max = Math.max(...array);
  return [max, array.indexOf(max)];
}

function solution(n) {
  const answer = [];

  for (let i = 1; i <= Math.sqrt(n); i++) {
    if (n % i === 0) {
      answer.push(i);
      if (n / i === i) continue;
      answer.push(n / i);
    }
  }

  return answer.sort((a, b) => a - b);
}

function solution(my_string) {
  const splitted = my_string.split(" ");
  let answer = parseInt(splitted[0]);
  for (let i = 1; i < splitted.length; i += 2) {
    if (splitted[i] === "+") {
      answer += parseInt(splitted[i + 1]);
    } else if (splitted[i] === "-") {
      answer -= parseInt(splitted[i + 1]);
    }
  }
  return answer;
}

function solution(s1, s2) {
  const similarity = s1.filter((char) => s2.includes(char)).length;
  return similarity;
}

const numberMap = {
  zero: "0",
  one: "1",
  two: "2",
  three: "3",
  four: "4",
  five: "5",
  six: "6",
  seven: "7",
  eight: "8",
  nine: "9",
};

function solution(numbers) {
  let answer = "";
  let searchWord = "";

  for (let i = 0; i < numbers.length; i++) {
    searchWord += numbers[i];
    if (numberMap[searchWord]) {
      answer += numberMap[searchWord];
      searchWord = "";
    }
  }

  return answer * 1;
}

function solution(my_string, num1, num2) {
  my_string = my_string.split("");
  let temp = "";
  temp = my_string[num1];
  my_string[num1] = my_string[num2];
  my_string[num2] = temp;
  return my_string.join("");
}

function solution(my_string, num1, num2) {
  my_string = my_string.split("");
  [my_string[num1], my_string[num2]] = [my_string[num2], my_string[num1]];
  return my_string.join("");
}

function solution(my_string) {
  let answer = "";
  for (let i = 0; i < my_string.length; i++) {
    const asciiNum = my_string[i].charCodeAt();
    if (asciiNum <= 90) {
      answer += String.fromCharCode(asciiNum + 32);
    } else {
      answer += String.fromCharCode(asciiNum - 32);
    }
  }
  return answer;
}

function solution(strlist) {
  return strlist.map((str) => str.length);
}

function solution(sides) {
  const max = Math.max(...sides);
  const maxIndex = sides.indexOf(max);
  const answer =
    sides.reduce((acc, curr, index) => {
      if (index === maxIndex) return acc;
      return acc + curr;
    }) > max
      ? 1
      : 2;
  return answer;
}

function solution(my_string) {
  return [...new Set(my_string.split(""))].join("");
}

function solution(cipher, code) {
  let answer = "";
  for (let i = 0; i < cipher.length; i++) {
    if ((i + 1) % code === 0) answer += cipher[i];
  }
  return answer;
}

function solution(array, n) {
  let closest;
  let gap = Infinity;
  array.forEach((num) => {
    const currGap = Math.abs(num - n);
    if (currGap < gap) {
      closest = num;
      gap = currGap;
    } else if (currGap === gap && num < closest) {
      closest = num;
    }
  });
  return closest;
}

function solution(order) {
  return order.toString().match(/3|6|9/g)?.length || 0;
}

function solution(my_string) {
  const numbers = my_string.match(/[0-9]/g).map((num) => num * 1);
  return numbers.sort((a, b) => a - b);
}

function solution(my_string) {
  const numbers = my_string.match(/[0-9]/g).map((num) => num * 1);
  const sum = numbers.reduce((acc, curr) => acc + curr);
  return sum;
}

const checkIsPrime = (number) => {
  for (let j = 2; j <= Math.floor(Math.sqrt(number)); j++) {
    if (number % j === 0 && number !== j) return false;
  }

  return true;
};

const getPrimesUnderNumber = (limitNumber) => {
  const primes = [2];

  for (let i = 3; i <= limitNumber; i++) {
    checkIsPrime(i) && primes.push(i);
  }

  return primes;
};

const solution = (n) => {
  const answer = [];
  const primes = getPrimesUnderNumber(n);

  let index = 0;
  while (primes[index] <= n) {
    if (n % primes[index] === 0) {
      answer.push(primes[index]);
    }
    index++;
  }

  return answer;
};

function solution(my_string) {
  const vowel = ["a", "e", "i", "o", "u"];
  return my_string
    .split("")
    .filter((char) => !vowel.includes(char))
    .join("");
}

function solution(s) {
  let answer = 0;
  s = s.split(" ");
  s.forEach((num, index) => {
    if (index === 0) return;
    if ((num === "Z") | (s[index - 1] === "Z")) return;
    answer += s[index - 1] * 1;
  });
  answer += s[s.length - 1] !== "Z" ? s[s.length - 1] * 1 : 0;
  return answer;
}

const solution = (numbers, k) => {
  const passedLength = (k - 1) * 2;
  const index = passedLength % numbers.length;
  return numbers[index];
};

const solution = (n) => {
  let answer = 0;
  for (let i = 4; i <= n; i++) {
    for (let j = 2; j <= Math.floor(Math.sqrt(i)); j++) {
      if (i % j === 0) {
        answer++;
        break;
      }
    }
  }
  return answer;
};

const solution = (n) => {
  const screener = new Array(n + 1).fill(false);
  for (let i = 2; i <= Math.floor(Math.sqrt(n)); i++) {
    if (screener[i]) continue;

    let multiplier = 2;
    while (i * multiplier <= n) {
      screener[i * multiplier] = true;
      multiplier++;
    }
  }

  return screener.filter((result) => result).length;
};

function solution(s) {
  let answer = 0;
  let currChar = "";
  let sameCount = 0;
  let diffCount = 0;
  let isSplitted = true;
  s.split("").forEach((char) => {
    if (isSplitted) {
      answer++;
      currChar = char;
      sameCount = 1;
      diffCount = 0;
      isSplitted = false;
      return;
    }

    if (currChar === char) {
      sameCount++;
    } else {
      diffCount++;
    }

    if (sameCount === diffCount) {
      isSplitted = true;
    }
  });
  return answer;
}

const solution = (box, n) => {
  return (
    Math.floor(box[0] / n) * Math.floor(box[1] / n) * Math.floor(box[2] / n)
  );
};

const solution = (numbers) => {
  let firstMax = 0;
  let secondMax = 0;
  numbers.forEach((number) => {
    if (numbers[i] > firstMax) {
      secondMax = firstMax;
      firstMax = numbers[i];
    } else if (numbers[i] > secondMax) {
      secondMax = numbers[i];
    }
  });
  return firstMax * secondMax;
};

const solution = (n) => {
  const memo = new Array(10).fill(0);
  memo[0] = 1;
  memo[1] = 1;
  memo[2] = 2;

  const _memoFactorial = (number) => {
    if (memo[number]) return memo[number];

    memo[number] = number * _memoFactorial(number - 1);
    return memo[number];
  };
  _memoFactorial(10);

  let maxFactorial = 0;
  memo.some((num, index) => {
    if (num <= n) {
      maxFactorial = index;
      return false;
    }

    return true;
  });

  return maxFactorial;
};

function solution(s) {
  const answer = [];
  const charMap = {};
  s.split("").forEach((char, index) => {
    if (charMap[char] === undefined) {
      answer[index] = -1;
      charMap[char] = index;
      return;
    }

    answer[index] = index - charMap[char];
    charMap[char] = index;
  });
  return answer;
}

const fs = require("fs");
const [[N, L], ...board] = fs
  .readFileSync("/dev/stdin")
  .toString()
  .trim()
  .split("\n")
  .map((line) => line.split(" ").map((el) => el * 1));

let answer = 0;

for (let i = 0; i < N; i++) {
  runRoad(i, "column");
  runRoad(i, "row");
}

console.log(answer);

function runRoad(index, direction) {
  let gapFlag = false;
  let connectCount = 1;

  // 길 한 칸씩 진행
  for (let j = 1; j < N; j++) {
    const gap = getGap(index, j, direction);

    // 단차에 따라 다르게 진행
    if (gap === 0) {
      // 단차가 없는 경우
      // 단차가 없는 평지라면, 계수한다.
      connectCount++;
    } else if (Math.abs(gap) === 1) {
      // 단차가 있는 경우
      // 해결되지 못한 단차가 있었다면 탐색 종료
      if (gapFlag) return;

      if (gap === 1) {
        // 높이가 1 증가한 경우

        // 현재까지 connect 길이가
        // 경사로를 놓을 수 없다면, 탐색을 종료한다.
        if (connectCount < L) return;
      } else {
        // 높이가 1 감소한 경우
        // 단차를 true로 바꿔주고
        // 가능성을 보아 기회를 한 번 더 준다.
        gapFlag = true;
      }

      connectCount = 1;
    } else {
      // 단차가 2 이상이면, 탐색 종료
      return;
    }

    if (gapFlag && connectCount >= L) {
      // 단차가 있었는데 경사로를 둘 길이가 된다면,
      // gapFlag를 false로 바꾸고
      // 연속된 평지 길이를 0으로 초기화한다.
      gapFlag = false;
      connectCount = 0;
    }
  }

  // 마지막으로 단차가 남았는지 확인 후,
  // 모든 역경과 시련을 이겨냈다면
  // 통과시켜준다.
  if (!gapFlag) {
    answer++;
  }
}

function getGap(fixed, variable, direction) {
  if (direction === "column") {
    const gap = board[fixed][variable] - board[fixed][variable - 1];
    if (Math.abs(gap) > 1) {
      return 2;
    } else if (gap === 1) {
      return 1;
    } else if (gap === -1) {
      return -1;
    } else {
      return 0;
    }
  }

  if (direction === "row") {
    const gap = board[variable][fixed] - board[variable - 1][fixed];
    if (Math.abs(gap) > 1) {
      return 2;
    } else if (gap === 1) {
      return 1;
    } else if (gap === -1) {
      return -1;
    } else {
      return 0;
    }
  }
}

// 입력 값 처리 부분
const fs = require("fs");
const [numbers, ...medals] = fs
  .readFileSync("/dev/stdin")
  .toString()
  .split("\n")
  .map((line) => line.split(" ").map((el) => el * 1));
const [N, K] = numbers;

solveProblem();

// 문제 해결 방식
// 1. 주어진 K 값으로 탐색하여 target을 구한다.
// 2. target과 타국들과의 메달 비교를 통해 rank를 도출.
function solveProblem() {
  const target = getTarget(K, medals);
  const rank = getRank(target, medals);

  console.log(rank);
}

// target 국가를 구하는 함수
// 주어진 K를 전체 국가의 ID과 비교하여 찾는다.
// @return {Array}: target 국가 정보
function getTarget(K, medals) {
  let result;
  for (let i = 0; i < N; i++) {
    if (medals[i][0] === K) result = medals[i];
  }

  return result;
}

// rank를 구하는 함수
// 금메달 비교 후 target 국가보다 많으면 rank + 1
// 금메달이 같으면, 은메달 비교 후 target 국가보다 많으면 rank + 1
// 은메달이 같으면, 동메달 비교 후 target 국가보다 많으면 rank + 1
// @return {number}: 최종 rank를 반환
function getRank(target, medals) {
  let result = 1;

  // 전체 국가와 비교
  for (let i = 0; i < N; i++) {
    // 본인 국가는 지나가기
    if (medals[i][0] === target[0]) continue;

    if (medals[i][1] >= target[1]) {
      // 금메달 비교
      if (medals[i][1] > target[1]) {
        result++;
      } else if (medals[i][2] >= target[2]) {
        // 은메달 비교
        if (medals[i][2] > target[2]) {
          result++;
        } else if (medals[i][3] >= target[3]) {
          // 동메달 비교
          if (medals[i][3] > target[3]) {
            result++;
          }
        }
      }
    }
  }

  return result;
}

const fs = require("fs");
let [chessPieces, ...commands] = fs
  .readFileSync("/dev/stdin")
  .toString()
  .trim()
  .split("\n");

chessPieces = chessPieces.split(" ");
const N = chessPieces.pop();

solveProblem();

function solveProblem() {
  // 이동을 숫자의 증감으로 표현할 수 있도록
  // 열을 숫자로 변환함.
  chessPieces = positionToAscii(chessPieces);

  // 명령 배열을 돌며 명령 수행
  commands.forEach((command) => {
    chessPieces = handleCommand(chessPieces, command);
  });

  // 출력을 위해 다시 체스 포지션 문자열로 변경
  chessPieces = asciiToPosition(chessPieces);

  // 결과 출력
  console.log(chessPieces.join("\n"));
}

// 명령 수행
// @chessPieces {Array}: king, stone의 위치 정보를 담은 이차원 배열
// @command {String}: 명령 문자열
// @return {Array}: king, stone의 위치 정보를 담고 있는 이차원 배열
function handleCommand(chessPieces, command) {
  let [king, stone] = chessPieces;

  // king 이동.
  king = moveChessPiece(king, command);
  if (king[0] === stone[0] && king[1] === stone[1]) {
    // king과 store의 위치가 같으면,
    // stone도 이동시킴.
    stone = moveChessPiece(stone, command);
  }

  // 두 말의 위치가 보드 내에 있다면,
  // 변경된 위치 정보 반환
  if (checkPosition(...king) && checkPosition(...stone)) return [king, stone];

  // 두 말의 위치가 보드 밖에 있다면,
  // 변경전 위치 정보 반환
  return chessPieces;
}

// 체스말 이동 함수
// @chessPiece {Array} : 이동할 체스말 위치 정보
// @command {String}: 명령 문자열
function moveChessPiece(chessPiece, command) {
  let [movedColumn, movedRow] = chessPiece;

  switch (command[0]) {
    case "R":
      movedColumn++;
      break;
    case "L":
      movedColumn--;
      break;
    case "T":
      movedRow++;
      break;
    case "B":
      movedRow--;
      break;
  }

  if (command[1]) {
    switch (command[1]) {
      case "T":
        movedRow++;
        break;
      case "B":
        movedRow--;
        break;
    }
  }

  return [movedColumn, movedRow];
}

// 위치 확인 함수
// 체스말의 위치가 보드 내에 있는지 확인
// @column, row {String}: 체스말 열, 행 정보
// @return {Boolean}
function checkPosition(column, row) {
  if (column >= 65 && column <= 72 && row >= 1 && row <= 8) return true;

  return false;
}

// 체스판 위치 => 아스키코드 변환 함수
// @return {Array} : 아스키코드로 변환된 king, stone의 위치 정보 이차원 배열
function positionToAscii(chessPieces) {
  chessPieces = chessPieces.map((chessPiece) => {
    chessPiece = chessPiece.split("");
    chessPiece[0] = chessPiece[0].charCodeAt();
    chessPiece[1] = chessPiece[1] * 1;

    return chessPiece;
  });

  return chessPieces;
}

// 아스키코드 => 체스판 위치 변환 함수
// @return {Array} : 문자열로 변환된 king, stone의 위치 정보 배열
function asciiToPosition(chessPieces) {
  chessPieces = chessPieces.map((chessPiece) => {
    chessPiece[0] = String.fromCharCode(chessPiece[0]);
    chessPiece[1] = chessPiece[1] * 1;

    return chessPiece.join("");
  });

  return chessPieces;
}

const fs = require("fs");
const words = fs
  .readFileSync("/dev/stdin")
  .toString()
  .trim()
  .split("\n")
  .map((el) => el.split(""));

let answer = "";

for (let j = 0; j < 15; j++) {
  for (let i = 0; i < words.length; i++) {
    if (words[i][j]) answer += words[i][j];
  }
}

console.log(answer);

const fs = require("fs");
const input = fs.readFileSync("/dev/stdin").toString().trim().split("\n");

const [N, M] = input
  .shift()
  .split(" ")
  .map((el) => parseInt(el));
const board = input.map((line) => line.split(" ").map((el) => parseInt(el)));

let max = 0;

let visited = new Array(N);
for (let i = 0; i < N; i++) {
  visited[i] = new Array(M);
}

let awesomeVisited = new Array(N);
for (let i = 0; i < N; i++) {
  awesomeVisited[i] = new Array(M);
}

for (let i = 0; i < N; i++) {
  for (let j = 0; j < M; j++) {
    dfs(0, 0, i, j);
  }
}

console.log(max);

function dfs(depth, answer, x, y) {
  if (depth === 4) {
    if (max < answer) {
      max = answer;
    }
    return;
  }

  let dx = [1, -1, 0, 0];
  let dy = [0, 0, 1, -1];

  answer += board[x][y];
  visited[x][y] = true;

  checkAwesomeShape(x, y);

  for (let i = 0; i < 4; i++) {
    const newX = x + dx[i];
    const newY = y + dy[i];
    if (isRange(newX, newY)) {
      if (visited[newX][newY]) continue;
      checkAwesomeShape(x, y);
      dfs(depth + 1, answer, newX, newY);
    }
  }
  answer -= board[x][y];
  visited[x][y] = false;
}

function isRange(x, y) {
  if (x >= 0 && y >= 0 && x < N && y < M) {
    return true;
  } else {
    return false;
  }
}

function checkAwesomeShape(x, y) {
  let upward;
  let downward;
  let right;
  let left;

  // 윗방향
  if (isRange(x, y + 1)) {
    upward = board[x][y + 1];
  }
  // 아랫방향
  if (isRange(x, y - 1)) {
    downward = board[x][y - 1];
  }
  // 오른쪽방향
  if (isRange(x + 1, y)) {
    right = board[x + 1][y];
  }
  // 왼쪽방향
  if (isRange(x - 1, y)) {
    left = board[x - 1][y];
  }

  if (upward && right && left) {
    const upwardShape = board[x][y] + upward + right + left;
    if (max < upwardShape) max = upwardShape;
  }

  if (upward && right && downward) {
    const rightShape = board[x][y] + upward + right + downward;
    if (max < rightShape) max = rightShape;
  }

  if (left && right && downward) {
    const downShape = board[x][y] + left + right + downward;
    if (max < downShape) max = downShape;
  }

  if (upward && left && downward) {
    const leftShape = board[x][y] + left + upward + downward;
    if (max < leftShape) max = leftShape;
  }
}

const fs = require("fs");
const input = fs.readFileSync("/dev/stdin").toString().trim().split("\n");

const N = parseInt(input[0]);
const numbers = input[1].split(" ").map((el) => +el);

const getNGE = (n, numArr) => {
  const stack = [];
  for (let i = 0; i < n; i++) {
    while (stack.length && numArr[stack[stack.length - 1]] < numArr[i]) {
      numArr[stack.pop()] = numArr[i];
    }
    stack.push(i);
  }

  while (stack.length) {
    numArr[stack.pop()] = -1;
  }

  return numArr;
};

const answer = getNGE(N, numbers);

console.log(answer.join(" "));

const fs = require("fs");
const input = fs.readFileSync("/dev/stdin").toString().trim();

const stack = [];
let cutNum = 1;
let answer = 0;

for (let i = 0; i < input.length; i++) {
  switch (input[i]) {
    case ")":
      if (input[i - 1] === "(") {
        stack.pop();
        answer += stack.length;
      } else if (stack.length) {
        stack.pop();
        answer++;
      }
      break;
    default:
      stack.push(input[i]);
  }
}

console.log(answer);

const fs = require("fs");
let input = fs.readFileSync("/dev/stdin").toString().trim().split(" ");
input = input.map((el) => parseInt(el));

let a = input[0];
let b = input[1];

if (a < b) {
  let a = input[1];
  let b = input[0];
}

let gcd = 1;

for (let i = 2; i <= b; i++) {
  if (a % i === 0 && b % i === 0) {
    gcd = i;
  }
}

const lcm = (a * b) / gcd;

console.log(gcd);
console.log(lcm);

const fs = require("fs");
const input = fs.readFileSync("/dev/stdin").toString().trim();

const stack = [];
let isTag = false;
let answerStr = "";

function reverseStr(str) {
  switch (str) {
    case "<":
      while (stack.length) {
        answerStr += stack.pop();
      }
      answerStr += str;
      isTag = true;
      break;
    case ">":
      answerStr += str;
      isTag = false;
      break;
    case " ":
      if (!isTag) {
        while (stack.length) {
          answerStr += stack.pop();
        }
      }
      answerStr += str;
      break;
    case undefined:
      while (stack.length) {
        answerStr += stack.pop();
      }
      break;
    default:
      if (isTag) {
        answerStr += str;
      } else {
        stack.push(str);
      }
  }
}

for (let i = 0; i <= input.length; i++) {
  reverseStr(input[i]);
}

console.log(answerStr);

const fs = require("fs");
const input = fs.readFileSync("/dev/stdin").toString().trim().split("\n");

const N = parseInt(input[0]);
const answerArr = [];
const deque = [];

const workDeque = (lineData) => {
  switch (lineData[0]) {
    case "pop_front":
      answerArr.push(deque.length ? deque.shift() : -1);
      break;
    case "pop_back":
      answerArr.push(deque.length ? deque.pop() : -1);
      break;
    case "size":
      answerArr.push(deque.length);
      break;
    case "empty":
      answerArr.push(deque.length ? 0 : 1);
      break;
    case "front":
      answerArr.push(deque.length ? deque[0] : -1);
      break;
    case "back":
      answerArr.push(deque.length ? deque[deque.length - 1] : -1);
      break;
    case "push_back":
      deque.push(lineData[1]);
      break;
    default:
      deque.unshift(lineData[1]);
      break;
  }
};

for (let i = 1; i <= N; i++) {
  const line = input[i].split(" ");
  workDeque(line);
}

console.log(answerArr.join("\n"));