@[inline]

def Std.Time.Nanosecond.Offset.toDays (nanoseconds : Offset) : Day.Offset

Convert Nanosecond.Offset into Day.Offset.

Equations

• nanoseconds.toDays = Std.Time.Internal.UnitVal.cast Std.Time.Nanosecond.Offset.toDays._proof_1✝ (Std.Time.Internal.UnitVal.div nanoseconds 86400000000000)

@[inline]

def Std.Time.Nanosecond.Offset.ofDays (days : Day.Offset) : Offset

Convert Day.Offset into Nanosecond.Offset.

Equations

• Std.Time.Nanosecond.Offset.ofDays days = Std.Time.Internal.UnitVal.cast Std.Time.Nanosecond.Offset.ofDays._proof_1✝ (Std.Time.Internal.UnitVal.mul days 86400000000000)

@[inline]

def Std.Time.Nanosecond.Offset.toWeeks (nanoseconds : Offset) : Week.Offset

Convert Nanosecond.Offset into Week.Offset.

Equations

• nanoseconds.toWeeks = Std.Time.Internal.UnitVal.cast Std.Time.Nanosecond.Offset.toWeeks._proof_1✝ (Std.Time.Internal.UnitVal.div nanoseconds 604800000000000)

@[inline]

def Std.Time.Nanosecond.Offset.ofWeeks (weeks : Week.Offset) : Offset

Convert Week.Offset into Nanosecond.Offset.

Equations

• Std.Time.Nanosecond.Offset.ofWeeks weeks = Std.Time.Internal.UnitVal.cast Std.Time.Nanosecond.Offset.ofWeeks._proof_1✝ (Std.Time.Internal.UnitVal.mul weeks 604800000000000)

@[inline]

def Std.Time.Millisecond.Offset.toDays (milliseconds : Offset) : Day.Offset

Convert Millisecond.Offset into Day.Offset.

Equations

• milliseconds.toDays = Std.Time.Internal.UnitVal.cast Std.Time.Millisecond.Offset.toDays._proof_1✝ (Std.Time.Internal.UnitVal.div milliseconds 86400000)

@[inline]

def Std.Time.Millisecond.Offset.ofDays (days : Day.Offset) : Offset

Convert Day.Offset into Millisecond.Offset.

Equations

• Std.Time.Millisecond.Offset.ofDays days = Std.Time.Internal.UnitVal.cast Std.Time.Millisecond.Offset.ofDays._proof_1✝ (Std.Time.Internal.UnitVal.mul days 86400000)

@[inline]

def Std.Time.Millisecond.Offset.toWeeks (milliseconds : Offset) : Week.Offset

Convert Millisecond.Offset into Week.Offset.

Equations

• milliseconds.toWeeks = Std.Time.Internal.UnitVal.cast Std.Time.Millisecond.Offset.toWeeks._proof_1✝ (Std.Time.Internal.UnitVal.div milliseconds 604800000)

@[inline]

def Std.Time.Millisecond.Offset.ofWeeks (weeks : Week.Offset) : Offset

Convert Week.Offset into Millisecond.Offset.

Equations

• Std.Time.Millisecond.Offset.ofWeeks weeks = Std.Time.Internal.UnitVal.cast Std.Time.Millisecond.Offset.ofWeeks._proof_1✝ (Std.Time.Internal.UnitVal.mul weeks 604800000)

@[inline]

def Std.Time.Second.Offset.toDays (seconds : Offset) : Day.Offset

Convert Second.Offset into Day.Offset.

Equations

• seconds.toDays = Std.Time.Internal.UnitVal.cast Std.Time.Second.Offset.toDays._proof_1✝ (Std.Time.Internal.UnitVal.div seconds 86400)

@[inline]

def Std.Time.Second.Offset.ofDays (days : Day.Offset) : Offset

Convert Day.Offset into Second.Offset.

Equations

• Std.Time.Second.Offset.ofDays days = Std.Time.Internal.UnitVal.cast Std.Time.Second.Offset.ofDays._proof_1✝ (Std.Time.Internal.UnitVal.mul days 86400)

@[inline]

def Std.Time.Second.Offset.toWeeks (seconds : Offset) : Week.Offset

Convert Second.Offset into Week.Offset.

Equations

• seconds.toWeeks = Std.Time.Internal.UnitVal.cast Std.Time.Second.Offset.toWeeks._proof_1✝ (Std.Time.Internal.UnitVal.div seconds 604800)

@[inline]

def Std.Time.Second.Offset.ofWeeks (weeks : Week.Offset) : Offset

Convert Week.Offset into Second.Offset.

Equations

• Std.Time.Second.Offset.ofWeeks weeks = Std.Time.Internal.UnitVal.cast Std.Time.Second.Offset.ofWeeks._proof_1✝ (Std.Time.Internal.UnitVal.mul weeks 604800)

@[inline]

def Std.Time.Minute.Offset.toDays (minutes : Offset) : Day.Offset

Convert Minute.Offset into Day.Offset.

Equations

• minutes.toDays = Std.Time.Internal.UnitVal.cast Std.Time.Minute.Offset.toDays._proof_1✝ (Std.Time.Internal.UnitVal.div minutes 1440)

@[inline]

def Std.Time.Minute.Offset.ofDays (days : Day.Offset) : Offset

Convert Day.Offset into Minute.Offset.

Equations

