peon/src/peon/stdlib/arithmetics.pn

## Builtin arithmetic operators for Peon


operator `+`(a, b: int): int {
    #pragma[magic: AddInt64, pure]
    return;
}


operator `+`(a, b: uint): uint {
    #pragma[magic: AddUInt64, pure]
    return;
}


operator `+`(a, b: int32): int32 {
    #pragma[magic: AddInt32, pure]
    return;
}


operator `+`(a, b: uint32): uint32 {
    #pragma[magic: AddUInt32, pure]
    return;
}


operator `+`(a, b: int16): int16 {
    #pragma[magic: AddInt16, pure]
    return;
}


operator `+`(a, b: uint16): uint16 {
    #pragma[magic: AddUInt16, pure]
    return;
}


operator `+`(a, b: int8): int8 {
    #pragma[magic: AddInt8, pure]
    return;
}


operator `+`(a, b: uint8): uint8 {
    #pragma[magic: AddUInt8, pure]
    return;
}


operator `-`(a, b: int): int {
    #pragma[magic: SubInt64, pure]
    return;
}


operator `-`(a, b: uint): uint {
    #pragma[magic: SubUInt64, pure]
    return;
}


operator `-`(a, b: int32): int32 {
    #pragma[magic: SubInt32, pure]
    return;
}


operator `-`(a, b: uint32): uint32 {
    #pragma[magic: SubUInt32, pure]
    return;
}


operator `-`(a, b: int16): int16 {
    #pragma[magic: SubInt16, pure]
    return;
}


operator `-`(a, b: uint16): uint16 {
    #pragma[magic: SubUInt16, pure]
    return;
}


operator `-`(a, b: int8): int8 {
    #pragma[magic: SubInt8, pure]
    return;
}


operator `-`(a, b: uint8): uint8 {
    #pragma[magic: SubUInt8, pure]
    return;
}


operator `*`(a, b: int): int {
    #pragma[magic: MulInt64, pure]
    return;
}


operator `*`(a, b: uint): uint {
    #pragma[magic: MulUInt64, pure]
    return;
}


operator `*`(a, b: int32): int32 {
    #pragma[magic: MulInt32, pure]
    return;
}


operator `*`(a, b: uint32): uint32 {
    #pragma[magic: MulUInt32, pure]
    return;
}


operator `*`(a, b: int16): int16 {
    #pragma[magic: MulInt16, pure]
    return;
}


operator `*`(a, b: uint16): uint16 {
    #pragma[magic: MulUInt16, pure]
    return;
}


operator `*`(a, b: int8): int8 {
    #pragma[magic: MulInt8, pure]
    return;
}


operator `*`(a, b: uint8): uint8 {
    #pragma[magic: MulUInt8, pure]
    return;
}


operator `/`(a, b: int): int {
    #pragma[magic: DivInt64, pure]
    return;
}


operator `/`(a, b: uint): uint {
    #pragma[magic: DivUInt64, pure]
    return;
}


operator `/`(a, b: int32): int32 {
    #pragma[magic: DivInt32, pure]
    return;
}


operator `/`(a, b: uint32): uint32 {
    #pragma[magic: DivUInt32, pure]
    return;
}


operator `/`(a, b: int16): int16 {
    #pragma[magic: DivInt16, pure]
    return;
}


operator `/`(a, b: uint16): uint16 {
    #pragma[magic: DivUInt16, pure]
    return;
}


operator `/`(a, b: int8): int8 {
    #pragma[magic: DivInt8, pure]
    return;
}


operator `/`(a, b: uint8): uint8 {
    #pragma[magic: DivUInt8, pure]
    return;
}