integers.go

package tlb
// Code autogenerated. DO NOT EDIT. 

import (
	"encoding/hex"
	"fmt"
	"math/big"
	"strings"
	"strconv"

	"github.com/tonkeeper/tongo/boc"
)
 
type VarUInteger1 big.Int

func (u VarUInteger1) MarshalTLB(c *boc.Cell, encoder *Encoder) error {
	i := big.Int(u)
	b := i.Bytes()
	err := c.WriteLimUint(len(b), 0)
	if err != nil {
		return err
	}
	return c.WriteBytes(b)
}

func (u *VarUInteger1) UnmarshalTLB(c *boc.Cell, decoder *Decoder) error {
	ln, err := c.ReadLimUint(0)
	if err != nil {
		return err
	}
	val, err := c.ReadBigUint(int(ln) * 8)
	if err != nil {
		return err
	}
	*u = VarUInteger1(*val)
	return nil
}

func (u VarUInteger1) MarshalJSON() ([]byte, error) {
	i := big.Int(u)
	return []byte(fmt.Sprintf("\"%s\"", i.String())), nil
}

func (u *VarUInteger1) UnmarshalJSON(p []byte) error {
	var z big.Int
	_, ok := z.SetString(strings.Trim(string(p), "\""), 10)
	if !ok {
		return fmt.Errorf("invalid integer: %s", p)
	}
	*u = VarUInteger1(z)
	return nil
}

type VarUInteger2 big.Int

func (u VarUInteger2) MarshalTLB(c *boc.Cell, encoder *Encoder) error {
	i := big.Int(u)
	b := i.Bytes()
	err := c.WriteLimUint(len(b), 1)
	if err != nil {
		return err
	}
	return c.WriteBytes(b)
}

func (u *VarUInteger2) UnmarshalTLB(c *boc.Cell, decoder *Decoder) error {
	ln, err := c.ReadLimUint(1)
	if err != nil {
		return err
	}
	val, err := c.ReadBigUint(int(ln) * 8)
	if err != nil {
		return err
	}
	*u = VarUInteger2(*val)
	return nil
}

func (u VarUInteger2) MarshalJSON() ([]byte, error) {
	i := big.Int(u)
	return []byte(fmt.Sprintf("\"%s\"", i.String())), nil
}

func (u *VarUInteger2) UnmarshalJSON(p []byte) error {
	var z big.Int
	_, ok := z.SetString(strings.Trim(string(p), "\""), 10)
	if !ok {
		return fmt.Errorf("invalid integer: %s", p)
	}
	*u = VarUInteger2(z)
	return nil
}

type VarUInteger3 big.Int

func (u VarUInteger3) MarshalTLB(c *boc.Cell, encoder *Encoder) error {
	i := big.Int(u)
	b := i.Bytes()
	err := c.WriteLimUint(len(b), 2)
	if err != nil {
		return err
	}
	return c.WriteBytes(b)
}

func (u *VarUInteger3) UnmarshalTLB(c *boc.Cell, decoder *Decoder) error {
	ln, err := c.ReadLimUint(2)
	if err != nil {
		return err
	}
	val, err := c.ReadBigUint(int(ln) * 8)
	if err != nil {
		return err
	}
	*u = VarUInteger3(*val)
	return nil
}

func (u VarUInteger3) MarshalJSON() ([]byte, error) {
	i := big.Int(u)
	return []byte(fmt.Sprintf("\"%s\"", i.String())), nil
}

func (u *VarUInteger3) UnmarshalJSON(p []byte) error {
	var z big.Int
	_, ok := z.SetString(strings.Trim(string(p), "\""), 10)
	if !ok {
		return fmt.Errorf("invalid integer: %s", p)
	}
	*u = VarUInteger3(z)
	return nil
}

type VarUInteger4 big.Int

func (u VarUInteger4) MarshalTLB(c *boc.Cell, encoder *Encoder) error {
	i := big.Int(u)
	b := i.Bytes()
	err := c.WriteLimUint(len(b), 3)
	if err != nil {
		return err
	}
	return c.WriteBytes(b)
}

func (u *VarUInteger4) UnmarshalTLB(c *boc.Cell, decoder *Decoder) error {
	ln, err := c.ReadLimUint(3)
	if err != nil {
		return err
	}
	val, err := c.ReadBigUint(int(ln) * 8)
	if err != nil {
		return err
	}
	*u = VarUInteger4(*val)
	return nil
}

func (u VarUInteger4) MarshalJSON() ([]byte, error) {
	i := big.Int(u)
	return []byte(fmt.Sprintf("\"%s\"", i.String())), nil
}

func (u *VarUInteger4) UnmarshalJSON(p []byte) error {
	var z big.Int
	_, ok := z.SetString(strings.Trim(string(p), "\""), 10)
	if !ok {
		return fmt.Errorf("invalid integer: %s", p)
	}
	*u = VarUInteger4(z)
	return nil
}

type VarUInteger5 big.Int

func (u VarUInteger5) MarshalTLB(c *boc.Cell, encoder *Encoder) error {
	i := big.Int(u)
	b := i.Bytes()
	err := c.WriteLimUint(len(b), 4)
	if err != nil {
		return err
	}
	return c.WriteBytes(b)
}

func (u *VarUInteger5) UnmarshalTLB(c *boc.Cell, decoder *Decoder) error {
	ln, err := c.ReadLimUint(4)
	if err != nil {
		return err
	}
	val, err := c.ReadBigUint(int(ln) * 8)
	if err != nil {
		return err
	}
	*u = VarUInteger5(*val)
	return nil
}

func (u VarUInteger5) MarshalJSON() ([]byte, error) {
	i := big.Int(u)
	return []byte(fmt.Sprintf("\"%s\"", i.String())), nil
}

func (u *VarUInteger5) UnmarshalJSON(p []byte) error {
	var z big.Int
	_, ok := z.SetString(strings.Trim(string(p), "\""), 10)
	if !ok {
		return fmt.Errorf("invalid integer: %s", p)
	}
	*u = VarUInteger5(z)
	return nil
}

type VarUInteger6 big.Int

func (u VarUInteger6) MarshalTLB(c *boc.Cell, encoder *Encoder) error {
	i := big.Int(u)
	b := i.Bytes()
	err := c.WriteLimUint(len(b), 5)
	if err != nil {
		return err
	}
	return c.WriteBytes(b)
}

func (u *VarUInteger6) UnmarshalTLB(c *boc.Cell, decoder *Decoder) error {
	ln, err := c.ReadLimUint(5)
	if err != nil {
		return err
	}
	val, err := c.ReadBigUint(int(ln) * 8)
	if err != nil {
		return err
	}
	*u = VarUInteger6(*val)
	return nil
}

func (u VarUInteger6) MarshalJSON() ([]byte, error) {
	i := big.Int(u)
	return []byte(fmt.Sprintf("\"%s\"", i.String())), nil
}

func (u *VarUInteger6) UnmarshalJSON(p []byte) error {
	var z big.Int
	_, ok := z.SetString(strings.Trim(string(p), "\""), 10)
	if !ok {
		return fmt.Errorf("invalid integer: %s", p)
	}
	*u = VarUInteger6(z)
	return nil
}

type VarUInteger7 big.Int

func (u VarUInteger7) MarshalTLB(c *boc.Cell, encoder *Encoder) error {
	i := big.Int(u)
	b := i.Bytes()
	err := c.WriteLimUint(len(b), 6)
	if err != nil {
		return err
	}
	return c.WriteBytes(b)
}

func (u *VarUInteger7) UnmarshalTLB(c *boc.Cell, decoder *Decoder) error {
	ln, err := c.ReadLimUint(6)
	if err != nil {
		return err
	}
	val, err := c.ReadBigUint(int(ln) * 8)
	if err != nil {
		return err
	}
	*u = VarUInteger7(*val)
	return nil
}

func (u VarUInteger7) MarshalJSON() ([]byte, error) {
	i := big.Int(u)
	return []byte(fmt.Sprintf("\"%s\"", i.String())), nil
}

func (u *VarUInteger7) UnmarshalJSON(p []byte) error {
	var z big.Int
	_, ok := z.SetString(strings.Trim(string(p), "\""), 10)
	if !ok {
		return fmt.Errorf("invalid integer: %s", p)
	}
	*u = VarUInteger7(z)
	return nil
}

type VarUInteger8 big.Int

func (u VarUInteger8) MarshalTLB(c *boc.Cell, encoder *Encoder) error {
	i := big.Int(u)
	b := i.Bytes()
	err := c.WriteLimUint(len(b), 7)
	if err != nil {
		return err
	}
	return c.WriteBytes(b)
}

func (u *VarUInteger8) UnmarshalTLB(c *boc.Cell, decoder *Decoder) error {
	ln, err := c.ReadLimUint(7)
	if err != nil {
		return err
	}
	val, err := c.ReadBigUint(int(ln) * 8)
	if err != nil {
		return err
	}
	*u = VarUInteger8(*val)
	return nil
}

func (u VarUInteger8) MarshalJSON() ([]byte, error) {
	i := big.Int(u)
	return []byte(fmt.Sprintf("\"%s\"", i.String())), nil
}

func (u *VarUInteger8) UnmarshalJSON(p []byte) error {
	var z big.Int
	_, ok := z.SetString(strings.Trim(string(p), "\""), 10)
	if !ok {
		return fmt.Errorf("invalid integer: %s", p)
	}
	*u = VarUInteger8(z)
	return nil
}

type VarUInteger9 big.Int

func (u VarUInteger9) MarshalTLB(c *boc.Cell, encoder *Encoder) error {
	i := big.Int(u)
	b := i.Bytes()
	err := c.WriteLimUint(len(b), 8)
	if err != nil {
		return err
	}
	return c.WriteBytes(b)
}

func (u *VarUInteger9) UnmarshalTLB(c *boc.Cell, decoder *Decoder) error {
	ln, err := c.ReadLimUint(8)
	if err != nil {
		return err
	}
	val, err := c.ReadBigUint(int(ln) * 8)
	if err != nil {
		return err
	}
	*u = VarUInteger9(*val)
	return nil
}

func (u VarUInteger9) MarshalJSON() ([]byte, error) {
	i := big.Int(u)
	return []byte(fmt.Sprintf("\"%s\"", i.String())), nil
}

func (u *VarUInteger9) UnmarshalJSON(p []byte) error {
	var z big.Int
	_, ok := z.SetString(strings.Trim(string(p), "\""), 10)
	if !ok {
		return fmt.Errorf("invalid integer: %s", p)
	}
	*u = VarUInteger9(z)
	return nil
}

type VarUInteger10 big.Int

func (u VarUInteger10) MarshalTLB(c *boc.Cell, encoder *Encoder) error {
	i := big.Int(u)
	b := i.Bytes()
	err := c.WriteLimUint(len(b), 9)
	if err != nil {
		return err
	}
	return c.WriteBytes(b)
}

func (u *VarUInteger10) UnmarshalTLB(c *boc.Cell, decoder *Decoder) error {
	ln, err := c.ReadLimUint(9)
	if err != nil {
		return err
	}
	val, err := c.ReadBigUint(int(ln) * 8)
	if err != nil {
		return err
	}
	*u = VarUInteger10(*val)
	return nil
}

func (u VarUInteger10) MarshalJSON() ([]byte, error) {
	i := big.Int(u)
	return []byte(fmt.Sprintf("\"%s\"", i.String())), nil
}

func (u *VarUInteger10) UnmarshalJSON(p []byte) error {
	var z big.Int
	_, ok := z.SetString(strings.Trim(string(p), "\""), 10)
	if !ok {
		return fmt.Errorf("invalid integer: %s", p)
	}
	*u = VarUInteger10(z)
	return nil
}

type VarUInteger11 big.Int

func (u VarUInteger11) MarshalTLB(c *boc.Cell, encoder *Encoder) error {
	i := big.Int(u)
	b := i.Bytes()
	err := c.WriteLimUint(len(b), 10)
	if err != nil {
		return err
	}
	return c.WriteBytes(b)
}

func (u *VarUInteger11) UnmarshalTLB(c *boc.Cell, decoder *Decoder) error {
	ln, err := c.ReadLimUint(10)
	if err != nil {
		return err
	}
	val, err := c.ReadBigUint(int(ln) * 8)
	if err != nil {
		return err
	}
	*u = VarUInteger11(*val)
	return nil
}

func (u VarUInteger11) MarshalJSON() ([]byte, error) {
	i := big.Int(u)
	return []byte(fmt.Sprintf("\"%s\"", i.String())), nil
}

func (u *VarUInteger11) UnmarshalJSON(p []byte) error {
	var z big.Int
	_, ok := z.SetString(strings.Trim(string(p), "\""), 10)
	if !ok {
		return fmt.Errorf("invalid integer: %s", p)
	}
	*u = VarUInteger11(z)
	return nil
}

type VarUInteger12 big.Int

func (u VarUInteger12) MarshalTLB(c *boc.Cell, encoder *Encoder) error {
	i := big.Int(u)
	b := i.Bytes()
	err := c.WriteLimUint(len(b), 11)
	if err != nil {
		return err
	}
	return c.WriteBytes(b)
}

func (u *VarUInteger12) UnmarshalTLB(c *boc.Cell, decoder *Decoder) error {
	ln, err := c.ReadLimUint(11)
	if err != nil {
		return err
	}
	val, err := c.ReadBigUint(int(ln) * 8)
	if err != nil {
		return err
	}
	*u = VarUInteger12(*val)
	return nil
}

func (u VarUInteger12) MarshalJSON() ([]byte, error) {
	i := big.Int(u)
	return []byte(fmt.Sprintf("\"%s\"", i.String())), nil
}

func (u *VarUInteger12) UnmarshalJSON(p []byte) error {
	var z big.Int
	_, ok := z.SetString(strings.Trim(string(p), "\""), 10)
	if !ok {
		return fmt.Errorf("invalid integer: %s", p)
	}
	*u = VarUInteger12(z)
	return nil
}

type VarUInteger13 big.Int

func (u VarUInteger13) MarshalTLB(c *boc.Cell, encoder *Encoder) error {
	i := big.Int(u)
	b := i.Bytes()
	err := c.WriteLimUint(len(b), 12)
	if err != nil {
		return err
	}
	return c.WriteBytes(b)
}

func (u *VarUInteger13) UnmarshalTLB(c *boc.Cell, decoder *Decoder) error {
	ln, err := c.ReadLimUint(12)
	if err != nil {
		return err
	}
	val, err := c.ReadBigUint(int(ln) * 8)
	if err != nil {
		return err
	}
	*u = VarUInteger13(*val)
	return nil
}

func (u VarUInteger13) MarshalJSON() ([]byte, error) {
	i := big.Int(u)
	return []byte(fmt.Sprintf("\"%s\"", i.String())), nil
}

func (u *VarUInteger13) UnmarshalJSON(p []byte) error {
	var z big.Int
	_, ok := z.SetString(strings.Trim(string(p), "\""), 10)
	if !ok {
		return fmt.Errorf("invalid integer: %s", p)
	}
	*u = VarUInteger13(z)
	return nil
}

type VarUInteger14 big.Int

func (u VarUInteger14) MarshalTLB(c *boc.Cell, encoder *Encoder) error {
	i := big.Int(u)
	b := i.Bytes()
	err := c.WriteLimUint(len(b), 13)
	if err != nil {
		return err
	}
	return c.WriteBytes(b)
}

func (u *VarUInteger14) UnmarshalTLB(c *boc.Cell, decoder *Decoder) error {
	ln, err := c.ReadLimUint(13)
	if err != nil {
		return err
	}
	val, err := c.ReadBigUint(int(ln) * 8)
	if err != nil {
		return err
	}
	*u = VarUInteger14(*val)
	return nil
}

func (u VarUInteger14) MarshalJSON() ([]byte, error) {
	i := big.Int(u)
	return []byte(fmt.Sprintf("\"%s\"", i.String())), nil
}

func (u *VarUInteger14) UnmarshalJSON(p []byte) error {
	var z big.Int
	_, ok := z.SetString(strings.Trim(string(p), "\""), 10)
	if !ok {
		return fmt.Errorf("invalid integer: %s", p)
	}
	*u = VarUInteger14(z)
	return nil
}

type VarUInteger15 big.Int

func (u VarUInteger15) MarshalTLB(c *boc.Cell, encoder *Encoder) error {
	i := big.Int(u)
	b := i.Bytes()
	err := c.WriteLimUint(len(b), 14)
	if err != nil {
		return err
	}
	return c.WriteBytes(b)
}

func (u *VarUInteger15) UnmarshalTLB(c *boc.Cell, decoder *Decoder) error {
	ln, err := c.ReadLimUint(14)
	if err != nil {
		return err
	}
	val, err := c.ReadBigUint(int(ln) * 8)
	if err != nil {
		return err
	}
	*u = VarUInteger15(*val)
	return nil
}

func (u VarUInteger15) MarshalJSON() ([]byte, error) {
	i := big.Int(u)
	return []byte(fmt.Sprintf("\"%s\"", i.String())), nil
}

func (u *VarUInteger15) UnmarshalJSON(p []byte) error {
	var z big.Int
	_, ok := z.SetString(strings.Trim(string(p), "\""), 10)
	if !ok {
		return fmt.Errorf("invalid integer: %s", p)
	}
	*u = VarUInteger15(z)
	return nil
}

type VarUInteger16 big.Int

func (u VarUInteger16) MarshalTLB(c *boc.Cell, encoder *Encoder) error {
	i := big.Int(u)
	b := i.Bytes()
	err := c.WriteLimUint(len(b), 15)
	if err != nil {
		return err
	}
	return c.WriteBytes(b)
}

func (u *VarUInteger16) UnmarshalTLB(c *boc.Cell, decoder *Decoder) error {
	ln, err := c.ReadLimUint(15)
	if err != nil {
		return err
	}
	val, err := c.ReadBigUint(int(ln) * 8)
	if err != nil {
		return err
	}
	*u = VarUInteger16(*val)
	return nil
}

func (u VarUInteger16) MarshalJSON() ([]byte, error) {
	i := big.Int(u)
	return []byte(fmt.Sprintf("\"%s\"", i.String())), nil
}

func (u *VarUInteger16) UnmarshalJSON(p []byte) error {
	var z big.Int
	_, ok := z.SetString(strings.Trim(string(p), "\""), 10)
	if !ok {
		return fmt.Errorf("invalid integer: %s", p)
	}
	*u = VarUInteger16(z)
	return nil
}

type VarUInteger17 big.Int

func (u VarUInteger17) MarshalTLB(c *boc.Cell, encoder *Encoder) error {
	i := big.Int(u)
	b := i.Bytes()
	err := c.WriteLimUint(len(b), 16)
	if err != nil {
		return err
	}
	return c.WriteBytes(b)
}

func (u *VarUInteger17) UnmarshalTLB(c *boc.Cell, decoder *Decoder) error {
	ln, err := c.ReadLimUint(16)
	if err != nil {
		return err
	}
	val, err := c.ReadBigUint(int(ln) * 8)
	if err != nil {
		return err
	}
	*u = VarUInteger17(*val)
	return nil
}

func (u VarUInteger17) MarshalJSON() ([]byte, error) {
	i := big.Int(u)
	return []byte(fmt.Sprintf("\"%s\"", i.String())), nil
}

func (u *VarUInteger17) UnmarshalJSON(p []byte) error {
	var z big.Int
	_, ok := z.SetString(strings.Trim(string(p), "\""), 10)
	if !ok {
		return fmt.Errorf("invalid integer: %s", p)
	}
	*u = VarUInteger17(z)
	return nil
}

type VarUInteger18 big.Int

func (u VarUInteger18) MarshalTLB(c *boc.Cell, encoder *Encoder) error {
	i := big.Int(u)
	b := i.Bytes()
	err := c.WriteLimUint(len(b), 17)
	if err != nil {
		return err
	}
	return c.WriteBytes(b)
}

func (u *VarUInteger18) UnmarshalTLB(c *boc.Cell, decoder *Decoder) error {
	ln, err := c.ReadLimUint(17)
	if err != nil {
		return err
	}
	val, err := c.ReadBigUint(int(ln) * 8)
	if err != nil {
		return err
	}
	*u = VarUInteger18(*val)
	return nil
}

func (u VarUInteger18) MarshalJSON() ([]byte, error) {
	i := big.Int(u)
	return []byte(fmt.Sprintf("\"%s\"", i.String())), nil
}