• Std.Time.Minute.Offset.ofDays days = Std.Time.Internal.UnitVal.cast Std.Time.Minute.Offset.ofDays._proof_1✝ (Std.Time.Internal.UnitVal.mul days 1440)

@[inline]

def Std.Time.Minute.Offset.toWeeks (minutes : Offset) : Week.Offset

Convert Minute.Offset into Week.Offset.

Equations

• minutes.toWeeks = Std.Time.Internal.UnitVal.cast Std.Time.Minute.Offset.toWeeks._proof_1✝ (Std.Time.Internal.UnitVal.div minutes 10080)

@[inline]

def Std.Time.Minute.Offset.ofWeeks (weeks : Week.Offset) : Offset

Convert Week.Offset into Minute.Offset.

Equations

• Std.Time.Minute.Offset.ofWeeks weeks = Std.Time.Internal.UnitVal.cast Std.Time.Minute.Offset.ofWeeks._proof_1✝ (Std.Time.Internal.UnitVal.mul weeks 10080)

@[inline]

def Std.Time.Hour.Offset.toDays (hours : Offset) : Day.Offset

Convert Hour.Offset into Day.Offset.

Equations

• hours.toDays = Std.Time.Internal.UnitVal.cast Std.Time.Hour.Offset.toDays._proof_1✝ (Std.Time.Internal.UnitVal.div hours 24)

@[inline]

def Std.Time.Hour.Offset.ofDays (days : Day.Offset) : Offset

Convert Day.Offset into Hour.Offset.

Equations

• Std.Time.Hour.Offset.ofDays days = Std.Time.Internal.UnitVal.cast Std.Time.Hour.Offset.ofDays._proof_1✝ (Std.Time.Internal.UnitVal.mul days 24)

@[inline]

def Std.Time.Hour.Offset.toWeeks (hours : Offset) : Week.Offset

Convert Hour.Offset into Week.Offset.

Equations

• hours.toWeeks = Std.Time.Internal.UnitVal.cast Std.Time.Hour.Offset.toWeeks._proof_1✝ (Std.Time.Internal.UnitVal.div hours 168)

@[inline]

def Std.Time.Hour.Offset.ofWeeks (weeks : Week.Offset) : Offset

Convert Week.Offset into Hour.Offset.

Equations

• Std.Time.Hour.Offset.ofWeeks weeks = Std.Time.Internal.UnitVal.cast Std.Time.Hour.Offset.ofWeeks._proof_1✝ (Std.Time.Internal.UnitVal.mul weeks 168)

instance Std.Time.instHAddOffset : HAdd Nanosecond.Offset Nanosecond.Offset Nanosecond.Offset

Equations

• Std.Time.instHAddOffset = { hAdd := fun (x y : Std.Time.Nanosecond.Offset) => Std.Time.Internal.UnitVal.add x y }

instance Std.Time.instHAddOffsetOffset : HAdd Nanosecond.Offset Millisecond.Offset Nanosecond.Offset

Equations

• Std.Time.instHAddOffsetOffset = { hAdd := fun (x : Std.Time.Nanosecond.Offset) (y : Std.Time.Millisecond.Offset) => Std.Time.Internal.UnitVal.add x y.toNanoseconds }

instance Std.Time.instHAddOffsetOffset_1 : HAdd Nanosecond.Offset Second.Offset Nanosecond.Offset

Equations

• Std.Time.instHAddOffsetOffset_1 = { hAdd := fun (x : Std.Time.Nanosecond.Offset) (y : Std.Time.Second.Offset) => Std.Time.Internal.UnitVal.add x y.toNanoseconds }

instance Std.Time.instHAddOffsetOffset_2 : HAdd Nanosecond.Offset Minute.Offset Nanosecond.Offset

Equations

• Std.Time.instHAddOffsetOffset_2 = { hAdd := fun (x : Std.Time.Nanosecond.Offset) (y : Std.Time.Minute.Offset) => Std.Time.Internal.UnitVal.add x y.toNanoseconds }

instance Std.Time.instHAddOffsetOffset_3 : HAdd Nanosecond.Offset Hour.Offset Nanosecond.Offset

Equations

• Std.Time.instHAddOffsetOffset_3 = { hAdd := fun (x : Std.Time.Nanosecond.Offset) (y : Std.Time.Hour.Offset) => Std.Time.Internal.UnitVal.add x y.toNanoseconds }

instance Std.Time.instHAddOffsetOffset_4 : HAdd Nanosecond.Offset Day.Offset Nanosecond.Offset

Equations

• Std.Time.instHAddOffsetOffset_4 = { hAdd := fun (x : Std.Time.Nanosecond.Offset) (y : Std.Time.Day.Offset) => Std.Time.Internal.UnitVal.add x y.toNanoseconds }

instance Std.Time.instHAddOffsetOffset_5 : HAdd Nanosecond.Offset Week.Offset Nanosecond.Offset

Equations

• Std.Time.instHAddOffsetOffset_5 = { hAdd := fun (x : Std.Time.Nanosecond.Offset) (y : Std.Time.Week.Offset) => Std.Time.Internal.UnitVal.add x y.toNanoseconds }

instance Std.Time.instHAddOffsetOffset_6 : HAdd Millisecond.Offset Nanosecond.Offset Nanosecond.Offset

Equations

