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"));

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

const n = parseInt(input.shift());
const stack = [];
const answerArr = [];
let isExist = true;

for (let j = 0; j < n; j++) {
  let num = 1;
  while (num <= n) {
    if (num <= parseInt(input[j])) {
      while (num <= parseInt(input[j])) {
        stack.push(num);
        answerArr.push("+");
        num++;
      }
    } else {
      try {
        while (stack[stack.length - 1] !== parseInt(input[j])) {
          stack.pop();
          answerArr.push("-");
        }
        stack.pop();
        answerArr.push("-");
      } catch {
        isExist = false;
      }
    }
  }
}

if (!isExist) {
  console.log("NO");
} else {
  console.log(answerArr.join("\n"));
}

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

const n = parseInt(input.shift());
const stack = [];
const answerArr = [];
let isExist = true; // 가능 / 불가능 확인을 위한 flag
let num = 1; // push 해야할 수

for (let j = 0; j < n; j++) {
  if (num <= parseInt(input[j])) {
    // push 해야 할 수가 제시된 수보다 작으면
    // 제시된 수까지 push 한다.
    while (num <= parseInt(input[j])) {
      stack.push(num);
      answerArr.push("+");
      num++;
    }
  } else if (stack[stack.length - 1] > parseInt(input[j])) {
    // push 해야 할 수가 제시된 수보다 크고,
    // stack에 있는 수가 제시된 수보다 크면
    // 아무리 pop해도 스택 수열을 만들 수 없다.
    isExist = false;
    break;
  }

  // 제시된 수까지 push 되었기 때문에,
  // pop 해주면 된다.
  stack.pop();
  answerArr.push("-");
}

if (!isExist) {
  console.log("NO");
} else {
  console.log(answerArr.join("\n"));
}

const fs = require("fs");
const input = fs.readFileSync("/dev/stdin").toString().trim().split("\n");
const N = parseInt(input[0]);
const que = [];
const answerArr = [];

function workQue(cmd) {
  switch (cmd) {
    case "pop":
      answerArr.push(que.length ? que.shift() : -1);
      break;
    case "size":
      answerArr.push(que.length);
      break;
    case "empty":
      answerArr.push(que.length ? 0 : 1);
      break;
    case "front":
      answerArr.push(que.length ? que[0] : -1);
      break;
    case "back":
      answerArr.push(que.length ? que[que.length - 1] : -1);
      break;
    default:
      const line = cmd.split(" ");
      que.push(parseInt(line[1]));
  }
}

for (let i = 1; i <= N; i++) {
  workQue(input[i]);
}

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

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

const N = parseInt(input[0]);
const K = parseInt(input[1]);

let queue = new Array(N);
queue = queue.fill(0).map((el, index) => (el = index + 1));

let count = 0;
const answerArr = [];

// K번째 있는 사람을 죽이는 함수
// length가 K보다 클 때와 작을 때를 나누어 구현했다.
function kill(cnt) {
  while (cnt !== 0) {
    if (queue.length >= cnt) {
      queue.push(...queue.splice(0, cnt));
      answerArr.push(queue.pop());
      cnt = 0;
    } else {
      cnt -= queue.length;
    }
  }
}

while (count < N) {
  kill(K);
  count++;
}

console.log(`<${answerArr.join(", ")}>`);

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

let str = input.shift();
str = str.trim().split("");
const N = parseInt(input.shift());
let index = parseInt(str.length > 0 ? str.legnth - 1 : 0);

for (let i = 0; i < N; i++) {
  switch (input[i].trim()) {
    case "L":
      if (index !== 0) {
        index -= 1;
      }
      break;
    case "D":
      if (index !== str.length - 1) {
        index += 1;
      }
      break;
    case "B":
      if (index !== 0) {
        str.splice(index - 1, 1);
      }
      break;
    default:
      const line = input[i].split(" ");
      str.splice(index - 1, 0, line[1]);
  }
}

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

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

let str = input.shift();
const N = parseInt(input.shift());
const cursorLeft = str.trim().split("");
let cursorRight = [];

for (let i = 0; i < N; i++) {
  switch (input[i]) {
    case "L":
      if (cursorLeft.length) {
        cursorRight.push(cursorLeft.pop());
      }
      break;
    case "D":
      if (cursorRight.length) {
        cursorLeft.push(cursorRight.pop());
      }
      break;
    case "B":
      if (cursorLeft.length) {
        cursorLeft.pop();
      }
      break;
    default:
      const line = input[i].split(" ");
      cursorLeft.push(line[1]);
  }
}

