import macros;macro ImportExpand(s:untyped):untyped = parseStmt($s[2])
when not defined(second_compile):
    const tmp = staticExec("nim cpp -d:danger --mm:refc -o:a.out -d:second_compile Main.nim")
    static:
        echo tmp
        quit()
ImportExpand "cplib/tmpl/sheep.nim" <=== "when not declared CPLIB_TMPL_SHEEP:\n    const CPLIB_TMPL_SHEEP* = 1\n    {.warning[UnusedImport]: off.}\n    {.hint[XDeclaredButNotUsed]: off.}\n    import algorithm\n    import sequtils\n    import tables\n    import macros\n    import math\n    import sets\n    import strutils\n    import strformat\n    import sugar\n    import heapqueue\n    import streams\n    import deques\n    import bitops\n    import std/lenientops\n    import options\n    #入力系\n    proc scanf(formatstr: cstring){.header: \"<stdio.h>\", varargs.}\n    proc getchar(): char {.importc: \"getchar_unlocked\", header: \"<stdio.h>\", discardable.}\n    proc ii(): int {.inline.} = scanf(\"%lld\\n\", addr result)\n    proc lii(N: int): seq[int] {.inline.} = newSeqWith(N, ii())\n    proc si(): string {.inline.} =\n        result = \"\"\n        var c: char\n        while true:\n            c = getchar()\n            if c == ' ' or c == '\\n':\n                break\n            result &= c\n    #chmin,chmax\n    template `max=`(x, y) = x = max(x, y)\n    template `min=`(x, y) = x = min(x, y)\n    #bit演算\n    proc `%`*(x: int, y: int): int =\n        result = x mod y\n        if y > 0 and result < 0: result += y\n        if y < 0 and result > 0: result += y\n    proc `//`*(x: int, y: int): int{.inline.} =\n        result = x div y\n        if y > 0 and result * y > x: result -= 1\n        if y < 0 and result * y < x: result -= 1\n    proc `%=`(x: var int, y: int): void = x = x%y\n    proc `//=`(x: var int, y: int): void = x = x//y\n    proc `**`(x: int, y: int): int = x^y\n    proc `**=`(x: var int, y: int): void = x = x^y\n    proc `^`(x: int, y: int): int = x xor y\n    proc `|`(x: int, y: int): int = x or y\n    proc `&`(x: int, y: int): int = x and y\n    proc `>>`(x: int, y: int): int = x shr y\n    proc `<<`(x: int, y: int): int = x shl y\n    proc `~`(x: int): int = not x\n    proc `^=`(x: var int, y: int): void = x = x ^ y\n    proc `&=`(x: var int, y: int): void = x = x & y\n    proc `|=`(x: var int, y: int): void = x = x | y\n    proc `>>=`(x: var int, y: int): void = x = x >> y\n    proc `<<=`(x: var int, y: int): void = x = x << y\n    proc `[]`(x: int, n: int): bool = (x and (1 shl n)) != 0\n    #便利な変換\n    proc `!`(x: char, a = '0'): int = int(x)-int(a)\n    #定数\n    #[ include cplib/utils/constants ]#\n    when not declared CPLIB_UTILS_CONSTANTS:\n        const CPLIB_UTILS_CONSTANTS* = 1\n        const INF32*: int32 = 100100111.int32\n        const INF64*: int = int(3300300300300300491)\n    const INF = INF64\n    #converter\n\n    #range\n    iterator range(start: int, ends: int, step: int): int =\n        var i = start\n        if step < 0:\n            while i > ends:\n                yield i\n                i += step\n        elif step > 0:\n            while i < ends:\n                yield i\n                i += step\n    iterator range(ends: int): int = (for i in 0..<ends: yield i)\n    iterator range(start: int, ends: int): int = (for i in\n            start..<ends: yield i)\n\n    #joinが非stringでめちゃくちゃ遅いやつのパッチ\n    proc join*[T: not string](a: openArray[T], sep: string = \"\"): string = a.mapit($it).join(sep)\n"
ImportExpand "cplib/modint/modint.nim" <=== "when not declared CPLIB_MODINT_MODINT:\n    const CPLIB_MODINT_MODINT* = 1\n    #[ include cplib/modint/barrett_impl ]#\n    when not declared CPLIB_MODINT_MODINT_BARRETT:\n        const CPLIB_MODINT_MODINT_BARRETT* = 1\n        when compileOption(\"mm\", \"orc\") or compileOption(\"mm\", \"arc\"):\n            {.fatal: \"Plese Use refc\".}\n        import std/macros\n        type StaticBarrettModint*[M: static[uint32]] = object\n            a: uint32\n        type DynamicBarrettModint*[M: static[uint32]] = object\n            a: uint32\n        type BarrettModint* = StaticBarrettModint or DynamicBarrettModint\n    \n        proc get_im*(M: uint32): uint = cast[uint](-1) div M + 1\n        func get_param*[M: static[uint32]](self: typedesc[DynamicBarrettModint[M]]): ptr[tuple[M, im: uint]] =\n            {.cast(noSideEffect).}:\n                var p {.global.}: tuple[M, im: uint] = (998244353u, get_im(998244353u32))\n                return p.addr\n        template get_M*(T: typedesc[BarrettModint]): uint =\n            when T is StaticBarrettModint: T.M.uint\n            else: (get_param(T))[].M.uint\n        proc setMod*[T: static[uint32]](self: typedesc[DynamicBarrettModint[T]], M: SomeInteger or SomeUnsignedInt) =\n            (get_param(self))[] = (M: M.uint, im: get_im(M.uint32))\n    \n        template umod*[T: BarrettModint](self: typedesc[T] or T): uint32 =\n            when self is typedesc:\n                when self is StaticBarrettModint: self.M\n                else: cast[uint32](((get_param(self))[]).M)\n            else: T.umod\n        template `mod`*[T: BarrettModint](self: typedesc[T] or T): int32 = (T.umod).int32\n        {.emit: \"\"\"\n        #include <cstdio>\n        inline unsigned long long calc_mul(const unsigned long long &a, const unsigned long long &b) {\n            return (unsigned long long)(((__uint128_t)(a) * b) >> 64);\n        }\n        \"\"\".}\n        proc calc_mul*(a, b: culonglong): culonglong {.importcpp: \"calc_mul(#, #)\", nodecl, inline.}\n        proc rem*(T: typedesc[BarrettModint], a: uint): uint32 =\n            when T is StaticBarrettModint:\n                const im = get_im(T.M)\n                const M = get_M(T)\n                var x = (calc_mul(cast[culonglong](a), cast[culonglong](im))).uint\n                var r = a - x * M\n                if M <= r: r += M\n                return cast[uint32](r)\n            else:\n                var p = get_param(T)[]\n                var x = (calc_mul(cast[culonglong](a), cast[culonglong](p.im))).uint\n                var r = a - x * p.M\n                if p.M <= r: r += p.M\n                return cast[uint32](r)\n        proc init*(T: typedesc[BarrettModint], a: T or SomeInteger): auto =\n            when a is T: return a\n            else:\n                if a in 0..<T.mod.int: return T(a: a.uint32)\n                var a = a mod T.mod.int\n                if a < 0: a += T.mod.int\n                return T(a: a.uint32)\n    \n        proc `-`*[T: BarrettModint](a: T): T = T(a: T.umod - a.a)\n        proc `+=`*[T: BarrettModint](a: var T, b: T or SomeInteger) =\n            a.a += init(T, b).a\n            if a.a >= T.umod: a.a -= T.umod\n        proc `-=`*[T: BarrettModint](a: var T, b: T or SomeInteger) =\n            a.a -= init(T, b).a\n            if a.a >= T.umod: a.a += T.umod\n        proc `*=`*[T: BarrettModint] (a: var T, b: T or SomeInteger) =\n            a.a = rem(T, (a.a).uint * (init(T, b).a).uint)\n        proc inv*[T: BarrettModint](x: T): T =\n            assert x.val != 0\n            var x: int32 = int32(x.val)\n            var y: int32 = T.mod\n            var u = 1i32\n            var v, t = 0i32\n            while y > 0:\n                t = x div y\n                x -= t * y\n                u -= t * v\n                swap(x, y)\n                swap(u, v)\n            return init(T, u)\n        proc `/=`*[T: BarrettModint](a: var T, b: T or SomeInteger) = a *= init(T, b).inv\n        proc val*(a: BarrettModint): int = a.a.int\n        macro declarStaticBarrettModint*(name, M) =\n            let converter_name = ident(\"to\" & $`name`)\n            quote do:\n                type `name`* = StaticBarrettModint[`M`]\n                converter `converter_name`*(a: int): StaticBarrettModint[`M`] = init(StaticBarrettModint[`M`], a)\n        macro declarDynamicBarrettModint*(name, id) =\n            let converter_name = ident(\"to\" & $`name`)\n            quote do:\n                type `name`* = DynamicBarrettModint[`id`]\n                converter `converter_name`*(a: int): DynamicBarrettModint[`id`] = init(DynamicBarrettModint[`id`], a)\n    #[ include cplib/modint/montgomery_impl ]#\n    when not declared CPLIB_MODINT_MODINT_MONTGOMERY:\n        const CPLIB_MODINT_MODINT_MONTGOMERY* = 1\n        when compileOption(\"mm\", \"orc\") or compileOption(\"mm\", \"arc\"):\n            {.fatal: \"Plese Use refc\".}\n        import std/macros\n        type StaticMontgomeryModint*[M: static[uint32]] = object\n            a: uint32\n        type DynamicMontgomeryModint*[M: static[uint32]] = object\n            a: uint32\n        type MontgomeryModint* = StaticMontgomeryModint or DynamicMontgomeryModint\n    \n        proc get_r*(M: uint32): uint32 =\n            result = M\n            for _ in 0..<4: result *= 2u32 - M * result\n        proc get_n2*(M: uint32): uint32 = uint32((not uint(M - 1u32)) mod uint(M))\n        proc check_params(M, r: uint32) =\n            assert M < (1u32 shl 30), \"invalid mod >= 2^30\"\n            assert (M and 1u32) == 1u32, \"invalid mod % 2 == 0\"\n            assert r * M == 1, \"r * mod != 1\"\n        func get_param*[M: static[uint32]](self: typedesc[DynamicMontgomeryModint[M]]): ptr[tuple[M, r, n2: uint32]] =\n            {.cast(noSideEffect).}:\n                var p {.global.}: tuple[M, r, n2: uint32] = (998244353u32, get_r(998244353u32), get_n2(998244353u32))\n                return p.addr\n        template get_M*(T: typedesc[MontgomeryModint]): uint32 =\n            when T is StaticMontgomeryModint: T.M\n            else: (get_param(T))[].M\n        proc setMod*[T: static[uint32]](self: typedesc[DynamicMontgomeryModint[T]], M: SomeInteger or SomeUnsignedInt) =\n            var r = get_r(M.uint32)\n            var n2 = get_n2(M.uint32)\n            var p = (M.uint32, r, n2)\n            (get_param(self))[] = p\n            check_params(M.uint32, r)\n    \n        template umod*[T: MontgomeryModint](self: typedesc[T] or T): uint32 =\n            when self is typedesc:\n                when self is StaticMontgomeryModint: self.M\n                else: ((get_param(self))[]).M\n            else: T.umod\n        template `mod`*[T: MontgomeryModint](self: typedesc[T] or T): int32 = (T.umod).int32\n    \n        func reduce(T: typedesc[MontgomeryModint], b: uint): uint32 =\n            when T is StaticMontgomeryModint:\n                const r = get_r(T.M)\n                return cast[uint32]((b + uint(cast[uint32](b) * (not (r - 1u32))) * T.M) shr 32)\n            else:\n                var p = (get_param(T))[]\n                return cast[uint32]((b + uint(cast[uint32](b) * (not (p.r - 1u32))) * p.M) shr 32)\n        proc init*(T: typedesc[MontgomeryModint], a: T or SomeInteger): auto =\n            when a is T: return a\n            elif T is StaticMontgomeryModint:\n                const r = get_r(T.M)\n                const n2 = get_n2(T.M)\n                check_params(T.M, r)\n                var ai = reduce(T, uint(a.int32 mod T.M.int32 + T.M.int32) * n2)\n                result = StaticMontgomeryModint[T.M](a: ai)\n            elif T is DynamicMontgomeryModint:\n                var p = (get_param(T))[]\n                var ai = reduce(T, uint(a.int32 mod p.M.int32 + p.M.int32) * p.n2)\n                result = DynamicMontgomeryModint[T.M](a: ai)\n    \n        proc `+=`*[T: MontgomeryModint](a: var T, b: T or SomeInteger) =\n            a.a += init(T, b).a - T.get_M * 2u32\n            if cast[int32](a.a) < 0i32: a.a += T.get_M * 2u32\n        proc `-=`*[T: MontgomeryModint](a: var T, b: T or SomeInteger) =\n            a.a -= init(T, b).a\n            if cast[int32](a.a) < 0i32: a.a += T.get_M * 2u32\n        proc val*[T: MontgomeryModint](a: T): int =\n            result = reduce(T, a.a).int\n            if result.uint32 >= T.get_M: result -= T.get_M.int\n    \n        proc `-`*[T: MontgomeryModint](a: T): T = init(T, 0) - a\n        proc `*=`*[T: MontgomeryModint] (a: var T, b: T or SomeInteger) = a.a = reduce(T, uint(a.a) * init(T, b).a)\n        proc inv*[T: MontgomeryModint](x: T): T =\n            assert x.val != 0\n            var x: int32 = int32(x.val)\n            var y: int32 = T.mod\n            var u = 1i32\n            var v, t = 0i32\n            while y > 0:\n                t = x div y\n                x -= t * y\n                u -= t * v\n                swap(x, y)\n                swap(u, v)\n            return init(T, u)\n        proc `/=`*[T: MontgomeryModint](a: var T, b: T or SomeInteger) = a *= init(T, b).inv\n    \n        macro declarStaticMontgomeryModint*(name, M) =\n            let converter_name = ident(\"to\" & $`name`)\n            quote do:\n                type `name`* = StaticMontgomeryModint[`M`]\n                converter `converter_name`*(a: int): StaticMontgomeryModint[`M`] = init(StaticMontgomeryModint[`M`], a)\n        macro declarDynamicMontgomeryModint*(name, id) =\n            let converter_name = ident(\"to\" & $`name`)\n            quote do:\n                type `name`* = DynamicMontgomeryModint[`id`]\n                converter `converter_name`*(a: int): DynamicMontgomeryModint[`id`] = init(DynamicMontgomeryModint[`id`], a)\n    import std/math\n    import std/algorithm\n    #[ import cplib/math/isqrt ]#\n    when not declared CPLIB_MATH_ISQRT:\n        const CPLIB_MATH_ISQRT* = 1\n        proc isqrt*(n: int): int =\n            var x = n\n            var y = (x + 1) shr 1\n            while y < x:\n                x = y\n                y = (x + n div x) shr 1\n            return x\n    declarStaticMontgomeryModint(modint998244353_montgomery, 998244353u32)\n    declarStaticMontgomeryModint(modint1000000007_montgomery, 1000000007u32)\n    declarDynamicMontgomeryModint(modint_montgomery, 1u32)\n    declarStaticBarrettModint(modint998244353_barrett, 998244353u32)\n    declarStaticBarrettModint(modint1000000007_barrett, 1000000007u32)\n    declarDynamicBarrettModint(modint_barrett, 1u32)\n    func `+`*(a, b: MontgomeryModint or BarrettModint): auto = (result = a; result += b)\n    func `-`*(a, b: MontgomeryModint or BarrettModint): auto = (result = a; result -= b)\n    func `*`*(a, b: MontgomeryModint or BarrettModint): auto = (result = a; result *= b)\n    func `/`*(a, b: MontgomeryModint or BarrettModint): auto = (result = a; result /= b)\n    func `+`*(a: MontgomeryModint or BarrettModint, b: SomeInteger): auto = (result = a; result += b)\n    func `-`*(a: MontgomeryModint or BarrettModint, b: SomeInteger): auto = (result = a; result -= b)\n    func `*`*(a: MontgomeryModint or BarrettModint, b: SomeInteger): auto = (result = a; result *= b)\n    func `/`*(a: MontgomeryModint or BarrettModint, b: SomeInteger): auto = (result = a; result /= b)\n    func `+`*(a: SomeInteger, b: MontgomeryModint or BarrettModint): auto = b + a\n    func `-`*(a: SomeInteger, b: MontgomeryModint or BarrettModint): auto = b - a\n    func `*`*(a: SomeInteger, b: MontgomeryModint or BarrettModint): auto = b * a\n    func `/`*(a: SomeInteger, b: MontgomeryModint or BarrettModint): auto = b / a\n    proc `/`*[ModInt: MontgomeryModint or BarrettModint](a: ModInt, b: static int): auto =\n        const tmp = init(Modint, b).inv\n        return a * tmp\n    func pow*(a: MontgomeryModint or BarrettModint, n: int): auto =\n        result = init(typeof(a), 1)\n        var a = a\n        var n = n\n        while n > 0:\n            if (n and 1) == 1: result *= a\n            a *= a\n            n = (n shr 1)\n    func `$`*(a: MontgomeryModint or BarrettModint): string = $(a.val)\n    proc estimate_rational*(a: MontgomeryModint or BarrettModint, ub: int = isqrt(typeof(a).mod)): string =\n        var v: seq[tuple[s, n, d: int]]\n        for d in 1..ub:\n            var n = (a * d).val\n            if n * 2 > a.mod:\n                n = - (a.mod - n)\n            if gcd(n, d) > 1: continue\n            v.add((n.abs + d, n, d))\n        v.sort\n        return $v[0].n & \"/\" & $v[0].d\n"
ImportExpand "cplib/collections/defaultdict.nim" <=== "when not declared CPLIB_COLLECTIONS_DEFAULTDICT:\n    const CPLIB_COLLECTIONS_DEFAULTDICT* = 1\n    import tables\n    import hashes\n    type DefaultDict*[K, V] = object\n        table: Table[K, V]\n        default: V\n    proc initDefaultDict*[K, V](default: V): DefaultDict[K, V] = DefaultDict[K, V](table: initTable[K, V](), default: default)\n    proc `==`*[K, V](src, dst: DefaultDict[K, V]): bool = src.table == dst.table\n    proc `[]=`*[K, V](d: var DefaultDict[K, V], key: K, val: V) = d.table[key] = val\n    proc `[]`*[K, V](d: DefaultDict[K, V], key: K): V =\n        if key notin d.table: return d.default()\n        return d.table[key]\n    proc `[]`*[K, V](d: var DefaultDict[K, V], key: K): var V =\n        if key notin d.table: d.table[key] = d.default\n        return d.table[key]\n    proc clear*[K, V](d: var DefaultDict[K, V]) = d.table = initTable[K, V](0)\n    proc contains*[K, V](d: var DefaultDict[K, V], key: K): bool = d.table.contains(key)\n    proc del*[K, V](d: var DefaultDict[K, V], key: K) = d.table.del(key)\n    proc hash*[K, V](d: DefaultDict[K, V]): Hash = d.table.hash\n    proc hasKey*[K, V](d: DefaultDict[K, V], key: K): bool = d.table.hasKey(key)\n    proc len*[K, V](d: DefaultDict[K, V]): int = d.table.len\n    proc pop*[K, V](d: var DefaultDict, key: K, val: var V): bool = d.table.pop(key, val)\n    proc take*[K, V](d: var DefaultDict, key: K, val: var V): bool = d.table.pop(key, val)\n    proc toDefaultDict*[K, V](pairs: openArray[(K, V)], default: V): DefaultDict[K, V] =\n        result = initDefaultDict[K, V](default)\n        result.table = pairs.toTable\n    proc toDefaultDict*[K, V](table: Table[K, V], default: V): DefaultDict[K, V] =\n        result = initDefaultDict[K, V](default)\n        result.table = table\n    iterator pairs*[K, V](d: DefaultDict[K, V]): (K, V) =\n        for k, v in d.table: yield (k, v)\n    iterator mpairs*[K, V](d: var DefaultDict[K, V]): (K, var V) =\n        for k, v in d.table.mpairs: yield (k, v)\n    iterator keys*[K, V](d: DefaultDict[K, V]): K =\n        for k in d.table.keys: yield k\n    iterator values*[K, V](d: DefaultDict[K, V]): V =\n        for v in d.table.values: yield v\n    proc `$`*[K, V](d: DefaultDict[K, V]): string = $(d.table)\n"
ImportExpand "cplib/matrix/matrix.nim" <=== "when not declared CPLIB_MATRIX_MATRIX:\n    const CPLIB_MATRIX_MATRIX* = 1\n    import sequtils\n    import strutils\n    import hashes\n    import std/math\n    type Matrix*[T] = object\n        arr: seq[seq[T]]\n    proc initMatrix*[T](arr: seq[seq[T]]): Matrix[T] =\n        assert arr.len == 0 or arr.mapIt(it.len).allIt(it == arr[0].len), \"all elements in arr must be the same size.\"\n        Matrix[T](arr: arr)\n    proc toMatrix*[T](arr: seq[seq[T]]): Matrix[T] = initMatrix(arr)\n    proc initMatrix*[T](arr: seq[T], vertical: bool = false): Matrix[T] =\n        if vertical: Matrix[T](arr: arr.mapIt(@[it]))\n        else: Matrix[T](arr: @[arr])\n    proc initMatrix*[T](h, w: int, val: T): Matrix[T] = Matrix[T](arr: newSeqWith(h, newSeqWith(w, val)))\n\n    proc h*[T](m: Matrix[T]): int = m.arr.len\n    proc w*[T](m: Matrix[T]): int =\n        if m.h == 0: return 0\n        m.arr[0].len\n    proc `$`*[T](m: Matrix[T]): string =\n        for i in 0..<m.arr.len:\n            result &= m.arr[i].mapIt($it).join(\" \")\n            if i != m.arr.len - 1: result &= \"\\n\"\n    proc `==`*[T](a, b: Matrix[T]): bool = a.arr == b.arr\n    proc `[]`*[T](m: Matrix[T], r: int): seq[T] = m.arr[r]\n    proc `[]`*[T](m: var Matrix[T], r: int): var seq[T] = m.arr[r]\n    proc `[]=`*[T](m: var Matrix[T], r: int, row: seq[T]) = m.arr[r] = row\n\n    proc `[]`*[T](m: Matrix[T], r: int, c: int): T = m.arr[r][c]\n    proc `[]`*[T](m: var Matrix[T], r: int, c: int): var T = m.arr[r][c]\n    proc `[]=`*[T](m: var Matrix[T], r: int, c: int, val: T) = m.arr[r][c] = val\n\n    proc `-`*[T](m: Matrix[T]): Matrix[T] = Matrix[T](arr: m.arr.mapIt(it.mapIt(-it)))\n    proc `*=`*[T](a: var Matrix[T], b: Matrix[T]) =\n        assert a.w == b.h\n        var ans = initMatrix[T](a.h, b.w, 0)\n        for i in 0..<a.h:\n            for j in 0..<b.w:\n                for k in 0..<a.w:\n                    ans[i, j] += a[i, k] * b[k, j]\n        swap(ans, a)\n    proc `*=`*[T](a: var Matrix[T], x: T) =\n        for i in 0..<a.h:\n            for j in 0..<a.w:\n                a[i, j] *= x\n    proc `*`*[T](a, b: Matrix[T]): Matrix[T] = (result = a; result *= b)\n    proc `*`*[T](a: Matrix[T], x: T): Matrix[T] = (result = a; result *= x)\n    proc `*`*[T](x: T, a: Matrix[T]): Matrix[T] = a * x\n    template defineMatrixAssignmentOp(assign, op: untyped) =\n        proc assign*[T](a: var Matrix[T], b: Matrix[T]) =\n            assert a.h == b.h and a.w == b.w\n            for i in 0..<a.h:\n                for j in 0..<a.w:\n                    assign(a[i, j], b[i, j])\n        proc assign*[T](a: var Matrix[T], x: T) =\n            for i in 0..<a.h:\n                for j in 0..<a.w:\n                    assign(a[i, j], x)\n        proc op*[T](a, b: Matrix[T]): Matrix[T] = (result = a; assign(result, b))\n        proc op*[T](a: Matrix[T], x: T): Matrix[T] = (result = a; assign(result, x))\n        proc op*[T](x: T, a: Matrix[T]): Matrix[T] = op(a, x)\n    defineMatrixAssignmentOp(`+=`, `+`)\n    defineMatrixAssignmentOp(`-=`, `-`)\n\n    template defineMatrixIntOps(assign, op: untyped) =\n        proc assign*(a: var Matrix[int], b: Matrix[int]) =\n            assert a.h == b.h and a.w == b.w\n            for i in 0..<a.h:\n                for j in 0..<a.w:\n                    a[i, j] = op(a[i, j], b[i, j])\n        proc assign*(a: var Matrix[int], x: int) =\n            for i in 0..<a.h:\n                for j in 0..<a.w:\n                    a[i, j] = op(a[i, j], x)\n        proc op*(a, b: Matrix[int]): Matrix[int] = (result = a; assign(result, b))\n        proc op*(a: Matrix[int], x: int): Matrix[int] = (result = a; assign(result, x))\n        proc op*(x: int, a: Matrix[int]): Matrix[int] = op(a, x)\n    defineMatrixIntOps(`and=`, `and`)\n    defineMatrixIntOps(`or=`, `or`)\n    defineMatrixIntOps(`xor=`, `xor`)\n    defineMatrixIntOps(`shl=`, `shl`)\n    defineMatrixIntOps(`shr=`, `shr`)\n    defineMatrixIntOps(`div=`, `div`)\n    defineMatrixIntOps(`mod=`, `mod`)\n\n    proc hash*[T](m: Matrix[T]): Hash = hash(m.arr)\n    proc identity_matrix*[T](n: int, one, zero: T): Matrix[T] =\n        result = initMatrix[T](n, n, zero)\n        for i in 0..<n: result[i][i] = one\n    proc identity_matrix*[T](n: int): Matrix[T] = identity_matrix[T](n, 1, 0)\n    proc pow*[T](m: Matrix[T], n: int): Matrix[T] =\n        result = identity_matrix[T](m.h)\n        var m = m\n        var n = n\n        while n > 0:\n            if (n and 1) == 1: result *= m\n            m *= m\n            n = n shr 1\n    proc `**`*[T](m: Matrix[T], n: int): Matrix[T] = m.pow(n)\n    proc sum*[T](m: Matrix[T]): T = m.arr.mapit(it.sum).sum\n"
type mint = modint998244353_montgomery



var N,M,K = ii()
var d = initDefaultDict[int,int](0)
for i in range(1,M+1):
    d[M//i] += 1

var mt = newSeqWith(len(d),newseqwith(len(d),mint(0)))

var tmp : seq[(int,int)]
for key,value in d:
    tmp.add((key,value))

for i in range(len(tmp)):
    for j in range(len(tmp)):
        if abs(tmp[i][0]-tmp[j][0]) <= K:
            mt[i][j] = tmp[j][1].mint()

var mtri = mt.tomatrix()
var vec = @[tmp.mapit(it[1].mint())].tomatrix()

echo (vec * mtri.pow(N-1)).sum()