• Std.Time.instHAddOffsetOffset_6 = { hAdd := fun (x : Std.Time.Millisecond.Offset) (y : Std.Time.Nanosecond.Offset) => Std.Time.Internal.UnitVal.add x.toNanoseconds y }

instance Std.Time.instHAddOffset_1 : HAdd Millisecond.Offset Millisecond.Offset Millisecond.Offset

Equations

• Std.Time.instHAddOffset_1 = { hAdd := fun (x y : Std.Time.Millisecond.Offset) => Std.Time.Internal.UnitVal.add x y }

instance Std.Time.instHAddOffsetOffset_7 : HAdd Millisecond.Offset Second.Offset Millisecond.Offset

Equations

• Std.Time.instHAddOffsetOffset_7 = { hAdd := fun (x : Std.Time.Millisecond.Offset) (y : Std.Time.Second.Offset) => Std.Time.Internal.UnitVal.add x y.toMilliseconds }

instance Std.Time.instHAddOffsetOffset_8 : HAdd Millisecond.Offset Minute.Offset Millisecond.Offset

Equations

• Std.Time.instHAddOffsetOffset_8 = { hAdd := fun (x : Std.Time.Millisecond.Offset) (y : Std.Time.Minute.Offset) => Std.Time.Internal.UnitVal.add x y.toMilliseconds }

instance Std.Time.instHAddOffsetOffset_9 : HAdd Millisecond.Offset Hour.Offset Millisecond.Offset

Equations

• Std.Time.instHAddOffsetOffset_9 = { hAdd := fun (x : Std.Time.Millisecond.Offset) (y : Std.Time.Hour.Offset) => Std.Time.Internal.UnitVal.add x y.toMilliseconds }

instance Std.Time.instHAddOffsetOffset_10 : HAdd Millisecond.Offset Day.Offset Millisecond.Offset

Equations

• Std.Time.instHAddOffsetOffset_10 = { hAdd := fun (x : Std.Time.Millisecond.Offset) (y : Std.Time.Day.Offset) => Std.Time.Internal.UnitVal.add x y.toMilliseconds }

instance Std.Time.instHAddOffsetOffset_11 : HAdd Millisecond.Offset Week.Offset Millisecond.Offset

Equations

• Std.Time.instHAddOffsetOffset_11 = { hAdd := fun (x : Std.Time.Millisecond.Offset) (y : Std.Time.Week.Offset) => Std.Time.Internal.UnitVal.add x y.toMilliseconds }

instance Std.Time.instHAddOffsetOffset_12 : HAdd Second.Offset Nanosecond.Offset Nanosecond.Offset

Equations

• Std.Time.instHAddOffsetOffset_12 = { hAdd := fun (x : Std.Time.Second.Offset) (y : Std.Time.Nanosecond.Offset) => Std.Time.Internal.UnitVal.add x.toNanoseconds y }

instance Std.Time.instHAddOffsetOffset_13 : HAdd Second.Offset Millisecond.Offset Millisecond.Offset

Equations

• Std.Time.instHAddOffsetOffset_13 = { hAdd := fun (x : Std.Time.Second.Offset) (y : Std.Time.Millisecond.Offset) => Std.Time.Internal.UnitVal.add x.toMilliseconds y }

instance Std.Time.instHAddOffset_2 : HAdd Second.Offset Second.Offset Second.Offset

Equations

• Std.Time.instHAddOffset_2 = { hAdd := fun (x y : Std.Time.Second.Offset) => Std.Time.Internal.UnitVal.add x y }

instance Std.Time.instHAddOffsetOffset_14 : HAdd Second.Offset Minute.Offset Second.Offset

Equations

• Std.Time.instHAddOffsetOffset_14 = { hAdd := fun (x : Std.Time.Second.Offset) (y : Std.Time.Minute.Offset) => Std.Time.Internal.UnitVal.add x y.toSeconds }

instance Std.Time.instHAddOffsetOffset_15 : HAdd Second.Offset Hour.Offset Second.Offset

Equations

• Std.Time.instHAddOffsetOffset_15 = { hAdd := fun (x : Std.Time.Second.Offset) (y : Std.Time.Hour.Offset) => Std.Time.Internal.UnitVal.add x y.toSeconds }

instance Std.Time.instHAddOffsetOffset_16 : HAdd Second.Offset Day.Offset Second.Offset

Equations

• Std.Time.instHAddOffsetOffset_16 = { hAdd := fun (x : Std.Time.Second.Offset) (y : Std.Time.Day.Offset) => Std.Time.Internal.UnitVal.add x y.toSeconds }

instance Std.Time.instHAddOffsetOffset_17 : HAdd Second.Offset Week.Offset Second.Offset

Equations

• Std.Time.instHAddOffsetOffset_17 = { hAdd := fun (x : Std.Time.Second.Offset) (y : Std.Time.Week.Offset) => Std.Time.Internal.UnitVal.add x y.toSeconds }

instance Std.Time.instHAddOffsetOffset_18 : HAdd Minute.Offset Nanosecond.Offset Nanosecond.Offset

Equations

• Std.Time.instHAddOffsetOffset_18 = { hAdd := fun (x : Std.Time.Minute.Offset) (y : Std.Time.Nanosecond.Offset) => Std.Time.Internal.UnitVal.add x.toNanoseconds y }

instance Std.Time.instHAddOffsetOffset_19 : HAdd Minute.Offset Millisecond.Offset Millisecond.Offset

Equations