cursorRight = cursorRight.reverse();

console.log([...cursorLeft, ...cursorRight].join(""));

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

const T = parseInt(input.shift());
const answerArr = [];

for (let i = 0; i < T; i++) {
  const line = input[i];
  const stack = [];
  let answer = "YES";

  for (let j = 0; j < line.length; j++) {
    if (line[j] === "(") {
      stack.push("(");
    } else {
      if (!stack.pop()) {
        answer = "NO";
        break;
      }
    }
  }
  if (stack.length > 0) {
    answer = "NO";
  }

  answerArr.push(answer);
}

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

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

const N = input.shift();
const stack = [];
const answerArr = [];

for (let i = 0; i < N; i++) {
  switch (input[i]) {
    case "pop":
      answerArr.push(stack.length ? stack.pop() : -1);
      break;
    case "size":
      answerArr.push(stack.length);
      break;
    case "empty":
      answerArr.push(stack.length ? 0 : 1);
      break;
    case "top":
      answerArr.push(stack.length ? stack[stack.length - 1] : -1);
      break;
    default:
      stack.push(input[i].split(" ")[1]);
  }
}

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

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

const T = input.shift();
const answerArr = [];

for (let i = 0; i < T; i++) {
  const line = input[i].split(" ");
  let reversedLine = [];
  let reversedWord = "";
  for (let l = 0; l < line.length; l++) {
    const reversedWord = line[l].split("").reverse().join("");
    reversedLine.push(reversedWord);
  }
  answerArr.push(reversedLine.join(" "));
}

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

const fs = require("fs");
let input = fs.readFileSync("/dev/stdin").toString().trim().split("\n");
const T = parseInt(input.shift());
const answerArr = [];

for (let i = 0; i < T; i++) {
  let line = input[i];
  let str = "";
  const stack = [];

  for (let j = 0; j <= line.length; j++) {
    if (line[j] === " " || line[j] === undefined) {
      while (stack.length > 0) {
        str += stack.pop();
      }
      str += " ";
    } else {
      stack.push(line[j]);
    }
  }
  answerArr.push(str);
}

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

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

const N = parseInt(input.shift());
let numbers = input.toString().trim().split(" ");
const set = new Set(numbers);
const setArr = [...set];
setArr.sort();

const indexArr = new Array(setArr.length);

for (let i = 0; i < N; i++) {
  const index = indexArr.indexOf(numbers[i]);
  numbers[i] = index;
}

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

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

const N = parseInt(input[0]);
let numbers = input[1]
  .toString()
  .split(" ")
  .map((el) => parseInt(el));
const set = new Set(numbers);
let indexArr = [...set];
indexArr.sort((a, b) => a - b);

for (let i = 0; i < N; i++) {
  let low = 0;
  let high = N - 1;
  let mid = Math.floor(high + low / 2);
  while (numbers[i] !== indexArr[mid]) {
    if (numbers[i] < indexArr[mid]) {
      high = mid - 1;
      mid = Math.floor(high + low / 2);
    } else {
      low = mid + 1;
      mid = Math.floor(high + low / 2);
    }
  }
  numbers[i] = mid;
}

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

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

const N = parseInt(input[0]);
let numbers = input[1]
  .toString()
  .split(" ")
  .map((el) => parseInt(el));
const set = new Set(numbers);
let indexArr = [...set];
indexArr.sort((a, b) => a - b);
const indexObj = {};

indexArr.forEach((el, index) => (indexObj[el] = index));

for (let i = 0; i < N; i++) {
  numbers[i] = indexObj[numbers[i]];
}

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

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

const N = input.shift();

let strArr = new Set(input);
strArr = [...strArr];
strArr.sort();

strArr.sort((a, b) => a.length - b.length);

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

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

const N = input.shift();
input = input.map((el) => el.split(" "));

input.sort((a, b) => parseInt(a[0]) - parseInt(b[0]));

input = input.map((el) => el.join(" "));

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

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

const N = parseInt(input.shift());
input = input.map((el) => el.split(" "));

