diff --git a/examples/gno.land/p/demo/grc/grc20/token.gno b/examples/gno.land/p/demo/grc/grc20/token.gno
index 4986eaebf04..3ab3abc63a3 100644
--- a/examples/gno.land/p/demo/grc/grc20/token.gno
+++ b/examples/gno.land/p/demo/grc/grc20/token.gno
@@ -1,6 +1,7 @@
 package grc20
 
 import (
+	"math/overflow"
 	"std"
 	"strconv"
 
@@ -169,24 +170,17 @@ func (led *PrivateLedger) Approve(owner, spender std.Address, amount uint64) err
 }
 
 // Mint increases the total supply of the token and adds the specified amount to the specified address.
-func (led *PrivateLedger) Mint(address std.Address, amount uint64) (err error) {
+func (led *PrivateLedger) Mint(address std.Address, amount uint64) error {
 	if !address.IsValid() {
 		return ErrInvalidAddress
 	}
 
-	defer func() {
-		if r := recover(); r != nil {
-			if r != "addition overflow" {
-				panic(r)
-			}
-			err = ErrOverflow
-		}
-	}()
-
-	// Convert amount and totalSupply to signed integers to enable
-	// overflow checking (not occuring on unsigned) when computing the sum.
-	// The maximum value for totalSupply is therefore 1<<63.
-	sum := int64(led.totalSupply) + int64(amount)
+	// XXX: math/overflow is not supporting uint64.
+	// This checks prevents overflow but makes the totalSupply limited to a uint63.
+	sum, ok := overflow.Add64(int64(led.totalSupply), int64(amount))
+	if !ok {
+		return ErrOverflow
+	}
 
 	led.totalSupply = uint64(sum)
 	currentBalance := led.balanceOf(address)
diff --git a/gnovm/pkg/gnolang/op_bench_test.go b/gnovm/pkg/gnolang/op_bench_test.go
deleted file mode 100644
index 5874f980285..00000000000
--- a/gnovm/pkg/gnolang/op_bench_test.go
+++ /dev/null
@@ -1,70 +0,0 @@
-package gnolang
-
-import (
-	"testing"
-
-	"github.com/gnolang/gno/tm2/pkg/overflow"
-)
-
-func BenchmarkOpAdd(b *testing.B) {
-	m := NewMachine("bench", nil)
-	x := TypedValue{T: IntType}
-	x.SetInt(4)
-	y := TypedValue{T: IntType}
-	y.SetInt(3)
-
-	b.ResetTimer()
-
-	for range b.N {
-		m.PushOp(OpHalt)
-		m.PushExpr(&BinaryExpr{})
-		m.PushValue(x)
-		m.PushValue(y)
-		m.PushOp(OpAdd)
-		m.Run()
-	}
-}
-
-//go:noinline
-func AddNoOverflow(x, y int) int { return x + y }
-
-func BenchmarkAddNoOverflow(b *testing.B) {
-	x, y := 4, 3
-	c := 0
-	for range b.N {
-		c = AddNoOverflow(x, y)
-	}
-	if c != 7 {
-		b.Error("invalid result")
-	}
-}
-
-func BenchmarkAddOverflow(b *testing.B) {
-	x, y := 4, 3
-	c := 0
-	for range b.N {
-		c = overflow.Addp(x, y)
-	}
-	if c != 7 {
-		b.Error("invalid result")
-	}
-}
-
-func TestOpAdd1(t *testing.T) {
-	m := NewMachine("test", nil)
-	a := TypedValue{T: IntType}
-	a.SetInt(4)
-	b := TypedValue{T: IntType}
-	b.SetInt(3)
-	t.Log("a:", a, "b:", b)
-
-	start := m.NumValues
-	m.PushOp(OpHalt)
-	m.PushExpr(&BinaryExpr{})
-	m.PushValue(a)
-	m.PushValue(b)
-	m.PushOp(OpAdd)
-	m.Run()
-	res := m.ReapValues(start)
-	t.Log("res:", res)
-}
diff --git a/gnovm/pkg/gnolang/op_binary.go b/gnovm/pkg/gnolang/op_binary.go
index 765f3ccbfbd..0e8eec9db23 100644
--- a/gnovm/pkg/gnolang/op_binary.go
+++ b/gnovm/pkg/gnolang/op_binary.go
@@ -7,7 +7,6 @@ import (
 
 	"github.com/cockroachdb/apd/v3"
 	"github.com/gnolang/gno/gnovm/pkg/gnolang/internal/softfloat"
-	"github.com/gnolang/gno/tm2/pkg/overflow"
 )
 
 // ----------------------------------------
@@ -185,9 +184,7 @@ func (m *Machine) doOpAdd() {
 	}
 
 	// add rv to lv.
-	if err := addAssign(m.Alloc, lv, rv); err != nil {
-		panic(err)
-	}
+	addAssign(m.Alloc, lv, rv)
 }
 
 func (m *Machine) doOpSub() {
@@ -201,9 +198,7 @@ func (m *Machine) doOpSub() {
 	}
 
 	// sub rv from lv.
-	if err := subAssign(lv, rv); err != nil {
-		panic(err)
-	}
+	subAssign(lv, rv)
 }
 
 func (m *Machine) doOpBor() {
@@ -259,7 +254,8 @@ func (m *Machine) doOpQuo() {
 	}
 
 	// lv / rv
-	if err := quoAssign(lv, rv); err != nil {
+	err := quoAssign(lv, rv)
+	if err != nil {
 		panic(err)
 	}
 }
@@ -275,7 +271,8 @@ func (m *Machine) doOpRem() {
 	}
 
 	// lv % rv
-	if err := remAssign(lv, rv); err != nil {
+	err := remAssign(lv, rv)
+	if err != nil {
 		panic(err)
 	}
 }
@@ -687,38 +684,23 @@ func isGeq(lv, rv *TypedValue) bool {
 	}
 }
 
-// addAssign adds lv to rv and stores the result to lv.
-// It returns an exception in case of overflow on signed integers.
-// The assignement is performed even in case of exception.
-func addAssign(alloc *Allocator, lv, rv *TypedValue) *Exception {
+// for doOpAdd and doOpAddAssign.
+func addAssign(alloc *Allocator, lv, rv *TypedValue) {
 	// set the result in lv.
 	// NOTE this block is replicated in op_assign.go
-	ok := true
 	switch baseOf(lv.T) {
 	case StringType, UntypedStringType:
 		lv.V = alloc.NewString(lv.GetString() + rv.GetString())
-	// Signed integers may overflow, which triggers an exception.
 	case IntType:
-		var r int
-		r, ok = overflow.Add(lv.GetInt(), rv.GetInt())
-		lv.SetInt(r)
+		lv.SetInt(lv.GetInt() + rv.GetInt())
 	case Int8Type:
-		var r int8
-		r, ok = overflow.Add8(lv.GetInt8(), rv.GetInt8())
-		lv.SetInt8(r)
+		lv.SetInt8(lv.GetInt8() + rv.GetInt8())
 	case Int16Type:
-		var r int16
-		r, ok = overflow.Add16(lv.GetInt16(), rv.GetInt16())
-		lv.SetInt16(r)
+		lv.SetInt16(lv.GetInt16() + rv.GetInt16())
 	case Int32Type, UntypedRuneType:
-		var r int32
-		r, ok = overflow.Add32(lv.GetInt32(), rv.GetInt32())
-		lv.SetInt32(r)
+		lv.SetInt32(lv.GetInt32() + rv.GetInt32())
 	case Int64Type:
-		var r int64
-		r, ok = overflow.Add64(lv.GetInt64(), rv.GetInt64())
-		lv.SetInt64(r)
-	// Unsigned integers do not overflow, they just wrap.
+		lv.SetInt64(lv.GetInt64() + rv.GetInt64())
 	case UintType:
 		lv.SetUint(lv.GetUint() + rv.GetUint())
 	case Uint8Type:
@@ -758,42 +740,23 @@ func addAssign(alloc *Allocator, lv, rv *TypedValue) *Exception {
 			lv.T,
 		))
 	}
-	if !ok {
-		return &Exception{Value: typedString("addition overflow")}
-	}
-	return nil
 }
 
-// subAssign subtracts lv to rv and stores the result to lv.
-// It returns an exception in case of overflow on signed integers.
-// The subtraction is performed even in case of exception.
-func subAssign(lv, rv *TypedValue) *Exception {
+// for doOpSub and doOpSubAssign.
+func subAssign(lv, rv *TypedValue) {
 	// set the result in lv.
 	// NOTE this block is replicated in op_assign.go
-	ok := true
 	switch baseOf(lv.T) {
-	// Signed integers may overflow, which triggers an exception.
 	case IntType:
-		var r int
-		r, ok = overflow.Sub(lv.GetInt(), rv.GetInt())
-		lv.SetInt(r)
+		lv.SetInt(lv.GetInt() - rv.GetInt())
 	case Int8Type:
-		var r int8
-		r, ok = overflow.Sub8(lv.GetInt8(), rv.GetInt8())
-		lv.SetInt8(r)
+		lv.SetInt8(lv.GetInt8() - rv.GetInt8())
 	case Int16Type:
-		var r int16
-		r, ok = overflow.Sub16(lv.GetInt16(), rv.GetInt16())
-		lv.SetInt16(r)
+		lv.SetInt16(lv.GetInt16() - rv.GetInt16())
 	case Int32Type, UntypedRuneType:
-		var r int32
-		r, ok = overflow.Sub32(lv.GetInt32(), rv.GetInt32())
-		lv.SetInt32(r)
+		lv.SetInt32(lv.GetInt32() - rv.GetInt32())
 	case Int64Type:
-		var r int64
-		r, ok = overflow.Sub64(lv.GetInt64(), rv.GetInt64())
-		lv.SetInt64(r)
-	// Unsigned integers do not overflow, they just wrap.
+		lv.SetInt64(lv.GetInt64() - rv.GetInt64())
 	case UintType:
 		lv.SetUint(lv.GetUint() - rv.GetUint())
 	case Uint8Type:
@@ -833,39 +796,23 @@ func subAssign(lv, rv *TypedValue) *Exception {
 			lv.T,
 		))
 	}
-	if !ok {
-		return &Exception{Value: typedString("subtraction overflow")}
-	}
-	return nil
 }
 
 // for doOpMul and doOpMulAssign.
-func mulAssign(lv, rv *TypedValue) *Exception {
+func mulAssign(lv, rv *TypedValue) {
 	// set the result in lv.
 	// NOTE this block is replicated in op_assign.go
-	ok := true
 	switch baseOf(lv.T) {
-	// Signed integers may overflow, which triggers a panic.
 	case IntType:
-		var r int
-		r, ok = overflow.Mul(lv.GetInt(), rv.GetInt())
-		lv.SetInt(r)
+		lv.SetInt(lv.GetInt() * rv.GetInt())
 	case Int8Type:
-		var r int8
-		r, ok = overflow.Mul8(lv.GetInt8(), rv.GetInt8())
-		lv.SetInt8(r)
+		lv.SetInt8(lv.GetInt8() * rv.GetInt8())
 	case Int16Type:
-		var r int16
-		r, ok = overflow.Mul16(lv.GetInt16(), rv.GetInt16())
-		lv.SetInt16(r)
+		lv.SetInt16(lv.GetInt16() * rv.GetInt16())
 	case Int32Type, UntypedRuneType:
-		var r int32
-		r, ok = overflow.Mul32(lv.GetInt32(), rv.GetInt32())
-		lv.SetInt32(r)
+		lv.SetInt32(lv.GetInt32() * rv.GetInt32())
 	case Int64Type:
-		var r int64
-		r, ok = overflow.Mul64(lv.GetInt64(), rv.GetInt64())
-		lv.SetInt64(r)
+		lv.SetInt64(lv.GetInt64() * rv.GetInt64())
 	case UintType:
 		lv.SetUint(lv.GetUint() * rv.GetUint())
 	case Uint8Type:
@@ -903,102 +850,95 @@ func mulAssign(lv, rv *TypedValue) *Exception {
 			lv.T,
 		))
 	}
-	if !ok {
-		return &Exception{Value: typedString("multiplication overflow")}
-	}
-	return nil
 }
 
 // for doOpQuo and doOpQuoAssign.
 func quoAssign(lv, rv *TypedValue) *Exception {
+	expt := &Exception{
+		Value: typedString("division by zero"),
+	}
+
 	// set the result in lv.
 	// NOTE this block is replicated in op_assign.go
-	ok := true
 	switch baseOf(lv.T) {
-	// Signed integers may overflow or cause a division by 0, which triggers a panic.
 	case IntType:
-		var q int
-		q, _, ok = overflow.Quotient(lv.GetInt(), rv.GetInt())
-		lv.SetInt(q)
+		if rv.GetInt() == 0 {
+			return expt
+		}
+		lv.SetInt(lv.GetInt() / rv.GetInt())
 	case Int8Type:
-		var q int8
-		q, _, ok = overflow.Quotient8(lv.GetInt8(), rv.GetInt8())
-		lv.SetInt8(q)
+		if rv.GetInt8() == 0 {
+			return expt
+		}
+		lv.SetInt8(lv.GetInt8() / rv.GetInt8())
 	case Int16Type:
-		var q int16
-		q, _, ok = overflow.Quotient16(lv.GetInt16(), rv.GetInt16())
-		lv.SetInt16(q)
+		if rv.GetInt16() == 0 {
+			return expt
+		}
+		lv.SetInt16(lv.GetInt16() / rv.GetInt16())
 	case Int32Type, UntypedRuneType:
-		var q int32
-		q, _, ok = overflow.Quotient32(lv.GetInt32(), rv.GetInt32())
-		lv.SetInt32(q)
+		if rv.GetInt32() == 0 {
+			return expt
+		}
+		lv.SetInt32(lv.GetInt32() / rv.GetInt32())
 	case Int64Type:
-		var q int64
-		q, _, ok = overflow.Quotient64(lv.GetInt64(), rv.GetInt64())
-		lv.SetInt64(q)
-	// Unsigned integers do not cause overflow, but a division by 0 may still occur.
+		if rv.GetInt64() == 0 {
+			return expt
+		}
+		lv.SetInt64(lv.GetInt64() / rv.GetInt64())
 	case UintType:
-		y := rv.GetUint()
-		ok = y != 0
-		if ok {
-			lv.SetUint(lv.GetUint() / y)
+		if rv.GetUint() == 0 {
+			return expt
 		}
+		lv.SetUint(lv.GetUint() / rv.GetUint())
 	case Uint8Type:
-		y := rv.GetUint8()
-		ok = y != 0
-		if ok {
-			lv.SetUint8(lv.GetUint8() / y)
+		if rv.GetUint8() == 0 {
+			return expt
 		}
+		lv.SetUint8(lv.GetUint8() / rv.GetUint8())
 	case DataByteType:
-		y := rv.GetUint8()
-		ok = y != 0
-		if ok {
-			lv.SetDataByte(lv.GetDataByte() / y)
+		if rv.GetUint8() == 0 {
+			return expt
 		}
+		lv.SetDataByte(lv.GetDataByte() / rv.GetUint8())
 	case Uint16Type:
-		y := rv.GetUint16()
-		ok = y != 0
-		if ok {
-			lv.SetUint16(lv.GetUint16() / y)
+		if rv.GetUint16() == 0 {
+			return expt
 		}
+		lv.SetUint16(lv.GetUint16() / rv.GetUint16())
 	case Uint32Type:
-		y := rv.GetUint32()
-		ok = y != 0
-		if ok {
-			lv.SetUint32(lv.GetUint32() / y)
+		if rv.GetUint32() == 0 {
+			return expt
 		}
+		lv.SetUint32(lv.GetUint32() / rv.GetUint32())
 	case Uint64Type:
-		y := rv.GetUint64()
-		ok = y != 0
-		if ok {
-			lv.SetUint64(lv.GetUint64() / y)
+		if rv.GetUint64() == 0 {
+			return expt
 		}
-	// XXX Handling float overflows is more complex.
+		lv.SetUint64(lv.GetUint64() / rv.GetUint64())
 	case Float32Type:
 		// NOTE: gno doesn't fuse *+.
-		ok = !softfloat.Feq32(rv.GetFloat32(), softfloat.Fintto32(0))
+		ok := !softfloat.Feq32(rv.GetFloat32(), softfloat.Fintto32(0))
 
 		if ok {
 			lv.SetFloat32(softfloat.Fdiv32(lv.GetFloat32(), rv.GetFloat32()))
 		}
 	case Float64Type:
 		// NOTE: gno doesn't fuse *+.
-		ok = !softfloat.Feq64(rv.GetFloat64(), softfloat.Fintto64(0))
+		ok := !softfloat.Feq64(rv.GetFloat64(), softfloat.Fintto64(0))
 		if ok {
 			lv.SetFloat64(softfloat.Fdiv64(lv.GetFloat64(), rv.GetFloat64()))
 		}
 	case BigintType, UntypedBigintType:
 		if rv.GetBigInt().Sign() == 0 {
-			ok = false
-			break
+			return expt
 		}
 		lb := lv.GetBigInt()
 		lb = big.NewInt(0).Quo(lb, rv.GetBigInt())
 		lv.V = BigintValue{V: lb}
 	case BigdecType, UntypedBigdecType:
 		if rv.GetBigDec().Cmp(apd.New(0, 0)) == 0 {
-			ok = false
-			break
+			return expt
 		}
 		lb := lv.GetBigDec()
 		rb := rv.GetBigDec()
@@ -1015,83 +955,81 @@ func quoAssign(lv, rv *TypedValue) *Exception {
 		))
 	}
 
-	if !ok {
-		return &Exception{Value: typedString("division by zero or overflow")}
-	}
 	return nil
 }
 
 // for doOpRem and doOpRemAssign.
 func remAssign(lv, rv *TypedValue) *Exception {
+	expt := &Exception{
+		Value: typedString("division by zero"),
+	}
+
 	// set the result in lv.
 	// NOTE this block is replicated in op_assign.go
-	ok := true
 	switch baseOf(lv.T) {
-	// Signed integers may overflow or cause a division by 0, which triggers a panic.
 	case IntType:
-		var r int
-		_, r, ok = overflow.Quotient(lv.GetInt(), rv.GetInt())
-		lv.SetInt(r)
+		if rv.GetInt() == 0 {
+			return expt
+		}
+		lv.SetInt(lv.GetInt() % rv.GetInt())
 	case Int8Type:
-		var r int8
-		_, r, ok = overflow.Quotient8(lv.GetInt8(), rv.GetInt8())
-		lv.SetInt8(r)
+		if rv.GetInt8() == 0 {
+			return expt
+		}
+		lv.SetInt8(lv.GetInt8() % rv.GetInt8())
 	case Int16Type:
-		var r int16
-		_, r, ok = overflow.Quotient16(lv.GetInt16(), rv.GetInt16())
-		lv.SetInt16(r)
+		if rv.GetInt16() == 0 {
+			return expt
+		}
+		lv.SetInt16(lv.GetInt16() % rv.GetInt16())
 	case Int32Type, UntypedRuneType:
-		var r int32
-		_, r, ok = overflow.Quotient32(lv.GetInt32(), rv.GetInt32())
-		lv.SetInt32(r)
+		if rv.GetInt32() == 0 {
+			return expt
+		}
+		lv.SetInt32(lv.GetInt32() % rv.GetInt32())
 	case Int64Type:
-		var r int64
-		_, r, ok = overflow.Quotient64(lv.GetInt64(), rv.GetInt64())
-		lv.SetInt64(r)
-	// Unsigned integers do not cause overflow, but a division by 0 may still occur.
+		if rv.GetInt64() == 0 {
+			return expt
+		}
+		lv.SetInt64(lv.GetInt64() % rv.GetInt64())
 	case UintType:
-		y := rv.GetUint()
-		ok = y != 0
-		if ok {
-			lv.SetUint(lv.GetUint() % y)
+		if rv.GetUint() == 0 {
+			return expt
 		}
+		lv.SetUint(lv.GetUint() % rv.GetUint())
 	case Uint8Type:
-		y := rv.GetUint8()
-		ok = y != 0
-		if ok {
-			lv.SetUint8(lv.GetUint8() % y)
+		if rv.GetUint8() == 0 {
+			return expt
 		}
+		lv.SetUint8(lv.GetUint8() % rv.GetUint8())
 	case DataByteType:
-		y := rv.GetUint8()
-		ok = y != 0
-		if ok {
-			lv.SetDataByte(lv.GetDataByte() % y)
+		if rv.GetUint8() == 0 {
+			return expt
 		}
+		lv.SetDataByte(lv.GetDataByte() % rv.GetUint8())
 	case Uint16Type:
-		y := rv.GetUint16()
-		ok = y != 0
-		if ok {
-			lv.SetUint16(lv.GetUint16() % y)
+		if rv.GetUint16() == 0 {
+			return expt
 		}
+		lv.SetUint16(lv.GetUint16() % rv.GetUint16())
 	case Uint32Type:
-		y := rv.GetUint32()
-		ok = y != 0
-		if ok {
-			lv.SetUint32(lv.GetUint32() % y)
+		if rv.GetUint32() == 0 {
+			return expt
 		}
+		lv.SetUint32(lv.GetUint32() % rv.GetUint32())
 	case Uint64Type:
-		y := rv.GetUint64()
-		ok = y != 0
-		if ok {
-			lv.SetUint64(lv.GetUint64() % y)
+		if rv.GetUint64() == 0 {
+			return expt
 		}
+		lv.SetUint64(lv.GetUint64() % rv.GetUint64())
 	case BigintType, UntypedBigintType:
-		ok = rv.GetBigInt().Sign() != 0
-		if ok {
-			lb := lv.GetBigInt()
-			lb = big.NewInt(0).Rem(lb, rv.GetBigInt())
-			lv.V = BigintValue{V: lb}
+		if rv.GetBigInt().Sign() == 0 {
+			return expt
 		}
+
+		lb := lv.GetBigInt()
+		lb = big.NewInt(0).Rem(lb, rv.GetBigInt())
+		lv.V = BigintValue{V: lb}
 	default:
 		panic(fmt.Sprintf(
 			"operators %% and %%= not defined for %s",
@@ -1099,9 +1037,6 @@ func remAssign(lv, rv *TypedValue) *Exception {
 		))
 	}
 
-	if !ok {
-		return &Exception{Value: typedString("division by zero or overflow")}
-	}
 	return nil
 }
 
diff --git a/gnovm/pkg/gnolang/op_inc_dec.go b/gnovm/pkg/gnolang/op_inc_dec.go
index c67a4be6ed5..708aae821ac 100644
--- a/gnovm/pkg/gnolang/op_inc_dec.go
+++ b/gnovm/pkg/gnolang/op_inc_dec.go
@@ -6,7 +6,6 @@ import (
 
 	"github.com/cockroachdb/apd/v3"
 	"github.com/gnolang/gno/gnovm/pkg/gnolang/internal/softfloat"
-	"github.com/gnolang/gno/tm2/pkg/overflow"
 )
 
 func (m *Machine) doOpInc() {
@@ -33,18 +32,16 @@ func (m *Machine) doOpInc() {
 	// because it could be a type alias
 	// type num int
 	switch baseOf(lv.T) {
-	// Signed integers may overflow, which triggers a panic.
 	case IntType:
-		lv.SetInt(overflow.Addp(lv.GetInt(), 1))
+		lv.SetInt(lv.GetInt() + 1)
 	case Int8Type:
-		lv.SetInt8(overflow.Add8p(lv.GetInt8(), 1))
+		lv.SetInt8(lv.GetInt8() + 1)
 	case Int16Type:
-		lv.SetInt16(overflow.Add16p(lv.GetInt16(), 1))
+		lv.SetInt16(lv.GetInt16() + 1)
 	case Int32Type:
-		lv.SetInt32(overflow.Add32p(lv.GetInt32(), 1))
+		lv.SetInt32(lv.GetInt32() + 1)
 	case Int64Type:
-		lv.SetInt64(overflow.Add64p(lv.GetInt64(), 1))
-	// Unsigned integers do not overflow, they just wrap.
+		lv.SetInt64(lv.GetInt64() + 1)
 	case UintType:
 		lv.SetUint(lv.GetUint() + 1)
 	case Uint8Type:
@@ -105,18 +102,16 @@ func (m *Machine) doOpDec() {
 		}
 	}
 	switch baseOf(lv.T) {
-	// Signed integers may overflow, which triggers a panic.
 	case IntType:
-		lv.SetInt(overflow.Subp(lv.GetInt(), 1))
+		lv.SetInt(lv.GetInt() - 1)
 	case Int8Type:
-		lv.SetInt8(overflow.Sub8p(lv.GetInt8(), 1))
+		lv.SetInt8(lv.GetInt8() - 1)
 	case Int16Type:
-		lv.SetInt16(overflow.Sub16p(lv.GetInt16(), 1))
+		lv.SetInt16(lv.GetInt16() - 1)
 	case Int32Type:
-		lv.SetInt32(overflow.Sub32p(lv.GetInt32(), 1))
+		lv.SetInt32(lv.GetInt32() - 1)
 	case Int64Type:
-		lv.SetInt64(overflow.Sub64p(lv.GetInt64(), 1))
-	// Unsigned integers do not overflow, they just wrap.
+		lv.SetInt64(lv.GetInt64() - 1)
 	case UintType:
 		lv.SetUint(lv.GetUint() - 1)
 	case Uint8Type:
diff --git a/gnovm/stdlibs/generated.go b/gnovm/stdlibs/generated.go
index 6e757561ef2..ab35fc6b6bf 100644
--- a/gnovm/stdlibs/generated.go
+++ b/gnovm/stdlibs/generated.go
@@ -896,6 +896,7 @@ var initOrder = [...]string{
 	"hash",
 	"hash/adler32",
 	"html",
+	"math/overflow",
 	"math/rand",
 	"path",
 	"sort",
diff --git a/gnovm/stdlibs/math/const_test.gno b/gnovm/stdlibs/math/const_test.gno
index fbe59d61878..b892a12898b 100644
--- a/gnovm/stdlibs/math/const_test.gno
+++ b/gnovm/stdlibs/math/const_test.gno
@@ -31,76 +31,19 @@ func TestMaxUint(t *testing.T) {
 }
 
 func TestMaxInt(t *testing.T) {
-	defer func() {
-		if r := recover(); r != nil {
-			if r != "addition overflow" {
-				panic(r)
-			}
-		}
-	}()
-	v := int(math.MaxInt)
-	if v+1 == math.MinInt {
-		t.Errorf("int should overflow")
+	if v := int(math.MaxInt); v+1 != math.MinInt {
+		t.Errorf("MaxInt should wrap around to MinInt: %d", v+1)
 	}
-	t.Errorf("expected panic did not occur")
-}
-
-func TestMaxInt8(t *testing.T) {
-	defer func() {
-		if r := recover(); r != nil {
-			if r != "addition overflow" {
-				panic(r)
-			}
-		}
-	}()
-	v := int8(math.MaxInt8)
-	if v+1 == math.MinInt8 {
-		t.Errorf("int8 should overflow")
+	if v := int8(math.MaxInt8); v+1 != math.MinInt8 {
+		t.Errorf("MaxInt8 should wrap around to MinInt8: %d", v+1)
 	}
-	t.Errorf("expected panic did not occur")
-}
-
-func TestMaxInt16(t *testing.T) {
-	defer func() {
-		if r := recover(); r != nil {
-			if r != "addition overflow" {
-				panic(r)
-			}
-		}
-	}()
-	v := int16(math.MaxInt16)
-	if v+1 == math.MinInt16 {
-		t.Errorf("int16 should overflow")
+	if v := int16(math.MaxInt16); v+1 != math.MinInt16 {
+		t.Errorf("MaxInt16 should wrap around to MinInt16: %d", v+1)
 	}
-	t.Errorf("expected panic did not occur")
-}
-
-func TestMaxInt32(t *testing.T) {
-	defer func() {
-		if r := recover(); r != nil {
-			if r != "addition overflow" {
-				panic(r)
-			}
-		}
-	}()
-	v := int32(math.MaxInt32)
-	if v+1 == math.MinInt32 {
-		t.Errorf("int32 should overflow")
+	if v := int32(math.MaxInt32); v+1 != math.MinInt32 {
+		t.Errorf("MaxInt32 should wrap around to MinInt32: %d", v+1)
 	}
-	t.Errorf("expected panic did not occur")
-}
-
-func TestMaxInt64(t *testing.T) {
-	defer func() {
-		if r := recover(); r != nil {
-			if r != "addition overflow" {
-				panic(r)
-			}
-		}
-	}()
-	v := int64(math.MaxInt64)
-	if v+1 == math.MinInt64 {
-		t.Errorf("int64 should overflow")
+	if v := int64(math.MaxInt64); v+1 != math.MinInt64 {
+		t.Errorf("MaxInt64 should wrap around to MinInt64: %d", v+1)
 	}
-	t.Errorf("expected panic did not occur")
 }
diff --git a/gnovm/stdlibs/math/overflow/overflow.gno b/gnovm/stdlibs/math/overflow/overflow.gno
new file mode 100644
index 00000000000..0bc2e03a522
--- /dev/null
+++ b/gnovm/stdlibs/math/overflow/overflow.gno
@@ -0,0 +1,501 @@
+// This is modified from https://github.com/JohnCGriffin/overflow (MIT).
+// NOTE: there was a bug with the original Quotient* functions, and
+// testing method. These have been fixed here, and tests ported to
+// tests/files/maths_int*.go respectively.
+// Note: moved over from p/demo/maths.
+
+/*
+Package overflow offers overflow-checked integer arithmetic operations
+for int, int32, and int64. Each of the operations returns a
+result,bool combination.  This was prompted by the need to know when
+to flow into higher precision types from the math.big library.
+
+For instance, assuing a 64 bit machine:
+
+10 + 20 -> 30
+int(math.MaxInt64) + 1 -> -9223372036854775808
+
+whereas
+
+overflow.Add(10,20) -> (30, true)
+overflow.Add(math.MaxInt64,1) -> (0, false)
+
+Add, Sub, Mul, Div are for int.  Add64, Add32, etc. are specifically sized.
+
+If anybody wishes an unsigned version, submit a pull request for code
+and new tests.
+*/
+package overflow
+
+import "math"
+
+//go:generate ./overflow_template.sh
+
+func _is64Bit() bool {
+	maxU32 := uint(math.MaxUint32)
+	return ((maxU32 << 1) >> 1) == maxU32
+}
+
+/********** PARTIAL TEST COVERAGE FROM HERE DOWN *************
+
+The only way that I could see to do this is a combination of
+my normal 64 bit system and a GopherJS running on Node.  My
+understanding is that its ints are 32 bit.
+
+So, FEEL FREE to carefully review the code visually.
+
+*************************************************************/
+
+// Unspecified size, i.e. normal signed int
+
+// Add sums two ints, returning the result and a boolean status.
+func Add(a, b int) (int, bool) {
+	if _is64Bit() {
+		r64, ok := Add64(int64(a), int64(b))
+		return int(r64), ok
+	}
+	r32, ok := Add32(int32(a), int32(b))
+	return int(r32), ok
+}
+
+// Sub returns the difference of two ints and a boolean status.
+func Sub(a, b int) (int, bool) {
+	if _is64Bit() {
+		r64, ok := Sub64(int64(a), int64(b))
+		return int(r64), ok
+	}
+	r32, ok := Sub32(int32(a), int32(b))
+	return int(r32), ok
+}
+
+// Mul returns the product of two ints and a boolean status.
+func Mul(a, b int) (int, bool) {
+	if _is64Bit() {
+		r64, ok := Mul64(int64(a), int64(b))
+		return int(r64), ok
+	}
+	r32, ok := Mul32(int32(a), int32(b))
+	return int(r32), ok
+}
+
+// Div returns the quotient of two ints and a boolean status
+func Div(a, b int) (int, bool) {
+	if _is64Bit() {
+		r64, ok := Div64(int64(a), int64(b))
+		return int(r64), ok
+	}
+	r32, ok := Div32(int32(a), int32(b))
+	return int(r32), ok
+}
+
+// Quo returns the quotient, remainder and status of two ints
+func Quo(a, b int) (int, int, bool) {
+	if _is64Bit() {
+		q64, r64, ok := Quo64(int64(a), int64(b))
+		return int(q64), int(r64), ok
+	}
+	q32, r32, ok := Quo32(int32(a), int32(b))
+	return int(q32), int(r32), ok
+}
+
+/************* Panic versions for int ****************/
+
+// Addp returns the sum of two ints, panicking on overflow
+func Addp(a, b int) int {
+	r, ok := Add(a, b)
+	if !ok {
+		panic("addition overflow")
+	}
+	return r
+}
+
+// Subp returns the difference of two ints, panicking on overflow.
+func Subp(a, b int) int {
+	r, ok := Sub(a, b)
+	if !ok {
+		panic("subtraction overflow")
+	}
+	return r
+}
+
+// Mulp returns the product of two ints, panicking on overflow.
+func Mulp(a, b int) int {
+	r, ok := Mul(a, b)
+	if !ok {
+		panic("multiplication overflow")
+	}
+	return r
+}
+
+// Divp returns the quotient of two ints, panicking on overflow.
+func Divp(a, b int) int {
+	r, ok := Div(a, b)
+	if !ok {
+		panic("division failure")
+	}
+	return r
+}
+
+//----------------------------------------
+// This is generated code, created by overflow_template.sh executed
+// by "go generate"
+
+// Add8 performs + operation on two int8 operands
+// returning a result and status
+func Add8(a, b int8) (int8, bool) {
+	c := a + b
+	if (c > a) == (b > 0) {
+		return c, true
+	}
+	return c, false
+}
+
+// Add8p is the unchecked panicking version of Add8
+func Add8p(a, b int8) int8 {
+	r, ok := Add8(a, b)
+	if !ok {
+		panic("addition overflow")
+	}
+	return r
+}
+
+// Sub8 performs - operation on two int8 operands
+// returning a result and status
+func Sub8(a, b int8) (int8, bool) {
+	c := a - b
+	if (c < a) == (b > 0) {
+		return c, true
+	}
+	return c, false
+}
+
+// Sub8p is the unchecked panicking version of Sub8
+func Sub8p(a, b int8) int8 {
+	r, ok := Sub8(a, b)
+	if !ok {
+		panic("subtraction overflow")
+	}
+	return r
+}
+
+// Mul8 performs * operation on two int8 operands
+// returning a result and status
+func Mul8(a, b int8) (int8, bool) {
+	if a == 0 || b == 0 {
+		return 0, true
+	}
+	c := a * b
+	if (c < 0) == ((a < 0) != (b < 0)) {
+		if c/b == a {
+			return c, true
+		}
+	}
+	return c, false
+}
+
+// Mul8p is the unchecked panicking version of Mul8
+func Mul8p(a, b int8) int8 {
+	r, ok := Mul8(a, b)
+	if !ok {
+		panic("multiplication overflow")
+	}
+	return r
+}
+
+// Div8 performs / operation on two int8 operands
+// returning a result and status
+func Div8(a, b int8) (int8, bool) {
+	q, _, ok := Quo8(a, b)
+	return q, ok
+}
+
+// Div8p is the unchecked panicking version of Div8
+func Div8p(a, b int8) int8 {
+	r, ok := Div8(a, b)
+	if !ok {
+		panic("division failure")
+	}
+	return r
+}
+
+// Quo8 performs + operation on two int8 operands
+// returning a quotient, a remainder and status
+func Quo8(a, b int8) (int8, int8, bool) {
+	if b == 0 {
+		return 0, 0, false
+	} else if b == -1 && a == int8(math.MinInt8) {
+		return 0, 0, false
+	}
+	c := a / b
+	return c, a % b, true
+}
+
+// Add16 performs + operation on two int16 operands
+// returning a result and status
+func Add16(a, b int16) (int16, bool) {
+	c := a + b
+	if (c > a) == (b > 0) {
+		return c, true
+	}
+	return c, false
+}
+
+// Add16p is the unchecked panicking version of Add16
+func Add16p(a, b int16) int16 {
+	r, ok := Add16(a, b)
+	if !ok {
+		panic("addition overflow")
+	}
+	return r
+}
+
+// Sub16 performs - operation on two int16 operands
+// returning a result and status
+func Sub16(a, b int16) (int16, bool) {
+	c := a - b
+	if (c < a) == (b > 0) {
+		return c, true
+	}
+	return c, false
+}
+
+// Sub16p is the unchecked panicking version of Sub16
+func Sub16p(a, b int16) int16 {
+	r, ok := Sub16(a, b)
+	if !ok {
+		panic("subtraction overflow")
+	}
+	return r
+}
+
+// Mul16 performs * operation on two int16 operands
+// returning a result and status
+func Mul16(a, b int16) (int16, bool) {
+	if a == 0 || b == 0 {
+		return 0, true
+	}
+	c := a * b
+	if (c < 0) == ((a < 0) != (b < 0)) {
+		if c/b == a {
+			return c, true
+		}
+	}
+	return c, false
+}
+
+// Mul16p is the unchecked panicking version of Mul16
+func Mul16p(a, b int16) int16 {
+	r, ok := Mul16(a, b)
+	if !ok {
+		panic("multiplication overflow")
+	}
+	return r
+}
+
+// Div16 performs / operation on two int16 operands
+// returning a result and status
+func Div16(a, b int16) (int16, bool) {
+	q, _, ok := Quo16(a, b)
+	return q, ok
+}
+
+// Div16p is the unchecked panicking version of Div16
+func Div16p(a, b int16) int16 {
+	r, ok := Div16(a, b)
+	if !ok {
+		panic("division failure")
+	}
+	return r
+}
+
+// Quo16 performs + operation on two int16 operands
+// returning a quotient, a remainder and status
+func Quo16(a, b int16) (int16, int16, bool) {
+	if b == 0 {
+		return 0, 0, false
+	} else if b == -1 && a == int16(math.MinInt16) {
+		return 0, 0, false
+	}
+	c := a / b
+	return c, a % b, true
+}
+
+// Add32 performs + operation on two int32 operands
+// returning a result and status
+func Add32(a, b int32) (int32, bool) {
+	c := a + b
+	if (c > a) == (b > 0) {
+		return c, true
+	}
+	return c, false
+}
+
+// Add32p is the unchecked panicking version of Add32
+func Add32p(a, b int32) int32 {
+	r, ok := Add32(a, b)
+	if !ok {
+		panic("addition overflow")
+	}
+	return r
+}
+
+// Sub32 performs - operation on two int32 operands
+// returning a result and status
+func Sub32(a, b int32) (int32, bool) {
+	c := a - b
+	if (c < a) == (b > 0) {
+		return c, true
+	}
+	return c, false
+}
+
+// Sub32p is the unchecked panicking version of Sub32
+func Sub32p(a, b int32) int32 {
+	r, ok := Sub32(a, b)
+	if !ok {
+		panic("subtraction overflow")
+	}
+	return r
+}
+
+// Mul32 performs * operation on two int32 operands
+// returning a result and status
+func Mul32(a, b int32) (int32, bool) {
+	if a == 0 || b == 0 {
+		return 0, true
+	}
+	c := a * b
+	if (c < 0) == ((a < 0) != (b < 0)) {
+		if c/b == a {
+			return c, true
+		}
+	}
+	return c, false
+}
+
+// Mul32p is the unchecked panicking version of Mul32
+func Mul32p(a, b int32) int32 {
+	r, ok := Mul32(a, b)
+	if !ok {
+		panic("multiplication overflow")
+	}
+	return r
+}
+
+// Div32 performs / operation on two int32 operands
+// returning a result and status
+func Div32(a, b int32) (int32, bool) {
+	q, _, ok := Quo32(a, b)
+	return q, ok
+}
+
+// Div32p is the unchecked panicking version of Div32
+func Div32p(a, b int32) int32 {
+	r, ok := Div32(a, b)
+	if !ok {
+		panic("division failure")
+	}
+	return r
+}
+
+// Quo32 performs + operation on two int32 operands
+// returning a quotient, a remainder and status
+func Quo32(a, b int32) (int32, int32, bool) {
+	if b == 0 {
+		return 0, 0, false
+	} else if b == -1 && a == int32(math.MinInt32) {
+		return 0, 0, false
+	}
+	c := a / b
+	return c, a % b, true
+}
+
+// Add64 performs + operation on two int64 operands
+// returning a result and status
+func Add64(a, b int64) (int64, bool) {
+	c := a + b
+	if (c > a) == (b > 0) {
+		return c, true
+	}
+	return c, false
+}
+
+// Add64p is the unchecked panicking version of Add64
+func Add64p(a, b int64) int64 {
+	r, ok := Add64(a, b)
+	if !ok {
+		panic("addition overflow")
+	}
+	return r
+}
+
+// Sub64 performs - operation on two int64 operands
+// returning a result and status
+func Sub64(a, b int64) (int64, bool) {
+	c := a - b
+	if (c < a) == (b > 0) {
+		return c, true
+	}
+	return c, false
+}
+
+// Sub64p is the unchecked panicking version of Sub64
+func Sub64p(a, b int64) int64 {
+	r, ok := Sub64(a, b)
+	if !ok {
+		panic("subtraction overflow")
+	}
+	return r
+}
+
+// Mul64 performs * operation on two int64 operands
+// returning a result and status
+func Mul64(a, b int64) (int64, bool) {
+	if a == 0 || b == 0 {
+		return 0, true
+	}
+	c := a * b
+	if (c < 0) == ((a < 0) != (b < 0)) {
+		if c/b == a {
+			return c, true
+		}
+	}
+	return c, false
+}
+
+// Mul64p is the unchecked panicking version of Mul64
+func Mul64p(a, b int64) int64 {
+	r, ok := Mul64(a, b)
+	if !ok {
+		panic("multiplication overflow")
+	}
+	return r
+}
+
+// Div64 performs / operation on two int64 operands
+// returning a result and status
+func Div64(a, b int64) (int64, bool) {
+	q, _, ok := Quo64(a, b)
+	return q, ok
+}
+
+// Div64p is the unchecked panicking version of Div64
+func Div64p(a, b int64) int64 {
+	r, ok := Div64(a, b)
+	if !ok {
+		panic("division failure")
+	}
+	return r
+}
+
+// Quo64 performs + operation on two int64 operands
+// returning a quotient, a remainder and status
+func Quo64(a, b int64) (int64, int64, bool) {
+	if b == 0 {
+		return 0, 0, false
+	} else if b == -1 && a == math.MinInt64 {
+		return 0, 0, false
+	}
+	c := a / b
+	return c, a % b, true
+}
diff --git a/gnovm/stdlibs/math/overflow/overflow_test.gno b/gnovm/stdlibs/math/overflow/overflow_test.gno
new file mode 100644
index 00000000000..b7881aec480
--- /dev/null
+++ b/gnovm/stdlibs/math/overflow/overflow_test.gno
@@ -0,0 +1,200 @@
+package overflow
+
+import (
+	"math"
+	"testing"
+)
+
+// sample all possibilities of 8 bit numbers
+// by checking against 64 bit numbers
+
+func TestAlgorithms(t *testing.T) {
+	errors := 0
+
+	for a64 := int64(math.MinInt8); a64 <= int64(math.MaxInt8); a64++ {
+		for b64 := int64(math.MinInt8); b64 <= int64(math.MaxInt8) && errors < 10; b64++ {
+
+			a8 := int8(a64)
+			b8 := int8(b64)
+
+			if int64(a8) != a64 || int64(b8) != b64 {
+				t.Fatal("LOGIC FAILURE IN TEST")
+			}
+
+			// ADDITION
+			{
+				r64 := a64 + b64
+
+				// now the verification
+				result, ok := Add8(a8, b8)
+				if ok && int64(result) != r64 {
+					t.Errorf("failed to fail on %v + %v = %v instead of %v\n",
+						a8, b8, result, r64)
+					errors++
+				}
+				if !ok && int64(result) == r64 {
+					t.Fail()
+					errors++
+				}
+			}
+
+			// SUBTRACTION
+			{
+				r64 := a64 - b64
+
+				// now the verification
+				result, ok := Sub8(a8, b8)
+				if ok && int64(result) != r64 {
+					t.Errorf("failed to fail on %v - %v = %v instead of %v\n",
+						a8, b8, result, r64)
+				}
+				if !ok && int64(result) == r64 {
+					t.Fail()
+					errors++
+				}
+			}
+
+			// MULTIPLICATION
+			{
+				r64 := a64 * b64
+
+				// now the verification
+				result, ok := Mul8(a8, b8)
+				if ok && int64(result) != r64 {
+					t.Errorf("failed to fail on %v * %v = %v instead of %v\n",
+						a8, b8, result, r64)
+					errors++
+				}
+				if !ok && int64(result) == r64 {
+					t.Fail()
+					errors++
+				}
+			}
+
+			// DIVISION
+			if b8 != 0 {
+				r64 := a64 / b64
+				rem64 := a64 % b64
+
+				// now the verification
+				result, rem, ok := Quo8(a8, b8)
+				if ok && int64(result) != r64 {
+					t.Errorf("failed to fail on %v / %v = %v instead of %v\n",
+						a8, b8, result, r64)
+					errors++
+				}
+				if ok && int64(rem) != rem64 {
+					t.Errorf("failed to fail on %v %% %v = %v instead of %v\n",
+						a8, b8, rem, rem64)
+					errors++
+				}
+			}
+		}
+	}
+}
+
+func TestQuotient(t *testing.T) {
+	q, r, ok := Quo(100, 3)
+	if r != 1 || q != 33 || !ok {
+		t.Errorf("expected 100/3 => 33, r=1")
+	}
+	if _, _, ok = Quo(1, 0); ok {
+		t.Error("unexpected lack of failure")
+	}
+}
+
+func TestLong(t *testing.T) {
+	if testing.Short() {
+		t.Skip()
+	}
+
+	ctr := int64(0)
+
+	for a64 := int64(math.MinInt16); a64 <= int64(math.MaxInt16); a64++ {
+		for b64 := int64(math.MinInt16); b64 <= int64(math.MaxInt16); b64++ {
+			a16 := int16(a64)
+			b16 := int16(b64)
+			if int64(a16) != a64 || int64(b16) != b64 {
+				panic("LOGIC FAILURE IN TEST")
+			}
+			ctr++
+
+			// ADDITION
+			{
+				r64 := a64 + b64
+
+				// now the verification
+				result, ok := Add16(a16, b16)
+				if int64(math.MinInt16) <= r64 && r64 <= int64(math.MaxInt16) {
+					if !ok || int64(result) != r64 {
+						println("add", a16, b16, result, r64)
+						panic("incorrect result for non-overflow")
+					}
+				} else {
+					if ok {
+						println("add", a16, b16, result, r64)
+						panic("incorrect ok result")
+					}
+				}
+			}
+
+			// SUBTRACTION
+			{
+				r64 := a64 - b64
+
+				// now the verification
+				result, ok := Sub16(a16, b16)
+				if int64(math.MinInt16) <= r64 && r64 <= int64(math.MaxInt16) {
+					if !ok || int64(result) != r64 {
+						println("sub", a16, b16, result, r64)
+						panic("incorrect result for non-overflow")
+					}
+				} else {
+					if ok {
+						println("sub", a16, b16, result, r64)
+						panic("incorrect ok result")
+					}
+				}
+			}
+
+			// MULTIPLICATION
+			{
+				r64 := a64 * b64
+
+				// now the verification
+				result, ok := Mul16(a16, b16)
+				if int64(math.MinInt16) <= r64 && r64 <= int64(math.MaxInt16) {
+					if !ok || int64(result) != r64 {
+						println("mul", a16, b16, result, r64)
+						panic("incorrect result for non-overflow")
+					}
+				} else {
+					if ok {
+						println("mul", a16, b16, result, r64)
+						panic("incorrect ok result")
+					}
+				}
+			}
+
+			// DIVISION
+			if b16 != 0 {
+				r64 := a64 / b64
+
+				// now the verification
+				result, _, ok := Quo16(a16, b16)
+				if int64(math.MinInt16) <= r64 && r64 <= int64(math.MaxInt16) {
+					if !ok || int64(result) != r64 {
+						println("quo", a16, b16, result, r64)
+						panic("incorrect result for non-overflow")
+					}
+				} else {
+					if ok {
+						println("quo", a16, b16, result, r64)
+						panic("incorrect ok result")
+					}
+				}
+			}
+		}
+	}
+	println("done", ctr)
+}
diff --git a/gnovm/stdlibs/std/coins.gno b/gnovm/stdlibs/std/coins.gno
index 679674e443e..47e88e238d2 100644
--- a/gnovm/stdlibs/std/coins.gno
+++ b/gnovm/stdlibs/std/coins.gno
@@ -1,6 +1,9 @@
 package std
 
-import "strconv"
+import (
+	"math/overflow"
+	"strconv"
+)
 
 // NOTE: this is selectively copied over from tm2/pkgs/std/coin.go
 
@@ -53,7 +56,13 @@ func (c Coin) IsEqual(other Coin) bool {
 // An invalid result panics.
 func (c Coin) Add(other Coin) Coin {
 	mustMatchDenominations(c.Denom, other.Denom)
-	c.Amount += other.Amount
+
+	sum, ok := overflow.Add64(c.Amount, other.Amount)
+	if !ok {
+		panic("coin add overflow/underflow: " + strconv.Itoa(int(c.Amount)) + " +/- " + strconv.Itoa(int(other.Amount)))
+	}
+
+	c.Amount = sum
 	return c
 }
 
@@ -63,7 +72,13 @@ func (c Coin) Add(other Coin) Coin {
 // An invalid result panics.
 func (c Coin) Sub(other Coin) Coin {
 	mustMatchDenominations(c.Denom, other.Denom)
-	c.Amount -= other.Amount
+
+	dff, ok := overflow.Sub64(c.Amount, other.Amount)
+	if !ok {
+		panic("coin sub overflow/underflow: " + strconv.Itoa(int(c.Amount)) + " +/- " + strconv.Itoa(int(other.Amount)))
+	}
+	c.Amount = dff
+
 	return c
 }
 
@@ -98,7 +113,10 @@ func NewCoins(coins ...Coin) Coins {
 
 	for _, coin := range coins {
 		if currentAmount, exists := coinMap[coin.Denom]; exists {
-			coinMap[coin.Denom] = currentAmount + coin.Amount
+			var ok bool
+			if coinMap[coin.Denom], ok = overflow.Add64(currentAmount, coin.Amount); !ok {
+				panic("coin sub overflow/underflow: " + strconv.Itoa(int(currentAmount)) + " +/- " + strconv.Itoa(int(coin.Amount)))
+			}
 		} else {
 			coinMap[coin.Denom] = coin.Amount
 		}
diff --git a/gnovm/tests/files/overflow0.gno b/gnovm/tests/files/overflow0.gno
deleted file mode 100644
index 1313f064322..00000000000
--- a/gnovm/tests/files/overflow0.gno
+++ /dev/null
@@ -1,10 +0,0 @@
-package main
-
-func main() {
-	var a, b, c int8 = -1<<7, -1, 0
-	c = a / b	// overflow: -128 instead of 128
-	println(c)
-}
-
-// Error:
-// division by zero or overflow
diff --git a/gnovm/tests/files/overflow1.gno b/gnovm/tests/files/overflow1.gno
deleted file mode 100644
index a416e9a3498..00000000000
--- a/gnovm/tests/files/overflow1.gno
+++ /dev/null
@@ -1,10 +0,0 @@
-package main
-
-func main() {
-	var a, b, c int16 = -1<<15, -1, 0
-	c = a / b	// overflow: -32768 instead of 32768
-	println(c)
-}
-
-// Error:
-// division by zero or overflow
diff --git a/gnovm/tests/files/overflow2.gno b/gnovm/tests/files/overflow2.gno
deleted file mode 100644
index 353729bcdf2..00000000000
--- a/gnovm/tests/files/overflow2.gno
+++ /dev/null
@@ -1,10 +0,0 @@
-package main
-
-func main() {
-	var a, b, c int32 = -1<<31, -1, 0
-	c = a / b	// overflow: -2147483648 instead of 2147483648
-	println(c)
-}
-
-// Error:
-// division by zero or overflow
diff --git a/gnovm/tests/files/overflow3.gno b/gnovm/tests/files/overflow3.gno
deleted file mode 100644
index a09c59dfb03..00000000000
--- a/gnovm/tests/files/overflow3.gno
+++ /dev/null
@@ -1,10 +0,0 @@
-package main
-
-func main() {
-	var a, b, c int64 = -1<<63, -1, 0
-	c = a / b	// overflow: -9223372036854775808 instead of 9223372036854775808
-	println(c)
-}
-
-// Error:
-// division by zero or overflow
diff --git a/gnovm/tests/files/overflow4.gno b/gnovm/tests/files/overflow4.gno
deleted file mode 100644
index 26b05567b07..00000000000
--- a/gnovm/tests/files/overflow4.gno
+++ /dev/null
@@ -1,10 +0,0 @@
-package main
-
-func main() {
-	var a, b, c int = -1<<63, -1, 0
-	c = a / b	// overflow: -9223372036854775808 instead of 9223372036854775808
-	println(c)
-}
-
-// Error:
-// division by zero or overflow
diff --git a/gnovm/tests/files/overflow5.gno b/gnovm/tests/files/overflow5.gno
deleted file mode 100644
index ef7f976eb24..00000000000
--- a/gnovm/tests/files/overflow5.gno
+++ /dev/null
@@ -1,10 +0,0 @@
-package main
-
-func main() {
-	var a, b, c int = -5, 7, 0
-	c = a % b	// 0 quotient triggers a false negative in gnolang/overflow
-	println(c)
-}
-
-// Output:
-// -5
diff --git a/gnovm/tests/files/recover14.gno b/gnovm/tests/files/recover14.gno
index 3c96404fcbe..30a34ab291a 100644
--- a/gnovm/tests/files/recover14.gno
+++ b/gnovm/tests/files/recover14.gno
@@ -12,4 +12,4 @@ func main() {
 }
 
 // Output:
-// recover: division by zero or overflow
+// recover: division by zero
diff --git a/misc/genstd/util.go b/misc/genstd/util.go
index 13e90836f36..025fe4b673e 100644
--- a/misc/genstd/util.go
+++ b/misc/genstd/util.go
@@ -70,8 +70,7 @@ func findDirs() (gitRoot string, relPath string, err error) {
 	}
 	p := wd
 	for {
-		// .git is normally a directory, or a file in case of a git worktree.
-		if _, e := os.Stat(filepath.Join(p, ".git")); e == nil {
+		if s, e := os.Stat(filepath.Join(p, ".git")); e == nil && s.IsDir() {
 			// make relPath relative to the git root
 			rp := strings.TrimPrefix(wd, p+string(filepath.Separator))
 			// normalize separator to /
diff --git a/tm2/pkg/overflow/README.md b/tm2/pkg/overflow/README.md
index 26ba7dc9985..55a9ba4c327 100644
--- a/tm2/pkg/overflow/README.md
+++ b/tm2/pkg/overflow/README.md
@@ -2,25 +2,26 @@
 
 Check for int/int8/int16/int64/int32 integer overflow in Golang arithmetic.
 
-Originally forked from https://github.com/JohnCGriffin/overflow.
+Forked from https://github.com/JohnCGriffin/overflow
 
 ### Install
-
-The majority of repetitive code is generated by overflow_template.sh. If you
-have to change an algorithm, change it there and regenerate the Go code via:
-
-```sh
+```
+go get github.com/johncgriffin/overflow
+```
+Note that because Go has no template types, the majority of repetitive code is 
+generated by overflow_template.sh.  If you have to change an
+algorithm, change it there and regenerate the Go code via:
+```
 go generate
 ```
-
 ### Synopsis
 
-```go
+```
 package main
 
 import "fmt"
 import "math"
-import "github.com/gnolang/gno/tm2/pkg/overflow"
+import "github.com/JohnCGriffin/overflow"
 
 func main() {
 
@@ -28,33 +29,38 @@ func main() {
 
 	for i := 0; i < 10; i++ {
 		sum, ok := overflow.Add(addend, i)
-		fmt.Printf("%v+%v -> (%v, %v)\n",
+		fmt.Printf("%v+%v -> (%v,%v)\n",
 			addend, i, sum, ok)
 	}
 
 }
 ```
-
 yields the output
-
-```console
-9223372036854775802+0 -> (9223372036854775802, true)
-9223372036854775802+1 -> (9223372036854775803, true)
-9223372036854775802+2 -> (9223372036854775804, true)
-9223372036854775802+3 -> (9223372036854775805, true)
-9223372036854775802+4 -> (9223372036854775806, true)
-9223372036854775802+5 -> (9223372036854775807, true)
-9223372036854775802+6 -> (0, false)
-9223372036854775802+7 -> (0, false)
-9223372036854775802+8 -> (0, false)
-9223372036854775802+9 -> (0, false)
+```
+9223372036854775802+0 -> (9223372036854775802,true)
+9223372036854775802+1 -> (9223372036854775803,true)
+9223372036854775802+2 -> (9223372036854775804,true)
+9223372036854775802+3 -> (9223372036854775805,true)
+9223372036854775802+4 -> (9223372036854775806,true)
+9223372036854775802+5 -> (9223372036854775807,true)
+9223372036854775802+6 -> (0,false)
+9223372036854775802+7 -> (0,false)
+9223372036854775802+8 -> (0,false)
+9223372036854775802+9 -> (0,false)
 ```
 
 For int, int64, and int32 types, provide Add, Add32, Add64, Sub, Sub32, Sub64, etc.  
+Unsigned types not covered at the moment, but such additions are welcome.
 
 ### Stay calm and panic
 
-There's a good case to be made that a panic is an unidiomatic but proper
-response. If you believe that there's no valid way to continue your program
-after math goes wayward, you can use the easier Addp, Mulp, Subp, and Divp
-versions which return the normal result or panic.
+There's a good case to be made that a panic is an unidiomatic but proper response.  Iff you
+believe that there's no valid way to continue your program after math goes wayward, you can
+use the easier Addp, Mulp, Subp, and Divp versions which return the normal result or panic.
+
+
+
+
+
+
+
diff --git a/tm2/pkg/overflow/overflow_impl.go b/tm2/pkg/overflow/overflow_impl.go
index 0f057f65387..a9a90c43835 100644
--- a/tm2/pkg/overflow/overflow_impl.go
+++ b/tm2/pkg/overflow/overflow_impl.go
@@ -1,8 +1,10 @@
 package overflow
 
-// Code generated by overflow_template.sh from 'go generate'. DO NOT EDIT.
+// This is generated code, created by overflow_template.sh executed
+// by "go generate"
 
-// Add8 performs + operation on two int8 operands, returning a result and status.
+// Add8 performs + operation on two int8 operands
+// returning a result and status
 func Add8(a, b int8) (int8, bool) {
 	c := a + b
 	if (c > a) == (b > 0) {
@@ -11,7 +13,7 @@ func Add8(a, b int8) (int8, bool) {
 	return c, false
 }
 
-// Add8p is the unchecked panicing version of Add8.
+// Add8p is the unchecked panicing version of Add8
 func Add8p(a, b int8) int8 {
 	r, ok := Add8(a, b)
 	if !ok {
@@ -20,7 +22,8 @@ func Add8p(a, b int8) int8 {
 	return r
 }
 
-// Sub8 performs - operation on two int8 operands, returning a result and status.
+// Sub8 performs - operation on two int8 operands
+// returning a result and status
 func Sub8(a, b int8) (int8, bool) {
 	c := a - b
 	if (c < a) == (b > 0) {
@@ -29,7 +32,7 @@ func Sub8(a, b int8) (int8, bool) {
 	return c, false
 }
 
-// Sub8p is the unchecked panicing version of Sub8.
+// Sub8p is the unchecked panicing version of Sub8
 func Sub8p(a, b int8) int8 {
 	r, ok := Sub8(a, b)
 	if !ok {
@@ -38,7 +41,8 @@ func Sub8p(a, b int8) int8 {
 	return r
 }
 
-// Mul8 performs * operation on two int8 operands returning a result and status.
+// Mul8 performs * operation on two int8 operands
+// returning a result and status
 func Mul8(a, b int8) (int8, bool) {
 	if a == 0 || b == 0 {
 		return 0, true
@@ -52,7 +56,7 @@ func Mul8(a, b int8) (int8, bool) {
 	return c, false
 }
 
-// Mul8p is the unchecked panicing version of Mul8.
+// Mul8p is the unchecked panicing version of Mul8
 func Mul8p(a, b int8) int8 {
 	r, ok := Mul8(a, b)
 	if !ok {
@@ -61,13 +65,14 @@ func Mul8p(a, b int8) int8 {
 	return r
 }
 
-// Div8 performs / operation on two int8 operands, returning a result and status.
+// Div8 performs / operation on two int8 operands
+// returning a result and status
 func Div8(a, b int8) (int8, bool) {
 	q, _, ok := Quotient8(a, b)
 	return q, ok
 }
 
-// Div8p is the unchecked panicing version of Div8.
+// Div8p is the unchecked panicing version of Div8
 func Div8p(a, b int8) int8 {
 	r, ok := Div8(a, b)
 	if !ok {
@@ -76,19 +81,19 @@ func Div8p(a, b int8) int8 {
 	return r
 }
 
-// Quotient8 performs / operation on two int8 operands, returning a quotient,
-// a remainder and status.
+// Quotient8 performs + operation on two int8 operands
+// returning a quotient, a remainder and status
 func Quotient8(a, b int8) (int8, int8, bool) {
 	if b == 0 {
 		return 0, 0, false
 	}
 	c := a / b
-	status := (c < 0) == ((a < 0) != (b < 0)) || (c == 0) // no sign check for 0 quotient
-	return c, a%b, status
+	status := (c < 0) == ((a < 0) != (b < 0))
+	return c, a % b, status
 }
 
-
-// Add16 performs + operation on two int16 operands, returning a result and status.
+// Add16 performs + operation on two int16 operands
+// returning a result and status
 func Add16(a, b int16) (int16, bool) {
 	c := a + b
 	if (c > a) == (b > 0) {
@@ -97,7 +102,7 @@ func Add16(a, b int16) (int16, bool) {
 	return c, false
 }
 
-// Add16p is the unchecked panicing version of Add16.
+// Add16p is the unchecked panicing version of Add16
 func Add16p(a, b int16) int16 {
 	r, ok := Add16(a, b)
 	if !ok {
@@ -106,7 +111,8 @@ func Add16p(a, b int16) int16 {
 	return r
 }
 
-// Sub16 performs - operation on two int16 operands, returning a result and status.
+// Sub16 performs - operation on two int16 operands
+// returning a result and status
 func Sub16(a, b int16) (int16, bool) {
 	c := a - b
 	if (c < a) == (b > 0) {
@@ -115,7 +121,7 @@ func Sub16(a, b int16) (int16, bool) {
 	return c, false
 }
 
-// Sub16p is the unchecked panicing version of Sub16.
+// Sub16p is the unchecked panicing version of Sub16
 func Sub16p(a, b int16) int16 {
 	r, ok := Sub16(a, b)
 	if !ok {
@@ -124,7 +130,8 @@ func Sub16p(a, b int16) int16 {
 	return r
 }
 
-// Mul16 performs * operation on two int16 operands returning a result and status.
+// Mul16 performs * operation on two int16 operands
+// returning a result and status
 func Mul16(a, b int16) (int16, bool) {
 	if a == 0 || b == 0 {
 		return 0, true
@@ -138,7 +145,7 @@ func Mul16(a, b int16) (int16, bool) {
 	return c, false
 }
 
-// Mul16p is the unchecked panicing version of Mul16.
+// Mul16p is the unchecked panicing version of Mul16
 func Mul16p(a, b int16) int16 {
 	r, ok := Mul16(a, b)
 	if !ok {
@@ -147,13 +154,14 @@ func Mul16p(a, b int16) int16 {
 	return r
 }
 
-// Div16 performs / operation on two int16 operands, returning a result and status.
+// Div16 performs / operation on two int16 operands
+// returning a result and status
 func Div16(a, b int16) (int16, bool) {
 	q, _, ok := Quotient16(a, b)
 	return q, ok
 }
 
-// Div16p is the unchecked panicing version of Div16.
+// Div16p is the unchecked panicing version of Div16
 func Div16p(a, b int16) int16 {
 	r, ok := Div16(a, b)
 	if !ok {
@@ -162,19 +170,19 @@ func Div16p(a, b int16) int16 {
 	return r
 }
 
-// Quotient16 performs / operation on two int16 operands, returning a quotient,
-// a remainder and status.
+// Quotient16 performs + operation on two int16 operands
+// returning a quotient, a remainder and status
 func Quotient16(a, b int16) (int16, int16, bool) {
 	if b == 0 {
 		return 0, 0, false
 	}
 	c := a / b
-	status := (c < 0) == ((a < 0) != (b < 0)) || (c == 0) // no sign check for 0 quotient
-	return c, a%b, status
+	status := (c < 0) == ((a < 0) != (b < 0))
+	return c, a % b, status
 }
 
-
-// Add32 performs + operation on two int32 operands, returning a result and status.
+// Add32 performs + operation on two int32 operands
+// returning a result and status
 func Add32(a, b int32) (int32, bool) {
 	c := a + b
 	if (c > a) == (b > 0) {
@@ -183,7 +191,7 @@ func Add32(a, b int32) (int32, bool) {
 	return c, false
 }
 
-// Add32p is the unchecked panicing version of Add32.
+// Add32p is the unchecked panicing version of Add32
 func Add32p(a, b int32) int32 {
 	r, ok := Add32(a, b)
 	if !ok {
@@ -192,7 +200,8 @@ func Add32p(a, b int32) int32 {
 	return r
 }
 
-// Sub32 performs - operation on two int32 operands, returning a result and status.
+// Sub32 performs - operation on two int32 operands
+// returning a result and status
 func Sub32(a, b int32) (int32, bool) {
 	c := a - b
 	if (c < a) == (b > 0) {
@@ -201,7 +210,7 @@ func Sub32(a, b int32) (int32, bool) {
 	return c, false
 }
 
-// Sub32p is the unchecked panicing version of Sub32.
+// Sub32p is the unchecked panicing version of Sub32
 func Sub32p(a, b int32) int32 {
 	r, ok := Sub32(a, b)
 	if !ok {
@@ -210,7 +219,8 @@ func Sub32p(a, b int32) int32 {
 	return r
 }
 
-// Mul32 performs * operation on two int32 operands returning a result and status.
+// Mul32 performs * operation on two int32 operands
+// returning a result and status
 func Mul32(a, b int32) (int32, bool) {
 	if a == 0 || b == 0 {
 		return 0, true
@@ -224,7 +234,7 @@ func Mul32(a, b int32) (int32, bool) {
 	return c, false
 }
 
-// Mul32p is the unchecked panicing version of Mul32.
+// Mul32p is the unchecked panicing version of Mul32
 func Mul32p(a, b int32) int32 {
 	r, ok := Mul32(a, b)
 	if !ok {
@@ -233,13 +243,14 @@ func Mul32p(a, b int32) int32 {
 	return r
 }
 
-// Div32 performs / operation on two int32 operands, returning a result and status.
+// Div32 performs / operation on two int32 operands
+// returning a result and status
 func Div32(a, b int32) (int32, bool) {
 	q, _, ok := Quotient32(a, b)
 	return q, ok
 }
 
-// Div32p is the unchecked panicing version of Div32.
+// Div32p is the unchecked panicing version of Div32
 func Div32p(a, b int32) int32 {
 	r, ok := Div32(a, b)
 	if !ok {
@@ -248,19 +259,19 @@ func Div32p(a, b int32) int32 {
 	return r
 }
 
-// Quotient32 performs / operation on two int32 operands, returning a quotient,
-// a remainder and status.
+// Quotient32 performs + operation on two int32 operands
+// returning a quotient, a remainder and status
 func Quotient32(a, b int32) (int32, int32, bool) {
 	if b == 0 {
 		return 0, 0, false
 	}
 	c := a / b
-	status := (c < 0) == ((a < 0) != (b < 0)) || (c == 0) // no sign check for 0 quotient
-	return c, a%b, status
+	status := (c < 0) == ((a < 0) != (b < 0))
+	return c, a % b, status
 }
 
-
-// Add64 performs + operation on two int64 operands, returning a result and status.
+// Add64 performs + operation on two int64 operands
+// returning a result and status
 func Add64(a, b int64) (int64, bool) {
 	c := a + b
 	if (c > a) == (b > 0) {
@@ -269,7 +280,7 @@ func Add64(a, b int64) (int64, bool) {
 	return c, false
 }
 
-// Add64p is the unchecked panicing version of Add64.
+// Add64p is the unchecked panicing version of Add64
 func Add64p(a, b int64) int64 {
 	r, ok := Add64(a, b)
 	if !ok {
@@ -278,7 +289,8 @@ func Add64p(a, b int64) int64 {
 	return r
 }
 
-// Sub64 performs - operation on two int64 operands, returning a result and status.
+// Sub64 performs - operation on two int64 operands
+// returning a result and status
 func Sub64(a, b int64) (int64, bool) {
 	c := a - b
 	if (c < a) == (b > 0) {
@@ -287,7 +299,7 @@ func Sub64(a, b int64) (int64, bool) {
 	return c, false
 }
 
-// Sub64p is the unchecked panicing version of Sub64.
+// Sub64p is the unchecked panicing version of Sub64
 func Sub64p(a, b int64) int64 {
 	r, ok := Sub64(a, b)
 	if !ok {
@@ -296,7 +308,8 @@ func Sub64p(a, b int64) int64 {
 	return r
 }
 
-// Mul64 performs * operation on two int64 operands returning a result and status.
+// Mul64 performs * operation on two int64 operands
+// returning a result and status
 func Mul64(a, b int64) (int64, bool) {
 	if a == 0 || b == 0 {
 		return 0, true
@@ -310,7 +323,7 @@ func Mul64(a, b int64) (int64, bool) {
 	return c, false
 }
 
-// Mul64p is the unchecked panicing version of Mul64.
+// Mul64p is the unchecked panicing version of Mul64
 func Mul64p(a, b int64) int64 {
 	r, ok := Mul64(a, b)
 	if !ok {
@@ -319,13 +332,14 @@ func Mul64p(a, b int64) int64 {
 	return r
 }
 
-// Div64 performs / operation on two int64 operands, returning a result and status.
+// Div64 performs / operation on two int64 operands
+// returning a result and status
 func Div64(a, b int64) (int64, bool) {
 	q, _, ok := Quotient64(a, b)
 	return q, ok
 }
 
-// Div64p is the unchecked panicing version of Div64.
+// Div64p is the unchecked panicing version of Div64
 func Div64p(a, b int64) int64 {
 	r, ok := Div64(a, b)
 	if !ok {
@@ -334,14 +348,13 @@ func Div64p(a, b int64) int64 {
 	return r
 }
 
-// Quotient64 performs / operation on two int64 operands, returning a quotient,
-// a remainder and status.
+// Quotient64 performs + operation on two int64 operands
+// returning a quotient, a remainder and status
 func Quotient64(a, b int64) (int64, int64, bool) {
 	if b == 0 {
 		return 0, 0, false
 	}
 	c := a / b
-	status := (c < 0) == ((a < 0) != (b < 0)) || (c == 0) // no sign check for 0 quotient
-	return c, a%b, status
+	status := (c < 0) == ((a < 0) != (b < 0))
+	return c, a % b, status
 }
-
diff --git a/tm2/pkg/overflow/overflow_template.sh b/tm2/pkg/overflow/overflow_template.sh
index 0cc3c9595bf..a2a85f2c581 100755
--- a/tm2/pkg/overflow/overflow_template.sh
+++ b/tm2/pkg/overflow/overflow_template.sh
@@ -4,94 +4,109 @@ exec > overflow_impl.go
 
 echo "package overflow
 
-// Code generated by overflow_template.sh from 'go generate'. DO NOT EDIT."
+// This is generated code, created by overflow_template.sh executed
+// by \"go generate\"
+
+"
+
 
 for SIZE in 8 16 32 64
 do
-	echo "
-// Add${SIZE} performs + operation on two int${SIZE} operands, returning a result and status.
+echo "
+
+// Add${SIZE} performs + operation on two int${SIZE} operands
+// returning a result and status
 func Add${SIZE}(a, b int${SIZE}) (int${SIZE}, bool) {
-	c := a + b
-	if (c > a) == (b > 0) {
-		return c, true
-	}
-	return c, false
+        c := a + b
+        if (c > a) == (b > 0) {
+                return c, true
+        }
+        return c, false
 }
 
-// Add${SIZE}p is the unchecked panicing version of Add${SIZE}.
+// Add${SIZE}p is the unchecked panicing version of Add${SIZE}
 func Add${SIZE}p(a, b int${SIZE}) int${SIZE} {
-	r, ok := Add${SIZE}(a, b)
-	if !ok {
-		panic(\"addition overflow\")
-	}
-	return r
+        r, ok := Add${SIZE}(a, b)
+        if !ok {
+                panic(\"addition overflow\")
+        }
+        return r
 }
 
-// Sub${SIZE} performs - operation on two int${SIZE} operands, returning a result and status.
+
+// Sub${SIZE} performs - operation on two int${SIZE} operands
+// returning a result and status
 func Sub${SIZE}(a, b int${SIZE}) (int${SIZE}, bool) {
-	c := a - b
-	if (c < a) == (b > 0) {
-		return c, true
-	}
-	return c, false
+        c := a - b
+        if (c < a) == (b > 0) {
+                return c, true
+        }
+        return c, false
 }
 
-// Sub${SIZE}p is the unchecked panicing version of Sub${SIZE}.
+// Sub${SIZE}p is the unchecked panicing version of Sub${SIZE}
 func Sub${SIZE}p(a, b int${SIZE}) int${SIZE} {
-	r, ok := Sub${SIZE}(a, b)
-	if !ok {
-		panic(\"subtraction overflow\")
-	}
-	return r
+        r, ok := Sub${SIZE}(a, b)
+        if !ok {
+                panic(\"subtraction overflow\")
+        }
+        return r
 }
 
-// Mul${SIZE} performs * operation on two int${SIZE} operands returning a result and status.
+
+// Mul${SIZE} performs * operation on two int${SIZE} operands
+// returning a result and status
 func Mul${SIZE}(a, b int${SIZE}) (int${SIZE}, bool) {
-	if a == 0 || b == 0 {
-		return 0, true
-	}
-	c := a * b
-	if (c < 0) == ((a < 0) != (b < 0)) {
-		if c/b == a {
-			return c, true
-		}
-	}
-	return c, false
+        if a == 0 || b == 0 {
+                return 0, true
+        }
+        c := a * b
+        if (c < 0) == ((a < 0) != (b < 0)) {
+                if c/b == a {
+                        return c, true
+                }
+        }
+        return c, false
 }
 
-// Mul${SIZE}p is the unchecked panicing version of Mul${SIZE}.
+// Mul${SIZE}p is the unchecked panicing version of Mul${SIZE}
 func Mul${SIZE}p(a, b int${SIZE}) int${SIZE} {
-	r, ok := Mul${SIZE}(a, b)
-	if !ok {
-		panic(\"multiplication overflow\")
-	}
-	return r
+        r, ok := Mul${SIZE}(a, b)
+        if !ok {
+                panic(\"multiplication overflow\")
+        }
+        return r
 }
 
-// Div${SIZE} performs / operation on two int${SIZE} operands, returning a result and status.
+
+
+// Div${SIZE} performs / operation on two int${SIZE} operands
+// returning a result and status
 func Div${SIZE}(a, b int${SIZE}) (int${SIZE}, bool) {
-	q, _, ok := Quotient${SIZE}(a, b)
-	return q, ok
+        q, _, ok := Quotient${SIZE}(a, b)
+        return q, ok
 }
 
-// Div${SIZE}p is the unchecked panicing version of Div${SIZE}.
+// Div${SIZE}p is the unchecked panicing version of Div${SIZE}
 func Div${SIZE}p(a, b int${SIZE}) int${SIZE} {
-	r, ok := Div${SIZE}(a, b)
-	if !ok {
-		panic(\"division failure\")
-	}
-	return r
+        r, ok := Div${SIZE}(a, b)
+        if !ok {
+                panic(\"division failure\")
+        }
+        return r
 }
 
-// Quotient${SIZE} performs / operation on two int${SIZE} operands, returning a quotient,
-// a remainder and status.
+// Quotient${SIZE} performs + operation on two int${SIZE} operands
+// returning a quotient, a remainder and status
 func Quotient${SIZE}(a, b int${SIZE}) (int${SIZE}, int${SIZE}, bool) {
-	if b == 0 {
-		return 0, 0, false
-	}
-	c := a / b
-	status := (c < 0) == ((a < 0) != (b < 0)) || (c == 0) // no sign check for 0 quotient
-	return c, a%b, status
+        if b == 0 {
+                return 0, 0, false
+        }
+        c := a / b
+        status := (c < 0) == ((a < 0) != (b < 0))
+        return c, a % b, status
 }
 "
 done
+
+go run -modfile ../../../misc/devdeps/go.mod mvdan.cc/gofumpt -w overflow_impl.go
diff --git a/tm2/pkg/overflow/overflow_test.go b/tm2/pkg/overflow/overflow_test.go
index e6327c9e862..2b2d345b55d 100644
--- a/tm2/pkg/overflow/overflow_test.go
+++ b/tm2/pkg/overflow/overflow_test.go
@@ -28,7 +28,8 @@ func TestAlgorithms(t *testing.T) {
 				// now the verification
 				result, ok := Add8(a8, b8)
 				if ok && int64(result) != r64 {
-					t.Errorf("failed to fail on %v + %v = %v instead of %v\n", a8, b8, result, r64)
+					t.Errorf("failed to fail on %v + %v = %v instead of %v\n",
+						a8, b8, result, r64)
 					errors++
 				}
 				if !ok && int64(result) == r64 {
@@ -44,7 +45,8 @@ func TestAlgorithms(t *testing.T) {
 				// now the verification
 				result, ok := Sub8(a8, b8)
 				if ok && int64(result) != r64 {
-					t.Errorf("failed to fail on %v - %v = %v instead of %v\n", a8, b8, result, r64)
+					t.Errorf("failed to fail on %v - %v = %v instead of %v\n",
+						a8, b8, result, r64)
 				}
 				if !ok && int64(result) == r64 {
 					t.Fail()
@@ -59,7 +61,8 @@ func TestAlgorithms(t *testing.T) {
 				// now the verification
 				result, ok := Mul8(a8, b8)
 				if ok && int64(result) != r64 {
-					t.Errorf("failed to fail on %v * %v = %v instead of %v\n", a8, b8, result, r64)
+					t.Errorf("failed to fail on %v * %v = %v instead of %v\n",
+						a8, b8, result, r64)
 					errors++
 				}
 				if !ok && int64(result) == r64 {
@@ -75,10 +78,11 @@ func TestAlgorithms(t *testing.T) {
 				// now the verification
 				result, _, ok := Quotient8(a8, b8)
 				if ok && int64(result) != r64 {
-					t.Errorf("failed to fail on %v / %v = %v instead of %v\n", a8, b8, result, r64)
+					t.Errorf("failed to fail on %v / %v = %v instead of %v\n",
+						a8, b8, result, r64)
 					errors++
 				}
-				if !ok && int64(result) == r64 {
+				if !ok && result != 0 && int64(result) == r64 {
 					t.Fail()
 					errors++
 				}