• Std.Time.instHAddOffsetOffset_19 = { hAdd := fun (x : Std.Time.Minute.Offset) (y : Std.Time.Millisecond.Offset) => Std.Time.Internal.UnitVal.add x.toMilliseconds y }

instance Std.Time.instHAddOffsetOffset_20 : HAdd Minute.Offset Second.Offset Second.Offset

Equations

• Std.Time.instHAddOffsetOffset_20 = { hAdd := fun (x : Std.Time.Minute.Offset) (y : Std.Time.Second.Offset) => Std.Time.Internal.UnitVal.add x.toSeconds y }

instance Std.Time.instHAddOffset_3 : HAdd Minute.Offset Minute.Offset Minute.Offset

Equations

• Std.Time.instHAddOffset_3 = { hAdd := fun (x y : Std.Time.Minute.Offset) => Std.Time.Internal.UnitVal.add x y }

instance Std.Time.instHAddOffsetOffset_21 : HAdd Minute.Offset Hour.Offset Minute.Offset

Equations

• Std.Time.instHAddOffsetOffset_21 = { hAdd := fun (x : Std.Time.Minute.Offset) (y : Std.Time.Hour.Offset) => Std.Time.Internal.UnitVal.add x y.toMinutes }

instance Std.Time.instHAddOffsetOffset_22 : HAdd Minute.Offset Day.Offset Minute.Offset

Equations

• Std.Time.instHAddOffsetOffset_22 = { hAdd := fun (x : Std.Time.Minute.Offset) (y : Std.Time.Day.Offset) => Std.Time.Internal.UnitVal.add x y.toMinutes }

instance Std.Time.instHAddOffsetOffset_23 : HAdd Minute.Offset Week.Offset Minute.Offset

Equations

• Std.Time.instHAddOffsetOffset_23 = { hAdd := fun (x : Std.Time.Minute.Offset) (y : Std.Time.Week.Offset) => Std.Time.Internal.UnitVal.add x y.toMinutes }

instance Std.Time.instHAddOffsetOffset_24 : HAdd Hour.Offset Nanosecond.Offset Nanosecond.Offset

Equations

• Std.Time.instHAddOffsetOffset_24 = { hAdd := fun (x : Std.Time.Hour.Offset) (y : Std.Time.Nanosecond.Offset) => Std.Time.Internal.UnitVal.add x.toNanoseconds y }

instance Std.Time.instHAddOffsetOffset_25 : HAdd Hour.Offset Millisecond.Offset Millisecond.Offset

Equations

• Std.Time.instHAddOffsetOffset_25 = { hAdd := fun (x : Std.Time.Hour.Offset) (y : Std.Time.Millisecond.Offset) => Std.Time.Internal.UnitVal.add x.toMilliseconds y }

instance Std.Time.instHAddOffsetOffset_26 : HAdd Hour.Offset Second.Offset Second.Offset

Equations

• Std.Time.instHAddOffsetOffset_26 = { hAdd := fun (x : Std.Time.Hour.Offset) (y : Std.Time.Second.Offset) => Std.Time.Internal.UnitVal.add x.toSeconds y }

instance Std.Time.instHAddOffsetOffset_27 : HAdd Hour.Offset Minute.Offset Minute.Offset

Equations

• Std.Time.instHAddOffsetOffset_27 = { hAdd := fun (x : Std.Time.Hour.Offset) (y : Std.Time.Minute.Offset) => Std.Time.Internal.UnitVal.add x.toMinutes y }

instance Std.Time.instHAddOffset_4 : HAdd Hour.Offset Hour.Offset Hour.Offset

Equations

• Std.Time.instHAddOffset_4 = { hAdd := fun (x y : Std.Time.Hour.Offset) => Std.Time.Internal.UnitVal.add x y }

instance Std.Time.instHAddOffsetOffset_28 : HAdd Hour.Offset Day.Offset Hour.Offset

Equations

• Std.Time.instHAddOffsetOffset_28 = { hAdd := fun (x : Std.Time.Hour.Offset) (y : Std.Time.Day.Offset) => Std.Time.Internal.UnitVal.add x y.toHours }

instance Std.Time.instHAddOffsetOffset_29 : HAdd Hour.Offset Week.Offset Hour.Offset

Equations

• Std.Time.instHAddOffsetOffset_29 = { hAdd := fun (x : Std.Time.Hour.Offset) (y : Std.Time.Week.Offset) => Std.Time.Internal.UnitVal.add x y.toHours }

instance Std.Time.instHAddOffsetOffset_30 : HAdd Day.Offset Nanosecond.Offset Nanosecond.Offset

Equations

• Std.Time.instHAddOffsetOffset_30 = { hAdd := fun (x : Std.Time.Day.Offset) (y : Std.Time.Nanosecond.Offset) => Std.Time.Internal.UnitVal.add x.toNanoseconds y }

instance Std.Time.instHAddOffsetOffset_31 : HAdd Day.Offset Millisecond.Offset Millisecond.Offset

Equations

• Std.Time.instHAddOffsetOffset_31 = { hAdd := fun (x : Std.Time.Day.Offset) (y : Std.Time.Millisecond.Offset) => Std.Time.Internal.UnitVal.add x.toMilliseconds y }

instance Std.Time.instHAddOffsetOffset_32 : HAdd Day.Offset Second.Offset Second.Offset

Equations

