proc `%`(a, b: PyFloatObject): PyObject {....raises: [], tags: [RootEffect],
    forbids: [].}

proc `//`(a, b: PyFloatObject): PyObject {....raises: [], tags: [RootEffect],
    forbids: [].}

proc abs(self: PyFloatObject): PyFloatObject {....raises: [], tags: [RootEffect],
    forbids: [].}

proc absPyFloatObjectMagic(selfNoCast: PyObject): PyObject {.cdecl, ...raises: [],
    tags: [RootEffect], forbids: [].}

proc addPyFloatObjectMagic(selfNoCast: PyObject; other: PyObject): PyObject {.
    cdecl, ...raises: [], tags: [RootEffect], forbids: [].}

proc as_integer_ratio(self: PyFloatObject): tuple[num, den: int] {.
    ...raises: [ValueError], tags: [], forbids: [].}

proc as_integer_ratioPyFloatObjectMethod(selfNoCast: PyObject;
    args: openArray[PyObject] = @[]; kwargs: PyKwArgType = nil): PyObject {.
    cdecl, ...raises: [], tags: [RootEffect], forbids: [].}

proc boolPyFloatObjectMagic(selfNoCast: PyObject): PyObject {.cdecl, ...raises: [],
    tags: [], forbids: [].}

proc divmod(a, b: PyFloatObject): tuple[d, m: PyFloatObject] {.
    ...raises: [ZeroDivisionError], tags: [RootEffect], forbids: [].}

proc divmodNonZero(a, b: PyFloatObject): tuple[d, m: PyFloatObject] {.
    ...raises: [], tags: [RootEffect], forbids: [].}

proc DUroundDUPyFloatObjectMethod(selfNoCast: PyObject;
                                  args: openArray[PyObject] = @[];
                                  kwargs: PyKwArgType = nil): PyObject {.cdecl,
    ...raises: [], tags: [RootEffect, WriteIOEffect], forbids: [].}

proc eqPyFloatObjectMagic(selfNoCast: PyObject; other: PyObject): PyObject {.
    cdecl, ...raises: [], tags: [RootEffect], forbids: [].}

proc floatPyFloatObjectMagic(selfNoCast: PyObject): PyObject {.cdecl,
    ...raises: [], tags: [], forbids: [].}

proc floorDiv(a, b: PyFloatObject): PyFloatObject {....raises: [ZeroDivisionError],
    tags: [RootEffect], forbids: [].}

proc floordivPyFloatObjectMagic(selfNoCast: PyObject; other: PyObject): PyObject {.
    cdecl, ...raises: [], tags: [RootEffect], forbids: [].}

proc floorMod(a, b: PyFloatObject): PyFloatObject {....raises: [ZeroDivisionError],
    tags: [RootEffect], forbids: [].}

proc fromhexPyFloatObjectMethod(selfNoCast: PyObject;
                                args: openArray[PyObject] = @[];
                                kwargs: PyKwArgType = nil): PyObject {.cdecl,
    ...raises: [], tags: [RootEffect], forbids: [].}

proc gtPyFloatObjectMagic(selfNoCast: PyObject; other: PyObject): PyObject {.
    cdecl, ...raises: [], tags: [RootEffect], forbids: [].}

proc hashPyFloatObjectMagic(selfNoCast: PyObject): PyObject {.cdecl, ...raises: [],
    tags: [RootEffect], forbids: [].}

proc hex(self: PyFloatObject): PyStrObject {....raises: [], tags: [RootEffect],
    forbids: [].}

proc hexPyFloatObjectMethod(selfNoCast: PyObject;
                            args: openArray[PyObject] = @[];
                            kwargs: PyKwArgType = nil): PyObject {.cdecl,
    ...raises: [], tags: [RootEffect], forbids: [].}

proc intPyFloatObjectMagic(selfNoCast: PyObject): PyObject {.cdecl, ...raises: [],
    tags: [RootEffect], forbids: [].}

proc is_integer(self: PyFloatObject): bool {....raises: [], tags: [], forbids: [].}

proc is_integerPyFloatObjectMethod(selfNoCast: PyObject;
                                   args: openArray[PyObject] = @[];
                                   kwargs: PyKwArgType = nil): PyObject {.cdecl,
    ...raises: [], tags: [RootEffect], forbids: [].}