func (u *VarUInteger18) UnmarshalJSON(p []byte) error {
	var z big.Int
	_, ok := z.SetString(strings.Trim(string(p), "\""), 10)
	if !ok {
		return fmt.Errorf("invalid integer: %s", p)
	}
	*u = VarUInteger18(z)
	return nil
}

type VarUInteger19 big.Int

func (u VarUInteger19) MarshalTLB(c *boc.Cell, encoder *Encoder) error {
	i := big.Int(u)
	b := i.Bytes()
	err := c.WriteLimUint(len(b), 18)
	if err != nil {
		return err
	}
	return c.WriteBytes(b)
}

func (u *VarUInteger19) UnmarshalTLB(c *boc.Cell, decoder *Decoder) error {
	ln, err := c.ReadLimUint(18)
	if err != nil {
		return err
	}
	val, err := c.ReadBigUint(int(ln) * 8)
	if err != nil {
		return err
	}
	*u = VarUInteger19(*val)
	return nil
}

func (u VarUInteger19) MarshalJSON() ([]byte, error) {
	i := big.Int(u)
	return []byte(fmt.Sprintf("\"%s\"", i.String())), nil
}

func (u *VarUInteger19) UnmarshalJSON(p []byte) error {
	var z big.Int
	_, ok := z.SetString(strings.Trim(string(p), "\""), 10)
	if !ok {
		return fmt.Errorf("invalid integer: %s", p)
	}
	*u = VarUInteger19(z)
	return nil
}

type VarUInteger20 big.Int

func (u VarUInteger20) MarshalTLB(c *boc.Cell, encoder *Encoder) error {
	i := big.Int(u)
	b := i.Bytes()
	err := c.WriteLimUint(len(b), 19)
	if err != nil {
		return err
	}
	return c.WriteBytes(b)
}

func (u *VarUInteger20) UnmarshalTLB(c *boc.Cell, decoder *Decoder) error {
	ln, err := c.ReadLimUint(19)
	if err != nil {
		return err
	}
	val, err := c.ReadBigUint(int(ln) * 8)
	if err != nil {
		return err
	}
	*u = VarUInteger20(*val)
	return nil
}

func (u VarUInteger20) MarshalJSON() ([]byte, error) {
	i := big.Int(u)
	return []byte(fmt.Sprintf("\"%s\"", i.String())), nil
}

func (u *VarUInteger20) UnmarshalJSON(p []byte) error {
	var z big.Int
	_, ok := z.SetString(strings.Trim(string(p), "\""), 10)
	if !ok {
		return fmt.Errorf("invalid integer: %s", p)
	}
	*u = VarUInteger20(z)
	return nil
}

type VarUInteger21 big.Int

func (u VarUInteger21) MarshalTLB(c *boc.Cell, encoder *Encoder) error {
	i := big.Int(u)
	b := i.Bytes()
	err := c.WriteLimUint(len(b), 20)
	if err != nil {
		return err
	}
	return c.WriteBytes(b)
}

func (u *VarUInteger21) UnmarshalTLB(c *boc.Cell, decoder *Decoder) error {
	ln, err := c.ReadLimUint(20)
	if err != nil {
		return err
	}
	val, err := c.ReadBigUint(int(ln) * 8)
	if err != nil {
		return err
	}
	*u = VarUInteger21(*val)
	return nil
}

func (u VarUInteger21) MarshalJSON() ([]byte, error) {
	i := big.Int(u)
	return []byte(fmt.Sprintf("\"%s\"", i.String())), nil
}

func (u *VarUInteger21) UnmarshalJSON(p []byte) error {
	var z big.Int
	_, ok := z.SetString(strings.Trim(string(p), "\""), 10)
	if !ok {
		return fmt.Errorf("invalid integer: %s", p)
	}
	*u = VarUInteger21(z)
	return nil
}

type VarUInteger22 big.Int

func (u VarUInteger22) MarshalTLB(c *boc.Cell, encoder *Encoder) error {
	i := big.Int(u)
	b := i.Bytes()
	err := c.WriteLimUint(len(b), 21)
	if err != nil {
		return err
	}
	return c.WriteBytes(b)
}

func (u *VarUInteger22) UnmarshalTLB(c *boc.Cell, decoder *Decoder) error {
	ln, err := c.ReadLimUint(21)
	if err != nil {
		return err
	}
	val, err := c.ReadBigUint(int(ln) * 8)
	if err != nil {
		return err
	}
	*u = VarUInteger22(*val)
	return nil
}

func (u VarUInteger22) MarshalJSON() ([]byte, error) {
	i := big.Int(u)
	return []byte(fmt.Sprintf("\"%s\"", i.String())), nil
}

func (u *VarUInteger22) UnmarshalJSON(p []byte) error {
	var z big.Int
	_, ok := z.SetString(strings.Trim(string(p), "\""), 10)
	if !ok {
		return fmt.Errorf("invalid integer: %s", p)
	}
	*u = VarUInteger22(z)
	return nil
}

type VarUInteger23 big.Int

func (u VarUInteger23) MarshalTLB(c *boc.Cell, encoder *Encoder) error {
	i := big.Int(u)
	b := i.Bytes()
	err := c.WriteLimUint(len(b), 22)
	if err != nil {
		return err
	}
	return c.WriteBytes(b)
}

func (u *VarUInteger23) UnmarshalTLB(c *boc.Cell, decoder *Decoder) error {
	ln, err := c.ReadLimUint(22)
	if err != nil {
		return err
	}
	val, err := c.ReadBigUint(int(ln) * 8)
	if err != nil {
		return err
	}
	*u = VarUInteger23(*val)
	return nil
}

func (u VarUInteger23) MarshalJSON() ([]byte, error) {
	i := big.Int(u)
	return []byte(fmt.Sprintf("\"%s\"", i.String())), nil
}

func (u *VarUInteger23) UnmarshalJSON(p []byte) error {
	var z big.Int
	_, ok := z.SetString(strings.Trim(string(p), "\""), 10)
	if !ok {
		return fmt.Errorf("invalid integer: %s", p)
	}
	*u = VarUInteger23(z)
	return nil
}

type VarUInteger24 big.Int

func (u VarUInteger24) MarshalTLB(c *boc.Cell, encoder *Encoder) error {
	i := big.Int(u)
	b := i.Bytes()
	err := c.WriteLimUint(len(b), 23)
	if err != nil {
		return err
	}
	return c.WriteBytes(b)
}

func (u *VarUInteger24) UnmarshalTLB(c *boc.Cell, decoder *Decoder) error {
	ln, err := c.ReadLimUint(23)
	if err != nil {
		return err
	}
	val, err := c.ReadBigUint(int(ln) * 8)
	if err != nil {
		return err
	}
	*u = VarUInteger24(*val)
	return nil
}

func (u VarUInteger24) MarshalJSON() ([]byte, error) {
	i := big.Int(u)
	return []byte(fmt.Sprintf("\"%s\"", i.String())), nil
}

func (u *VarUInteger24) UnmarshalJSON(p []byte) error {
	var z big.Int
	_, ok := z.SetString(strings.Trim(string(p), "\""), 10)
	if !ok {
		return fmt.Errorf("invalid integer: %s", p)
	}
	*u = VarUInteger24(z)
	return nil
}

type VarUInteger25 big.Int

func (u VarUInteger25) MarshalTLB(c *boc.Cell, encoder *Encoder) error {
	i := big.Int(u)
	b := i.Bytes()
	err := c.WriteLimUint(len(b), 24)
	if err != nil {
		return err
	}
	return c.WriteBytes(b)
}

func (u *VarUInteger25) UnmarshalTLB(c *boc.Cell, decoder *Decoder) error {
	ln, err := c.ReadLimUint(24)
	if err != nil {
		return err
	}
	val, err := c.ReadBigUint(int(ln) * 8)
	if err != nil {
		return err
	}
	*u = VarUInteger25(*val)
	return nil
}

func (u VarUInteger25) MarshalJSON() ([]byte, error) {
	i := big.Int(u)
	return []byte(fmt.Sprintf("\"%s\"", i.String())), nil
}

func (u *VarUInteger25) UnmarshalJSON(p []byte) error {
	var z big.Int
	_, ok := z.SetString(strings.Trim(string(p), "\""), 10)
	if !ok {
		return fmt.Errorf("invalid integer: %s", p)
	}
	*u = VarUInteger25(z)
	return nil
}

type VarUInteger26 big.Int

func (u VarUInteger26) MarshalTLB(c *boc.Cell, encoder *Encoder) error {
	i := big.Int(u)
	b := i.Bytes()
	err := c.WriteLimUint(len(b), 25)
	if err != nil {
		return err
	}
	return c.WriteBytes(b)
}

func (u *VarUInteger26) UnmarshalTLB(c *boc.Cell, decoder *Decoder) error {
	ln, err := c.ReadLimUint(25)
	if err != nil {
		return err
	}
	val, err := c.ReadBigUint(int(ln) * 8)
	if err != nil {
		return err
	}
	*u = VarUInteger26(*val)
	return nil
}

func (u VarUInteger26) MarshalJSON() ([]byte, error) {
	i := big.Int(u)
	return []byte(fmt.Sprintf("\"%s\"", i.String())), nil
}

func (u *VarUInteger26) UnmarshalJSON(p []byte) error {
	var z big.Int
	_, ok := z.SetString(strings.Trim(string(p), "\""), 10)
	if !ok {
		return fmt.Errorf("invalid integer: %s", p)
	}
	*u = VarUInteger26(z)
	return nil
}

type VarUInteger27 big.Int

func (u VarUInteger27) MarshalTLB(c *boc.Cell, encoder *Encoder) error {
	i := big.Int(u)
	b := i.Bytes()
	err := c.WriteLimUint(len(b), 26)
	if err != nil {
		return err
	}
	return c.WriteBytes(b)
}

func (u *VarUInteger27) UnmarshalTLB(c *boc.Cell, decoder *Decoder) error {
	ln, err := c.ReadLimUint(26)
	if err != nil {
		return err
	}
	val, err := c.ReadBigUint(int(ln) * 8)
	if err != nil {
		return err
	}
	*u = VarUInteger27(*val)
	return nil
}

func (u VarUInteger27) MarshalJSON() ([]byte, error) {
	i := big.Int(u)
	return []byte(fmt.Sprintf("\"%s\"", i.String())), nil
}

func (u *VarUInteger27) UnmarshalJSON(p []byte) error {
	var z big.Int
	_, ok := z.SetString(strings.Trim(string(p), "\""), 10)
	if !ok {
		return fmt.Errorf("invalid integer: %s", p)
	}
	*u = VarUInteger27(z)
	return nil
}

type VarUInteger28 big.Int

func (u VarUInteger28) MarshalTLB(c *boc.Cell, encoder *Encoder) error {
	i := big.Int(u)
	b := i.Bytes()
	err := c.WriteLimUint(len(b), 27)
	if err != nil {
		return err
	}
	return c.WriteBytes(b)
}

func (u *VarUInteger28) UnmarshalTLB(c *boc.Cell, decoder *Decoder) error {
	ln, err := c.ReadLimUint(27)
	if err != nil {
		return err
	}
	val, err := c.ReadBigUint(int(ln) * 8)
	if err != nil {
		return err
	}
	*u = VarUInteger28(*val)
	return nil
}

func (u VarUInteger28) MarshalJSON() ([]byte, error) {
	i := big.Int(u)
	return []byte(fmt.Sprintf("\"%s\"", i.String())), nil
}

func (u *VarUInteger28) UnmarshalJSON(p []byte) error {
	var z big.Int
	_, ok := z.SetString(strings.Trim(string(p), "\""), 10)
	if !ok {
		return fmt.Errorf("invalid integer: %s", p)
	}
	*u = VarUInteger28(z)
	return nil
}

type VarUInteger29 big.Int

func (u VarUInteger29) MarshalTLB(c *boc.Cell, encoder *Encoder) error {
	i := big.Int(u)
	b := i.Bytes()
	err := c.WriteLimUint(len(b), 28)
	if err != nil {
		return err
	}
	return c.WriteBytes(b)
}

func (u *VarUInteger29) UnmarshalTLB(c *boc.Cell, decoder *Decoder) error {
	ln, err := c.ReadLimUint(28)
	if err != nil {
		return err
	}
	val, err := c.ReadBigUint(int(ln) * 8)
	if err != nil {
		return err
	}
	*u = VarUInteger29(*val)
	return nil
}

func (u VarUInteger29) MarshalJSON() ([]byte, error) {
	i := big.Int(u)
	return []byte(fmt.Sprintf("\"%s\"", i.String())), nil
}

func (u *VarUInteger29) UnmarshalJSON(p []byte) error {
	var z big.Int
	_, ok := z.SetString(strings.Trim(string(p), "\""), 10)
	if !ok {
		return fmt.Errorf("invalid integer: %s", p)
	}
	*u = VarUInteger29(z)
	return nil
}

type VarUInteger30 big.Int

func (u VarUInteger30) MarshalTLB(c *boc.Cell, encoder *Encoder) error {
	i := big.Int(u)
	b := i.Bytes()
	err := c.WriteLimUint(len(b), 29)
	if err != nil {
		return err
	}
	return c.WriteBytes(b)
}

func (u *VarUInteger30) UnmarshalTLB(c *boc.Cell, decoder *Decoder) error {
	ln, err := c.ReadLimUint(29)
	if err != nil {
		return err
	}
	val, err := c.ReadBigUint(int(ln) * 8)
	if err != nil {
		return err
	}
	*u = VarUInteger30(*val)
	return nil
}

func (u VarUInteger30) MarshalJSON() ([]byte, error) {
	i := big.Int(u)
	return []byte(fmt.Sprintf("\"%s\"", i.String())), nil
}

func (u *VarUInteger30) UnmarshalJSON(p []byte) error {
	var z big.Int
	_, ok := z.SetString(strings.Trim(string(p), "\""), 10)
	if !ok {
		return fmt.Errorf("invalid integer: %s", p)
	}
	*u = VarUInteger30(z)
	return nil
}

type VarUInteger31 big.Int

func (u VarUInteger31) MarshalTLB(c *boc.Cell, encoder *Encoder) error {
	i := big.Int(u)
	b := i.Bytes()
	err := c.WriteLimUint(len(b), 30)
	if err != nil {
		return err
	}
	return c.WriteBytes(b)
}

func (u *VarUInteger31) UnmarshalTLB(c *boc.Cell, decoder *Decoder) error {
	ln, err := c.ReadLimUint(30)
	if err != nil {
		return err
	}
	val, err := c.ReadBigUint(int(ln) * 8)
	if err != nil {
		return err
	}
	*u = VarUInteger31(*val)
	return nil
}

func (u VarUInteger31) MarshalJSON() ([]byte, error) {
	i := big.Int(u)
	return []byte(fmt.Sprintf("\"%s\"", i.String())), nil
}

func (u *VarUInteger31) UnmarshalJSON(p []byte) error {
	var z big.Int
	_, ok := z.SetString(strings.Trim(string(p), "\""), 10)
	if !ok {
		return fmt.Errorf("invalid integer: %s", p)
	}
	*u = VarUInteger31(z)
	return nil
}

type VarUInteger32 big.Int

func (u VarUInteger32) MarshalTLB(c *boc.Cell, encoder *Encoder) error {
	i := big.Int(u)
	b := i.Bytes()
	err := c.WriteLimUint(len(b), 31)
	if err != nil {
		return err
	}
	return c.WriteBytes(b)
}

func (u *VarUInteger32) UnmarshalTLB(c *boc.Cell, decoder *Decoder) error {
	ln, err := c.ReadLimUint(31)
	if err != nil {
		return err
	}
	val, err := c.ReadBigUint(int(ln) * 8)
	if err != nil {
		return err
	}
	*u = VarUInteger32(*val)
	return nil
}

func (u VarUInteger32) MarshalJSON() ([]byte, error) {
	i := big.Int(u)
	return []byte(fmt.Sprintf("\"%s\"", i.String())), nil
}

func (u *VarUInteger32) UnmarshalJSON(p []byte) error {
	var z big.Int
	_, ok := z.SetString(strings.Trim(string(p), "\""), 10)
	if !ok {
		return fmt.Errorf("invalid integer: %s", p)
	}
	*u = VarUInteger32(z)
	return nil
}

type Uint1 uint8

func (u Uint1) MarshalTLB(c *boc.Cell, encoder *Encoder) error {
	return c.WriteUint(uint64(u), 1)
}

func (u *Uint1) UnmarshalTLB(c *boc.Cell, decoder *Decoder) error {
	v, err := c.ReadUint(1)
	*u = Uint1(v)
	return err
}

func (u Uint1) FixedSize() int {
	return 1
}

func (u Uint1) Equal(other any) bool {
	otherInt, ok := other.(Uint1)
	if !ok {
		return false
	}
	return u == otherInt
}
func (u Uint1) MarshalJSON() ([]byte, error) {
	return []byte(fmt.Sprintf("%d", u)), nil
}

func (u *Uint1) UnmarshalJSON(p []byte) error {
	value, err := strconv.ParseUint(strings.Trim(string(p), "\""), 10, 1)
	if err != nil {
		return err
	}
	*u = Uint1(value)
	return nil
}

type Int1 int8

func (u Int1) MarshalTLB(c *boc.Cell, encoder *Encoder) error {
	return c.WriteInt(int64(u), 1)
}

func (u *Int1) UnmarshalTLB(c *boc.Cell, decoder *Decoder) error {
	v, err := c.ReadInt(1)
	*u = Int1(v)
	return err
}

func (u Int1) FixedSize() int {
	return 1
}

func (u Int1) Equal(other any) bool {
	otherInt, ok := other.(Int1)
	if !ok {
		return false
	}
	return u == otherInt
}
func (u Int1) MarshalJSON() ([]byte, error) {
	return []byte(fmt.Sprintf("%d", u)), nil
}

func (u *Int1) UnmarshalJSON(p []byte) error {
	value, err := strconv.ParseInt(strings.Trim(string(p), "\""), 10, 1)
	if err != nil {
		return err
	}
	*u = Int1(value)
	return nil
}

type Uint2 uint8

func (u Uint2) MarshalTLB(c *boc.Cell, encoder *Encoder) error {
	return c.WriteUint(uint64(u), 2)
}

func (u *Uint2) UnmarshalTLB(c *boc.Cell, decoder *Decoder) error {
	v, err := c.ReadUint(2)
	*u = Uint2(v)
	return err
}

func (u Uint2) FixedSize() int {
	return 2
}

func (u Uint2) Equal(other any) bool {
	otherInt, ok := other.(Uint2)
	if !ok {
		return false
	}
	return u == otherInt
}
func (u Uint2) MarshalJSON() ([]byte, error) {
	return []byte(fmt.Sprintf("%d", u)), nil
}

func (u *Uint2) UnmarshalJSON(p []byte) error {
	value, err := strconv.ParseUint(strings.Trim(string(p), "\""), 10, 2)
	if err != nil {
		return err
	}
	*u = Uint2(value)
	return nil
}

type Int2 int8

func (u Int2) MarshalTLB(c *boc.Cell, encoder *Encoder) error {
	return c.WriteInt(int64(u), 2)
}

func (u *Int2) UnmarshalTLB(c *boc.Cell, decoder *Decoder) error {
	v, err := c.ReadInt(2)
	*u = Int2(v)
	return err
}

func (u Int2) FixedSize() int {
	return 2
}

func (u Int2) Equal(other any) bool {
	otherInt, ok := other.(Int2)
	if !ok {
		return false
	}
	return u == otherInt
}
func (u Int2) MarshalJSON() ([]byte, error) {
	return []byte(fmt.Sprintf("%d", u)), nil
}

func (u *Int2) UnmarshalJSON(p []byte) error {
	value, err := strconv.ParseInt(strings.Trim(string(p), "\""), 10, 2)
	if err != nil {
		return err
	}
	*u = Int2(value)
	return nil
}

type Uint3 uint8

func (u Uint3) MarshalTLB(c *boc.Cell, encoder *Encoder) error {
	return c.WriteUint(uint64(u), 3)
}

func (u *Uint3) UnmarshalTLB(c *boc.Cell, decoder *Decoder) error {
	v, err := c.ReadUint(3)
	*u = Uint3(v)
	return err
}

func (u Uint3) FixedSize() int {
	return 3
}

func (u Uint3) Equal(other any) bool {
	otherInt, ok := other.(Uint3)
	if !ok {
		return false
	}
	return u == otherInt
}
func (u Uint3) MarshalJSON() ([]byte, error) {
	return []byte(fmt.Sprintf("%d", u)), nil
}