• Std.Time.instHAddOffsetOffset_32 = { hAdd := fun (x : Std.Time.Day.Offset) (y : Std.Time.Second.Offset) => Std.Time.Internal.UnitVal.add x.toSeconds y }

instance Std.Time.instHAddOffsetOffset_33 : HAdd Day.Offset Minute.Offset Minute.Offset

Equations

• Std.Time.instHAddOffsetOffset_33 = { hAdd := fun (x : Std.Time.Day.Offset) (y : Std.Time.Minute.Offset) => Std.Time.Internal.UnitVal.add x.toMinutes y }

instance Std.Time.instHAddOffsetOffset_34 : HAdd Day.Offset Hour.Offset Hour.Offset

Equations

• Std.Time.instHAddOffsetOffset_34 = { hAdd := fun (x : Std.Time.Day.Offset) (y : Std.Time.Hour.Offset) => Std.Time.Internal.UnitVal.add x.toHours y }

instance Std.Time.instHAddOffset_5 : HAdd Day.Offset Day.Offset Day.Offset

Equations

• Std.Time.instHAddOffset_5 = { hAdd := fun (x y : Std.Time.Day.Offset) => Std.Time.Internal.UnitVal.add x y }

instance Std.Time.instHAddOffsetOffset_35 : HAdd Day.Offset Week.Offset Day.Offset

Equations

• Std.Time.instHAddOffsetOffset_35 = { hAdd := fun (x : Std.Time.Day.Offset) (y : Std.Time.Week.Offset) => Std.Time.Internal.UnitVal.add x y.toDays }

instance Std.Time.instHAddOffsetOffset_36 : HAdd Week.Offset Nanosecond.Offset Nanosecond.Offset

Equations

• Std.Time.instHAddOffsetOffset_36 = { hAdd := fun (x : Std.Time.Week.Offset) (y : Std.Time.Nanosecond.Offset) => Std.Time.Internal.UnitVal.add x.toNanoseconds y }

instance Std.Time.instHAddOffsetOffset_37 : HAdd Week.Offset Millisecond.Offset Millisecond.Offset

Equations

• Std.Time.instHAddOffsetOffset_37 = { hAdd := fun (x : Std.Time.Week.Offset) (y : Std.Time.Millisecond.Offset) => Std.Time.Internal.UnitVal.add x.toMilliseconds y }

instance Std.Time.instHAddOffsetOffset_38 : HAdd Week.Offset Second.Offset Second.Offset

Equations

• Std.Time.instHAddOffsetOffset_38 = { hAdd := fun (x : Std.Time.Week.Offset) (y : Std.Time.Second.Offset) => Std.Time.Internal.UnitVal.add x.toSeconds y }

instance Std.Time.instHAddOffsetOffset_39 : HAdd Week.Offset Minute.Offset Minute.Offset

Equations

• Std.Time.instHAddOffsetOffset_39 = { hAdd := fun (x : Std.Time.Week.Offset) (y : Std.Time.Minute.Offset) => Std.Time.Internal.UnitVal.add x.toMinutes y }

instance Std.Time.instHAddOffsetOffset_40 : HAdd Week.Offset Hour.Offset Hour.Offset

Equations

• Std.Time.instHAddOffsetOffset_40 = { hAdd := fun (x : Std.Time.Week.Offset) (y : Std.Time.Hour.Offset) => Std.Time.Internal.UnitVal.add x.toHours y }

instance Std.Time.instHAddOffsetOffset_41 : HAdd Week.Offset Day.Offset Day.Offset

Equations

• Std.Time.instHAddOffsetOffset_41 = { hAdd := fun (x : Std.Time.Week.Offset) (y : Std.Time.Day.Offset) => Std.Time.Internal.UnitVal.add x.toDays y }

instance Std.Time.instHAddOffset_6 : HAdd Week.Offset Week.Offset Week.Offset

Equations

• Std.Time.instHAddOffset_6 = { hAdd := fun (x y : Std.Time.Week.Offset) => Std.Time.Internal.UnitVal.add x y }

instance Std.Time.instHSubOffset : HSub Nanosecond.Offset Nanosecond.Offset Nanosecond.Offset

Equations

• Std.Time.instHSubOffset = { hSub := fun (x y : Std.Time.Nanosecond.Offset) => Std.Time.Internal.UnitVal.sub x y }

instance Std.Time.instHSubOffsetOffset : HSub Nanosecond.Offset Millisecond.Offset Nanosecond.Offset

Equations

• Std.Time.instHSubOffsetOffset = { hSub := fun (x : Std.Time.Nanosecond.Offset) (y : Std.Time.Millisecond.Offset) => Std.Time.Internal.UnitVal.sub x y.toNanoseconds }

instance Std.Time.instHSubOffsetOffset_1 : HSub Nanosecond.Offset Second.Offset Nanosecond.Offset

Equations

• Std.Time.instHSubOffsetOffset_1 = { hSub := fun (x : Std.Time.Nanosecond.Offset) (y : Std.Time.Second.Offset) => Std.Time.Internal.UnitVal.sub x y.toNanoseconds }

instance Std.Time.instHSubOffsetOffset_2 : HSub Nanosecond.Offset Minute.Offset Nanosecond.Offset

Equations

• Std.Time.instHSubOffsetOffset_2 = { hSub := fun (x : Std.Time.Nanosecond.Offset) (y : Std.Time.Minute.Offset) => Std.Time.Internal.UnitVal.sub x y.toNanoseconds }