proc ltPyFloatObjectMagic(selfNoCast: PyObject; other: PyObject): PyObject {.
    cdecl, ...raises: [], tags: [RootEffect], forbids: [].}

proc modPyFloatObjectMagic(selfNoCast: PyObject; other: PyObject): PyObject {.
    cdecl, ...raises: [], tags: [RootEffect], forbids: [].}

proc mulPyFloatObjectMagic(selfNoCast: PyObject; other: PyObject): PyObject {.
    cdecl, ...raises: [], tags: [RootEffect], forbids: [].}

proc negativePyFloatObjectMagic(selfNoCast: PyObject): PyObject {.cdecl,
    ...raises: [], tags: [RootEffect], forbids: [].}

proc newPyFloatFromhex(s: PyStrObject): PyFloatObject {....raises: [ValueError],
    tags: [RootEffect], forbids: [].}

proc newPyFloatObjectMagic(args: openArray[PyObject] = @[];
                           kwargs: PyKwArgType = nil): PyObject {.cdecl,
    ...raises: [], tags: [RootEffect, WriteIOEffect], forbids: [].}

proc positivePyFloatObjectMagic(selfNoCast: PyObject): PyObject {.cdecl,
    ...raises: [], tags: [], forbids: [].}

proc powPyFloatObjectMagic(selfNoCast: PyObject; arg1: PyObject; arg2: PyObject): PyObject {.
    cdecl, ...raises: [], tags: [RootEffect], forbids: [].}

proc reprPyFloatObjectMagic(selfNoCast: PyObject): PyObject {.cdecl, ...raises: [],
    tags: [RootEffect], forbids: [].}

proc strPyFloatObjectMagic(selfNoCast: PyObject): PyObject {.cdecl, ...raises: [],
    tags: [RootEffect], forbids: [].}

proc subPyFloatObjectMagic(selfNoCast: PyObject; other: PyObject): PyObject {.
    cdecl, ...raises: [], tags: [RootEffect], forbids: [].}

proc truedivPyFloatObjectMagic(selfNoCast: PyObject; other: PyObject): PyObject {.
    cdecl, ...raises: [], tags: [RootEffect], forbids: [].}

template `%`[T: SomeFloat](a: PyFloatObject; b: T): untyped

template `%`[T: SomeFloat](a: T; b: PyFloatObject): untyped

template `*`(self, casted: PyFloatObject): untyped

template `*`[T: SomeFloat](a: PyFloatObject; b: T): untyped

template `*`[T: SomeFloat](a: T; b: PyFloatObject): untyped

template `+`(self, casted: PyFloatObject): untyped

template `+`[T: SomeFloat](a: PyFloatObject; b: T): untyped

template `+`[T: SomeFloat](a: T; b: PyFloatObject): untyped

template `-`(self, casted: PyFloatObject): untyped

template `-`[T: SomeFloat](a: PyFloatObject; b: T): untyped

template `-`[T: SomeFloat](a: T; b: PyFloatObject): untyped

template `/`(self, casted: PyFloatObject): untyped

template `/`[T: SomeFloat](a: PyFloatObject; b: T): untyped

template `/`[T: SomeFloat](a: T; b: PyFloatObject): untyped

template `//`[T: SomeFloat](a: PyFloatObject; b: T): untyped

template `//`[T: SomeFloat](a: T; b: PyFloatObject): untyped

template `<`(self, casted: PyFloatObject): untyped

template `<`[T: SomeFloat](a: PyFloatObject; b: T): untyped

template `<`[T: SomeFloat](a: T; b: PyFloatObject): untyped

template `<=`[T: SomeFloat](a: PyFloatObject; b: T): untyped

template `<=`[T: SomeFloat](a: T; b: PyFloatObject): untyped

template `==`(self, casted: PyFloatObject): untyped

template `==`[T: SomeFloat](a: PyFloatObject; b: T): untyped

template `==`[T: SomeFloat](a: T; b: PyFloatObject): untyped

template `>`(self, casted: PyFloatObject): untyped

template divmod[T: SomeFloat](a: PyFloatObject; b: T): untyped

template divmod[T: SomeFloat](a: T; b: PyFloatObject): untyped

template pow[T: SomeFloat](a: PyFloatObject; b: T): untyped

template pow[T: SomeFloat](a: T; b: PyFloatObject): untyped