function processData(input) {
  // get `n` and `d` from input
  const lines = input.split('\n');
  const firstLine = lines[0].split(' ').map(Number);
  const n = firstLine[0];
  const d = firstLine[1];

  // process each line
  lines.slice(1, lines.length).forEach(line => {
    // no need to shift in these cases
    if (n === 1 || d === n) {
      console.info(line);
    } else {
      // shift digits
      const a = line.split(' ').map(Number);
      let lastLastItem = null;
      let count = 0;
      let i = 0;
      while (count < n) {
        i++;
        const start = i;
        let j = start;
        do {
          count++;
          let lastItem = lastLastItem;
          lastLastItem = a[j];
          a[j] = lastItem;
          j = shiftLeft(n, d, j);
        } while (j !== start);
        a[start] = lastLastItem;
      }
      console.info(a.reduce((acc, value) => {
        return acc+' '+value;
      }));
    }
  });
}

/**
 * @param {Number} n total number of elements
 * @param {Number} d number of shifts to left
 * @param {Number} i index to begin shifting from
 * @returns {Number} new index after shifting to left
 */
function shiftLeft(n, d, i) {
  return (n-d+i)%n;
}

function main() {
  	// ...
    loopUntilAllSwapped(a, d);
    console.log(a.join(' ') + '\n');
}

/**
 * If a.length can be divided by d evenly, swapSeries will end 
 * where it started without swapping all numbers.
 * This function ensures that all numbers are swapped.
 * 
 * Variables:
 * a: array of numbers
 * d: number of left-rotations to perform
 * c: count of numbers swapped
 * i: index to start swapSeries() from
 */
function loopUntilAllSwapped(a, d) {
    let c = 0;
    let i = 0;
    while (c < a.length) {
        c += swapSeries(a, i, d);
        i++;
    }
}

/**
 * Swaps elements in an array in-place.
 *
 * Variables:
 * a: array of numbers
 * i: index to start with
 * d: number of left-rotations to perform
 * c: count of numbers swapped, returned to loopUntilAllSwapped()
 * iS: index source (index of number to be moved)
 * iD: index destination (index iS will be moved to)
 * q: a queue that acts as a temporary buffer for numbers as they 
 *     move from source to destination
 *
 * Algorithm:
 * 1. Find index destination (iD) of a[iS] after d rotations to 
 *    left
 * 2. Place destination in temporary buffer (q).
 * 3. Replace destination with index source (iS) value (a[iS]).
 * 4. Repeat until we end where we started (iS === i) 
 */
function swapSeries(a, i, d) {
    let c=0;
    let iS = i;
    let q = [a[iS]];
    do {
        let iD = h(a.length, d, iS);
        q.push(a[iD]);
        a[iD] = q.shift();
        iS = iD;
        c++;
    } while (iS !== i);
    return c;
}

/**
 * A constant-time formula to find index destination of i 
 * after d rotations to left.
 */
function h(n, d, i) {
    return ((n-d%n)%n+i)%n;
}