instance Std.Time.instHSubOffsetOffset_3 : HSub Nanosecond.Offset Hour.Offset Nanosecond.Offset

Equations

• Std.Time.instHSubOffsetOffset_3 = { hSub := fun (x : Std.Time.Nanosecond.Offset) (y : Std.Time.Hour.Offset) => Std.Time.Internal.UnitVal.sub x y.toNanoseconds }

instance Std.Time.instHSubOffsetOffset_4 : HSub Nanosecond.Offset Day.Offset Nanosecond.Offset

Equations

• Std.Time.instHSubOffsetOffset_4 = { hSub := fun (x : Std.Time.Nanosecond.Offset) (y : Std.Time.Day.Offset) => Std.Time.Internal.UnitVal.sub x y.toNanoseconds }

instance Std.Time.instHSubOffsetOffset_5 : HSub Nanosecond.Offset Week.Offset Nanosecond.Offset

Equations

• Std.Time.instHSubOffsetOffset_5 = { hSub := fun (x : Std.Time.Nanosecond.Offset) (y : Std.Time.Week.Offset) => Std.Time.Internal.UnitVal.sub x y.toNanoseconds }

instance Std.Time.instHSubOffsetOffset_6 : HSub Millisecond.Offset Nanosecond.Offset Nanosecond.Offset

Equations

• Std.Time.instHSubOffsetOffset_6 = { hSub := fun (x : Std.Time.Millisecond.Offset) (y : Std.Time.Nanosecond.Offset) => Std.Time.Internal.UnitVal.sub x.toNanoseconds y }

instance Std.Time.instHSubOffset_1 : HSub Millisecond.Offset Millisecond.Offset Millisecond.Offset

Equations

• Std.Time.instHSubOffset_1 = { hSub := fun (x y : Std.Time.Millisecond.Offset) => Std.Time.Internal.UnitVal.sub x y }

instance Std.Time.instHSubOffsetOffset_7 : HSub Millisecond.Offset Second.Offset Millisecond.Offset

Equations

• Std.Time.instHSubOffsetOffset_7 = { hSub := fun (x : Std.Time.Millisecond.Offset) (y : Std.Time.Second.Offset) => Std.Time.Internal.UnitVal.sub x y.toMilliseconds }

instance Std.Time.instHSubOffsetOffset_8 : HSub Millisecond.Offset Minute.Offset Millisecond.Offset

Equations

• Std.Time.instHSubOffsetOffset_8 = { hSub := fun (x : Std.Time.Millisecond.Offset) (y : Std.Time.Minute.Offset) => Std.Time.Internal.UnitVal.sub x y.toMilliseconds }

instance Std.Time.instHSubOffsetOffset_9 : HSub Millisecond.Offset Hour.Offset Millisecond.Offset

Equations

• Std.Time.instHSubOffsetOffset_9 = { hSub := fun (x : Std.Time.Millisecond.Offset) (y : Std.Time.Hour.Offset) => Std.Time.Internal.UnitVal.sub x y.toMilliseconds }

instance Std.Time.instHSubOffsetOffset_10 : HSub Millisecond.Offset Day.Offset Millisecond.Offset

Equations

• Std.Time.instHSubOffsetOffset_10 = { hSub := fun (x : Std.Time.Millisecond.Offset) (y : Std.Time.Day.Offset) => Std.Time.Internal.UnitVal.sub x y.toMilliseconds }

instance Std.Time.instHSubOffsetOffset_11 : HSub Millisecond.Offset Week.Offset Millisecond.Offset

Equations

• Std.Time.instHSubOffsetOffset_11 = { hSub := fun (x : Std.Time.Millisecond.Offset) (y : Std.Time.Week.Offset) => Std.Time.Internal.UnitVal.sub x y.toMilliseconds }

instance Std.Time.instHSubOffsetOffset_12 : HSub Second.Offset Nanosecond.Offset Nanosecond.Offset

Equations

• Std.Time.instHSubOffsetOffset_12 = { hSub := fun (x : Std.Time.Second.Offset) (y : Std.Time.Nanosecond.Offset) => Std.Time.Internal.UnitVal.sub x.toNanoseconds y }

instance Std.Time.instHSubOffsetOffset_13 : HSub Second.Offset Millisecond.Offset Millisecond.Offset

Equations

• Std.Time.instHSubOffsetOffset_13 = { hSub := fun (x : Std.Time.Second.Offset) (y : Std.Time.Millisecond.Offset) => Std.Time.Internal.UnitVal.sub x.toMilliseconds y }

instance Std.Time.instHSubOffset_2 : HSub Second.Offset Second.Offset Second.Offset

Equations

• Std.Time.instHSubOffset_2 = { hSub := fun (x y : Std.Time.Second.Offset) => Std.Time.Internal.UnitVal.sub x y }

instance Std.Time.instHSubOffsetOffset_14 : HSub Second.Offset Minute.Offset Second.Offset

Equations

• Std.Time.instHSubOffsetOffset_14 = { hSub := fun (x : Std.Time.Second.Offset) (y : Std.Time.Minute.Offset) => Std.Time.Internal.UnitVal.sub x y.toSeconds }

instance Std.Time.instHSubOffsetOffset_15 : HSub Second.Offset Hour.Offset Second.Offset

Equations