input.sort((a, b) => {
  if (parseInt(a[0]) === parseInt(b[0])) {
    return parseInt(a[1]) - parseInt(b[1]);
  } else {
    return parseInt(a[0]) - parseInt(b[0]);
  }
});

input = input.map((el) => el.join(" "));

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

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

const N = parseInt(input.shift());
input = input.map((el) => el.split(" "));

input.sort((a, b) => {
  if (parseInt(a[1]) === parseInt(b[1])) {
    return parseInt(a[0]) - parseInt(b[0]);
  } else {
    return parseInt(a[1]) - parseInt(b[1]);
  }
});

input = input.map((el) => el.join(" "));

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

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

const N = input.shift();

input.sort((a, b) => a - b);

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

const fs = require("fs");
const input = fs.readFileSync("/dev/stdin").toString().trim().split("\n");
const N = input.shift();
const lines = ["WBWBWBWB", "BWBWBWBW"];
let min = 64;

for (let a = 0; a <= input.length - 8; a++) {
  for (let b = 0; b <= input[a].length - 8; b++) {
    let count = 0;
    for (let k = 0; k < 8; k++) {
      for (let m = 0; m < 8; m++) {
        if (k % 2 === 0) {
          if (input[a + k][b + m] === lines[0][m]) {
            count++;
          }
        } else {
          if (input[a + k][b + m] === lines[1][m]) {
            count++;
          }
        }
      }
    }
    if (count > 32) {
      if (min > 64 - count) min = 64 - count;
    } else {
      if (min > count) min = count;
    }
  }
}

console.log(min);

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

const N = input.shift();

const answerArr = input.sort((a, b) => a - b);

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

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

const N = input.shift();

for (let i = 0; i < input.length; i++) {
  let swap;
  for (let j = 0; j < input.length - 1 - i; j++) {
    if (input[j] > input[j + 1]) {
      swap = input[j + 1];
      input[j + 1] = input[j];
      input[j] = swap;
    }
  }
  if (!swap) {
    break;
  }
}

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

const fs = require("fs");
const input = parseInt(fs.readFileSync("/dev/stdin").toString().trim());
let num = 665;
let count = 0;

while (count !== input) {
  num++;
  if (String(num).includes("666")) {
    count++;
  }
}

console.log(num);

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

const answer = [];
let count = 0;

function movePlate(from, to, other, num) {
  if (num === 0) {
    return;
  } else {
    movePlate(from, other, to, num - 1);
    answer.push(`${from} ${to}`);
    count++;
    movePlate(other, to, from, num - 1);
  }
}

movePlate(1, 3, 2, input);

console.log(count);
console.log(answer.join("\n"));

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

for (let i = 0; i < input; i++) {
  for (let j = 0; j < input; j++) {
    makeStar(i, j, input);
  }
  answer.push("\n");
}

function makeStar(x, y, num) {
  if (x % 3 === 1 && y % 3 === 1) {
    answer.push(" ");
  } else {
    if (num === 1) {
      answer.push("*");
    } else {
      makeStar(Math.floor(x / 3), Math.floor(y / 3), num / 3);
    }
  }
}

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

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

input[0] = input[0].split(" ");
const N = parseInt(input[0][0]);
const M = parseInt(input[0][1]);
const cards = input[1].split(" ").map((card) => parseInt(card));
let answer = 0;

const getCombinations = (arr, selectNumber) => {
  const results = [];
  if (selectNumber === 1) {
    return arr.map((element) => [element]);
  }

  arr.forEach((fixed, index, origin) => {
    const rest = origin.slice(index + 1);
    const combinations = getCombinations(rest, selectNumber - 1);
    const attached = combinations.map((element) => [fixed, ...element]);
    results.push(...attached);
  });
  return results;
};

getCombinations(cards, 3).forEach((result) => {
  const sum = result[0] + result[1] + result[2];
  if (sum <= M && answer <= sum) {
    answer = sum;
  }
});

console.log(answer);

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

const T = parseInt(input[0]);
const answerArr = [];

for (let i = 1; i <= T; i++) {
  const c = input[i].split(" ").map((num) => parseInt(num));
  const distance = c[1] - c[0];
  const max = Math.ceil(Math.sqrt(distance));
  if (distance <= max * (max - 1)) {
    answerArr.push(max * 2 - 2);
  } else {
    answerArr.push(max * 2 - 1);
  }
}

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