func (u *Uint3) UnmarshalJSON(p []byte) error {
	value, err := strconv.ParseUint(strings.Trim(string(p), "\""), 10, 3)
	if err != nil {
		return err
	}
	*u = Uint3(value)
	return nil
}

type Int3 int8

func (u Int3) MarshalTLB(c *boc.Cell, encoder *Encoder) error {
	return c.WriteInt(int64(u), 3)
}

func (u *Int3) UnmarshalTLB(c *boc.Cell, decoder *Decoder) error {
	v, err := c.ReadInt(3)
	*u = Int3(v)
	return err
}

func (u Int3) FixedSize() int {
	return 3
}

func (u Int3) Equal(other any) bool {
	otherInt, ok := other.(Int3)
	if !ok {
		return false
	}
	return u == otherInt
}
func (u Int3) MarshalJSON() ([]byte, error) {
	return []byte(fmt.Sprintf("%d", u)), nil
}

func (u *Int3) UnmarshalJSON(p []byte) error {
	value, err := strconv.ParseInt(strings.Trim(string(p), "\""), 10, 3)
	if err != nil {
		return err
	}
	*u = Int3(value)
	return nil
}

type Uint4 uint8

func (u Uint4) MarshalTLB(c *boc.Cell, encoder *Encoder) error {
	return c.WriteUint(uint64(u), 4)
}

func (u *Uint4) UnmarshalTLB(c *boc.Cell, decoder *Decoder) error {
	v, err := c.ReadUint(4)
	*u = Uint4(v)
	return err
}

func (u Uint4) FixedSize() int {
	return 4
}

func (u Uint4) Equal(other any) bool {
	otherInt, ok := other.(Uint4)
	if !ok {
		return false
	}
	return u == otherInt
}
func (u Uint4) MarshalJSON() ([]byte, error) {
	return []byte(fmt.Sprintf("%d", u)), nil
}

func (u *Uint4) UnmarshalJSON(p []byte) error {
	value, err := strconv.ParseUint(strings.Trim(string(p), "\""), 10, 4)
	if err != nil {
		return err
	}
	*u = Uint4(value)
	return nil
}

type Int4 int8

func (u Int4) MarshalTLB(c *boc.Cell, encoder *Encoder) error {
	return c.WriteInt(int64(u), 4)
}

func (u *Int4) UnmarshalTLB(c *boc.Cell, decoder *Decoder) error {
	v, err := c.ReadInt(4)
	*u = Int4(v)
	return err
}

func (u Int4) FixedSize() int {
	return 4
}

func (u Int4) Equal(other any) bool {
	otherInt, ok := other.(Int4)
	if !ok {
		return false
	}
	return u == otherInt
}
func (u Int4) MarshalJSON() ([]byte, error) {
	return []byte(fmt.Sprintf("%d", u)), nil
}

func (u *Int4) UnmarshalJSON(p []byte) error {
	value, err := strconv.ParseInt(strings.Trim(string(p), "\""), 10, 4)
	if err != nil {
		return err
	}
	*u = Int4(value)
	return nil
}

type Uint5 uint8

func (u Uint5) MarshalTLB(c *boc.Cell, encoder *Encoder) error {
	return c.WriteUint(uint64(u), 5)
}

func (u *Uint5) UnmarshalTLB(c *boc.Cell, decoder *Decoder) error {
	v, err := c.ReadUint(5)
	*u = Uint5(v)
	return err
}

func (u Uint5) FixedSize() int {
	return 5
}

func (u Uint5) Equal(other any) bool {
	otherInt, ok := other.(Uint5)
	if !ok {
		return false
	}
	return u == otherInt
}
func (u Uint5) MarshalJSON() ([]byte, error) {
	return []byte(fmt.Sprintf("%d", u)), nil
}

func (u *Uint5) UnmarshalJSON(p []byte) error {
	value, err := strconv.ParseUint(strings.Trim(string(p), "\""), 10, 5)
	if err != nil {
		return err
	}
	*u = Uint5(value)
	return nil
}

type Int5 int8

func (u Int5) MarshalTLB(c *boc.Cell, encoder *Encoder) error {
	return c.WriteInt(int64(u), 5)
}

func (u *Int5) UnmarshalTLB(c *boc.Cell, decoder *Decoder) error {
	v, err := c.ReadInt(5)
	*u = Int5(v)
	return err
}

func (u Int5) FixedSize() int {
	return 5
}

func (u Int5) Equal(other any) bool {
	otherInt, ok := other.(Int5)
	if !ok {
		return false
	}
	return u == otherInt
}
func (u Int5) MarshalJSON() ([]byte, error) {
	return []byte(fmt.Sprintf("%d", u)), nil
}

func (u *Int5) UnmarshalJSON(p []byte) error {
	value, err := strconv.ParseInt(strings.Trim(string(p), "\""), 10, 5)
	if err != nil {
		return err
	}
	*u = Int5(value)
	return nil
}

type Uint6 uint8

func (u Uint6) MarshalTLB(c *boc.Cell, encoder *Encoder) error {
	return c.WriteUint(uint64(u), 6)
}

func (u *Uint6) UnmarshalTLB(c *boc.Cell, decoder *Decoder) error {
	v, err := c.ReadUint(6)
	*u = Uint6(v)
	return err
}

func (u Uint6) FixedSize() int {
	return 6
}

func (u Uint6) Equal(other any) bool {
	otherInt, ok := other.(Uint6)
	if !ok {
		return false
	}
	return u == otherInt
}
func (u Uint6) MarshalJSON() ([]byte, error) {
	return []byte(fmt.Sprintf("%d", u)), nil
}

func (u *Uint6) UnmarshalJSON(p []byte) error {
	value, err := strconv.ParseUint(strings.Trim(string(p), "\""), 10, 6)
	if err != nil {
		return err
	}
	*u = Uint6(value)
	return nil
}

type Int6 int8

func (u Int6) MarshalTLB(c *boc.Cell, encoder *Encoder) error {
	return c.WriteInt(int64(u), 6)
}

func (u *Int6) UnmarshalTLB(c *boc.Cell, decoder *Decoder) error {
	v, err := c.ReadInt(6)
	*u = Int6(v)
	return err
}

func (u Int6) FixedSize() int {
	return 6
}

func (u Int6) Equal(other any) bool {
	otherInt, ok := other.(Int6)
	if !ok {
		return false
	}
	return u == otherInt
}
func (u Int6) MarshalJSON() ([]byte, error) {
	return []byte(fmt.Sprintf("%d", u)), nil
}

func (u *Int6) UnmarshalJSON(p []byte) error {
	value, err := strconv.ParseInt(strings.Trim(string(p), "\""), 10, 6)
	if err != nil {
		return err
	}
	*u = Int6(value)
	return nil
}

type Uint7 uint8

func (u Uint7) MarshalTLB(c *boc.Cell, encoder *Encoder) error {
	return c.WriteUint(uint64(u), 7)
}

func (u *Uint7) UnmarshalTLB(c *boc.Cell, decoder *Decoder) error {
	v, err := c.ReadUint(7)
	*u = Uint7(v)
	return err
}

func (u Uint7) FixedSize() int {
	return 7
}

func (u Uint7) Equal(other any) bool {
	otherInt, ok := other.(Uint7)
	if !ok {
		return false
	}
	return u == otherInt
}
func (u Uint7) MarshalJSON() ([]byte, error) {
	return []byte(fmt.Sprintf("%d", u)), nil
}

func (u *Uint7) UnmarshalJSON(p []byte) error {
	value, err := strconv.ParseUint(strings.Trim(string(p), "\""), 10, 7)
	if err != nil {
		return err
	}
	*u = Uint7(value)
	return nil
}

type Int7 int8

func (u Int7) MarshalTLB(c *boc.Cell, encoder *Encoder) error {
	return c.WriteInt(int64(u), 7)
}

func (u *Int7) UnmarshalTLB(c *boc.Cell, decoder *Decoder) error {
	v, err := c.ReadInt(7)
	*u = Int7(v)
	return err
}

func (u Int7) FixedSize() int {
	return 7
}

func (u Int7) Equal(other any) bool {
	otherInt, ok := other.(Int7)
	if !ok {
		return false
	}
	return u == otherInt
}
func (u Int7) MarshalJSON() ([]byte, error) {
	return []byte(fmt.Sprintf("%d", u)), nil
}

func (u *Int7) UnmarshalJSON(p []byte) error {
	value, err := strconv.ParseInt(strings.Trim(string(p), "\""), 10, 7)
	if err != nil {
		return err
	}
	*u = Int7(value)
	return nil
}

type Uint8 uint8

func (u Uint8) MarshalTLB(c *boc.Cell, encoder *Encoder) error {
	return c.WriteUint(uint64(u), 8)
}

func (u *Uint8) UnmarshalTLB(c *boc.Cell, decoder *Decoder) error {
	v, err := c.ReadUint(8)
	*u = Uint8(v)
	return err
}

func (u Uint8) FixedSize() int {
	return 8
}

func (u Uint8) Equal(other any) bool {
	otherInt, ok := other.(Uint8)
	if !ok {
		return false
	}
	return u == otherInt
}
func (u Uint8) MarshalJSON() ([]byte, error) {
	return []byte(fmt.Sprintf("%d", u)), nil
}

func (u *Uint8) UnmarshalJSON(p []byte) error {
	value, err := strconv.ParseUint(strings.Trim(string(p), "\""), 10, 8)
	if err != nil {
		return err
	}
	*u = Uint8(value)
	return nil
}

type Int8 int8

func (u Int8) MarshalTLB(c *boc.Cell, encoder *Encoder) error {
	return c.WriteInt(int64(u), 8)
}

func (u *Int8) UnmarshalTLB(c *boc.Cell, decoder *Decoder) error {
	v, err := c.ReadInt(8)
	*u = Int8(v)
	return err
}

func (u Int8) FixedSize() int {
	return 8
}

func (u Int8) Equal(other any) bool {
	otherInt, ok := other.(Int8)
	if !ok {
		return false
	}
	return u == otherInt
}
func (u Int8) MarshalJSON() ([]byte, error) {
	return []byte(fmt.Sprintf("%d", u)), nil
}

func (u *Int8) UnmarshalJSON(p []byte) error {
	value, err := strconv.ParseInt(strings.Trim(string(p), "\""), 10, 8)
	if err != nil {
		return err
	}
	*u = Int8(value)
	return nil
}

type Uint9 uint16

func (u Uint9) MarshalTLB(c *boc.Cell, encoder *Encoder) error {
	return c.WriteUint(uint64(u), 9)
}

func (u *Uint9) UnmarshalTLB(c *boc.Cell, decoder *Decoder) error {
	v, err := c.ReadUint(9)
	*u = Uint9(v)
	return err
}

func (u Uint9) FixedSize() int {
	return 9
}

func (u Uint9) Equal(other any) bool {
	otherInt, ok := other.(Uint9)
	if !ok {
		return false
	}
	return u == otherInt
}
func (u Uint9) MarshalJSON() ([]byte, error) {
	return []byte(fmt.Sprintf("%d", u)), nil
}

func (u *Uint9) UnmarshalJSON(p []byte) error {
	value, err := strconv.ParseUint(strings.Trim(string(p), "\""), 10, 9)
	if err != nil {
		return err
	}
	*u = Uint9(value)
	return nil
}

type Int9 int16

func (u Int9) MarshalTLB(c *boc.Cell, encoder *Encoder) error {
	return c.WriteInt(int64(u), 9)
}

func (u *Int9) UnmarshalTLB(c *boc.Cell, decoder *Decoder) error {
	v, err := c.ReadInt(9)
	*u = Int9(v)
	return err
}

func (u Int9) FixedSize() int {
	return 9
}

func (u Int9) Equal(other any) bool {
	otherInt, ok := other.(Int9)
	if !ok {
		return false
	}
	return u == otherInt
}
func (u Int9) MarshalJSON() ([]byte, error) {
	return []byte(fmt.Sprintf("%d", u)), nil
}

func (u *Int9) UnmarshalJSON(p []byte) error {
	value, err := strconv.ParseInt(strings.Trim(string(p), "\""), 10, 9)
	if err != nil {
		return err
	}
	*u = Int9(value)
	return nil
}

type Uint10 uint16

func (u Uint10) MarshalTLB(c *boc.Cell, encoder *Encoder) error {
	return c.WriteUint(uint64(u), 10)
}

func (u *Uint10) UnmarshalTLB(c *boc.Cell, decoder *Decoder) error {
	v, err := c.ReadUint(10)
	*u = Uint10(v)
	return err
}

func (u Uint10) FixedSize() int {
	return 10
}

func (u Uint10) Equal(other any) bool {
	otherInt, ok := other.(Uint10)
	if !ok {
		return false
	}
	return u == otherInt
}
func (u Uint10) MarshalJSON() ([]byte, error) {
	return []byte(fmt.Sprintf("%d", u)), nil
}

func (u *Uint10) UnmarshalJSON(p []byte) error {
	value, err := strconv.ParseUint(strings.Trim(string(p), "\""), 10, 10)
	if err != nil {
		return err
	}
	*u = Uint10(value)
	return nil
}

type Int10 int16

func (u Int10) MarshalTLB(c *boc.Cell, encoder *Encoder) error {
	return c.WriteInt(int64(u), 10)
}

func (u *Int10) UnmarshalTLB(c *boc.Cell, decoder *Decoder) error {
	v, err := c.ReadInt(10)
	*u = Int10(v)
	return err
}

func (u Int10) FixedSize() int {
	return 10
}

func (u Int10) Equal(other any) bool {
	otherInt, ok := other.(Int10)
	if !ok {
		return false
	}
	return u == otherInt
}
func (u Int10) MarshalJSON() ([]byte, error) {
	return []byte(fmt.Sprintf("%d", u)), nil
}

func (u *Int10) UnmarshalJSON(p []byte) error {
	value, err := strconv.ParseInt(strings.Trim(string(p), "\""), 10, 10)
	if err != nil {
		return err
	}
	*u = Int10(value)
	return nil
}

type Uint11 uint16

func (u Uint11) MarshalTLB(c *boc.Cell, encoder *Encoder) error {
	return c.WriteUint(uint64(u), 11)
}

func (u *Uint11) UnmarshalTLB(c *boc.Cell, decoder *Decoder) error {
	v, err := c.ReadUint(11)
	*u = Uint11(v)
	return err
}

func (u Uint11) FixedSize() int {
	return 11
}

func (u Uint11) Equal(other any) bool {
	otherInt, ok := other.(Uint11)
	if !ok {
		return false
	}
	return u == otherInt
}
func (u Uint11) MarshalJSON() ([]byte, error) {
	return []byte(fmt.Sprintf("%d", u)), nil
}

func (u *Uint11) UnmarshalJSON(p []byte) error {
	value, err := strconv.ParseUint(strings.Trim(string(p), "\""), 10, 11)
	if err != nil {
		return err
	}
	*u = Uint11(value)
	return nil
}

type Int11 int16

func (u Int11) MarshalTLB(c *boc.Cell, encoder *Encoder) error {
	return c.WriteInt(int64(u), 11)
}

func (u *Int11) UnmarshalTLB(c *boc.Cell, decoder *Decoder) error {
	v, err := c.ReadInt(11)
	*u = Int11(v)
	return err
}

func (u Int11) FixedSize() int {
	return 11
}

func (u Int11) Equal(other any) bool {
	otherInt, ok := other.(Int11)
	if !ok {
		return false
	}
	return u == otherInt
}
func (u Int11) MarshalJSON() ([]byte, error) {
	return []byte(fmt.Sprintf("%d", u)), nil
}

func (u *Int11) UnmarshalJSON(p []byte) error {
	value, err := strconv.ParseInt(strings.Trim(string(p), "\""), 10, 11)
	if err != nil {
		return err
	}
	*u = Int11(value)
	return nil
}

type Uint12 uint16

func (u Uint12) MarshalTLB(c *boc.Cell, encoder *Encoder) error {
	return c.WriteUint(uint64(u), 12)
}

func (u *Uint12) UnmarshalTLB(c *boc.Cell, decoder *Decoder) error {
	v, err := c.ReadUint(12)
	*u = Uint12(v)
	return err
}

func (u Uint12) FixedSize() int {
	return 12
}

func (u Uint12) Equal(other any) bool {
	otherInt, ok := other.(Uint12)
	if !ok {
		return false
	}
	return u == otherInt
}
func (u Uint12) MarshalJSON() ([]byte, error) {
	return []byte(fmt.Sprintf("%d", u)), nil
}

func (u *Uint12) UnmarshalJSON(p []byte) error {
	value, err := strconv.ParseUint(strings.Trim(string(p), "\""), 10, 12)
	if err != nil {
		return err
	}
	*u = Uint12(value)
	return nil
}

type Int12 int16

func (u Int12) MarshalTLB(c *boc.Cell, encoder *Encoder) error {
	return c.WriteInt(int64(u), 12)
}

func (u *Int12) UnmarshalTLB(c *boc.Cell, decoder *Decoder) error {
	v, err := c.ReadInt(12)
	*u = Int12(v)
	return err
}

func (u Int12) FixedSize() int {
	return 12
}

func (u Int12) Equal(other any) bool {
	otherInt, ok := other.(Int12)
	if !ok {
		return false
	}
	return u == otherInt
}
func (u Int12) MarshalJSON() ([]byte, error) {
	return []byte(fmt.Sprintf("%d", u)), nil
}

func (u *Int12) UnmarshalJSON(p []byte) error {
	value, err := strconv.ParseInt(strings.Trim(string(p), "\""), 10, 12)
	if err != nil {
		return err
	}
	*u = Int12(value)
	return nil
}

type Uint13 uint16

func (u Uint13) MarshalTLB(c *boc.Cell, encoder *Encoder) error {
	return c.WriteUint(uint64(u), 13)
}

func (u *Uint13) UnmarshalTLB(c *boc.Cell, decoder *Decoder) error {
	v, err := c.ReadUint(13)
	*u = Uint13(v)
	return err
}

func (u Uint13) FixedSize() int {
	return 13
}

func (u Uint13) Equal(other any) bool {
	otherInt, ok := other.(Uint13)
	if !ok {
		return false
	}
	return u == otherInt
}
func (u Uint13) MarshalJSON() ([]byte, error) {
	return []byte(fmt.Sprintf("%d", u)), nil
}

func (u *Uint13) UnmarshalJSON(p []byte) error {
	value, err := strconv.ParseUint(strings.Trim(string(p), "\""), 10, 13)
	if err != nil {
		return err
	}
	*u = Uint13(value)
	return nil
}

type Int13 int16

func (u Int13) MarshalTLB(c *boc.Cell, encoder *Encoder) error {
	return c.WriteInt(int64(u), 13)
}

func (u *Int13) UnmarshalTLB(c *boc.Cell, decoder *Decoder) error {
	v, err := c.ReadInt(13)
	*u = Int13(v)
	return err
}

func (u Int13) FixedSize() int {
	return 13
}

func (u Int13) Equal(other any) bool {
	otherInt, ok := other.(Int13)
	if !ok {
		return false
	}
	return u == otherInt
}
func (u Int13) MarshalJSON() ([]byte, error) {
	return []byte(fmt.Sprintf("%d", u)), nil
}

func (u *Int13) UnmarshalJSON(p []byte) error {
	value, err := strconv.ParseInt(strings.Trim(string(p), "\""), 10, 13)
	if err != nil {
		return err
	}
	*u = Int13(value)
	return nil
}

type Uint14 uint16

func (u Uint14) MarshalTLB(c *boc.Cell, encoder *Encoder) error {
	return c.WriteUint(uint64(u), 14)
}

func (u *Uint14) UnmarshalTLB(c *boc.Cell, decoder *Decoder) error {
	v, err := c.ReadUint(14)
	*u = Uint14(v)
	return err
}

func (u Uint14) FixedSize() int {
	return 14
}

func (u Uint14) Equal(other any) bool {
	otherInt, ok := other.(Uint14)
	if !ok {
		return false
	}
	return u == otherInt
}
func (u Uint14) MarshalJSON() ([]byte, error) {
	return []byte(fmt.Sprintf("%d", u)), nil
}

func (u *Uint14) UnmarshalJSON(p []byte) error {
	value, err := strconv.ParseUint(strings.Trim(string(p), "\""), 10, 14)
	if err != nil {
		return err
	}
	*u = Uint14(value)
	return nil
}

type Int14 int16

func (u Int14) MarshalTLB(c *boc.Cell, encoder *Encoder) error {
	return c.WriteInt(int64(u), 14)
}

func (u *Int14) UnmarshalTLB(c *boc.Cell, decoder *Decoder) error {
	v, err := c.ReadInt(14)
	*u = Int14(v)
	return err
}

