proc `$`(sq: seq[SomeInteger]): string

proc `$`(sq: seq[SomeNumber]): string

proc `&&`(sa, sb: string): string {....raises: [], tags: [], forbids: [].}

proc `&&=`(sa: var string; sb: string) {....raises: [], tags: [], forbids: [].}

proc `+`(sa, sb: string): string {....raises: [], tags: [], forbids: [].}

proc `+=`(sa: var string; sb: string) {....raises: [], tags: [], forbids: [].}

proc `/`(sa, sb: string): string {....raises: [], tags: [], forbids: [].}

proc `/`[A: SomeInteger; B: SomeInteger](a: openArray[A]; b: openArray[B]): auto

proc all(args: varargs[bool]): bool {....raises: [], tags: [], forbids: [].}

proc any(args: varargs[bool]): bool {....raises: [], tags: [], forbids: [].}

proc cargc(): cint {....raises: [], tags: [ReadIOEffect], forbids: [].}

proc cargv(argc: cint): cstringArray {....raises: [], tags: [ReadIOEffect],
                                       forbids: [].}

proc divides(a, b: SomeInteger): bool {.inline.}

proc dividesSomeElement[A: SomeInteger; B: SomeInteger](a: A; bs: seq[B]): bool {.
    inline.}

proc ones(nd: int; T: typedesc): seq[T:type] {.inline.}

proc product[T](arr: openArray[T]): T {.inline.}

proc toSeq[I](arr: openArray[I]): auto {.inline.}

proc toSeq[I](arr: openArray[I]; T: typedesc): seq[T:type] {.inline.}

iterator dimensions[T](arr: openArray[T]): int {.inline.}

iterator reversedDimensions[T](arr: openArray[T]; start: int = 0): int {.inline.}