import { readFileSync } from "fs";

////////////////////////////////////////////////////////////////////////////////
// Library
////////////////////////////////////////////////////////////////////////////////
/*
 * types
 */
type BinaryOperation<T> = (x: T, y: T) => T;

/*
 * functions
 */
// eslint-disable-next-line @typescript-eslint/no-unused-vars
const range = (n: number | bigint) => Array.from(Array(Number(n)), (_, i) => i);

// eslint-disable-next-line @typescript-eslint/no-unused-vars
const tuple = <Ts extends unknown[]>(...ts: Ts) => ts;

// eslint-disable-next-line @typescript-eslint/no-unused-vars
const zip = <T, S>(ts: T[], ss: S[]) =>
  range(min([ts.length, ss.length])).map((i) => tuple(ts[i], ss[i]));

// eslint-disable-next-line @typescript-eslint/no-unused-vars
const unzip = <T, S>(tss: [T, S][]) =>
  tss.reduce(
    ([ts, ss], [t, s]) => {
      ts.push(t);
      ss.push(s);
      return tuple(ts, ss);
    },
    [[], []] as [T[], S[]]
  );

// eslint-disable-next-line @typescript-eslint/no-unused-vars
const getCin = () => {
  const inputs = readFileSync("/dev/stdin", "utf-8")
    .split("\n")
    .flatMap((l) => l.split(" "));
  let count = 0;
  const cin = () => inputs[count++];
  return tuple(
    cin,
    () => Number(cin()),
    () => BigInt(cin())
  );
};

// eslint-disable-next-line @typescript-eslint/no-unused-vars
const isNumber = (x: unknown): x is number => typeof x === "number";

// eslint-disable-next-line @typescript-eslint/no-unused-vars
const isBigint = (x: unknown): x is bigint => typeof x === "bigint";

// eslint-disable-next-line @typescript-eslint/no-unused-vars
const max = ((ts: [] | number[] | bigint[]) =>
  ts.length === 0
    ? undefined
    : isNumber(ts[0])
    ? (ts as number[]).reduce((acc, t) => Math.max(acc, t))
    : (ts as bigint[]).reduce((acc, t) => (acc >= t ? acc : t))) as {
  (ts: []): undefined;
  (ts: number[]): number;
  (ts: bigint[]): bigint;
};

// eslint-disable-next-line @typescript-eslint/no-unused-vars
const min = ((ts: [] | number[] | bigint[]) =>
  ts.length === 0
    ? undefined
    : isNumber(ts[0])
    ? (ts as number[]).reduce((acc, t) => Math.min(acc, t))
    : (ts as bigint[]).reduce((acc, t) => (acc <= t ? acc : t))) as {
  (ts: []): undefined;
  (ts: number[]): number;
  (ts: bigint[]): bigint;
};

// eslint-disable-next-line @typescript-eslint/no-unused-vars
const sum = ((ts: [] | number[] | bigint[]) =>
  ts.length === 0
    ? undefined
    : isNumber(ts[0])
    ? (ts as number[]).reduce((acc, t) => acc + t)
    : (ts as bigint[]).reduce((acc, t) => acc + t)) as {
  (ts: []): undefined;
  (ts: number[]): number;
  (ts: bigint[]): bigint;
};

// eslint-disable-next-line @typescript-eslint/no-unused-vars
const abs = ((t: number | bigint) =>
  isNumber(t) ? Math.abs(t) : t >= 0n ? t : -t) as {
  (t: number): number;
  (t: bigint): bigint;
};

// eslint-disable-next-line @typescript-eslint/no-unused-vars
const getModCalc = ((t: number | bigint) =>
  isNumber(t)
    ? (() => {
        type CalcType = BinaryOperation<number>;
        const modAdd: CalcType = (x, y) => ((((x % t) + (y % t)) % t) + t) % t;
        const modSub: CalcType = (x, y) => ((((x % t) - (y % t)) % t) + t) % t;
        const modProd: CalcType = (x, y) => ((((x % t) * (y % t)) % t) + t) % t;
        const modPow: CalcType = (x, t) => {
          const isEvens = (() => {
            const isEvens: boolean[] = [];
            for (let tmpT = t; tmpT !== 1; tmpT = Math.floor(tmpT / 2))
              isEvens.push(tmpT % 2 === 0);
            return isEvens;
          })();
          return isEvens.reduceRight(
            (acc, b) => (b ? modProd(acc, acc) : modProd(x, modProd(acc, acc))),
            x
          );
        };
        return tuple(modAdd, modSub, modProd, modPow);
      })()
    : (() => {
        type CalcType = BinaryOperation<bigint>;
        const modAdd: CalcType = (x, y) => ((((x % t) + (y % t)) % t) + t) % t;
        const modSub: CalcType = (x, y) => ((((x % t) - (y % t)) % t) + t) % t;
        const modProd: CalcType = (x, y) => ((((x % t) * (y % t)) % t) + t) % t;
        const modPow: CalcType = (x, t) => {
          const isEvens = (() => {
            const isEvens: boolean[] = [];
            for (let tmpT = t; tmpT !== 1n; tmpT /= 2n)
              isEvens.push(tmpT % 2n === 0n);
            return isEvens;
          })();
          return isEvens.reduceRight(
            (acc, t) => (t ? modProd(acc, acc) : modProd(x, modProd(acc, acc))),
            x
          );
        };
        return tuple(modAdd, modSub, modProd, modPow);
      })()) as {
  (t: number): [
    BinaryOperation<number>,
    BinaryOperation<number>,
    BinaryOperation<number>,
    BinaryOperation<number>
  ];
  (t: bigint): [
    BinaryOperation<bigint>,
    BinaryOperation<bigint>,
    BinaryOperation<bigint>,
    BinaryOperation<bigint>
  ];
};

////////////////////////////////////////////////////////////////////////////////
// Application
////////////////////////////////////////////////////////////////////////////////
const getAns = (N: number): number =>
  sum(
    range(N - 1)
      .map((i) => i + 1)
      .map((a) => Math.floor((N - 1) / a))
  );

/** main */
const main = () => {
  // eslint-disable-next-line @typescript-eslint/no-unused-vars
  const [cin, nCin, bCin] = getCin();

  const N = nCin();
  const ans = getAns(N);
  console.log(ans);
};
main();


Measured memory_bytes: 95944