func (u Int14) FixedSize() int {
	return 14
}

func (u Int14) Equal(other any) bool {
	otherInt, ok := other.(Int14)
	if !ok {
		return false
	}
	return u == otherInt
}
func (u Int14) MarshalJSON() ([]byte, error) {
	return []byte(fmt.Sprintf("%d", u)), nil
}

func (u *Int14) UnmarshalJSON(p []byte) error {
	value, err := strconv.ParseInt(strings.Trim(string(p), "\""), 10, 14)
	if err != nil {
		return err
	}
	*u = Int14(value)
	return nil
}

type Uint15 uint16

func (u Uint15) MarshalTLB(c *boc.Cell, encoder *Encoder) error {
	return c.WriteUint(uint64(u), 15)
}

func (u *Uint15) UnmarshalTLB(c *boc.Cell, decoder *Decoder) error {
	v, err := c.ReadUint(15)
	*u = Uint15(v)
	return err
}

func (u Uint15) FixedSize() int {
	return 15
}

func (u Uint15) Equal(other any) bool {
	otherInt, ok := other.(Uint15)
	if !ok {
		return false
	}
	return u == otherInt
}
func (u Uint15) MarshalJSON() ([]byte, error) {
	return []byte(fmt.Sprintf("%d", u)), nil
}

func (u *Uint15) UnmarshalJSON(p []byte) error {
	value, err := strconv.ParseUint(strings.Trim(string(p), "\""), 10, 15)
	if err != nil {
		return err
	}
	*u = Uint15(value)
	return nil
}

type Int15 int16

func (u Int15) MarshalTLB(c *boc.Cell, encoder *Encoder) error {
	return c.WriteInt(int64(u), 15)
}

func (u *Int15) UnmarshalTLB(c *boc.Cell, decoder *Decoder) error {
	v, err := c.ReadInt(15)
	*u = Int15(v)
	return err
}

func (u Int15) FixedSize() int {
	return 15
}

func (u Int15) Equal(other any) bool {
	otherInt, ok := other.(Int15)
	if !ok {
		return false
	}
	return u == otherInt
}
func (u Int15) MarshalJSON() ([]byte, error) {
	return []byte(fmt.Sprintf("%d", u)), nil
}

func (u *Int15) UnmarshalJSON(p []byte) error {
	value, err := strconv.ParseInt(strings.Trim(string(p), "\""), 10, 15)
	if err != nil {
		return err
	}
	*u = Int15(value)
	return nil
}

type Uint16 uint16

func (u Uint16) MarshalTLB(c *boc.Cell, encoder *Encoder) error {
	return c.WriteUint(uint64(u), 16)
}

func (u *Uint16) UnmarshalTLB(c *boc.Cell, decoder *Decoder) error {
	v, err := c.ReadUint(16)
	*u = Uint16(v)
	return err
}

func (u Uint16) FixedSize() int {
	return 16
}

func (u Uint16) Equal(other any) bool {
	otherInt, ok := other.(Uint16)
	if !ok {
		return false
	}
	return u == otherInt
}
func (u Uint16) MarshalJSON() ([]byte, error) {
	return []byte(fmt.Sprintf("%d", u)), nil
}

func (u *Uint16) UnmarshalJSON(p []byte) error {
	value, err := strconv.ParseUint(strings.Trim(string(p), "\""), 10, 16)
	if err != nil {
		return err
	}
	*u = Uint16(value)
	return nil
}

type Int16 int16

func (u Int16) MarshalTLB(c *boc.Cell, encoder *Encoder) error {
	return c.WriteInt(int64(u), 16)
}

func (u *Int16) UnmarshalTLB(c *boc.Cell, decoder *Decoder) error {
	v, err := c.ReadInt(16)
	*u = Int16(v)
	return err
}

func (u Int16) FixedSize() int {
	return 16
}

func (u Int16) Equal(other any) bool {
	otherInt, ok := other.(Int16)
	if !ok {
		return false
	}
	return u == otherInt
}
func (u Int16) MarshalJSON() ([]byte, error) {
	return []byte(fmt.Sprintf("%d", u)), nil
}

func (u *Int16) UnmarshalJSON(p []byte) error {
	value, err := strconv.ParseInt(strings.Trim(string(p), "\""), 10, 16)
	if err != nil {
		return err
	}
	*u = Int16(value)
	return nil
}

type Uint17 uint32

func (u Uint17) MarshalTLB(c *boc.Cell, encoder *Encoder) error {
	return c.WriteUint(uint64(u), 17)
}

func (u *Uint17) UnmarshalTLB(c *boc.Cell, decoder *Decoder) error {
	v, err := c.ReadUint(17)
	*u = Uint17(v)
	return err
}

func (u Uint17) FixedSize() int {
	return 17
}

func (u Uint17) Equal(other any) bool {
	otherInt, ok := other.(Uint17)
	if !ok {
		return false
	}
	return u == otherInt
}
func (u Uint17) MarshalJSON() ([]byte, error) {
	return []byte(fmt.Sprintf("%d", u)), nil
}

func (u *Uint17) UnmarshalJSON(p []byte) error {
	value, err := strconv.ParseUint(strings.Trim(string(p), "\""), 10, 17)
	if err != nil {
		return err
	}
	*u = Uint17(value)
	return nil
}

type Int17 int32

func (u Int17) MarshalTLB(c *boc.Cell, encoder *Encoder) error {
	return c.WriteInt(int64(u), 17)
}

func (u *Int17) UnmarshalTLB(c *boc.Cell, decoder *Decoder) error {
	v, err := c.ReadInt(17)
	*u = Int17(v)
	return err
}

func (u Int17) FixedSize() int {
	return 17
}

func (u Int17) Equal(other any) bool {
	otherInt, ok := other.(Int17)
	if !ok {
		return false
	}
	return u == otherInt
}
func (u Int17) MarshalJSON() ([]byte, error) {
	return []byte(fmt.Sprintf("%d", u)), nil
}

func (u *Int17) UnmarshalJSON(p []byte) error {
	value, err := strconv.ParseInt(strings.Trim(string(p), "\""), 10, 17)
	if err != nil {
		return err
	}
	*u = Int17(value)
	return nil
}

type Uint18 uint32

func (u Uint18) MarshalTLB(c *boc.Cell, encoder *Encoder) error {
	return c.WriteUint(uint64(u), 18)
}

func (u *Uint18) UnmarshalTLB(c *boc.Cell, decoder *Decoder) error {
	v, err := c.ReadUint(18)
	*u = Uint18(v)
	return err
}

func (u Uint18) FixedSize() int {
	return 18
}

func (u Uint18) Equal(other any) bool {
	otherInt, ok := other.(Uint18)
	if !ok {
		return false
	}
	return u == otherInt
}
func (u Uint18) MarshalJSON() ([]byte, error) {
	return []byte(fmt.Sprintf("%d", u)), nil
}

func (u *Uint18) UnmarshalJSON(p []byte) error {
	value, err := strconv.ParseUint(strings.Trim(string(p), "\""), 10, 18)
	if err != nil {
		return err
	}
	*u = Uint18(value)
	return nil
}

type Int18 int32

func (u Int18) MarshalTLB(c *boc.Cell, encoder *Encoder) error {
	return c.WriteInt(int64(u), 18)
}

func (u *Int18) UnmarshalTLB(c *boc.Cell, decoder *Decoder) error {
	v, err := c.ReadInt(18)
	*u = Int18(v)
	return err
}

func (u Int18) FixedSize() int {
	return 18
}

func (u Int18) Equal(other any) bool {
	otherInt, ok := other.(Int18)
	if !ok {
		return false
	}
	return u == otherInt
}
func (u Int18) MarshalJSON() ([]byte, error) {
	return []byte(fmt.Sprintf("%d", u)), nil
}

func (u *Int18) UnmarshalJSON(p []byte) error {
	value, err := strconv.ParseInt(strings.Trim(string(p), "\""), 10, 18)
	if err != nil {
		return err
	}
	*u = Int18(value)
	return nil
}

type Uint19 uint32

func (u Uint19) MarshalTLB(c *boc.Cell, encoder *Encoder) error {
	return c.WriteUint(uint64(u), 19)
}

func (u *Uint19) UnmarshalTLB(c *boc.Cell, decoder *Decoder) error {
	v, err := c.ReadUint(19)
	*u = Uint19(v)
	return err
}

func (u Uint19) FixedSize() int {
	return 19
}

func (u Uint19) Equal(other any) bool {
	otherInt, ok := other.(Uint19)
	if !ok {
		return false
	}
	return u == otherInt
}
func (u Uint19) MarshalJSON() ([]byte, error) {
	return []byte(fmt.Sprintf("%d", u)), nil
}

func (u *Uint19) UnmarshalJSON(p []byte) error {
	value, err := strconv.ParseUint(strings.Trim(string(p), "\""), 10, 19)
	if err != nil {
		return err
	}
	*u = Uint19(value)
	return nil
}

type Int19 int32

func (u Int19) MarshalTLB(c *boc.Cell, encoder *Encoder) error {
	return c.WriteInt(int64(u), 19)
}

func (u *Int19) UnmarshalTLB(c *boc.Cell, decoder *Decoder) error {
	v, err := c.ReadInt(19)
	*u = Int19(v)
	return err
}

func (u Int19) FixedSize() int {
	return 19
}

func (u Int19) Equal(other any) bool {
	otherInt, ok := other.(Int19)
	if !ok {
		return false
	}
	return u == otherInt
}
func (u Int19) MarshalJSON() ([]byte, error) {
	return []byte(fmt.Sprintf("%d", u)), nil
}

func (u *Int19) UnmarshalJSON(p []byte) error {
	value, err := strconv.ParseInt(strings.Trim(string(p), "\""), 10, 19)
	if err != nil {
		return err
	}
	*u = Int19(value)
	return nil
}

type Uint20 uint32

func (u Uint20) MarshalTLB(c *boc.Cell, encoder *Encoder) error {
	return c.WriteUint(uint64(u), 20)
}

func (u *Uint20) UnmarshalTLB(c *boc.Cell, decoder *Decoder) error {
	v, err := c.ReadUint(20)
	*u = Uint20(v)
	return err
}

func (u Uint20) FixedSize() int {
	return 20
}

func (u Uint20) Equal(other any) bool {
	otherInt, ok := other.(Uint20)
	if !ok {
		return false
	}
	return u == otherInt
}
func (u Uint20) MarshalJSON() ([]byte, error) {
	return []byte(fmt.Sprintf("%d", u)), nil
}

func (u *Uint20) UnmarshalJSON(p []byte) error {
	value, err := strconv.ParseUint(strings.Trim(string(p), "\""), 10, 20)
	if err != nil {
		return err
	}
	*u = Uint20(value)
	return nil
}

type Int20 int32

func (u Int20) MarshalTLB(c *boc.Cell, encoder *Encoder) error {
	return c.WriteInt(int64(u), 20)
}

func (u *Int20) UnmarshalTLB(c *boc.Cell, decoder *Decoder) error {
	v, err := c.ReadInt(20)
	*u = Int20(v)
	return err
}

func (u Int20) FixedSize() int {
	return 20
}

func (u Int20) Equal(other any) bool {
	otherInt, ok := other.(Int20)
	if !ok {
		return false
	}
	return u == otherInt
}
func (u Int20) MarshalJSON() ([]byte, error) {
	return []byte(fmt.Sprintf("%d", u)), nil
}

func (u *Int20) UnmarshalJSON(p []byte) error {
	value, err := strconv.ParseInt(strings.Trim(string(p), "\""), 10, 20)
	if err != nil {
		return err
	}
	*u = Int20(value)
	return nil
}

type Uint21 uint32

func (u Uint21) MarshalTLB(c *boc.Cell, encoder *Encoder) error {
	return c.WriteUint(uint64(u), 21)
}

func (u *Uint21) UnmarshalTLB(c *boc.Cell, decoder *Decoder) error {
	v, err := c.ReadUint(21)
	*u = Uint21(v)
	return err
}

func (u Uint21) FixedSize() int {
	return 21
}

func (u Uint21) Equal(other any) bool {
	otherInt, ok := other.(Uint21)
	if !ok {
		return false
	}
	return u == otherInt
}
func (u Uint21) MarshalJSON() ([]byte, error) {
	return []byte(fmt.Sprintf("%d", u)), nil
}

func (u *Uint21) UnmarshalJSON(p []byte) error {
	value, err := strconv.ParseUint(strings.Trim(string(p), "\""), 10, 21)
	if err != nil {
		return err
	}
	*u = Uint21(value)
	return nil
}

type Int21 int32

func (u Int21) MarshalTLB(c *boc.Cell, encoder *Encoder) error {
	return c.WriteInt(int64(u), 21)
}

func (u *Int21) UnmarshalTLB(c *boc.Cell, decoder *Decoder) error {
	v, err := c.ReadInt(21)
	*u = Int21(v)
	return err
}

func (u Int21) FixedSize() int {
	return 21
}

func (u Int21) Equal(other any) bool {
	otherInt, ok := other.(Int21)
	if !ok {
		return false
	}
	return u == otherInt
}
func (u Int21) MarshalJSON() ([]byte, error) {
	return []byte(fmt.Sprintf("%d", u)), nil
}

func (u *Int21) UnmarshalJSON(p []byte) error {
	value, err := strconv.ParseInt(strings.Trim(string(p), "\""), 10, 21)
	if err != nil {
		return err
	}
	*u = Int21(value)
	return nil
}

type Uint22 uint32

func (u Uint22) MarshalTLB(c *boc.Cell, encoder *Encoder) error {
	return c.WriteUint(uint64(u), 22)
}

func (u *Uint22) UnmarshalTLB(c *boc.Cell, decoder *Decoder) error {
	v, err := c.ReadUint(22)
	*u = Uint22(v)
	return err
}

func (u Uint22) FixedSize() int {
	return 22
}

func (u Uint22) Equal(other any) bool {
	otherInt, ok := other.(Uint22)
	if !ok {
		return false
	}
	return u == otherInt
}
func (u Uint22) MarshalJSON() ([]byte, error) {
	return []byte(fmt.Sprintf("%d", u)), nil
}

func (u *Uint22) UnmarshalJSON(p []byte) error {
	value, err := strconv.ParseUint(strings.Trim(string(p), "\""), 10, 22)
	if err != nil {
		return err
	}
	*u = Uint22(value)
	return nil
}

type Int22 int32

func (u Int22) MarshalTLB(c *boc.Cell, encoder *Encoder) error {
	return c.WriteInt(int64(u), 22)
}

func (u *Int22) UnmarshalTLB(c *boc.Cell, decoder *Decoder) error {
	v, err := c.ReadInt(22)
	*u = Int22(v)
	return err
}

func (u Int22) FixedSize() int {
	return 22
}

func (u Int22) Equal(other any) bool {
	otherInt, ok := other.(Int22)
	if !ok {
		return false
	}
	return u == otherInt
}
func (u Int22) MarshalJSON() ([]byte, error) {
	return []byte(fmt.Sprintf("%d", u)), nil
}

func (u *Int22) UnmarshalJSON(p []byte) error {
	value, err := strconv.ParseInt(strings.Trim(string(p), "\""), 10, 22)
	if err != nil {
		return err
	}
	*u = Int22(value)
	return nil
}

type Uint23 uint32

func (u Uint23) MarshalTLB(c *boc.Cell, encoder *Encoder) error {
	return c.WriteUint(uint64(u), 23)
}

func (u *Uint23) UnmarshalTLB(c *boc.Cell, decoder *Decoder) error {
	v, err := c.ReadUint(23)
	*u = Uint23(v)
	return err
}

func (u Uint23) FixedSize() int {
	return 23
}

func (u Uint23) Equal(other any) bool {
	otherInt, ok := other.(Uint23)
	if !ok {
		return false
	}
	return u == otherInt
}
func (u Uint23) MarshalJSON() ([]byte, error) {
	return []byte(fmt.Sprintf("%d", u)), nil
}

func (u *Uint23) UnmarshalJSON(p []byte) error {
	value, err := strconv.ParseUint(strings.Trim(string(p), "\""), 10, 23)
	if err != nil {
		return err
	}
	*u = Uint23(value)
	return nil
}

type Int23 int32

func (u Int23) MarshalTLB(c *boc.Cell, encoder *Encoder) error {
	return c.WriteInt(int64(u), 23)
}

func (u *Int23) UnmarshalTLB(c *boc.Cell, decoder *Decoder) error {
	v, err := c.ReadInt(23)
	*u = Int23(v)
	return err
}

func (u Int23) FixedSize() int {
	return 23
}

func (u Int23) Equal(other any) bool {
	otherInt, ok := other.(Int23)
	if !ok {
		return false
	}
	return u == otherInt
}
func (u Int23) MarshalJSON() ([]byte, error) {
	return []byte(fmt.Sprintf("%d", u)), nil
}

func (u *Int23) UnmarshalJSON(p []byte) error {
	value, err := strconv.ParseInt(strings.Trim(string(p), "\""), 10, 23)
	if err != nil {
		return err
	}
	*u = Int23(value)
	return nil
}

type Uint24 uint32

func (u Uint24) MarshalTLB(c *boc.Cell, encoder *Encoder) error {
	return c.WriteUint(uint64(u), 24)
}

func (u *Uint24) UnmarshalTLB(c *boc.Cell, decoder *Decoder) error {
	v, err := c.ReadUint(24)
	*u = Uint24(v)
	return err
}

func (u Uint24) FixedSize() int {
	return 24
}

func (u Uint24) Equal(other any) bool {
	otherInt, ok := other.(Uint24)
	if !ok {
		return false
	}
	return u == otherInt
}
func (u Uint24) MarshalJSON() ([]byte, error) {
	return []byte(fmt.Sprintf("%d", u)), nil
}

func (u *Uint24) UnmarshalJSON(p []byte) error {
	value, err := strconv.ParseUint(strings.Trim(string(p), "\""), 10, 24)
	if err != nil {
		return err
	}
	*u = Uint24(value)
	return nil
}

type Int24 int32

func (u Int24) MarshalTLB(c *boc.Cell, encoder *Encoder) error {
	return c.WriteInt(int64(u), 24)
}

func (u *Int24) UnmarshalTLB(c *boc.Cell, decoder *Decoder) error {
	v, err := c.ReadInt(24)
	*u = Int24(v)
	return err
}

func (u Int24) FixedSize() int {
	return 24
}

func (u Int24) Equal(other any) bool {
	otherInt, ok := other.(Int24)
	if !ok {
		return false
	}
	return u == otherInt
}
func (u Int24) MarshalJSON() ([]byte, error) {
	return []byte(fmt.Sprintf("%d", u)), nil
}

func (u *Int24) UnmarshalJSON(p []byte) error {
	value, err := strconv.ParseInt(strings.Trim(string(p), "\""), 10, 24)
	if err != nil {
		return err
	}
	*u = Int24(value)
	return nil
}

type Uint25 uint32

func (u Uint25) MarshalTLB(c *boc.Cell, encoder *Encoder) error {
	return c.WriteUint(uint64(u), 25)
}

func (u *Uint25) UnmarshalTLB(c *boc.Cell, decoder *Decoder) error {
	v, err := c.ReadUint(25)
	*u = Uint25(v)
	return err
}

func (u Uint25) FixedSize() int {
	return 25
}

func (u Uint25) Equal(other any) bool {
	otherInt, ok := other.(Uint25)
	if !ok {
		return false
	}
	return u == otherInt
}
func (u Uint25) MarshalJSON() ([]byte, error) {
	return []byte(fmt.Sprintf("%d", u)), nil
}

func (u *Uint25) UnmarshalJSON(p []byte) error {
	value, err := strconv.ParseUint(strings.Trim(string(p), "\""), 10, 25)
	if err != nil {
		return err
	}
	*u = Uint25(value)
	return nil
}

type Int25 int32

func (u Int25) MarshalTLB(c *boc.Cell, encoder *Encoder) error {
	return c.WriteInt(int64(u), 25)
}

func (u *Int25) UnmarshalTLB(c *boc.Cell, decoder *Decoder) error {
	v, err := c.ReadInt(25)
	*u = Int25(v)
	return err
}

func (u Int25) FixedSize() int {
	return 25
}

func (u Int25) Equal(other any) bool {
	otherInt, ok := other.(Int25)
	if !ok {
		return false
	}
	return u == otherInt
}
func (u Int25) MarshalJSON() ([]byte, error) {
	return []byte(fmt.Sprintf("%d", u)), nil
}