• Std.Time.instHSubOffsetOffset_15 = { hSub := fun (x : Std.Time.Second.Offset) (y : Std.Time.Hour.Offset) => Std.Time.Internal.UnitVal.sub x y.toSeconds }

instance Std.Time.instHSubOffsetOffset_16 : HSub Second.Offset Day.Offset Second.Offset

Equations

• Std.Time.instHSubOffsetOffset_16 = { hSub := fun (x : Std.Time.Second.Offset) (y : Std.Time.Day.Offset) => Std.Time.Internal.UnitVal.sub x y.toSeconds }

instance Std.Time.instHSubOffsetOffset_17 : HSub Second.Offset Week.Offset Second.Offset

Equations

• Std.Time.instHSubOffsetOffset_17 = { hSub := fun (x : Std.Time.Second.Offset) (y : Std.Time.Week.Offset) => Std.Time.Internal.UnitVal.sub x y.toSeconds }

instance Std.Time.instHSubOffsetOffset_18 : HSub Minute.Offset Nanosecond.Offset Nanosecond.Offset

Equations

• Std.Time.instHSubOffsetOffset_18 = { hSub := fun (x : Std.Time.Minute.Offset) (y : Std.Time.Nanosecond.Offset) => Std.Time.Internal.UnitVal.sub x.toNanoseconds y }

instance Std.Time.instHSubOffsetOffset_19 : HSub Minute.Offset Millisecond.Offset Millisecond.Offset

Equations

• Std.Time.instHSubOffsetOffset_19 = { hSub := fun (x : Std.Time.Minute.Offset) (y : Std.Time.Millisecond.Offset) => Std.Time.Internal.UnitVal.sub x.toMilliseconds y }

instance Std.Time.instHSubOffsetOffset_20 : HSub Minute.Offset Second.Offset Second.Offset

Equations

• Std.Time.instHSubOffsetOffset_20 = { hSub := fun (x : Std.Time.Minute.Offset) (y : Std.Time.Second.Offset) => Std.Time.Internal.UnitVal.sub x.toSeconds y }

instance Std.Time.instHSubOffset_3 : HSub Minute.Offset Minute.Offset Minute.Offset

Equations

• Std.Time.instHSubOffset_3 = { hSub := fun (x y : Std.Time.Minute.Offset) => Std.Time.Internal.UnitVal.sub x y }

instance Std.Time.instHSubOffsetOffset_21 : HSub Minute.Offset Hour.Offset Minute.Offset

Equations

• Std.Time.instHSubOffsetOffset_21 = { hSub := fun (x : Std.Time.Minute.Offset) (y : Std.Time.Hour.Offset) => Std.Time.Internal.UnitVal.sub x y.toMinutes }

instance Std.Time.instHSubOffsetOffset_22 : HSub Minute.Offset Day.Offset Minute.Offset

Equations

• Std.Time.instHSubOffsetOffset_22 = { hSub := fun (x : Std.Time.Minute.Offset) (y : Std.Time.Day.Offset) => Std.Time.Internal.UnitVal.sub x y.toMinutes }

instance Std.Time.instHSubOffsetOffset_23 : HSub Minute.Offset Week.Offset Minute.Offset

Equations

• Std.Time.instHSubOffsetOffset_23 = { hSub := fun (x : Std.Time.Minute.Offset) (y : Std.Time.Week.Offset) => Std.Time.Internal.UnitVal.sub x y.toMinutes }

instance Std.Time.instHSubOffsetOffset_24 : HSub Hour.Offset Nanosecond.Offset Nanosecond.Offset

Equations

• Std.Time.instHSubOffsetOffset_24 = { hSub := fun (x : Std.Time.Hour.Offset) (y : Std.Time.Nanosecond.Offset) => Std.Time.Internal.UnitVal.sub x.toNanoseconds y }

instance Std.Time.instHSubOffsetOffset_25 : HSub Hour.Offset Millisecond.Offset Millisecond.Offset

Equations

• Std.Time.instHSubOffsetOffset_25 = { hSub := fun (x : Std.Time.Hour.Offset) (y : Std.Time.Millisecond.Offset) => Std.Time.Internal.UnitVal.sub x.toMilliseconds y }

instance Std.Time.instHSubOffsetOffset_26 : HSub Hour.Offset Second.Offset Second.Offset

Equations

• Std.Time.instHSubOffsetOffset_26 = { hSub := fun (x : Std.Time.Hour.Offset) (y : Std.Time.Second.Offset) => Std.Time.Internal.UnitVal.sub x.toSeconds y }

instance Std.Time.instHSubOffsetOffset_27 : HSub Hour.Offset Minute.Offset Minute.Offset

Equations

• Std.Time.instHSubOffsetOffset_27 = { hSub := fun (x : Std.Time.Hour.Offset) (y : Std.Time.Minute.Offset) => Std.Time.Internal.UnitVal.sub x.toMinutes y }

instance Std.Time.instHSubOffset_4 : HSub Hour.Offset Hour.Offset Hour.Offset

Equations

• Std.Time.instHSubOffset_4 = { hSub := fun (x y : Std.Time.Hour.Offset) => Std.Time.Internal.UnitVal.sub x y }

instance Std.Time.instHSubOffsetOffset_28 : HSub Hour.Offset Day.Offset Hour.Offset

Equations

