const chunks = [];
process.stdin.on("data", (chunk) => {
  chunks.push(chunk);
});
process.stdin.on("end", () => {
  const data = Buffer.concat(chunks).toString("utf8").trim();
  const lines = data.split("\n");
  const [N, K] = parseLine(lines[0]);
  const A = parseLine(lines[1]);
  console.log(solve(N, K, A));
});

function parseLine(line) {
  return line.split(" ").map((item) => parseInt(item, 10));
}

function solve(N, K, A) {
  // Sort by abs desc
  A.sort((a, b) => Math.abs(b) - Math.abs(a));

  if (A[K - 1] === 0) return 0;

  let negative = false;
  let lastNegative = null;
  let lastPositive = null;
  for (let i = 0; i < K; i++) {
    const a = A[i];
    if (a < 0) {
      negative = !negative;
      lastNegative = i;
    }
    if (a > 0) {
      lastPositive = i;
    }
  }

  if (negative) {
    let firstPositive = null;
    let firstNegative = null;
    // Find the first positive number and replace it.
    // Find the first negative number and replace eit.
    for (let i = K; i < N; i++) {
      if (A[i] === 0) {
        return 0;
      }
      if (A[i] > 0) {
        firstPositive = i;
        break;
      }
    }
    for (let i = K; i < N; i++) {
      if (A[i] === 0) {
        return 0;
      }
      if (A[i] < 0) {
        firstNegative = i;
        break;
      }
    }

    let doNegaitve = firstNegative !== null;
    let doPositive = firstPositive !== null;
    if (doNegaitve && doNegaitve) {
      const a = Math.abs(A[lastPositive] * A[firstPositive]);
      const b = Math.abs(A[lastNegative] * A[firstNegative]);
      if (a <= b) {
        doPositive = false;
      } else {
        doNegaitve = false;
      }
    }

    if (doNegaitve) {
      const temp = A[firstNegative];
      A[firstNegative] = A[lastPositive];
      A[lastPositive] = temp;
      negative = false;
    } else if (doPositive) {
      const temp = A[firstPositive];
      A[firstPositive] = A[lastNegative];
      A[lastNegative] = temp;
      negative = false;
    } else {
      // Return the biggest negative number.
      A.sort((a, b) => Math.abs(a) - Math.abs(b));
      negative = true;
    }
  }

  const MOD = 1000000007;
  let mult = 1;
  for (let i = 0; i < K; i++) {
    mult = (mult * Math.abs(A[i])) % MOD;
  }
  if (negative) {
    return (mult + MOD) % MOD;
  } else {
    return mult;
  }
}