func (u *Int25) UnmarshalJSON(p []byte) error {
	value, err := strconv.ParseInt(strings.Trim(string(p), "\""), 10, 25)
	if err != nil {
		return err
	}
	*u = Int25(value)
	return nil
}

type Uint26 uint32

func (u Uint26) MarshalTLB(c *boc.Cell, encoder *Encoder) error {
	return c.WriteUint(uint64(u), 26)
}

func (u *Uint26) UnmarshalTLB(c *boc.Cell, decoder *Decoder) error {
	v, err := c.ReadUint(26)
	*u = Uint26(v)
	return err
}

func (u Uint26) FixedSize() int {
	return 26
}

func (u Uint26) Equal(other any) bool {
	otherInt, ok := other.(Uint26)
	if !ok {
		return false
	}
	return u == otherInt
}
func (u Uint26) MarshalJSON() ([]byte, error) {
	return []byte(fmt.Sprintf("%d", u)), nil
}

func (u *Uint26) UnmarshalJSON(p []byte) error {
	value, err := strconv.ParseUint(strings.Trim(string(p), "\""), 10, 26)
	if err != nil {
		return err
	}
	*u = Uint26(value)
	return nil
}

type Int26 int32

func (u Int26) MarshalTLB(c *boc.Cell, encoder *Encoder) error {
	return c.WriteInt(int64(u), 26)
}

func (u *Int26) UnmarshalTLB(c *boc.Cell, decoder *Decoder) error {
	v, err := c.ReadInt(26)
	*u = Int26(v)
	return err
}

func (u Int26) FixedSize() int {
	return 26
}

func (u Int26) Equal(other any) bool {
	otherInt, ok := other.(Int26)
	if !ok {
		return false
	}
	return u == otherInt
}
func (u Int26) MarshalJSON() ([]byte, error) {
	return []byte(fmt.Sprintf("%d", u)), nil
}

func (u *Int26) UnmarshalJSON(p []byte) error {
	value, err := strconv.ParseInt(strings.Trim(string(p), "\""), 10, 26)
	if err != nil {
		return err
	}
	*u = Int26(value)
	return nil
}

type Uint27 uint32

func (u Uint27) MarshalTLB(c *boc.Cell, encoder *Encoder) error {
	return c.WriteUint(uint64(u), 27)
}

func (u *Uint27) UnmarshalTLB(c *boc.Cell, decoder *Decoder) error {
	v, err := c.ReadUint(27)
	*u = Uint27(v)
	return err
}

func (u Uint27) FixedSize() int {
	return 27
}

func (u Uint27) Equal(other any) bool {
	otherInt, ok := other.(Uint27)
	if !ok {
		return false
	}
	return u == otherInt
}
func (u Uint27) MarshalJSON() ([]byte, error) {
	return []byte(fmt.Sprintf("%d", u)), nil
}

func (u *Uint27) UnmarshalJSON(p []byte) error {
	value, err := strconv.ParseUint(strings.Trim(string(p), "\""), 10, 27)
	if err != nil {
		return err
	}
	*u = Uint27(value)
	return nil
}

type Int27 int32

func (u Int27) MarshalTLB(c *boc.Cell, encoder *Encoder) error {
	return c.WriteInt(int64(u), 27)
}

func (u *Int27) UnmarshalTLB(c *boc.Cell, decoder *Decoder) error {
	v, err := c.ReadInt(27)
	*u = Int27(v)
	return err
}

func (u Int27) FixedSize() int {
	return 27
}

func (u Int27) Equal(other any) bool {
	otherInt, ok := other.(Int27)
	if !ok {
		return false
	}
	return u == otherInt
}
func (u Int27) MarshalJSON() ([]byte, error) {
	return []byte(fmt.Sprintf("%d", u)), nil
}

func (u *Int27) UnmarshalJSON(p []byte) error {
	value, err := strconv.ParseInt(strings.Trim(string(p), "\""), 10, 27)
	if err != nil {
		return err
	}
	*u = Int27(value)
	return nil
}

type Uint28 uint32

func (u Uint28) MarshalTLB(c *boc.Cell, encoder *Encoder) error {
	return c.WriteUint(uint64(u), 28)
}

func (u *Uint28) UnmarshalTLB(c *boc.Cell, decoder *Decoder) error {
	v, err := c.ReadUint(28)
	*u = Uint28(v)
	return err
}

func (u Uint28) FixedSize() int {
	return 28
}

func (u Uint28) Equal(other any) bool {
	otherInt, ok := other.(Uint28)
	if !ok {
		return false
	}
	return u == otherInt
}
func (u Uint28) MarshalJSON() ([]byte, error) {
	return []byte(fmt.Sprintf("%d", u)), nil
}

func (u *Uint28) UnmarshalJSON(p []byte) error {
	value, err := strconv.ParseUint(strings.Trim(string(p), "\""), 10, 28)
	if err != nil {
		return err
	}
	*u = Uint28(value)
	return nil
}

type Int28 int32

func (u Int28) MarshalTLB(c *boc.Cell, encoder *Encoder) error {
	return c.WriteInt(int64(u), 28)
}

func (u *Int28) UnmarshalTLB(c *boc.Cell, decoder *Decoder) error {
	v, err := c.ReadInt(28)
	*u = Int28(v)
	return err
}

func (u Int28) FixedSize() int {
	return 28
}

func (u Int28) Equal(other any) bool {
	otherInt, ok := other.(Int28)
	if !ok {
		return false
	}
	return u == otherInt
}
func (u Int28) MarshalJSON() ([]byte, error) {
	return []byte(fmt.Sprintf("%d", u)), nil
}

func (u *Int28) UnmarshalJSON(p []byte) error {
	value, err := strconv.ParseInt(strings.Trim(string(p), "\""), 10, 28)
	if err != nil {
		return err
	}
	*u = Int28(value)
	return nil
}

type Uint29 uint32

func (u Uint29) MarshalTLB(c *boc.Cell, encoder *Encoder) error {
	return c.WriteUint(uint64(u), 29)
}

func (u *Uint29) UnmarshalTLB(c *boc.Cell, decoder *Decoder) error {
	v, err := c.ReadUint(29)
	*u = Uint29(v)
	return err
}

func (u Uint29) FixedSize() int {
	return 29
}

func (u Uint29) Equal(other any) bool {
	otherInt, ok := other.(Uint29)
	if !ok {
		return false
	}
	return u == otherInt
}
func (u Uint29) MarshalJSON() ([]byte, error) {
	return []byte(fmt.Sprintf("%d", u)), nil
}

func (u *Uint29) UnmarshalJSON(p []byte) error {
	value, err := strconv.ParseUint(strings.Trim(string(p), "\""), 10, 29)
	if err != nil {
		return err
	}
	*u = Uint29(value)
	return nil
}

type Int29 int32

func (u Int29) MarshalTLB(c *boc.Cell, encoder *Encoder) error {
	return c.WriteInt(int64(u), 29)
}

func (u *Int29) UnmarshalTLB(c *boc.Cell, decoder *Decoder) error {
	v, err := c.ReadInt(29)
	*u = Int29(v)
	return err
}

func (u Int29) FixedSize() int {
	return 29
}

func (u Int29) Equal(other any) bool {
	otherInt, ok := other.(Int29)
	if !ok {
		return false
	}
	return u == otherInt
}
func (u Int29) MarshalJSON() ([]byte, error) {
	return []byte(fmt.Sprintf("%d", u)), nil
}

func (u *Int29) UnmarshalJSON(p []byte) error {
	value, err := strconv.ParseInt(strings.Trim(string(p), "\""), 10, 29)
	if err != nil {
		return err
	}
	*u = Int29(value)
	return nil
}

type Uint30 uint32

func (u Uint30) MarshalTLB(c *boc.Cell, encoder *Encoder) error {
	return c.WriteUint(uint64(u), 30)
}

func (u *Uint30) UnmarshalTLB(c *boc.Cell, decoder *Decoder) error {
	v, err := c.ReadUint(30)
	*u = Uint30(v)
	return err
}

func (u Uint30) FixedSize() int {
	return 30
}

func (u Uint30) Equal(other any) bool {
	otherInt, ok := other.(Uint30)
	if !ok {
		return false
	}
	return u == otherInt
}
func (u Uint30) MarshalJSON() ([]byte, error) {
	return []byte(fmt.Sprintf("%d", u)), nil
}

func (u *Uint30) UnmarshalJSON(p []byte) error {
	value, err := strconv.ParseUint(strings.Trim(string(p), "\""), 10, 30)
	if err != nil {
		return err
	}
	*u = Uint30(value)
	return nil
}

type Int30 int32

func (u Int30) MarshalTLB(c *boc.Cell, encoder *Encoder) error {
	return c.WriteInt(int64(u), 30)
}

func (u *Int30) UnmarshalTLB(c *boc.Cell, decoder *Decoder) error {
	v, err := c.ReadInt(30)
	*u = Int30(v)
	return err
}

func (u Int30) FixedSize() int {
	return 30
}

func (u Int30) Equal(other any) bool {
	otherInt, ok := other.(Int30)
	if !ok {
		return false
	}
	return u == otherInt
}
func (u Int30) MarshalJSON() ([]byte, error) {
	return []byte(fmt.Sprintf("%d", u)), nil
}

func (u *Int30) UnmarshalJSON(p []byte) error {
	value, err := strconv.ParseInt(strings.Trim(string(p), "\""), 10, 30)
	if err != nil {
		return err
	}
	*u = Int30(value)
	return nil
}

type Uint31 uint32

func (u Uint31) MarshalTLB(c *boc.Cell, encoder *Encoder) error {
	return c.WriteUint(uint64(u), 31)
}

func (u *Uint31) UnmarshalTLB(c *boc.Cell, decoder *Decoder) error {
	v, err := c.ReadUint(31)
	*u = Uint31(v)
	return err
}

func (u Uint31) FixedSize() int {
	return 31
}

func (u Uint31) Equal(other any) bool {
	otherInt, ok := other.(Uint31)
	if !ok {
		return false
	}
	return u == otherInt
}
func (u Uint31) MarshalJSON() ([]byte, error) {
	return []byte(fmt.Sprintf("%d", u)), nil
}

func (u *Uint31) UnmarshalJSON(p []byte) error {
	value, err := strconv.ParseUint(strings.Trim(string(p), "\""), 10, 31)
	if err != nil {
		return err
	}
	*u = Uint31(value)
	return nil
}

type Int31 int32

func (u Int31) MarshalTLB(c *boc.Cell, encoder *Encoder) error {
	return c.WriteInt(int64(u), 31)
}

func (u *Int31) UnmarshalTLB(c *boc.Cell, decoder *Decoder) error {
	v, err := c.ReadInt(31)
	*u = Int31(v)
	return err
}

func (u Int31) FixedSize() int {
	return 31
}

func (u Int31) Equal(other any) bool {
	otherInt, ok := other.(Int31)
	if !ok {
		return false
	}
	return u == otherInt
}
func (u Int31) MarshalJSON() ([]byte, error) {
	return []byte(fmt.Sprintf("%d", u)), nil
}

func (u *Int31) UnmarshalJSON(p []byte) error {
	value, err := strconv.ParseInt(strings.Trim(string(p), "\""), 10, 31)
	if err != nil {
		return err
	}
	*u = Int31(value)
	return nil
}

type Uint32 uint32

func (u Uint32) MarshalTLB(c *boc.Cell, encoder *Encoder) error {
	return c.WriteUint(uint64(u), 32)
}

func (u *Uint32) UnmarshalTLB(c *boc.Cell, decoder *Decoder) error {
	v, err := c.ReadUint(32)
	*u = Uint32(v)
	return err
}

func (u Uint32) FixedSize() int {
	return 32
}

func (u Uint32) Equal(other any) bool {
	otherInt, ok := other.(Uint32)
	if !ok {
		return false
	}
	return u == otherInt
}
func (u Uint32) MarshalJSON() ([]byte, error) {
	return []byte(fmt.Sprintf("%d", u)), nil
}

func (u *Uint32) UnmarshalJSON(p []byte) error {
	value, err := strconv.ParseUint(strings.Trim(string(p), "\""), 10, 32)
	if err != nil {
		return err
	}
	*u = Uint32(value)
	return nil
}

type Int32 int32

func (u Int32) MarshalTLB(c *boc.Cell, encoder *Encoder) error {
	return c.WriteInt(int64(u), 32)
}

func (u *Int32) UnmarshalTLB(c *boc.Cell, decoder *Decoder) error {
	v, err := c.ReadInt(32)
	*u = Int32(v)
	return err
}

func (u Int32) FixedSize() int {
	return 32
}

func (u Int32) Equal(other any) bool {
	otherInt, ok := other.(Int32)
	if !ok {
		return false
	}
	return u == otherInt
}
func (u Int32) MarshalJSON() ([]byte, error) {
	return []byte(fmt.Sprintf("%d", u)), nil
}

func (u *Int32) UnmarshalJSON(p []byte) error {
	value, err := strconv.ParseInt(strings.Trim(string(p), "\""), 10, 32)
	if err != nil {
		return err
	}
	*u = Int32(value)
	return nil
}

type Uint33 uint64

func (u Uint33) MarshalTLB(c *boc.Cell, encoder *Encoder) error {
	return c.WriteUint(uint64(u), 33)
}

func (u *Uint33) UnmarshalTLB(c *boc.Cell, decoder *Decoder) error {
	v, err := c.ReadUint(33)
	*u = Uint33(v)
	return err
}

func (u Uint33) FixedSize() int {
	return 33
}

func (u Uint33) Equal(other any) bool {
	otherInt, ok := other.(Uint33)
	if !ok {
		return false
	}
	return u == otherInt
}
func (u Uint33) MarshalJSON() ([]byte, error) {
	return []byte(fmt.Sprintf("%d", u)), nil
}

func (u *Uint33) UnmarshalJSON(p []byte) error {
	value, err := strconv.ParseUint(strings.Trim(string(p), "\""), 10, 33)
	if err != nil {
		return err
	}
	*u = Uint33(value)
	return nil
}

type Int33 int64

func (u Int33) MarshalTLB(c *boc.Cell, encoder *Encoder) error {
	return c.WriteInt(int64(u), 33)
}

func (u *Int33) UnmarshalTLB(c *boc.Cell, decoder *Decoder) error {
	v, err := c.ReadInt(33)
	*u = Int33(v)
	return err
}

func (u Int33) FixedSize() int {
	return 33
}

func (u Int33) Equal(other any) bool {
	otherInt, ok := other.(Int33)
	if !ok {
		return false
	}
	return u == otherInt
}
func (u Int33) MarshalJSON() ([]byte, error) {
	return []byte(fmt.Sprintf("%d", u)), nil
}

func (u *Int33) UnmarshalJSON(p []byte) error {
	value, err := strconv.ParseInt(strings.Trim(string(p), "\""), 10, 33)
	if err != nil {
		return err
	}
	*u = Int33(value)
	return nil
}

type Uint34 uint64

func (u Uint34) MarshalTLB(c *boc.Cell, encoder *Encoder) error {
	return c.WriteUint(uint64(u), 34)
}

func (u *Uint34) UnmarshalTLB(c *boc.Cell, decoder *Decoder) error {
	v, err := c.ReadUint(34)
	*u = Uint34(v)
	return err
}

func (u Uint34) FixedSize() int {
	return 34
}

func (u Uint34) Equal(other any) bool {
	otherInt, ok := other.(Uint34)
	if !ok {
		return false
	}
	return u == otherInt
}
func (u Uint34) MarshalJSON() ([]byte, error) {
	return []byte(fmt.Sprintf("%d", u)), nil
}

func (u *Uint34) UnmarshalJSON(p []byte) error {
	value, err := strconv.ParseUint(strings.Trim(string(p), "\""), 10, 34)
	if err != nil {
		return err
	}
	*u = Uint34(value)
	return nil
}

type Int34 int64

func (u Int34) MarshalTLB(c *boc.Cell, encoder *Encoder) error {
	return c.WriteInt(int64(u), 34)
}

func (u *Int34) UnmarshalTLB(c *boc.Cell, decoder *Decoder) error {
	v, err := c.ReadInt(34)
	*u = Int34(v)
	return err
}

func (u Int34) FixedSize() int {
	return 34
}

func (u Int34) Equal(other any) bool {
	otherInt, ok := other.(Int34)
	if !ok {
		return false
	}
	return u == otherInt
}
func (u Int34) MarshalJSON() ([]byte, error) {
	return []byte(fmt.Sprintf("%d", u)), nil
}

func (u *Int34) UnmarshalJSON(p []byte) error {
	value, err := strconv.ParseInt(strings.Trim(string(p), "\""), 10, 34)
	if err != nil {
		return err
	}
	*u = Int34(value)
	return nil
}

type Uint35 uint64

func (u Uint35) MarshalTLB(c *boc.Cell, encoder *Encoder) error {
	return c.WriteUint(uint64(u), 35)
}

func (u *Uint35) UnmarshalTLB(c *boc.Cell, decoder *Decoder) error {
	v, err := c.ReadUint(35)
	*u = Uint35(v)
	return err
}

func (u Uint35) FixedSize() int {
	return 35
}

func (u Uint35) Equal(other any) bool {
	otherInt, ok := other.(Uint35)
	if !ok {
		return false
	}
	return u == otherInt
}
func (u Uint35) MarshalJSON() ([]byte, error) {
	return []byte(fmt.Sprintf("%d", u)), nil
}

func (u *Uint35) UnmarshalJSON(p []byte) error {
	value, err := strconv.ParseUint(strings.Trim(string(p), "\""), 10, 35)
	if err != nil {
		return err
	}
	*u = Uint35(value)
	return nil
}

type Int35 int64

func (u Int35) MarshalTLB(c *boc.Cell, encoder *Encoder) error {
	return c.WriteInt(int64(u), 35)
}

func (u *Int35) UnmarshalTLB(c *boc.Cell, decoder *Decoder) error {
	v, err := c.ReadInt(35)
	*u = Int35(v)
	return err
}

func (u Int35) FixedSize() int {
	return 35
}

func (u Int35) Equal(other any) bool {
	otherInt, ok := other.(Int35)
	if !ok {
		return false
	}
	return u == otherInt
}
func (u Int35) MarshalJSON() ([]byte, error) {
	return []byte(fmt.Sprintf("%d", u)), nil
}

func (u *Int35) UnmarshalJSON(p []byte) error {
	value, err := strconv.ParseInt(strings.Trim(string(p), "\""), 10, 35)
	if err != nil {
		return err
	}
	*u = Int35(value)
	return nil
}

type Uint36 uint64

func (u Uint36) MarshalTLB(c *boc.Cell, encoder *Encoder) error {
	return c.WriteUint(uint64(u), 36)
}

func (u *Uint36) UnmarshalTLB(c *boc.Cell, decoder *Decoder) error {
	v, err := c.ReadUint(36)
	*u = Uint36(v)
	return err
}

func (u Uint36) FixedSize() int {
	return 36
}

func (u Uint36) Equal(other any) bool {
	otherInt, ok := other.(Uint36)
	if !ok {
		return false
	}
	return u == otherInt
}
func (u Uint36) MarshalJSON() ([]byte, error) {
	return []byte(fmt.Sprintf("%d", u)), nil
}

func (u *Uint36) UnmarshalJSON(p []byte) error {
	value, err := strconv.ParseUint(strings.Trim(string(p), "\""), 10, 36)
	if err != nil {
		return err
	}
	*u = Uint36(value)
	return nil
}

type Int36 int64

func (u Int36) MarshalTLB(c *boc.Cell, encoder *Encoder) error {
	return c.WriteInt(int64(u), 36)
}

func (u *Int36) UnmarshalTLB(c *boc.Cell, decoder *Decoder) error {
	v, err := c.ReadInt(36)
	*u = Int36(v)
	return err
}

func (u Int36) FixedSize() int {
	return 36
}

func (u Int36) Equal(other any) bool {
	otherInt, ok := other.(Int36)
	if !ok {
		return false
	}
	return u == otherInt
}
func (u Int36) MarshalJSON() ([]byte, error) {
	return []byte(fmt.Sprintf("%d", u)), nil
}

func (u *Int36) UnmarshalJSON(p []byte) error {
	value, err := strconv.ParseInt(strings.Trim(string(p), "\""), 10, 36)
	if err != nil {
		return err
	}
	*u = Int36(value)
	return nil
}

type Uint37 uint64

func (u Uint37) MarshalTLB(c *boc.Cell, encoder *Encoder) error {
	return c.WriteUint(uint64(u), 37)
}