• Std.Time.instHSubOffsetOffset_28 = { hSub := fun (x : Std.Time.Hour.Offset) (y : Std.Time.Day.Offset) => Std.Time.Internal.UnitVal.sub x y.toHours }

instance Std.Time.instHSubOffsetOffset_29 : HSub Hour.Offset Week.Offset Hour.Offset

Equations

• Std.Time.instHSubOffsetOffset_29 = { hSub := fun (x : Std.Time.Hour.Offset) (y : Std.Time.Week.Offset) => Std.Time.Internal.UnitVal.sub x y.toHours }

instance Std.Time.instHSubOffsetOffset_30 : HSub Day.Offset Nanosecond.Offset Nanosecond.Offset

Equations

• Std.Time.instHSubOffsetOffset_30 = { hSub := fun (x : Std.Time.Day.Offset) (y : Std.Time.Nanosecond.Offset) => Std.Time.Internal.UnitVal.sub x.toNanoseconds y }

instance Std.Time.instHSubOffsetOffset_31 : HSub Day.Offset Millisecond.Offset Millisecond.Offset

Equations

• Std.Time.instHSubOffsetOffset_31 = { hSub := fun (x : Std.Time.Day.Offset) (y : Std.Time.Millisecond.Offset) => Std.Time.Internal.UnitVal.sub x.toMilliseconds y }

instance Std.Time.instHSubOffsetOffset_32 : HSub Day.Offset Second.Offset Second.Offset

Equations

• Std.Time.instHSubOffsetOffset_32 = { hSub := fun (x : Std.Time.Day.Offset) (y : Std.Time.Second.Offset) => Std.Time.Internal.UnitVal.sub x.toSeconds y }

instance Std.Time.instHSubOffsetOffset_33 : HSub Day.Offset Minute.Offset Minute.Offset

Equations

• Std.Time.instHSubOffsetOffset_33 = { hSub := fun (x : Std.Time.Day.Offset) (y : Std.Time.Minute.Offset) => Std.Time.Internal.UnitVal.sub x.toMinutes y }

instance Std.Time.instHSubOffsetOffset_34 : HSub Day.Offset Hour.Offset Hour.Offset

Equations

• Std.Time.instHSubOffsetOffset_34 = { hSub := fun (x : Std.Time.Day.Offset) (y : Std.Time.Hour.Offset) => Std.Time.Internal.UnitVal.sub x.toHours y }

instance Std.Time.instHSubOffset_5 : HSub Day.Offset Day.Offset Day.Offset

Equations

• Std.Time.instHSubOffset_5 = { hSub := fun (x y : Std.Time.Day.Offset) => Std.Time.Internal.UnitVal.sub x y }

instance Std.Time.instHSubOffsetOffset_35 : HSub Day.Offset Week.Offset Day.Offset

Equations

• Std.Time.instHSubOffsetOffset_35 = { hSub := fun (x : Std.Time.Day.Offset) (y : Std.Time.Week.Offset) => Std.Time.Internal.UnitVal.sub x y.toDays }

instance Std.Time.instHSubOffsetOffset_36 : HSub Week.Offset Nanosecond.Offset Nanosecond.Offset

Equations

• Std.Time.instHSubOffsetOffset_36 = { hSub := fun (x : Std.Time.Week.Offset) (y : Std.Time.Nanosecond.Offset) => Std.Time.Internal.UnitVal.sub x.toNanoseconds y }

instance Std.Time.instHSubOffsetOffset_37 : HSub Week.Offset Millisecond.Offset Millisecond.Offset

Equations

• Std.Time.instHSubOffsetOffset_37 = { hSub := fun (x : Std.Time.Week.Offset) (y : Std.Time.Millisecond.Offset) => Std.Time.Internal.UnitVal.sub x.toMilliseconds y }

instance Std.Time.instHSubOffsetOffset_38 : HSub Week.Offset Second.Offset Second.Offset

Equations

• Std.Time.instHSubOffsetOffset_38 = { hSub := fun (x : Std.Time.Week.Offset) (y : Std.Time.Second.Offset) => Std.Time.Internal.UnitVal.sub x.toSeconds y }

instance Std.Time.instHSubOffsetOffset_39 : HSub Week.Offset Minute.Offset Minute.Offset

Equations

• Std.Time.instHSubOffsetOffset_39 = { hSub := fun (x : Std.Time.Week.Offset) (y : Std.Time.Minute.Offset) => Std.Time.Internal.UnitVal.sub x.toMinutes y }

instance Std.Time.instHSubOffsetOffset_40 : HSub Week.Offset Hour.Offset Hour.Offset

Equations

• Std.Time.instHSubOffsetOffset_40 = { hSub := fun (x : Std.Time.Week.Offset) (y : Std.Time.Hour.Offset) => Std.Time.Internal.UnitVal.sub x.toHours y }

instance Std.Time.instHSubOffsetOffset_41 : HSub Week.Offset Day.Offset Day.Offset

Equations

• Std.Time.instHSubOffsetOffset_41 = { hSub := fun (x : Std.Time.Week.Offset) (y : Std.Time.Day.Offset) => Std.Time.Internal.UnitVal.sub x.toDays y }

instance Std.Time.instHSubOffset_6 : HSub Week.Offset Week.Offset Week.Offset

Equations

• Std.Time.instHSubOffset_6 = { hSub := fun (x y : Std.Time.Week.Offset) => Std.Time.Internal.UnitVal.sub x y }