func (u *Uint37) UnmarshalTLB(c *boc.Cell, decoder *Decoder) error {
	v, err := c.ReadUint(37)
	*u = Uint37(v)
	return err
}

func (u Uint37) FixedSize() int {
	return 37
}

func (u Uint37) Equal(other any) bool {
	otherInt, ok := other.(Uint37)
	if !ok {
		return false
	}
	return u == otherInt
}
func (u Uint37) MarshalJSON() ([]byte, error) {
	return []byte(fmt.Sprintf("%d", u)), nil
}

func (u *Uint37) UnmarshalJSON(p []byte) error {
	value, err := strconv.ParseUint(strings.Trim(string(p), "\""), 10, 37)
	if err != nil {
		return err
	}
	*u = Uint37(value)
	return nil
}

type Int37 int64

func (u Int37) MarshalTLB(c *boc.Cell, encoder *Encoder) error {
	return c.WriteInt(int64(u), 37)
}

func (u *Int37) UnmarshalTLB(c *boc.Cell, decoder *Decoder) error {
	v, err := c.ReadInt(37)
	*u = Int37(v)
	return err
}

func (u Int37) FixedSize() int {
	return 37
}

func (u Int37) Equal(other any) bool {
	otherInt, ok := other.(Int37)
	if !ok {
		return false
	}
	return u == otherInt
}
func (u Int37) MarshalJSON() ([]byte, error) {
	return []byte(fmt.Sprintf("%d", u)), nil
}

func (u *Int37) UnmarshalJSON(p []byte) error {
	value, err := strconv.ParseInt(strings.Trim(string(p), "\""), 10, 37)
	if err != nil {
		return err
	}
	*u = Int37(value)
	return nil
}

type Uint38 uint64

func (u Uint38) MarshalTLB(c *boc.Cell, encoder *Encoder) error {
	return c.WriteUint(uint64(u), 38)
}

func (u *Uint38) UnmarshalTLB(c *boc.Cell, decoder *Decoder) error {
	v, err := c.ReadUint(38)
	*u = Uint38(v)
	return err
}

func (u Uint38) FixedSize() int {
	return 38
}

func (u Uint38) Equal(other any) bool {
	otherInt, ok := other.(Uint38)
	if !ok {
		return false
	}
	return u == otherInt
}
func (u Uint38) MarshalJSON() ([]byte, error) {
	return []byte(fmt.Sprintf("%d", u)), nil
}

func (u *Uint38) UnmarshalJSON(p []byte) error {
	value, err := strconv.ParseUint(strings.Trim(string(p), "\""), 10, 38)
	if err != nil {
		return err
	}
	*u = Uint38(value)
	return nil
}

type Int38 int64

func (u Int38) MarshalTLB(c *boc.Cell, encoder *Encoder) error {
	return c.WriteInt(int64(u), 38)
}

func (u *Int38) UnmarshalTLB(c *boc.Cell, decoder *Decoder) error {
	v, err := c.ReadInt(38)
	*u = Int38(v)
	return err
}

func (u Int38) FixedSize() int {
	return 38
}

func (u Int38) Equal(other any) bool {
	otherInt, ok := other.(Int38)
	if !ok {
		return false
	}
	return u == otherInt
}
func (u Int38) MarshalJSON() ([]byte, error) {
	return []byte(fmt.Sprintf("%d", u)), nil
}

func (u *Int38) UnmarshalJSON(p []byte) error {
	value, err := strconv.ParseInt(strings.Trim(string(p), "\""), 10, 38)
	if err != nil {
		return err
	}
	*u = Int38(value)
	return nil
}

type Uint39 uint64

func (u Uint39) MarshalTLB(c *boc.Cell, encoder *Encoder) error {
	return c.WriteUint(uint64(u), 39)
}

func (u *Uint39) UnmarshalTLB(c *boc.Cell, decoder *Decoder) error {
	v, err := c.ReadUint(39)
	*u = Uint39(v)
	return err
}

func (u Uint39) FixedSize() int {
	return 39
}

func (u Uint39) Equal(other any) bool {
	otherInt, ok := other.(Uint39)
	if !ok {
		return false
	}
	return u == otherInt
}
func (u Uint39) MarshalJSON() ([]byte, error) {
	return []byte(fmt.Sprintf("%d", u)), nil
}

func (u *Uint39) UnmarshalJSON(p []byte) error {
	value, err := strconv.ParseUint(strings.Trim(string(p), "\""), 10, 39)
	if err != nil {
		return err
	}
	*u = Uint39(value)
	return nil
}

type Int39 int64

func (u Int39) MarshalTLB(c *boc.Cell, encoder *Encoder) error {
	return c.WriteInt(int64(u), 39)
}

func (u *Int39) UnmarshalTLB(c *boc.Cell, decoder *Decoder) error {
	v, err := c.ReadInt(39)
	*u = Int39(v)
	return err
}

func (u Int39) FixedSize() int {
	return 39
}

func (u Int39) Equal(other any) bool {
	otherInt, ok := other.(Int39)
	if !ok {
		return false
	}
	return u == otherInt
}
func (u Int39) MarshalJSON() ([]byte, error) {
	return []byte(fmt.Sprintf("%d", u)), nil
}

func (u *Int39) UnmarshalJSON(p []byte) error {
	value, err := strconv.ParseInt(strings.Trim(string(p), "\""), 10, 39)
	if err != nil {
		return err
	}
	*u = Int39(value)
	return nil
}

type Uint40 uint64

func (u Uint40) MarshalTLB(c *boc.Cell, encoder *Encoder) error {
	return c.WriteUint(uint64(u), 40)
}

func (u *Uint40) UnmarshalTLB(c *boc.Cell, decoder *Decoder) error {
	v, err := c.ReadUint(40)
	*u = Uint40(v)
	return err
}

func (u Uint40) FixedSize() int {
	return 40
}

func (u Uint40) Equal(other any) bool {
	otherInt, ok := other.(Uint40)
	if !ok {
		return false
	}
	return u == otherInt
}
func (u Uint40) MarshalJSON() ([]byte, error) {
	return []byte(fmt.Sprintf("%d", u)), nil
}

func (u *Uint40) UnmarshalJSON(p []byte) error {
	value, err := strconv.ParseUint(strings.Trim(string(p), "\""), 10, 40)
	if err != nil {
		return err
	}
	*u = Uint40(value)
	return nil
}

type Int40 int64

func (u Int40) MarshalTLB(c *boc.Cell, encoder *Encoder) error {
	return c.WriteInt(int64(u), 40)
}

func (u *Int40) UnmarshalTLB(c *boc.Cell, decoder *Decoder) error {
	v, err := c.ReadInt(40)
	*u = Int40(v)
	return err
}

func (u Int40) FixedSize() int {
	return 40
}

func (u Int40) Equal(other any) bool {
	otherInt, ok := other.(Int40)
	if !ok {
		return false
	}
	return u == otherInt
}
func (u Int40) MarshalJSON() ([]byte, error) {
	return []byte(fmt.Sprintf("%d", u)), nil
}

func (u *Int40) UnmarshalJSON(p []byte) error {
	value, err := strconv.ParseInt(strings.Trim(string(p), "\""), 10, 40)
	if err != nil {
		return err
	}
	*u = Int40(value)
	return nil
}

type Uint41 uint64

func (u Uint41) MarshalTLB(c *boc.Cell, encoder *Encoder) error {
	return c.WriteUint(uint64(u), 41)
}

func (u *Uint41) UnmarshalTLB(c *boc.Cell, decoder *Decoder) error {
	v, err := c.ReadUint(41)
	*u = Uint41(v)
	return err
}

func (u Uint41) FixedSize() int {
	return 41
}

func (u Uint41) Equal(other any) bool {
	otherInt, ok := other.(Uint41)
	if !ok {
		return false
	}
	return u == otherInt
}
func (u Uint41) MarshalJSON() ([]byte, error) {
	return []byte(fmt.Sprintf("%d", u)), nil
}

func (u *Uint41) UnmarshalJSON(p []byte) error {
	value, err := strconv.ParseUint(strings.Trim(string(p), "\""), 10, 41)
	if err != nil {
		return err
	}
	*u = Uint41(value)
	return nil
}

type Int41 int64

func (u Int41) MarshalTLB(c *boc.Cell, encoder *Encoder) error {
	return c.WriteInt(int64(u), 41)
}

func (u *Int41) UnmarshalTLB(c *boc.Cell, decoder *Decoder) error {
	v, err := c.ReadInt(41)
	*u = Int41(v)
	return err
}

func (u Int41) FixedSize() int {
	return 41
}

func (u Int41) Equal(other any) bool {
	otherInt, ok := other.(Int41)
	if !ok {
		return false
	}
	return u == otherInt
}
func (u Int41) MarshalJSON() ([]byte, error) {
	return []byte(fmt.Sprintf("%d", u)), nil
}

func (u *Int41) UnmarshalJSON(p []byte) error {
	value, err := strconv.ParseInt(strings.Trim(string(p), "\""), 10, 41)
	if err != nil {
		return err
	}
	*u = Int41(value)
	return nil
}

type Uint42 uint64

func (u Uint42) MarshalTLB(c *boc.Cell, encoder *Encoder) error {
	return c.WriteUint(uint64(u), 42)
}

func (u *Uint42) UnmarshalTLB(c *boc.Cell, decoder *Decoder) error {
	v, err := c.ReadUint(42)
	*u = Uint42(v)
	return err
}

func (u Uint42) FixedSize() int {
	return 42
}

func (u Uint42) Equal(other any) bool {
	otherInt, ok := other.(Uint42)
	if !ok {
		return false
	}
	return u == otherInt
}
func (u Uint42) MarshalJSON() ([]byte, error) {
	return []byte(fmt.Sprintf("%d", u)), nil
}

func (u *Uint42) UnmarshalJSON(p []byte) error {
	value, err := strconv.ParseUint(strings.Trim(string(p), "\""), 10, 42)
	if err != nil {
		return err
	}
	*u = Uint42(value)
	return nil
}

type Int42 int64

func (u Int42) MarshalTLB(c *boc.Cell, encoder *Encoder) error {
	return c.WriteInt(int64(u), 42)
}

func (u *Int42) UnmarshalTLB(c *boc.Cell, decoder *Decoder) error {
	v, err := c.ReadInt(42)
	*u = Int42(v)
	return err
}

func (u Int42) FixedSize() int {
	return 42
}

func (u Int42) Equal(other any) bool {
	otherInt, ok := other.(Int42)
	if !ok {
		return false
	}
	return u == otherInt
}
func (u Int42) MarshalJSON() ([]byte, error) {
	return []byte(fmt.Sprintf("%d", u)), nil
}

func (u *Int42) UnmarshalJSON(p []byte) error {
	value, err := strconv.ParseInt(strings.Trim(string(p), "\""), 10, 42)
	if err != nil {
		return err
	}
	*u = Int42(value)
	return nil
}

type Uint43 uint64

func (u Uint43) MarshalTLB(c *boc.Cell, encoder *Encoder) error {
	return c.WriteUint(uint64(u), 43)
}

func (u *Uint43) UnmarshalTLB(c *boc.Cell, decoder *Decoder) error {
	v, err := c.ReadUint(43)
	*u = Uint43(v)
	return err
}

func (u Uint43) FixedSize() int {
	return 43
}

func (u Uint43) Equal(other any) bool {
	otherInt, ok := other.(Uint43)
	if !ok {
		return false
	}
	return u == otherInt
}
func (u Uint43) MarshalJSON() ([]byte, error) {
	return []byte(fmt.Sprintf("%d", u)), nil
}

func (u *Uint43) UnmarshalJSON(p []byte) error {
	value, err := strconv.ParseUint(strings.Trim(string(p), "\""), 10, 43)
	if err != nil {
		return err
	}
	*u = Uint43(value)
	return nil
}

type Int43 int64

func (u Int43) MarshalTLB(c *boc.Cell, encoder *Encoder) error {
	return c.WriteInt(int64(u), 43)
}

func (u *Int43) UnmarshalTLB(c *boc.Cell, decoder *Decoder) error {
	v, err := c.ReadInt(43)
	*u = Int43(v)
	return err
}

func (u Int43) FixedSize() int {
	return 43
}

func (u Int43) Equal(other any) bool {
	otherInt, ok := other.(Int43)
	if !ok {
		return false
	}
	return u == otherInt
}
func (u Int43) MarshalJSON() ([]byte, error) {
	return []byte(fmt.Sprintf("%d", u)), nil
}

func (u *Int43) UnmarshalJSON(p []byte) error {
	value, err := strconv.ParseInt(strings.Trim(string(p), "\""), 10, 43)
	if err != nil {
		return err
	}
	*u = Int43(value)
	return nil
}

type Uint44 uint64

func (u Uint44) MarshalTLB(c *boc.Cell, encoder *Encoder) error {
	return c.WriteUint(uint64(u), 44)
}

func (u *Uint44) UnmarshalTLB(c *boc.Cell, decoder *Decoder) error {
	v, err := c.ReadUint(44)
	*u = Uint44(v)
	return err
}

func (u Uint44) FixedSize() int {
	return 44
}

func (u Uint44) Equal(other any) bool {
	otherInt, ok := other.(Uint44)
	if !ok {
		return false
	}
	return u == otherInt
}
func (u Uint44) MarshalJSON() ([]byte, error) {
	return []byte(fmt.Sprintf("%d", u)), nil
}

func (u *Uint44) UnmarshalJSON(p []byte) error {
	value, err := strconv.ParseUint(strings.Trim(string(p), "\""), 10, 44)
	if err != nil {
		return err
	}
	*u = Uint44(value)
	return nil
}

type Int44 int64

func (u Int44) MarshalTLB(c *boc.Cell, encoder *Encoder) error {
	return c.WriteInt(int64(u), 44)
}

func (u *Int44) UnmarshalTLB(c *boc.Cell, decoder *Decoder) error {
	v, err := c.ReadInt(44)
	*u = Int44(v)
	return err
}

func (u Int44) FixedSize() int {
	return 44
}

func (u Int44) Equal(other any) bool {
	otherInt, ok := other.(Int44)
	if !ok {
		return false
	}
	return u == otherInt
}
func (u Int44) MarshalJSON() ([]byte, error) {
	return []byte(fmt.Sprintf("%d", u)), nil
}

func (u *Int44) UnmarshalJSON(p []byte) error {
	value, err := strconv.ParseInt(strings.Trim(string(p), "\""), 10, 44)
	if err != nil {
		return err
	}
	*u = Int44(value)
	return nil
}

type Uint45 uint64

func (u Uint45) MarshalTLB(c *boc.Cell, encoder *Encoder) error {
	return c.WriteUint(uint64(u), 45)
}

func (u *Uint45) UnmarshalTLB(c *boc.Cell, decoder *Decoder) error {
	v, err := c.ReadUint(45)
	*u = Uint45(v)
	return err
}

func (u Uint45) FixedSize() int {
	return 45
}

func (u Uint45) Equal(other any) bool {
	otherInt, ok := other.(Uint45)
	if !ok {
		return false
	}
	return u == otherInt
}
func (u Uint45) MarshalJSON() ([]byte, error) {
	return []byte(fmt.Sprintf("%d", u)), nil
}

func (u *Uint45) UnmarshalJSON(p []byte) error {
	value, err := strconv.ParseUint(strings.Trim(string(p), "\""), 10, 45)
	if err != nil {
		return err
	}
	*u = Uint45(value)
	return nil
}

type Int45 int64

func (u Int45) MarshalTLB(c *boc.Cell, encoder *Encoder) error {
	return c.WriteInt(int64(u), 45)
}

func (u *Int45) UnmarshalTLB(c *boc.Cell, decoder *Decoder) error {
	v, err := c.ReadInt(45)
	*u = Int45(v)
	return err
}

func (u Int45) FixedSize() int {
	return 45
}

func (u Int45) Equal(other any) bool {
	otherInt, ok := other.(Int45)
	if !ok {
		return false
	}
	return u == otherInt
}
func (u Int45) MarshalJSON() ([]byte, error) {
	return []byte(fmt.Sprintf("%d", u)), nil
}

func (u *Int45) UnmarshalJSON(p []byte) error {
	value, err := strconv.ParseInt(strings.Trim(string(p), "\""), 10, 45)
	if err != nil {
		return err
	}
	*u = Int45(value)
	return nil
}

type Uint46 uint64

func (u Uint46) MarshalTLB(c *boc.Cell, encoder *Encoder) error {
	return c.WriteUint(uint64(u), 46)
}

func (u *Uint46) UnmarshalTLB(c *boc.Cell, decoder *Decoder) error {
	v, err := c.ReadUint(46)
	*u = Uint46(v)
	return err
}

func (u Uint46) FixedSize() int {
	return 46
}

func (u Uint46) Equal(other any) bool {
	otherInt, ok := other.(Uint46)
	if !ok {
		return false
	}
	return u == otherInt
}
func (u Uint46) MarshalJSON() ([]byte, error) {
	return []byte(fmt.Sprintf("%d", u)), nil
}

func (u *Uint46) UnmarshalJSON(p []byte) error {
	value, err := strconv.ParseUint(strings.Trim(string(p), "\""), 10, 46)
	if err != nil {
		return err
	}
	*u = Uint46(value)
	return nil
}

type Int46 int64

func (u Int46) MarshalTLB(c *boc.Cell, encoder *Encoder) error {
	return c.WriteInt(int64(u), 46)
}

func (u *Int46) UnmarshalTLB(c *boc.Cell, decoder *Decoder) error {
	v, err := c.ReadInt(46)
	*u = Int46(v)
	return err
}

func (u Int46) FixedSize() int {
	return 46
}

func (u Int46) Equal(other any) bool {
	otherInt, ok := other.(Int46)
	if !ok {
		return false
	}
	return u == otherInt
}
func (u Int46) MarshalJSON() ([]byte, error) {
	return []byte(fmt.Sprintf("%d", u)), nil
}

func (u *Int46) UnmarshalJSON(p []byte) error {
	value, err := strconv.ParseInt(strings.Trim(string(p), "\""), 10, 46)
	if err != nil {
		return err
	}
	*u = Int46(value)
	return nil
}

type Uint47 uint64

func (u Uint47) MarshalTLB(c *boc.Cell, encoder *Encoder) error {
	return c.WriteUint(uint64(u), 47)
}

func (u *Uint47) UnmarshalTLB(c *boc.Cell, decoder *Decoder) error {
	v, err := c.ReadUint(47)
	*u = Uint47(v)
	return err
}

func (u Uint47) FixedSize() int {
	return 47
}

func (u Uint47) Equal(other any) bool {
	otherInt, ok := other.(Uint47)
	if !ok {
		return false
	}
	return u == otherInt
}
func (u Uint47) MarshalJSON() ([]byte, error) {
	return []byte(fmt.Sprintf("%d", u)), nil
}

func (u *Uint47) UnmarshalJSON(p []byte) error {
	value, err := strconv.ParseUint(strings.Trim(string(p), "\""), 10, 47)
	if err != nil {
		return err
	}
	*u = Uint47(value)
	return nil
}

type Int47 int64

func (u Int47) MarshalTLB(c *boc.Cell, encoder *Encoder) error {
	return c.WriteInt(int64(u), 47)
}

func (u *Int47) UnmarshalTLB(c *boc.Cell, decoder *Decoder) error {
	v, err := c.ReadInt(47)
	*u = Int47(v)
	return err
}

func (u Int47) FixedSize() int {
	return 47
}

func (u Int47) Equal(other any) bool {
	otherInt, ok := other.(Int47)
	if !ok {
		return false
	}
	return u == otherInt
}
func (u Int47) MarshalJSON() ([]byte, error) {
	return []byte(fmt.Sprintf("%d", u)), nil
}

func (u *Int47) UnmarshalJSON(p []byte) error {
	value, err := strconv.ParseInt(strings.Trim(string(p), "\""), 10, 47)
	if err != nil {
		return err
	}
	*u = Int47(value)
	return nil
}

type Uint48 uint64

func (u Uint48) MarshalTLB(c *boc.Cell, encoder *Encoder) error {
	return c.WriteUint(uint64(u), 48)
}

func (u *Uint48) UnmarshalTLB(c *boc.Cell, decoder *Decoder) error {
	v, err := c.ReadUint(48)
	*u = Uint48(v)
	return err
}

func (u Uint48) FixedSize() int {
	return 48
}

func (u Uint48) Equal(other any) bool {
	otherInt, ok := other.(Uint48)
	if !ok {
		return false
	}
	return u == otherInt
}
func (u Uint48) MarshalJSON() ([]byte, error) {
	return []byte(fmt.Sprintf("%d", u)), nil
}

func (u *Uint48) UnmarshalJSON(p []byte) error {
	value, err := strconv.ParseUint(strings.Trim(string(p), "\""), 10, 48)
	if err != nil {
		return err
	}
	*u = Uint48(value)
	return nil
}

type Int48 int64

func (u Int48) MarshalTLB(c *boc.Cell, encoder *Encoder) error {
	return c.WriteInt(int64(u), 48)
}

func (u *Int48) UnmarshalTLB(c *boc.Cell, decoder *Decoder) error {
	v, err := c.ReadInt(48)
	*u = Int48(v)
	return err
}

func (u Int48) FixedSize() int {
	return 48
}

func (u Int48) Equal(other any) bool {
	otherInt, ok := other.(Int48)
	if !ok {
		return false
	}
	return u == otherInt
}
func (u Int48) MarshalJSON() ([]byte, error) {
	return []byte(fmt.Sprintf("%d", u)), nil
}

func (u *Int48) UnmarshalJSON(p []byte) error {
	value, err := strconv.ParseInt(strings.Trim(string(p), "\""), 10, 48)
	if err != nil {
		return err
	}
	*u = Int48(value)
	return nil
}

type Uint49 uint64

func (u Uint49) MarshalTLB(c *boc.Cell, encoder *Encoder) error {
	return c.WriteUint(uint64(u), 49)
}

func (u *Uint49) UnmarshalTLB(c *boc.Cell, decoder *Decoder) error {
	v, err := c.ReadUint(49)
	*u = Uint49(v)
	return err
}

func (u Uint49) FixedSize() int {
	return 49
}

func (u Uint49) Equal(other any) bool {
	otherInt, ok := other.(Uint49)
	if !ok {
		return false
	}
	return u == otherInt
}
func (u Uint49) MarshalJSON() ([]byte, error) {
	return []byte(fmt.Sprintf("%d", u)), nil
}

func (u *Uint49) UnmarshalJSON(p []byte) error {
	value, err := strconv.ParseUint(strings.Trim(string(p), "\""), 10, 49)
	if err != nil {
		return err
	}
	*u = Uint49(value)
	return nil
}

type Int49 int64

func (u Int49) MarshalTLB(c *boc.Cell, encoder *Encoder) error {
	return c.WriteInt(int64(u), 49)
}

func (u *Int49) UnmarshalTLB(c *boc.Cell, decoder *Decoder) error {
	v, err := c.ReadInt(49)
	*u = Int49(v)
	return err
}

func (u Int49) FixedSize() int {
	return 49
}

func (u Int49) Equal(other any) bool {
	otherInt, ok := other.(Int49)
	if !ok {
		return false
	}
	return u == otherInt
}
func (u Int49) MarshalJSON() ([]byte, error) {
	return []byte(fmt.Sprintf("%d", u)), nil
}

func (u *Int49) UnmarshalJSON(p []byte) error {
	value, err := strconv.ParseInt(strings.Trim(string(p), "\""), 10, 49)
	if err != nil {
		return err
	}
	*u = Int49(value)
	return nil
}

type Uint50 uint64

func (u Uint50) MarshalTLB(c *boc.Cell, encoder *Encoder) error {
	return c.WriteUint(uint64(u), 50)
}

func (u *Uint50) UnmarshalTLB(c *boc.Cell, decoder *Decoder) error {
	v, err := c.ReadUint(50)
	*u = Uint50(v)
	return err
}

func (u Uint50) FixedSize() int {
	return 50
}

func (u Uint50) Equal(other any) bool {
	otherInt, ok := other.(Uint50)
	if !ok {
		return false
	}
	return u == otherInt
}
func (u Uint50) MarshalJSON() ([]byte, error) {
	return []byte(fmt.Sprintf("%d", u)), nil
}

func (u *Uint50) UnmarshalJSON(p []byte) error {
	value, err := strconv.ParseUint(strings.Trim(string(p), "\""), 10, 50)
	if err != nil {
		return err
	}
	*u = Uint50(value)
	return nil
}

type Int50 int64

func (u Int50) MarshalTLB(c *boc.Cell, encoder *Encoder) error {
	return c.WriteInt(int64(u), 50)
}

func (u *Int50) UnmarshalTLB(c *boc.Cell, decoder *Decoder) error {
	v, err := c.ReadInt(50)
	*u = Int50(v)
	return err
}

func (u Int50) FixedSize() int {
	return 50
}

func (u Int50) Equal(other any) bool {
	otherInt, ok := other.(Int50)
	if !ok {
		return false
	}
	return u == otherInt
}
func (u Int50) MarshalJSON() ([]byte, error) {
	return []byte(fmt.Sprintf("%d", u)), nil
}

func (u *Int50) UnmarshalJSON(p []byte) error {
	value, err := strconv.ParseInt(strings.Trim(string(p), "\""), 10, 50)
	if err != nil {
		return err
	}
	*u = Int50(value)
	return nil
}

type Uint51 uint64

func (u Uint51) MarshalTLB(c *boc.Cell, encoder *Encoder) error {
	return c.WriteUint(uint64(u), 51)
}

func (u *Uint51) UnmarshalTLB(c *boc.Cell, decoder *Decoder) error {
	v, err := c.ReadUint(51)
	*u = Uint51(v)
	return err
}

func (u Uint51) FixedSize() int {
	return 51
}

func (u Uint51) Equal(other any) bool {
	otherInt, ok := other.(Uint51)
	if !ok {
		return false
	}
	return u == otherInt
}
func (u Uint51) MarshalJSON() ([]byte, error) {
	return []byte(fmt.Sprintf("%d", u)), nil
}

func (u *Uint51) UnmarshalJSON(p []byte) error {
	value, err := strconv.ParseUint(strings.Trim(string(p), "\""), 10, 51)
	if err != nil {
		return err
	}
	*u = Uint51(value)
	return nil
}

type Int51 int64

func (u Int51) MarshalTLB(c *boc.Cell, encoder *Encoder) error {
	return c.WriteInt(int64(u), 51)
}

func (u *Int51) UnmarshalTLB(c *boc.Cell, decoder *Decoder) error {
	v, err := c.ReadInt(51)
	*u = Int51(v)
	return err
}

func (u Int51) FixedSize() int {
	return 51
}

func (u Int51) Equal(other any) bool {
	otherInt, ok := other.(Int51)
	if !ok {
		return false
	}
	return u == otherInt
}
func (u Int51) MarshalJSON() ([]byte, error) {
	return []byte(fmt.Sprintf("%d", u)), nil
}

func (u *Int51) UnmarshalJSON(p []byte) error {
	value, err := strconv.ParseInt(strings.Trim(string(p), "\""), 10, 51)
	if err != nil {
		return err
	}
	*u = Int51(value)
	return nil
}

type Uint52 uint64

func (u Uint52) MarshalTLB(c *boc.Cell, encoder *Encoder) error {
	return c.WriteUint(uint64(u), 52)
}

func (u *Uint52) UnmarshalTLB(c *boc.Cell, decoder *Decoder) error {
	v, err := c.ReadUint(52)
	*u = Uint52(v)
	return err
}

func (u Uint52) FixedSize() int {
	return 52
}

func (u Uint52) Equal(other any) bool {
	otherInt, ok := other.(Uint52)
	if !ok {
		return false
	}
	return u == otherInt
}
func (u Uint52) MarshalJSON() ([]byte, error) {
	return []byte(fmt.Sprintf("%d", u)), nil
}

func (u *Uint52) UnmarshalJSON(p []byte) error {
	value, err := strconv.ParseUint(strings.Trim(string(p), "\""), 10, 52)
	if err != nil {
		return err
	}
	*u = Uint52(value)
	return nil
}

type Int52 int64

func (u Int52) MarshalTLB(c *boc.Cell, encoder *Encoder) error {
	return c.WriteInt(int64(u), 52)
}

func (u *Int52) UnmarshalTLB(c *boc.Cell, decoder *Decoder) error {
	v, err := c.ReadInt(52)
	*u = Int52(v)
	return err
}

func (u Int52) FixedSize() int {
	return 52
}

func (u Int52) Equal(other any) bool {
	otherInt, ok := other.(Int52)
	if !ok {
		return false
	}
	return u == otherInt
}
func (u Int52) MarshalJSON() ([]byte, error) {
	return []byte(fmt.Sprintf("%d", u)), nil
}

func (u *Int52) UnmarshalJSON(p []byte) error {
	value, err := strconv.ParseInt(strings.Trim(string(p), "\""), 10, 52)
	if err != nil {
		return err
	}
	*u = Int52(value)
	return nil
}

type Uint53 uint64

func (u Uint53) MarshalTLB(c *boc.Cell, encoder *Encoder) error {
	return c.WriteUint(uint64(u), 53)
}

func (u *Uint53) UnmarshalTLB(c *boc.Cell, decoder *Decoder) error {
	v, err := c.ReadUint(53)
	*u = Uint53(v)
	return err
}

func (u Uint53) FixedSize() int {
	return 53
}

func (u Uint53) Equal(other any) bool {
	otherInt, ok := other.(Uint53)
	if !ok {
		return false
	}
	return u == otherInt
}
func (u Uint53) MarshalJSON() ([]byte, error) {
	return []byte(fmt.Sprintf("%d", u)), nil
}

func (u *Uint53) UnmarshalJSON(p []byte) error {
	value, err := strconv.ParseUint(strings.Trim(string(p), "\""), 10, 53)
	if err != nil {
		return err
	}
	*u = Uint53(value)
	return nil
}

type Int53 int64

func (u Int53) MarshalTLB(c *boc.Cell, encoder *Encoder) error {
	return c.WriteInt(int64(u), 53)
}

func (u *Int53) UnmarshalTLB(c *boc.Cell, decoder *Decoder) error {
	v, err := c.ReadInt(53)
	*u = Int53(v)
	return err
}

func (u Int53) FixedSize() int {
	return 53
}

func (u Int53) Equal(other any) bool {
	otherInt, ok := other.(Int53)
	if !ok {
		return false
	}
	return u == otherInt
}
func (u Int53) MarshalJSON() ([]byte, error) {
	return []byte(fmt.Sprintf("%d", u)), nil
}

func (u *Int53) UnmarshalJSON(p []byte) error {
	value, err := strconv.ParseInt(strings.Trim(string(p), "\""), 10, 53)
	if err != nil {
		return err
	}
	*u = Int53(value)
	return nil
}

type Uint54 uint64

func (u Uint54) MarshalTLB(c *boc.Cell, encoder *Encoder) error {
	return c.WriteUint(uint64(u), 54)
}

func (u *Uint54) UnmarshalTLB(c *boc.Cell, decoder *Decoder) error {
	v, err := c.ReadUint(54)
	*u = Uint54(v)
	return err
}

func (u Uint54) FixedSize() int {
	return 54
}

func (u Uint54) Equal(other any) bool {
	otherInt, ok := other.(Uint54)
	if !ok {
		return false
	}
	return u == otherInt
}
func (u Uint54) MarshalJSON() ([]byte, error) {
	return []byte(fmt.Sprintf("%d", u)), nil
}

func (u *Uint54) UnmarshalJSON(p []byte) error {
	value, err := strconv.ParseUint(strings.Trim(string(p), "\""), 10, 54)
	if err != nil {
		return err
	}
	*u = Uint54(value)
	return nil
}

type Int54 int64

func (u Int54) MarshalTLB(c *boc.Cell, encoder *Encoder) error {
	return c.WriteInt(int64(u), 54)
}

func (u *Int54) UnmarshalTLB(c *boc.Cell, decoder *Decoder) error {
	v, err := c.ReadInt(54)
	*u = Int54(v)
	return err
}

func (u Int54) FixedSize() int {
	return 54
}

func (u Int54) Equal(other any) bool {
	otherInt, ok := other.(Int54)
	if !ok {
		return false
	}
	return u == otherInt
}
func (u Int54) MarshalJSON() ([]byte, error) {
	return []byte(fmt.Sprintf("%d", u)), nil
}

func (u *Int54) UnmarshalJSON(p []byte) error {
	value, err := strconv.ParseInt(strings.Trim(string(p), "\""), 10, 54)
	if err != nil {
		return err
	}
	*u = Int54(value)
	return nil
}

type Uint55 uint64

func (u Uint55) MarshalTLB(c *boc.Cell, encoder *Encoder) error {
	return c.WriteUint(uint64(u), 55)
}

func (u *Uint55) UnmarshalTLB(c *boc.Cell, decoder *Decoder) error {
	v, err := c.ReadUint(55)
	*u = Uint55(v)
	return err
}

func (u Uint55) FixedSize() int {
	return 55
}

func (u Uint55) Equal(other any) bool {
	otherInt, ok := other.(Uint55)
	if !ok {
		return false
	}
	return u == otherInt
}
func (u Uint55) MarshalJSON() ([]byte, error) {
	return []byte(fmt.Sprintf("%d", u)), nil
}

func (u *Uint55) UnmarshalJSON(p []byte) error {
	value, err := strconv.ParseUint(strings.Trim(string(p), "\""), 10, 55)
	if err != nil {
		return err
	}
	*u = Uint55(value)
	return nil
}

type Int55 int64

func (u Int55) MarshalTLB(c *boc.Cell, encoder *Encoder) error {
	return c.WriteInt(int64(u), 55)
}

func (u *Int55) UnmarshalTLB(c *boc.Cell, decoder *Decoder) error {
	v, err := c.ReadInt(55)
	*u = Int55(v)
	return err
}

func (u Int55) FixedSize() int {
	return 55
}

func (u Int55) Equal(other any) bool {
	otherInt, ok := other.(Int55)
	if !ok {
		return false
	}
	return u == otherInt
}
func (u Int55) MarshalJSON() ([]byte, error) {
	return []byte(fmt.Sprintf("%d", u)), nil
}

func (u *Int55) UnmarshalJSON(p []byte) error {
	value, err := strconv.ParseInt(strings.Trim(string(p), "\""), 10, 55)
	if err != nil {
		return err
	}
	*u = Int55(value)
	return nil
}

type Uint56 uint64

func (u Uint56) MarshalTLB(c *boc.Cell, encoder *Encoder) error {
	return c.WriteUint(uint64(u), 56)
}

func (u *Uint56) UnmarshalTLB(c *boc.Cell, decoder *Decoder) error {
	v, err := c.ReadUint(56)
	*u = Uint56(v)
	return err
}

func (u Uint56) FixedSize() int {
	return 56
}

func (u Uint56) Equal(other any) bool {
	otherInt, ok := other.(Uint56)
	if !ok {
		return false
	}
	return u == otherInt
}
func (u Uint56) MarshalJSON() ([]byte, error) {
	return []byte(fmt.Sprintf("%d", u)), nil
}

func (u *Uint56) UnmarshalJSON(p []byte) error {
	value, err := strconv.ParseUint(strings.Trim(string(p), "\""), 10, 56)
	if err != nil {
		return err
	}
	*u = Uint56(value)
	return nil
}

type Int56 int64

func (u Int56) MarshalTLB(c *boc.Cell, encoder *Encoder) error {
	return c.WriteInt(int64(u), 56)
}

func (u *Int56) UnmarshalTLB(c *boc.Cell, decoder *Decoder) error {
	v, err := c.ReadInt(56)
	*u = Int56(v)
	return err
}

func (u Int56) FixedSize() int {
	return 56
}

func (u Int56) Equal(other any) bool {
	otherInt, ok := other.(Int56)
	if !ok {
		return false
	}
	return u == otherInt
}
func (u Int56) MarshalJSON() ([]byte, error) {
	return []byte(fmt.Sprintf("%d", u)), nil
}

func (u *Int56) UnmarshalJSON(p []byte) error {
	value, err := strconv.ParseInt(strings.Trim(string(p), "\""), 10, 56)
	if err != nil {
		return err
	}
	*u = Int56(value)
	return nil
}

type Uint57 uint64

func (u Uint57) MarshalTLB(c *boc.Cell, encoder *Encoder) error {
	return c.WriteUint(uint64(u), 57)
}

func (u *Uint57) UnmarshalTLB(c *boc.Cell, decoder *Decoder) error {
	v, err := c.ReadUint(57)
	*u = Uint57(v)
	return err
}

func (u Uint57) FixedSize() int {
	return 57
}

func (u Uint57) Equal(other any) bool {
	otherInt, ok := other.(Uint57)
	if !ok {
		return false
	}
	return u == otherInt
}
func (u Uint57) MarshalJSON() ([]byte, error) {
	return []byte(fmt.Sprintf("\"%d\"", u)), nil
}

func (u *Uint57) UnmarshalJSON(p []byte) error {
	value, err := strconv.ParseUint(strings.Trim(string(p), "\""), 10, 57)
	if err != nil {
		return err
	}
	*u = Uint57(value)
	return nil
}

type Int57 int64

func (u Int57) MarshalTLB(c *boc.Cell, encoder *Encoder) error {
	return c.WriteInt(int64(u), 57)
}

func (u *Int57) UnmarshalTLB(c *boc.Cell, decoder *Decoder) error {
	v, err := c.ReadInt(57)
	*u = Int57(v)
	return err
}

func (u Int57) FixedSize() int {
	return 57
}

func (u Int57) Equal(other any) bool {
	otherInt, ok := other.(Int57)
	if !ok {
		return false
	}
	return u == otherInt
}
func (u Int57) MarshalJSON() ([]byte, error) {
	return []byte(fmt.Sprintf("\"%d\"", u)), nil
}

func (u *Int57) UnmarshalJSON(p []byte) error {
	value, err := strconv.ParseInt(strings.Trim(string(p), "\""), 10, 57)
	if err != nil {
		return err
	}
	*u = Int57(value)
	return nil
}

type Uint58 uint64

func (u Uint58) MarshalTLB(c *boc.Cell, encoder *Encoder) error {
	return c.WriteUint(uint64(u), 58)
}

func (u *Uint58) UnmarshalTLB(c *boc.Cell, decoder *Decoder) error {
	v, err := c.ReadUint(58)
	*u = Uint58(v)
	return err
}

func (u Uint58) FixedSize() int {
	return 58
}

func (u Uint58) Equal(other any) bool {
	otherInt, ok := other.(Uint58)
	if !ok {
		return false
	}
	return u == otherInt
}
func (u Uint58) MarshalJSON() ([]byte, error) {
	return []byte(fmt.Sprintf("\"%d\"", u)), nil
}

func (u *Uint58) UnmarshalJSON(p []byte) error {
	value, err := strconv.ParseUint(strings.Trim(string(p), "\""), 10, 58)
	if err != nil {
		return err
	}
	*u = Uint58(value)
	return nil
}

type Int58 int64

func (u Int58) MarshalTLB(c *boc.Cell, encoder *Encoder) error {
	return c.WriteInt(int64(u), 58)
}

func (u *Int58) UnmarshalTLB(c *boc.Cell, decoder *Decoder) error {
	v, err := c.ReadInt(58)
	*u = Int58(v)
	return err
}

func (u Int58) FixedSize() int {
	return 58
}

func (u Int58) Equal(other any) bool {
	otherInt, ok := other.(Int58)
	if !ok {
		return false
	}
	return u == otherInt
}
func (u Int58) MarshalJSON() ([]byte, error) {
	return []byte(fmt.Sprintf("\"%d\"", u)), nil
}

func (u *Int58) UnmarshalJSON(p []byte) error {
	value, err := strconv.ParseInt(strings.Trim(string(p), "\""), 10, 58)
	if err != nil {
		return err
	}
	*u = Int58(value)
	return nil
}

type Uint59 uint64

func (u Uint59) MarshalTLB(c *boc.Cell, encoder *Encoder) error {
	return c.WriteUint(uint64(u), 59)
}

func (u *Uint59) UnmarshalTLB(c *boc.Cell, decoder *Decoder) error {
	v, err := c.ReadUint(59)
	*u = Uint59(v)
	return err
}

func (u Uint59) FixedSize() int {
	return 59
}

func (u Uint59) Equal(other any) bool {
	otherInt, ok := other.(Uint59)
	if !ok {
		return false
	}
	return u == otherInt
}
func (u Uint59) MarshalJSON() ([]byte, error) {
	return []byte(fmt.Sprintf("\"%d\"", u)), nil
}

func (u *Uint59) UnmarshalJSON(p []byte) error {
	value, err := strconv.ParseUint(strings.Trim(string(p), "\""), 10, 59)
	if err != nil {
		return err
	}
	*u = Uint59(value)
	return nil
}

type Int59 int64

func (u Int59) MarshalTLB(c *boc.Cell, encoder *Encoder) error {
	return c.WriteInt(int64(u), 59)
}

func (u *Int59) UnmarshalTLB(c *boc.Cell, decoder *Decoder) error {
	v, err := c.ReadInt(59)
	*u = Int59(v)
	return err
}

func (u Int59) FixedSize() int {
	return 59
}

func (u Int59) Equal(other any) bool {
	otherInt, ok := other.(Int59)
	if !ok {
		return false
	}
	return u == otherInt
}
func (u Int59) MarshalJSON() ([]byte, error) {
	return []byte(fmt.Sprintf("\"%d\"", u)), nil
}

func (u *Int59) UnmarshalJSON(p []byte) error {
	value, err := strconv.ParseInt(strings.Trim(string(p), "\""), 10, 59)
	if err != nil {
		return err
	}
	*u = Int59(value)
	return nil
}

type Uint60 uint64

func (u Uint60) MarshalTLB(c *boc.Cell, encoder *Encoder) error {
	return c.WriteUint(uint64(u), 60)
}

func (u *Uint60) UnmarshalTLB(c *boc.Cell, decoder *Decoder) error {
	v, err := c.ReadUint(60)
	*u = Uint60(v)
	return err
}

func (u Uint60) FixedSize() int {
	return 60
}

func (u Uint60) Equal(other any) bool {
	otherInt, ok := other.(Uint60)
	if !ok {
		return false
	}
	return u == otherInt
}
func (u Uint60) MarshalJSON() ([]byte, error) {
	return []byte(fmt.Sprintf("\"%d\"", u)), nil
}

func (u *Uint60) UnmarshalJSON(p []byte) error {
	value, err := strconv.ParseUint(strings.Trim(string(p), "\""), 10, 60)
	if err != nil {
		return err
	}
	*u = Uint60(value)
	return nil
}

type Int60 int64

func (u Int60) MarshalTLB(c *boc.Cell, encoder *Encoder) error {
	return c.WriteInt(int64(u), 60)
}

func (u *Int60) UnmarshalTLB(c *boc.Cell, decoder *Decoder) error {
	v, err := c.ReadInt(60)
	*u = Int60(v)
	return err
}

func (u Int60) FixedSize() int {
	return 60
}

func (u Int60) Equal(other any) bool {
	otherInt, ok := other.(Int60)
	if !ok {
		return false
	}
	return u == otherInt
}
func (u Int60) MarshalJSON() ([]byte, error) {
	return []byte(fmt.Sprintf("\"%d\"", u)), nil
}

func (u *Int60) UnmarshalJSON(p []byte) error {
	value, err := strconv.ParseInt(strings.Trim(string(p), "\""), 10, 60)
	if err != nil {
		return err
	}
	*u = Int60(value)
	return nil
}

type Uint61 uint64

func (u Uint61) MarshalTLB(c *boc.Cell, encoder *Encoder) error {
	return c.WriteUint(uint64(u), 61)
}

func (u *Uint61) UnmarshalTLB(c *boc.Cell, decoder *Decoder) error {
	v, err := c.ReadUint(61)
	*u = Uint61(v)
	return err
}

func (u Uint61) FixedSize() int {
	return 61
}

func (u Uint61) Equal(other any) bool {
	otherInt, ok := other.(Uint61)
	if !ok {
		return false
	}
	return u == otherInt
}
func (u Uint61) MarshalJSON() ([]byte, error) {
	return []byte(fmt.Sprintf("\"%d\"", u)), nil
}

func (u *Uint61) UnmarshalJSON(p []byte) error {
	value, err := strconv.ParseUint(strings.Trim(string(p), "\""), 10, 61)
	if err != nil {
		return err
	}
	*u = Uint61(value)
	return nil
}

type Int61 int64

func (u Int61) MarshalTLB(c *boc.Cell, encoder *Encoder) error {
	return c.WriteInt(int64(u), 61)
}

func (u *Int61) UnmarshalTLB(c *boc.Cell, decoder *Decoder) error {
	v, err := c.ReadInt(61)
	*u = Int61(v)
	return err
}

func (u Int61) FixedSize() int {
	return 61
}

func (u Int61) Equal(other any) bool {
	otherInt, ok := other.(Int61)
	if !ok {
		return false
	}
	return u == otherInt
}
func (u Int61) MarshalJSON() ([]byte, error) {
	return []byte(fmt.Sprintf("\"%d\"", u)), nil
}

func (u *Int61) UnmarshalJSON(p []byte) error {
	value, err := strconv.ParseInt(strings.Trim(string(p), "\""), 10, 61)
	if err != nil {
		return err
	}
	*u = Int61(value)
	return nil
}

type Uint62 uint64

func (u Uint62) MarshalTLB(c *boc.Cell, encoder *Encoder) error {
	return c.WriteUint(uint64(u), 62)
}

func (u *Uint62) UnmarshalTLB(c *boc.Cell, decoder *Decoder) error {
	v, err := c.ReadUint(62)
	*u = Uint62(v)
	return err
}

func (u Uint62) FixedSize() int {
	return 62
}

func (u Uint62) Equal(other any) bool {
	otherInt, ok := other.(Uint62)
	if !ok {
		return false
	}
	return u == otherInt
}
func (u Uint62) MarshalJSON() ([]byte, error) {
	return []byte(fmt.Sprintf("\"%d\"", u)), nil
}

func (u *Uint62) UnmarshalJSON(p []byte) error {
	value, err := strconv.ParseUint(strings.Trim(string(p), "\""), 10, 62)
	if err != nil {
		return err
	}
	*u = Uint62(value)
	return nil
}

type Int62 int64

func (u Int62) MarshalTLB(c *boc.Cell, encoder *Encoder) error {
	return c.WriteInt(int64(u), 62)
}

func (u *Int62) UnmarshalTLB(c *boc.Cell, decoder *Decoder) error {
	v, err := c.ReadInt(62)
	*u = Int62(v)
	return err
}

func (u Int62) FixedSize() int {
	return 62
}

func (u Int62) Equal(other any) bool {
	otherInt, ok := other.(Int62)
	if !ok {
		return false
	}
	return u == otherInt
}
func (u Int62) MarshalJSON() ([]byte, error) {
	return []byte(fmt.Sprintf("\"%d\"", u)), nil
}

func (u *Int62) UnmarshalJSON(p []byte) error {
	value, err := strconv.ParseInt(strings.Trim(string(p), "\""), 10, 62)
	if err != nil {
		return err
	}
	*u = Int62(value)
	return nil
}

type Uint63 uint64

func (u Uint63) MarshalTLB(c *boc.Cell, encoder *Encoder) error {
	return c.WriteUint(uint64(u), 63)
}

func (u *Uint63) UnmarshalTLB(c *boc.Cell, decoder *Decoder) error {
	v, err := c.ReadUint(63)
	*u = Uint63(v)
	return err
}

func (u Uint63) FixedSize() int {
	return 63
}

func (u Uint63) Equal(other any) bool {
	otherInt, ok := other.(Uint63)
	if !ok {
		return false
	}
	return u == otherInt
}
func (u Uint63) MarshalJSON() ([]byte, error) {
	return []byte(fmt.Sprintf("\"%d\"", u)), nil
}

func (u *Uint63) UnmarshalJSON(p []byte) error {
	value, err := strconv.ParseUint(strings.Trim(string(p), "\""), 10, 63)
	if err != nil {
		return err
	}
	*u = Uint63(value)
	return nil
}

type Int63 int64

func (u Int63) MarshalTLB(c *boc.Cell, encoder *Encoder) error {
	return c.WriteInt(int64(u), 63)
}

func (u *Int63) UnmarshalTLB(c *boc.Cell, decoder *Decoder) error {
	v, err := c.ReadInt(63)
	*u = Int63(v)
	return err
}

func (u Int63) FixedSize() int {
	return 63
}

func (u Int63) Equal(other any) bool {
	otherInt, ok := other.(Int63)
	if !ok {
		return false
	}
	return u == otherInt
}
func (u Int63) MarshalJSON() ([]byte, error) {
	return []byte(fmt.Sprintf("\"%d\"", u)), nil
}

func (u *Int63) UnmarshalJSON(p []byte) error {
	value, err := strconv.ParseInt(strings.Trim(string(p), "\""), 10, 63)
	if err != nil {
		return err
	}
	*u = Int63(value)
	return nil
}

type Uint64 uint64

func (u Uint64) MarshalTLB(c *boc.Cell, encoder *Encoder) error {
	return c.WriteUint(uint64(u), 64)
}

func (u *Uint64) UnmarshalTLB(c *boc.Cell, decoder *Decoder) error {
	v, err := c.ReadUint(64)
	*u = Uint64(v)
	return err
}

func (u Uint64) FixedSize() int {
	return 64
}

func (u Uint64) Equal(other any) bool {
	otherInt, ok := other.(Uint64)
	if !ok {
		return false
	}
	return u == otherInt
}
func (u Uint64) MarshalJSON() ([]byte, error) {
	return []byte(fmt.Sprintf("\"%d\"", u)), nil
}

func (u *Uint64) UnmarshalJSON(p []byte) error {
	value, err := strconv.ParseUint(strings.Trim(string(p), "\""), 10, 64)
	if err != nil {
		return err
	}
	*u = Uint64(value)
	return nil
}

type Int64 int64

func (u Int64) MarshalTLB(c *boc.Cell, encoder *Encoder) error {
	return c.WriteInt(int64(u), 64)
}

func (u *Int64) UnmarshalTLB(c *boc.Cell, decoder *Decoder) error {
	v, err := c.ReadInt(64)
	*u = Int64(v)
	return err
}

func (u Int64) FixedSize() int {
	return 64
}

func (u Int64) Equal(other any) bool {
	otherInt, ok := other.(Int64)
	if !ok {
		return false
	}
	return u == otherInt
}
func (u Int64) MarshalJSON() ([]byte, error) {
	return []byte(fmt.Sprintf("\"%d\"", u)), nil
}

func (u *Int64) UnmarshalJSON(p []byte) error {
	value, err := strconv.ParseInt(strings.Trim(string(p), "\""), 10, 64)
	if err != nil {
		return err
	}
	*u = Int64(value)
	return nil
}

type Uint128 big.Int

func (u Uint128) MarshalTLB(c *boc.Cell, encoder *Encoder) error {
	x := big.Int(u)
	return c.WriteBigUint(&x, 128)
}

func (u *Uint128) UnmarshalTLB(c *boc.Cell, decoder *Decoder) error {
	v, err := c.ReadBigUint(128)
	if err != nil {
		return err
	}
	*u = Uint128(*v)
	return err
}

func (u Uint128) FixedSize() int {
	return 128
}

func (u Uint128) MarshalJSON() ([]byte, error) {
	i := big.Int(u)
	return []byte(fmt.Sprintf("\"%s\"", i.String())), nil
}

func (u *Uint128) UnmarshalJSON(p []byte) error {
	var z big.Int
	_, ok := z.SetString(strings.Trim(string(p), "\""), 10)
	if !ok {
		return fmt.Errorf("invalid integer: %s", p)
	}
	*u = Uint128(z)
	return nil
}

type Int128 big.Int

func (u Int128) MarshalTLB(c *boc.Cell, encoder *Encoder) error {
	x := big.Int(u)
	return c.WriteBigInt(&x, 128)
}

func (u *Int128) UnmarshalTLB(c *boc.Cell, decoder *Decoder) error {
	v, err := c.ReadBigInt(128)
	*u = Int128(*v)
	return err
}

func (u Int128) FixedSize() int {
	return 128
}

func (u Int128) MarshalJSON() ([]byte, error) {
	i := big.Int(u)
	return []byte(fmt.Sprintf("\"%s\"", i.String())), nil
}

func (u *Int128) UnmarshalJSON(p []byte) error {
	var z big.Int
	_, ok := z.SetString(strings.Trim(string(p), "\""), 10)
	if !ok {
		return fmt.Errorf("invalid integer: %s", p)
	}
	*u = Int128(z)
	return nil
}

type Uint256 big.Int

func (u Uint256) MarshalTLB(c *boc.Cell, encoder *Encoder) error {
	x := big.Int(u)
	return c.WriteBigUint(&x, 256)
}

func (u *Uint256) UnmarshalTLB(c *boc.Cell, decoder *Decoder) error {
	v, err := c.ReadBigUint(256)
	if err != nil {
		return err
	}
	*u = Uint256(*v)
	return err
}

func (u Uint256) FixedSize() int {
	return 256
}

func (u Uint256) MarshalJSON() ([]byte, error) {
	i := big.Int(u)
	return []byte(fmt.Sprintf("\"%s\"", i.String())), nil
}

func (u *Uint256) UnmarshalJSON(p []byte) error {
	var z big.Int
	_, ok := z.SetString(strings.Trim(string(p), "\""), 10)
	if !ok {
		return fmt.Errorf("invalid integer: %s", p)
	}
	*u = Uint256(z)
	return nil
}

type Int256 big.Int

func (u Int256) MarshalTLB(c *boc.Cell, encoder *Encoder) error {
	x := big.Int(u)
	return c.WriteBigInt(&x, 256)
}

func (u *Int256) UnmarshalTLB(c *boc.Cell, decoder *Decoder) error {
	v, err := c.ReadBigInt(256)
	*u = Int256(*v)
	return err
}

func (u Int256) FixedSize() int {
	return 256
}

func (u Int256) MarshalJSON() ([]byte, error) {
	i := big.Int(u)
	return []byte(fmt.Sprintf("\"%s\"", i.String())), nil
}

func (u *Int256) UnmarshalJSON(p []byte) error {
	var z big.Int
	_, ok := z.SetString(strings.Trim(string(p), "\""), 10)
	if !ok {
		return fmt.Errorf("invalid integer: %s", p)
	}
	*u = Int256(z)
	return nil
}

type Uint257 big.Int

func (u Uint257) MarshalTLB(c *boc.Cell, encoder *Encoder) error {
	x := big.Int(u)
	return c.WriteBigUint(&x, 257)
}

func (u *Uint257) UnmarshalTLB(c *boc.Cell, decoder *Decoder) error {
	v, err := c.ReadBigUint(257)
	if err != nil {
		return err
	}
	*u = Uint257(*v)
	return err
}

func (u Uint257) FixedSize() int {
	return 257
}

func (u Uint257) MarshalJSON() ([]byte, error) {
	i := big.Int(u)
	return []byte(fmt.Sprintf("\"%s\"", i.String())), nil
}

func (u *Uint257) UnmarshalJSON(p []byte) error {
	var z big.Int
	_, ok := z.SetString(strings.Trim(string(p), "\""), 10)
	if !ok {
		return fmt.Errorf("invalid integer: %s", p)
	}
	*u = Uint257(z)
	return nil
}

type Int257 big.Int

func (u Int257) MarshalTLB(c *boc.Cell, encoder *Encoder) error {
	x := big.Int(u)
	return c.WriteBigInt(&x, 257)
}

func (u *Int257) UnmarshalTLB(c *boc.Cell, decoder *Decoder) error {
	v, err := c.ReadBigInt(257)
	*u = Int257(*v)
	return err
}

func (u Int257) FixedSize() int {
	return 257
}

func (u Int257) MarshalJSON() ([]byte, error) {
	i := big.Int(u)
	return []byte(fmt.Sprintf("\"%s\"", i.String())), nil
}

func (u *Int257) UnmarshalJSON(p []byte) error {
	var z big.Int
	_, ok := z.SetString(strings.Trim(string(p), "\""), 10)
	if !ok {
		return fmt.Errorf("invalid integer: %s", p)
	}
	*u = Int257(z)
	return nil
}

type Bits80 [10]byte

func (u Bits80) FixedSize() int {
	return 80
}

func (u Bits80) MarshalJSON() ([]byte, error) {
	return []byte(fmt.Sprintf("\"%x\"", u[:])), nil
}

func (u *Bits80) UnmarshalJSON(b []byte) error {
	bs, err := hex.DecodeString(strings.Trim(string(b), "\""))
	if err != nil {
		return err
	}
	if len(bs) != 10 {
		return fmt.Errorf("can't parse Bits80 %v", string(b))
	}
	copy(u[:], bs)
	return nil
}

func (u Bits80) Equal(other any) bool {
	otherBits, ok := other.(Bits80)
	if !ok {
		return false
	}
	return u == otherBits
}

type Bits96 [12]byte

func (u Bits96) FixedSize() int {
	return 96
}

func (u Bits96) MarshalJSON() ([]byte, error) {
	return []byte(fmt.Sprintf("\"%x\"", u[:])), nil
}

func (u *Bits96) UnmarshalJSON(b []byte) error {
	bs, err := hex.DecodeString(strings.Trim(string(b), "\""))
	if err != nil {
		return err
	}
	if len(bs) != 12 {
		return fmt.Errorf("can't parse Bits96 %v", string(b))
	}
	copy(u[:], bs)
	return nil
}

func (u Bits96) Equal(other any) bool {
	otherBits, ok := other.(Bits96)
	if !ok {
		return false
	}
	return u == otherBits
}

type Bits256 [32]byte

func (u Bits256) FixedSize() int {
	return 256
}

func (u Bits256) MarshalJSON() ([]byte, error) {
	return []byte(fmt.Sprintf("\"%x\"", u[:])), nil
}

func (u *Bits256) UnmarshalJSON(b []byte) error {
	bs, err := hex.DecodeString(strings.Trim(string(b), "\""))
	if err != nil {
		return err
	}
	if len(bs) != 32 {
		return fmt.Errorf("can't parse Bits256 %v", string(b))
	}
	copy(u[:], bs)
	return nil
}

func (u Bits256) Equal(other any) bool {
	otherBits, ok := other.(Bits256)
	if !ok {
		return false
	}
	return u == otherBits
}

type Bits264 [33]byte

func (u Bits264) FixedSize() int {
	return 264
}

func (u Bits264) MarshalJSON() ([]byte, error) {
	return []byte(fmt.Sprintf("\"%x\"", u[:])), nil
}

func (u *Bits264) UnmarshalJSON(b []byte) error {
	bs, err := hex.DecodeString(strings.Trim(string(b), "\""))
	if err != nil {
		return err
	}
	if len(bs) != 33 {
		return fmt.Errorf("can't parse Bits264 %v", string(b))
	}
	copy(u[:], bs)
	return nil
}

func (u Bits264) Equal(other any) bool {
	otherBits, ok := other.(Bits264)
	if !ok {
		return false
	}
	return u == otherBits
}

type Bits320 [40]byte

func (u Bits320) FixedSize() int {
	return 320
}

func (u Bits320) MarshalJSON() ([]byte, error) {
	return []byte(fmt.Sprintf("\"%x\"", u[:])), nil
}

func (u *Bits320) UnmarshalJSON(b []byte) error {
	bs, err := hex.DecodeString(strings.Trim(string(b), "\""))
	if err != nil {
		return err
	}
	if len(bs) != 40 {
		return fmt.Errorf("can't parse Bits320 %v", string(b))
	}
	copy(u[:], bs)
	return nil
}

func (u Bits320) Equal(other any) bool {
	otherBits, ok := other.(Bits320)
	if !ok {
		return false
	}
	return u == otherBits
}

type Bits352 [44]byte

func (u Bits352) FixedSize() int {
	return 352
}

func (u Bits352) MarshalJSON() ([]byte, error) {
	return []byte(fmt.Sprintf("\"%x\"", u[:])), nil
}

func (u *Bits352) UnmarshalJSON(b []byte) error {
	bs, err := hex.DecodeString(strings.Trim(string(b), "\""))
	if err != nil {
		return err
	}
	if len(bs) != 44 {
		return fmt.Errorf("can't parse Bits352 %v", string(b))
	}
	copy(u[:], bs)
	return nil
}

func (u Bits352) Equal(other any) bool {
	otherBits, ok := other.(Bits352)
	if !ok {
		return false
	}
	return u == otherBits
}

type Bits512 [64]byte

func (u Bits512) FixedSize() int {
	return 512
}

func (u Bits512) MarshalJSON() ([]byte, error) {
	return []byte(fmt.Sprintf("\"%x\"", u[:])), nil
}

func (u *Bits512) UnmarshalJSON(b []byte) error {
	bs, err := hex.DecodeString(strings.Trim(string(b), "\""))
	if err != nil {
		return err
	}
	if len(bs) != 64 {
		return fmt.Errorf("can't parse Bits512 %v", string(b))
	}
	copy(u[:], bs)
	return nil
}

func (u Bits512) Equal(other any) bool {
	otherBits, ok := other.(Bits512)
	if !ok {
		return false
	}
	return u == otherBits
}