package decode

// Generated with numbers.go.tmpl

// Integer readers

// S read a nBits signed current endian integer
func (d *D) S(nBits int) int64 { return d.SE(nBits, d.Endian) }

// TryS try read a nBits signed current endian integer
func (d *D) TryS(nBits int) (int64, error) { return d.TrySE(nBits, d.Endian) }

// S1 read 1 bit signed current endian integer
func (d *D) S1() int64 { return d.SE(1, d.Endian) }

// TryS1 try read 1 bit signed current endian integer
func (d *D) TryS1() (int64, error) { return d.TrySE(1, d.Endian) }

// S2 read 2 bit signed current endian integer
func (d *D) S2() int64 { return d.SE(2, d.Endian) }

// TryS2 try read 2 bit signed current endian integer
func (d *D) TryS2() (int64, error) { return d.TrySE(2, d.Endian) }

// S3 read 3 bit signed current endian integer
func (d *D) S3() int64 { return d.SE(3, d.Endian) }

// TryS3 try read 3 bit signed current endian integer
func (d *D) TryS3() (int64, error) { return d.TrySE(3, d.Endian) }

// S4 read 4 bit signed current endian integer
func (d *D) S4() int64 { return d.SE(4, d.Endian) }

// TryS4 try read 4 bit signed current endian integer
func (d *D) TryS4() (int64, error) { return d.TrySE(4, d.Endian) }

// S5 read 5 bit signed current endian integer
func (d *D) S5() int64 { return d.SE(5, d.Endian) }

// TryS5 try read 5 bit signed current endian integer
func (d *D) TryS5() (int64, error) { return d.TrySE(5, d.Endian) }

// S6 read 6 bit signed current endian integer
func (d *D) S6() int64 { return d.SE(6, d.Endian) }

// TryS6 try read 6 bit signed current endian integer
func (d *D) TryS6() (int64, error) { return d.TrySE(6, d.Endian) }

// S7 read 7 bit signed current endian integer
func (d *D) S7() int64 { return d.SE(7, d.Endian) }

// TryS7 try read 7 bit signed current endian integer
func (d *D) TryS7() (int64, error) { return d.TrySE(7, d.Endian) }

// S8 read 8 bit signed current endian integer
func (d *D) S8() int64 { return d.SE(8, d.Endian) }

// TryS8 try read 8 bit signed current endian integer
func (d *D) TryS8() (int64, error) { return d.TrySE(8, d.Endian) }

// S9 read 9 bit signed current endian integer
func (d *D) S9() int64 { return d.SE(9, d.Endian) }

// TryS9 try read 9 bit signed current endian integer
func (d *D) TryS9() (int64, error) { return d.TrySE(9, d.Endian) }

// S10 read 10 bit signed current endian integer
func (d *D) S10() int64 { return d.SE(10, d.Endian) }

// TryS10 try read 10 bit signed current endian integer
func (d *D) TryS10() (int64, error) { return d.TrySE(10, d.Endian) }

// S11 read 11 bit signed current endian integer
func (d *D) S11() int64 { return d.SE(11, d.Endian) }

// TryS11 try read 11 bit signed current endian integer
func (d *D) TryS11() (int64, error) { return d.TrySE(11, d.Endian) }

// S12 read 12 bit signed current endian integer
func (d *D) S12() int64 { return d.SE(12, d.Endian) }

// TryS12 try read 12 bit signed current endian integer
func (d *D) TryS12() (int64, error) { return d.TrySE(12, d.Endian) }

// S13 read 13 bit signed current endian integer
func (d *D) S13() int64 { return d.SE(13, d.Endian) }

// TryS13 try read 13 bit signed current endian integer
func (d *D) TryS13() (int64, error) { return d.TrySE(13, d.Endian) }

// S14 read 14 bit signed current endian integer
func (d *D) S14() int64 { return d.SE(14, d.Endian) }

// TryS14 try read 14 bit signed current endian integer
func (d *D) TryS14() (int64, error) { return d.TrySE(14, d.Endian) }

// S15 read 15 bit signed current endian integer
func (d *D) S15() int64 { return d.SE(15, d.Endian) }

// TryS15 try read 15 bit signed current endian integer
func (d *D) TryS15() (int64, error) { return d.TrySE(15, d.Endian) }

// S16 read 16 bit signed current endian integer
func (d *D) S16() int64 { return d.SE(16, d.Endian) }

// TryS16 try read 16 bit signed current endian integer
func (d *D) TryS16() (int64, error) { return d.TrySE(16, d.Endian) }

// S17 read 17 bit signed current endian integer
func (d *D) S17() int64 { return d.SE(17, d.Endian) }

// TryS17 try read 17 bit signed current endian integer
func (d *D) TryS17() (int64, error) { return d.TrySE(17, d.Endian) }

// S18 read 18 bit signed current endian integer
func (d *D) S18() int64 { return d.SE(18, d.Endian) }

// TryS18 try read 18 bit signed current endian integer
func (d *D) TryS18() (int64, error) { return d.TrySE(18, d.Endian) }

// S19 read 19 bit signed current endian integer
func (d *D) S19() int64 { return d.SE(19, d.Endian) }

// TryS19 try read 19 bit signed current endian integer
func (d *D) TryS19() (int64, error) { return d.TrySE(19, d.Endian) }

// S20 read 20 bit signed current endian integer
func (d *D) S20() int64 { return d.SE(20, d.Endian) }

// TryS20 try read 20 bit signed current endian integer
func (d *D) TryS20() (int64, error) { return d.TrySE(20, d.Endian) }

// S21 read 21 bit signed current endian integer
func (d *D) S21() int64 { return d.SE(21, d.Endian) }

// TryS21 try read 21 bit signed current endian integer
func (d *D) TryS21() (int64, error) { return d.TrySE(21, d.Endian) }

// S22 read 22 bit signed current endian integer
func (d *D) S22() int64 { return d.SE(22, d.Endian) }

// TryS22 try read 22 bit signed current endian integer
func (d *D) TryS22() (int64, error) { return d.TrySE(22, d.Endian) }

// S23 read 23 bit signed current endian integer
func (d *D) S23() int64 { return d.SE(23, d.Endian) }

// TryS23 try read 23 bit signed current endian integer
func (d *D) TryS23() (int64, error) { return d.TrySE(23, d.Endian) }

// S24 read 24 bit signed current endian integer
func (d *D) S24() int64 { return d.SE(24, d.Endian) }

// TryS24 try read 24 bit signed current endian integer
func (d *D) TryS24() (int64, error) { return d.TrySE(24, d.Endian) }

// S25 read 25 bit signed current endian integer
func (d *D) S25() int64 { return d.SE(25, d.Endian) }

// TryS25 try read 25 bit signed current endian integer
func (d *D) TryS25() (int64, error) { return d.TrySE(25, d.Endian) }

// S26 read 26 bit signed current endian integer
func (d *D) S26() int64 { return d.SE(26, d.Endian) }

// TryS26 try read 26 bit signed current endian integer
func (d *D) TryS26() (int64, error) { return d.TrySE(26, d.Endian) }

// S27 read 27 bit signed current endian integer
func (d *D) S27() int64 { return d.SE(27, d.Endian) }

// TryS27 try read 27 bit signed current endian integer
func (d *D) TryS27() (int64, error) { return d.TrySE(27, d.Endian) }

// S28 read 28 bit signed current endian integer
func (d *D) S28() int64 { return d.SE(28, d.Endian) }

// TryS28 try read 28 bit signed current endian integer
func (d *D) TryS28() (int64, error) { return d.TrySE(28, d.Endian) }

// S29 read 29 bit signed current endian integer
func (d *D) S29() int64 { return d.SE(29, d.Endian) }

// TryS29 try read 29 bit signed current endian integer
func (d *D) TryS29() (int64, error) { return d.TrySE(29, d.Endian) }

// S30 read 30 bit signed current endian integer
func (d *D) S30() int64 { return d.SE(30, d.Endian) }

// TryS30 try read 30 bit signed current endian integer
func (d *D) TryS30() (int64, error) { return d.TrySE(30, d.Endian) }

// S31 read 31 bit signed current endian integer
func (d *D) S31() int64 { return d.SE(31, d.Endian) }

// TryS31 try read 31 bit signed current endian integer
func (d *D) TryS31() (int64, error) { return d.TrySE(31, d.Endian) }

// S32 read 32 bit signed current endian integer
func (d *D) S32() int64 { return d.SE(32, d.Endian) }

// TryS32 try read 32 bit signed current endian integer
func (d *D) TryS32() (int64, error) { return d.TrySE(32, d.Endian) }

// S33 read 33 bit signed current endian integer
func (d *D) S33() int64 { return d.SE(33, d.Endian) }

// TryS33 try read 33 bit signed current endian integer
func (d *D) TryS33() (int64, error) { return d.TrySE(33, d.Endian) }

// S34 read 34 bit signed current endian integer
func (d *D) S34() int64 { return d.SE(34, d.Endian) }

// TryS34 try read 34 bit signed current endian integer
func (d *D) TryS34() (int64, error) { return d.TrySE(34, d.Endian) }

// S35 read 35 bit signed current endian integer
func (d *D) S35() int64 { return d.SE(35, d.Endian) }

// TryS35 try read 35 bit signed current endian integer
func (d *D) TryS35() (int64, error) { return d.TrySE(35, d.Endian) }

// S36 read 36 bit signed current endian integer
func (d *D) S36() int64 { return d.SE(36, d.Endian) }

// TryS36 try read 36 bit signed current endian integer
func (d *D) TryS36() (int64, error) { return d.TrySE(36, d.Endian) }

// S37 read 37 bit signed current endian integer
func (d *D) S37() int64 { return d.SE(37, d.Endian) }

// TryS37 try read 37 bit signed current endian integer
func (d *D) TryS37() (int64, error) { return d.TrySE(37, d.Endian) }

// S38 read 38 bit signed current endian integer
func (d *D) S38() int64 { return d.SE(38, d.Endian) }

// TryS38 try read 38 bit signed current endian integer
func (d *D) TryS38() (int64, error) { return d.TrySE(38, d.Endian) }

// S39 read 39 bit signed current endian integer
func (d *D) S39() int64 { return d.SE(39, d.Endian) }

// TryS39 try read 39 bit signed current endian integer
func (d *D) TryS39() (int64, error) { return d.TrySE(39, d.Endian) }

// S40 read 40 bit signed current endian integer
func (d *D) S40() int64 { return d.SE(40, d.Endian) }

// TryS40 try read 40 bit signed current endian integer
func (d *D) TryS40() (int64, error) { return d.TrySE(40, d.Endian) }

// S41 read 41 bit signed current endian integer
func (d *D) S41() int64 { return d.SE(41, d.Endian) }

// TryS41 try read 41 bit signed current endian integer
func (d *D) TryS41() (int64, error) { return d.TrySE(41, d.Endian) }

// S42 read 42 bit signed current endian integer
func (d *D) S42() int64 { return d.SE(42, d.Endian) }

// TryS42 try read 42 bit signed current endian integer
func (d *D) TryS42() (int64, error) { return d.TrySE(42, d.Endian) }

// S43 read 43 bit signed current endian integer
func (d *D) S43() int64 { return d.SE(43, d.Endian) }

// TryS43 try read 43 bit signed current endian integer
func (d *D) TryS43() (int64, error) { return d.TrySE(43, d.Endian) }

// S44 read 44 bit signed current endian integer
func (d *D) S44() int64 { return d.SE(44, d.Endian) }

// TryS44 try read 44 bit signed current endian integer
func (d *D) TryS44() (int64, error) { return d.TrySE(44, d.Endian) }

// S45 read 45 bit signed current endian integer
func (d *D) S45() int64 { return d.SE(45, d.Endian) }

// TryS45 try read 45 bit signed current endian integer
func (d *D) TryS45() (int64, error) { return d.TrySE(45, d.Endian) }

// S46 read 46 bit signed current endian integer
func (d *D) S46() int64 { return d.SE(46, d.Endian) }

// TryS46 try read 46 bit signed current endian integer
func (d *D) TryS46() (int64, error) { return d.TrySE(46, d.Endian) }

// S47 read 47 bit signed current endian integer
func (d *D) S47() int64 { return d.SE(47, d.Endian) }

// TryS47 try read 47 bit signed current endian integer
func (d *D) TryS47() (int64, error) { return d.TrySE(47, d.Endian) }

// S48 read 48 bit signed current endian integer
func (d *D) S48() int64 { return d.SE(48, d.Endian) }

// TryS48 try read 48 bit signed current endian integer
func (d *D) TryS48() (int64, error) { return d.TrySE(48, d.Endian) }

// S49 read 49 bit signed current endian integer
func (d *D) S49() int64 { return d.SE(49, d.Endian) }

// TryS49 try read 49 bit signed current endian integer
func (d *D) TryS49() (int64, error) { return d.TrySE(49, d.Endian) }

// S50 read 50 bit signed current endian integer
func (d *D) S50() int64 { return d.SE(50, d.Endian) }

// TryS50 try read 50 bit signed current endian integer
func (d *D) TryS50() (int64, error) { return d.TrySE(50, d.Endian) }

// S51 read 51 bit signed current endian integer
func (d *D) S51() int64 { return d.SE(51, d.Endian) }

// TryS51 try read 51 bit signed current endian integer
func (d *D) TryS51() (int64, error) { return d.TrySE(51, d.Endian) }

// S52 read 52 bit signed current endian integer
func (d *D) S52() int64 { return d.SE(52, d.Endian) }

// TryS52 try read 52 bit signed current endian integer
func (d *D) TryS52() (int64, error) { return d.TrySE(52, d.Endian) }

// S53 read 53 bit signed current endian integer
func (d *D) S53() int64 { return d.SE(53, d.Endian) }

// TryS53 try read 53 bit signed current endian integer
func (d *D) TryS53() (int64, error) { return d.TrySE(53, d.Endian) }

// S54 read 54 bit signed current endian integer
func (d *D) S54() int64 { return d.SE(54, d.Endian) }

// TryS54 try read 54 bit signed current endian integer
func (d *D) TryS54() (int64, error) { return d.TrySE(54, d.Endian) }

// S55 read 55 bit signed current endian integer
func (d *D) S55() int64 { return d.SE(55, d.Endian) }

// TryS55 try read 55 bit signed current endian integer
func (d *D) TryS55() (int64, error) { return d.TrySE(55, d.Endian) }

// S56 read 56 bit signed current endian integer
func (d *D) S56() int64 { return d.SE(56, d.Endian) }

// TryS56 try read 56 bit signed current endian integer
func (d *D) TryS56() (int64, error) { return d.TrySE(56, d.Endian) }

// S57 read 57 bit signed current endian integer
func (d *D) S57() int64 { return d.SE(57, d.Endian) }

// TryS57 try read 57 bit signed current endian integer
func (d *D) TryS57() (int64, error) { return d.TrySE(57, d.Endian) }

// S58 read 58 bit signed current endian integer
func (d *D) S58() int64 { return d.SE(58, d.Endian) }

// TryS58 try read 58 bit signed current endian integer
func (d *D) TryS58() (int64, error) { return d.TrySE(58, d.Endian) }

// S59 read 59 bit signed current endian integer
func (d *D) S59() int64 { return d.SE(59, d.Endian) }

// TryS59 try read 59 bit signed current endian integer
func (d *D) TryS59() (int64, error) { return d.TrySE(59, d.Endian) }

// S60 read 60 bit signed current endian integer
func (d *D) S60() int64 { return d.SE(60, d.Endian) }

// TryS60 try read 60 bit signed current endian integer
func (d *D) TryS60() (int64, error) { return d.TrySE(60, d.Endian) }

// S61 read 61 bit signed current endian integer
func (d *D) S61() int64 { return d.SE(61, d.Endian) }

// TryS61 try read 61 bit signed current endian integer
func (d *D) TryS61() (int64, error) { return d.TrySE(61, d.Endian) }

// S62 read 62 bit signed current endian integer
func (d *D) S62() int64 { return d.SE(62, d.Endian) }

// TryS62 try read 62 bit signed current endian integer
func (d *D) TryS62() (int64, error) { return d.TrySE(62, d.Endian) }

// S63 read 63 bit signed current endian integer
func (d *D) S63() int64 { return d.SE(63, d.Endian) }

// TryS63 try read 63 bit signed current endian integer
func (d *D) TryS63() (int64, error) { return d.TrySE(63, d.Endian) }

// S64 read 64 bit signed current endian integer
func (d *D) S64() int64 { return d.SE(64, d.Endian) }

// TryS64 try read 64 bit signed current endian integer
func (d *D) TryS64() (int64, error) { return d.TrySE(64, d.Endian) }

// FieldS read a nBits signed current endian integer and add a field
func (d *D) FieldS(name string, nBits int) int64 { return d.FieldSE(name, nBits, d.Endian) }

// FieldS1 read 1 bit signed current endian integer and add a field
func (d *D) FieldS1(name string) int64 { return d.FieldSE(name, 1, d.Endian) }

// FieldS2 read 2 bit signed current endian integer and add a field
func (d *D) FieldS2(name string) int64 { return d.FieldSE(name, 2, d.Endian) }

// FieldS3 read 3 bit signed current endian integer and add a field
func (d *D) FieldS3(name string) int64 { return d.FieldSE(name, 3, d.Endian) }

// FieldS4 read 4 bit signed current endian integer and add a field
func (d *D) FieldS4(name string) int64 { return d.FieldSE(name, 4, d.Endian) }

// FieldS5 read 5 bit signed current endian integer and add a field
func (d *D) FieldS5(name string) int64 { return d.FieldSE(name, 5, d.Endian) }

// FieldS6 read 6 bit signed current endian integer and add a field
func (d *D) FieldS6(name string) int64 { return d.FieldSE(name, 6, d.Endian) }

// FieldS7 read 7 bit signed current endian integer and add a field
func (d *D) FieldS7(name string) int64 { return d.FieldSE(name, 7, d.Endian) }

// FieldS8 read 8 bit signed current endian integer and add a field
func (d *D) FieldS8(name string) int64 { return d.FieldSE(name, 8, d.Endian) }

// FieldS9 read 9 bit signed current endian integer and add a field
func (d *D) FieldS9(name string) int64 { return d.FieldSE(name, 9, d.Endian) }

// FieldS10 read 10 bit signed current endian integer and add a field
func (d *D) FieldS10(name string) int64 { return d.FieldSE(name, 10, d.Endian) }

// FieldS11 read 11 bit signed current endian integer and add a field
func (d *D) FieldS11(name string) int64 { return d.FieldSE(name, 11, d.Endian) }

// FieldS12 read 12 bit signed current endian integer and add a field
func (d *D) FieldS12(name string) int64 { return d.FieldSE(name, 12, d.Endian) }

// FieldS13 read 13 bit signed current endian integer and add a field
func (d *D) FieldS13(name string) int64 { return d.FieldSE(name, 13, d.Endian) }

// FieldS14 read 14 bit signed current endian integer and add a field
func (d *D) FieldS14(name string) int64 { return d.FieldSE(name, 14, d.Endian) }

// FieldS15 read 15 bit signed current endian integer and add a field
func (d *D) FieldS15(name string) int64 { return d.FieldSE(name, 15, d.Endian) }

// FieldS16 read 16 bit signed current endian integer and add a field
func (d *D) FieldS16(name string) int64 { return d.FieldSE(name, 16, d.Endian) }

// FieldS17 read 17 bit signed current endian integer and add a field
func (d *D) FieldS17(name string) int64 { return d.FieldSE(name, 17, d.Endian) }

// FieldS18 read 18 bit signed current endian integer and add a field
func (d *D) FieldS18(name string) int64 { return d.FieldSE(name, 18, d.Endian) }

// FieldS19 read 19 bit signed current endian integer and add a field
func (d *D) FieldS19(name string) int64 { return d.FieldSE(name, 19, d.Endian) }

// FieldS20 read 20 bit signed current endian integer and add a field
func (d *D) FieldS20(name string) int64 { return d.FieldSE(name, 20, d.Endian) }

// FieldS21 read 21 bit signed current endian integer and add a field
func (d *D) FieldS21(name string) int64 { return d.FieldSE(name, 21, d.Endian) }

// FieldS22 read 22 bit signed current endian integer and add a field
func (d *D) FieldS22(name string) int64 { return d.FieldSE(name, 22, d.Endian) }

// FieldS23 read 23 bit signed current endian integer and add a field
func (d *D) FieldS23(name string) int64 { return d.FieldSE(name, 23, d.Endian) }

// FieldS24 read 24 bit signed current endian integer and add a field
func (d *D) FieldS24(name string) int64 { return d.FieldSE(name, 24, d.Endian) }

// FieldS25 read 25 bit signed current endian integer and add a field
func (d *D) FieldS25(name string) int64 { return d.FieldSE(name, 25, d.Endian) }

// FieldS26 read 26 bit signed current endian integer and add a field
func (d *D) FieldS26(name string) int64 { return d.FieldSE(name, 26, d.Endian) }

// FieldS27 read 27 bit signed current endian integer and add a field
func (d *D) FieldS27(name string) int64 { return d.FieldSE(name, 27, d.Endian) }

// FieldS28 read 28 bit signed current endian integer and add a field
func (d *D) FieldS28(name string) int64 { return d.FieldSE(name, 28, d.Endian) }

// FieldS29 read 29 bit signed current endian integer and add a field
func (d *D) FieldS29(name string) int64 { return d.FieldSE(name, 29, d.Endian) }

// FieldS30 read 30 bit signed current endian integer and add a field
func (d *D) FieldS30(name string) int64 { return d.FieldSE(name, 30, d.Endian) }

// FieldS31 read 31 bit signed current endian integer and add a field
func (d *D) FieldS31(name string) int64 { return d.FieldSE(name, 31, d.Endian) }

// FieldS32 read 32 bit signed current endian integer and add a field
func (d *D) FieldS32(name string) int64 { return d.FieldSE(name, 32, d.Endian) }

// FieldS33 read 33 bit signed current endian integer and add a field
func (d *D) FieldS33(name string) int64 { return d.FieldSE(name, 33, d.Endian) }

// FieldS34 read 34 bit signed current endian integer and add a field
func (d *D) FieldS34(name string) int64 { return d.FieldSE(name, 34, d.Endian) }

// FieldS35 read 35 bit signed current endian integer and add a field
func (d *D) FieldS35(name string) int64 { return d.FieldSE(name, 35, d.Endian) }

// FieldS36 read 36 bit signed current endian integer and add a field
func (d *D) FieldS36(name string) int64 { return d.FieldSE(name, 36, d.Endian) }

// FieldS37 read 37 bit signed current endian integer and add a field
func (d *D) FieldS37(name string) int64 { return d.FieldSE(name, 37, d.Endian) }

// FieldS38 read 38 bit signed current endian integer and add a field
func (d *D) FieldS38(name string) int64 { return d.FieldSE(name, 38, d.Endian) }

// FieldS39 read 39 bit signed current endian integer and add a field
func (d *D) FieldS39(name string) int64 { return d.FieldSE(name, 39, d.Endian) }

// FieldS40 read 40 bit signed current endian integer and add a field
func (d *D) FieldS40(name string) int64 { return d.FieldSE(name, 40, d.Endian) }

// FieldS41 read 41 bit signed current endian integer and add a field
func (d *D) FieldS41(name string) int64 { return d.FieldSE(name, 41, d.Endian) }

// FieldS42 read 42 bit signed current endian integer and add a field
func (d *D) FieldS42(name string) int64 { return d.FieldSE(name, 42, d.Endian) }

// FieldS43 read 43 bit signed current endian integer and add a field
func (d *D) FieldS43(name string) int64 { return d.FieldSE(name, 43, d.Endian) }

// FieldS44 read 44 bit signed current endian integer and add a field
func (d *D) FieldS44(name string) int64 { return d.FieldSE(name, 44, d.Endian) }

// FieldS45 read 45 bit signed current endian integer and add a field
func (d *D) FieldS45(name string) int64 { return d.FieldSE(name, 45, d.Endian) }

// FieldS46 read 46 bit signed current endian integer and add a field
func (d *D) FieldS46(name string) int64 { return d.FieldSE(name, 46, d.Endian) }

// FieldS47 read 47 bit signed current endian integer and add a field
func (d *D) FieldS47(name string) int64 { return d.FieldSE(name, 47, d.Endian) }

// FieldS48 read 48 bit signed current endian integer and add a field
func (d *D) FieldS48(name string) int64 { return d.FieldSE(name, 48, d.Endian) }

// FieldS49 read 49 bit signed current endian integer and add a field
func (d *D) FieldS49(name string) int64 { return d.FieldSE(name, 49, d.Endian) }

// FieldS50 read 50 bit signed current endian integer and add a field
func (d *D) FieldS50(name string) int64 { return d.FieldSE(name, 50, d.Endian) }

// FieldS51 read 51 bit signed current endian integer and add a field
func (d *D) FieldS51(name string) int64 { return d.FieldSE(name, 51, d.Endian) }

// FieldS52 read 52 bit signed current endian integer and add a field
func (d *D) FieldS52(name string) int64 { return d.FieldSE(name, 52, d.Endian) }

// FieldS53 read 53 bit signed current endian integer and add a field
func (d *D) FieldS53(name string) int64 { return d.FieldSE(name, 53, d.Endian) }

// FieldS54 read 54 bit signed current endian integer and add a field
func (d *D) FieldS54(name string) int64 { return d.FieldSE(name, 54, d.Endian) }

// FieldS55 read 55 bit signed current endian integer and add a field
func (d *D) FieldS55(name string) int64 { return d.FieldSE(name, 55, d.Endian) }

// FieldS56 read 56 bit signed current endian integer and add a field
func (d *D) FieldS56(name string) int64 { return d.FieldSE(name, 56, d.Endian) }

// FieldS57 read 57 bit signed current endian integer and add a field
func (d *D) FieldS57(name string) int64 { return d.FieldSE(name, 57, d.Endian) }

// FieldS58 read 58 bit signed current endian integer and add a field
func (d *D) FieldS58(name string) int64 { return d.FieldSE(name, 58, d.Endian) }

// FieldS59 read 59 bit signed current endian integer and add a field
func (d *D) FieldS59(name string) int64 { return d.FieldSE(name, 59, d.Endian) }

// FieldS60 read 60 bit signed current endian integer and add a field
func (d *D) FieldS60(name string) int64 { return d.FieldSE(name, 60, d.Endian) }

// FieldS61 read 61 bit signed current endian integer and add a field
func (d *D) FieldS61(name string) int64 { return d.FieldSE(name, 61, d.Endian) }

// FieldS62 read 62 bit signed current endian integer and add a field
func (d *D) FieldS62(name string) int64 { return d.FieldSE(name, 62, d.Endian) }

// FieldS63 read 63 bit signed current endian integer and add a field
func (d *D) FieldS63(name string) int64 { return d.FieldSE(name, 63, d.Endian) }

// FieldS64 read 64 bit signed current endian integer and add a field
func (d *D) FieldS64(name string) int64 { return d.FieldSE(name, 64, d.Endian) }

// SBE read a nBits signed big-endian integer
func (d *D) SBE(nBits int) int64 { return d.SE(nBits, BigEndian) }

// TrySBE try read a nBits signed big-endian integer
func (d *D) TrySBE(nBits int) (int64, error) { return d.TrySE(nBits, BigEndian) }

// S8BE read 8 bit signed big-endian integer
func (d *D) S8BE() int64 { return d.SE(8, BigEndian) }

// TryS8BE try read 8 bit signed big-endian integer
func (d *D) TryS8BE() (int64, error) { return d.TrySE(8, BigEndian) }

// S9BE read 9 bit signed big-endian integer
func (d *D) S9BE() int64 { return d.SE(9, BigEndian) }

// TryS9BE try read 9 bit signed big-endian integer
func (d *D) TryS9BE() (int64, error) { return d.TrySE(9, BigEndian) }

// S10BE read 10 bit signed big-endian integer
func (d *D) S10BE() int64 { return d.SE(10, BigEndian) }

// TryS10BE try read 10 bit signed big-endian integer
func (d *D) TryS10BE() (int64, error) { return d.TrySE(10, BigEndian) }

// S11BE read 11 bit signed big-endian integer
func (d *D) S11BE() int64 { return d.SE(11, BigEndian) }

// TryS11BE try read 11 bit signed big-endian integer
func (d *D) TryS11BE() (int64, error) { return d.TrySE(11, BigEndian) }

// S12BE read 12 bit signed big-endian integer
func (d *D) S12BE() int64 { return d.SE(12, BigEndian) }

// TryS12BE try read 12 bit signed big-endian integer
func (d *D) TryS12BE() (int64, error) { return d.TrySE(12, BigEndian) }

// S13BE read 13 bit signed big-endian integer
func (d *D) S13BE() int64 { return d.SE(13, BigEndian) }

// TryS13BE try read 13 bit signed big-endian integer
func (d *D) TryS13BE() (int64, error) { return d.TrySE(13, BigEndian) }

// S14BE read 14 bit signed big-endian integer
func (d *D) S14BE() int64 { return d.SE(14, BigEndian) }

// TryS14BE try read 14 bit signed big-endian integer
func (d *D) TryS14BE() (int64, error) { return d.TrySE(14, BigEndian) }

// S15BE read 15 bit signed big-endian integer
func (d *D) S15BE() int64 { return d.SE(15, BigEndian) }

// TryS15BE try read 15 bit signed big-endian integer
func (d *D) TryS15BE() (int64, error) { return d.TrySE(15, BigEndian) }

// S16BE read 16 bit signed big-endian integer
func (d *D) S16BE() int64 { return d.SE(16, BigEndian) }

// TryS16BE try read 16 bit signed big-endian integer
func (d *D) TryS16BE() (int64, error) { return d.TrySE(16, BigEndian) }

// S17BE read 17 bit signed big-endian integer
func (d *D) S17BE() int64 { return d.SE(17, BigEndian) }

// TryS17BE try read 17 bit signed big-endian integer
func (d *D) TryS17BE() (int64, error) { return d.TrySE(17, BigEndian) }

// S18BE read 18 bit signed big-endian integer
func (d *D) S18BE() int64 { return d.SE(18, BigEndian) }

// TryS18BE try read 18 bit signed big-endian integer
func (d *D) TryS18BE() (int64, error) { return d.TrySE(18, BigEndian) }

// S19BE read 19 bit signed big-endian integer
func (d *D) S19BE() int64 { return d.SE(19, BigEndian) }

// TryS19BE try read 19 bit signed big-endian integer
func (d *D) TryS19BE() (int64, error) { return d.TrySE(19, BigEndian) }

// S20BE read 20 bit signed big-endian integer
func (d *D) S20BE() int64 { return d.SE(20, BigEndian) }

// TryS20BE try read 20 bit signed big-endian integer
func (d *D) TryS20BE() (int64, error) { return d.TrySE(20, BigEndian) }

// S21BE read 21 bit signed big-endian integer
func (d *D) S21BE() int64 { return d.SE(21, BigEndian) }

// TryS21BE try read 21 bit signed big-endian integer
func (d *D) TryS21BE() (int64, error) { return d.TrySE(21, BigEndian) }

// S22BE read 22 bit signed big-endian integer
func (d *D) S22BE() int64 { return d.SE(22, BigEndian) }

// TryS22BE try read 22 bit signed big-endian integer
func (d *D) TryS22BE() (int64, error) { return d.TrySE(22, BigEndian) }

// S23BE read 23 bit signed big-endian integer
func (d *D) S23BE() int64 { return d.SE(23, BigEndian) }

// TryS23BE try read 23 bit signed big-endian integer
func (d *D) TryS23BE() (int64, error) { return d.TrySE(23, BigEndian) }

// S24BE read 24 bit signed big-endian integer
func (d *D) S24BE() int64 { return d.SE(24, BigEndian) }

// TryS24BE try read 24 bit signed big-endian integer
func (d *D) TryS24BE() (int64, error) { return d.TrySE(24, BigEndian) }

// S25BE read 25 bit signed big-endian integer
func (d *D) S25BE() int64 { return d.SE(25, BigEndian) }

// TryS25BE try read 25 bit signed big-endian integer
func (d *D) TryS25BE() (int64, error) { return d.TrySE(25, BigEndian) }

// S26BE read 26 bit signed big-endian integer
func (d *D) S26BE() int64 { return d.SE(26, BigEndian) }

// TryS26BE try read 26 bit signed big-endian integer
func (d *D) TryS26BE() (int64, error) { return d.TrySE(26, BigEndian) }

// S27BE read 27 bit signed big-endian integer
func (d *D) S27BE() int64 { return d.SE(27, BigEndian) }

// TryS27BE try read 27 bit signed big-endian integer
func (d *D) TryS27BE() (int64, error) { return d.TrySE(27, BigEndian) }

// S28BE read 28 bit signed big-endian integer
func (d *D) S28BE() int64 { return d.SE(28, BigEndian) }

// TryS28BE try read 28 bit signed big-endian integer
func (d *D) TryS28BE() (int64, error) { return d.TrySE(28, BigEndian) }

// S29BE read 29 bit signed big-endian integer
func (d *D) S29BE() int64 { return d.SE(29, BigEndian) }

// TryS29BE try read 29 bit signed big-endian integer
func (d *D) TryS29BE() (int64, error) { return d.TrySE(29, BigEndian) }

// S30BE read 30 bit signed big-endian integer
func (d *D) S30BE() int64 { return d.SE(30, BigEndian) }

// TryS30BE try read 30 bit signed big-endian integer
func (d *D) TryS30BE() (int64, error) { return d.TrySE(30, BigEndian) }

// S31BE read 31 bit signed big-endian integer
func (d *D) S31BE() int64 { return d.SE(31, BigEndian) }

// TryS31BE try read 31 bit signed big-endian integer
func (d *D) TryS31BE() (int64, error) { return d.TrySE(31, BigEndian) }

// S32BE read 32 bit signed big-endian integer
func (d *D) S32BE() int64 { return d.SE(32, BigEndian) }

// TryS32BE try read 32 bit signed big-endian integer
func (d *D) TryS32BE() (int64, error) { return d.TrySE(32, BigEndian) }

// S33BE read 33 bit signed big-endian integer
func (d *D) S33BE() int64 { return d.SE(33, BigEndian) }

// TryS33BE try read 33 bit signed big-endian integer
func (d *D) TryS33BE() (int64, error) { return d.TrySE(33, BigEndian) }

// S34BE read 34 bit signed big-endian integer
func (d *D) S34BE() int64 { return d.SE(34, BigEndian) }

// TryS34BE try read 34 bit signed big-endian integer
func (d *D) TryS34BE() (int64, error) { return d.TrySE(34, BigEndian) }

// S35BE read 35 bit signed big-endian integer
func (d *D) S35BE() int64 { return d.SE(35, BigEndian) }

// TryS35BE try read 35 bit signed big-endian integer
func (d *D) TryS35BE() (int64, error) { return d.TrySE(35, BigEndian) }

// S36BE read 36 bit signed big-endian integer
func (d *D) S36BE() int64 { return d.SE(36, BigEndian) }

// TryS36BE try read 36 bit signed big-endian integer
func (d *D) TryS36BE() (int64, error) { return d.TrySE(36, BigEndian) }

// S37BE read 37 bit signed big-endian integer
func (d *D) S37BE() int64 { return d.SE(37, BigEndian) }

// TryS37BE try read 37 bit signed big-endian integer
func (d *D) TryS37BE() (int64, error) { return d.TrySE(37, BigEndian) }

// S38BE read 38 bit signed big-endian integer
func (d *D) S38BE() int64 { return d.SE(38, BigEndian) }

// TryS38BE try read 38 bit signed big-endian integer
func (d *D) TryS38BE() (int64, error) { return d.TrySE(38, BigEndian) }

// S39BE read 39 bit signed big-endian integer
func (d *D) S39BE() int64 { return d.SE(39, BigEndian) }

// TryS39BE try read 39 bit signed big-endian integer
func (d *D) TryS39BE() (int64, error) { return d.TrySE(39, BigEndian) }

// S40BE read 40 bit signed big-endian integer
func (d *D) S40BE() int64 { return d.SE(40, BigEndian) }

// TryS40BE try read 40 bit signed big-endian integer
func (d *D) TryS40BE() (int64, error) { return d.TrySE(40, BigEndian) }

// S41BE read 41 bit signed big-endian integer
func (d *D) S41BE() int64 { return d.SE(41, BigEndian) }

// TryS41BE try read 41 bit signed big-endian integer
func (d *D) TryS41BE() (int64, error) { return d.TrySE(41, BigEndian) }

// S42BE read 42 bit signed big-endian integer
func (d *D) S42BE() int64 { return d.SE(42, BigEndian) }

// TryS42BE try read 42 bit signed big-endian integer
func (d *D) TryS42BE() (int64, error) { return d.TrySE(42, BigEndian) }

// S43BE read 43 bit signed big-endian integer
func (d *D) S43BE() int64 { return d.SE(43, BigEndian) }

// TryS43BE try read 43 bit signed big-endian integer
func (d *D) TryS43BE() (int64, error) { return d.TrySE(43, BigEndian) }

// S44BE read 44 bit signed big-endian integer
func (d *D) S44BE() int64 { return d.SE(44, BigEndian) }

// TryS44BE try read 44 bit signed big-endian integer
func (d *D) TryS44BE() (int64, error) { return d.TrySE(44, BigEndian) }

// S45BE read 45 bit signed big-endian integer
func (d *D) S45BE() int64 { return d.SE(45, BigEndian) }

// TryS45BE try read 45 bit signed big-endian integer
func (d *D) TryS45BE() (int64, error) { return d.TrySE(45, BigEndian) }

// S46BE read 46 bit signed big-endian integer
func (d *D) S46BE() int64 { return d.SE(46, BigEndian) }

// TryS46BE try read 46 bit signed big-endian integer
func (d *D) TryS46BE() (int64, error) { return d.TrySE(46, BigEndian) }

// S47BE read 47 bit signed big-endian integer
func (d *D) S47BE() int64 { return d.SE(47, BigEndian) }

// TryS47BE try read 47 bit signed big-endian integer
func (d *D) TryS47BE() (int64, error) { return d.TrySE(47, BigEndian) }

// S48BE read 48 bit signed big-endian integer
func (d *D) S48BE() int64 { return d.SE(48, BigEndian) }

// TryS48BE try read 48 bit signed big-endian integer
func (d *D) TryS48BE() (int64, error) { return d.TrySE(48, BigEndian) }

// S49BE read 49 bit signed big-endian integer
func (d *D) S49BE() int64 { return d.SE(49, BigEndian) }

// TryS49BE try read 49 bit signed big-endian integer
func (d *D) TryS49BE() (int64, error) { return d.TrySE(49, BigEndian) }

// S50BE read 50 bit signed big-endian integer
func (d *D) S50BE() int64 { return d.SE(50, BigEndian) }

// TryS50BE try read 50 bit signed big-endian integer
func (d *D) TryS50BE() (int64, error) { return d.TrySE(50, BigEndian) }

// S51BE read 51 bit signed big-endian integer
func (d *D) S51BE() int64 { return d.SE(51, BigEndian) }

// TryS51BE try read 51 bit signed big-endian integer
func (d *D) TryS51BE() (int64, error) { return d.TrySE(51, BigEndian) }

// S52BE read 52 bit signed big-endian integer
func (d *D) S52BE() int64 { return d.SE(52, BigEndian) }

// TryS52BE try read 52 bit signed big-endian integer
func (d *D) TryS52BE() (int64, error) { return d.TrySE(52, BigEndian) }

// S53BE read 53 bit signed big-endian integer
func (d *D) S53BE() int64 { return d.SE(53, BigEndian) }

// TryS53BE try read 53 bit signed big-endian integer
func (d *D) TryS53BE() (int64, error) { return d.TrySE(53, BigEndian) }

// S54BE read 54 bit signed big-endian integer
func (d *D) S54BE() int64 { return d.SE(54, BigEndian) }

// TryS54BE try read 54 bit signed big-endian integer
func (d *D) TryS54BE() (int64, error) { return d.TrySE(54, BigEndian) }

// S55BE read 55 bit signed big-endian integer
func (d *D) S55BE() int64 { return d.SE(55, BigEndian) }

// TryS55BE try read 55 bit signed big-endian integer
func (d *D) TryS55BE() (int64, error) { return d.TrySE(55, BigEndian) }

// S56BE read 56 bit signed big-endian integer
func (d *D) S56BE() int64 { return d.SE(56, BigEndian) }

// TryS56BE try read 56 bit signed big-endian integer
func (d *D) TryS56BE() (int64, error) { return d.TrySE(56, BigEndian) }

// S57BE read 57 bit signed big-endian integer
func (d *D) S57BE() int64 { return d.SE(57, BigEndian) }

// TryS57BE try read 57 bit signed big-endian integer
func (d *D) TryS57BE() (int64, error) { return d.TrySE(57, BigEndian) }

// S58BE read 58 bit signed big-endian integer
func (d *D) S58BE() int64 { return d.SE(58, BigEndian) }

// TryS58BE try read 58 bit signed big-endian integer
func (d *D) TryS58BE() (int64, error) { return d.TrySE(58, BigEndian) }

// S59BE read 59 bit signed big-endian integer
func (d *D) S59BE() int64 { return d.SE(59, BigEndian) }

// TryS59BE try read 59 bit signed big-endian integer
func (d *D) TryS59BE() (int64, error) { return d.TrySE(59, BigEndian) }

// S60BE read 60 bit signed big-endian integer
func (d *D) S60BE() int64 { return d.SE(60, BigEndian) }

// TryS60BE try read 60 bit signed big-endian integer
func (d *D) TryS60BE() (int64, error) { return d.TrySE(60, BigEndian) }

// S61BE read 61 bit signed big-endian integer
func (d *D) S61BE() int64 { return d.SE(61, BigEndian) }

// TryS61BE try read 61 bit signed big-endian integer
func (d *D) TryS61BE() (int64, error) { return d.TrySE(61, BigEndian) }

// S62BE read 62 bit signed big-endian integer
func (d *D) S62BE() int64 { return d.SE(62, BigEndian) }

// TryS62BE try read 62 bit signed big-endian integer
func (d *D) TryS62BE() (int64, error) { return d.TrySE(62, BigEndian) }

// S63BE read 63 bit signed big-endian integer
func (d *D) S63BE() int64 { return d.SE(63, BigEndian) }

// TryS63BE try read 63 bit signed big-endian integer
func (d *D) TryS63BE() (int64, error) { return d.TrySE(63, BigEndian) }

// S64BE read 64 bit signed big-endian integer
func (d *D) S64BE() int64 { return d.SE(64, BigEndian) }

// TryS64BE try read 64 bit signed big-endian integer
func (d *D) TryS64BE() (int64, error) { return d.TrySE(64, BigEndian) }

// FieldSBE read a nBits signed big-endian integer and add a field
func (d *D) FieldSBE(name string, nBits int) int64 { return d.FieldSE(name, nBits, BigEndian) }

// FieldS8BE read 8 bit signed big-endian integer and add a field
func (d *D) FieldS8BE(name string) int64 { return d.FieldSE(name, 8, BigEndian) }

// FieldS9BE read 9 bit signed big-endian integer and add a field
func (d *D) FieldS9BE(name string) int64 { return d.FieldSE(name, 9, BigEndian) }

// FieldS10BE read 10 bit signed big-endian integer and add a field
func (d *D) FieldS10BE(name string) int64 { return d.FieldSE(name, 10, BigEndian) }

// FieldS11BE read 11 bit signed big-endian integer and add a field
func (d *D) FieldS11BE(name string) int64 { return d.FieldSE(name, 11, BigEndian) }

// FieldS12BE read 12 bit signed big-endian integer and add a field
func (d *D) FieldS12BE(name string) int64 { return d.FieldSE(name, 12, BigEndian) }

// FieldS13BE read 13 bit signed big-endian integer and add a field
func (d *D) FieldS13BE(name string) int64 { return d.FieldSE(name, 13, BigEndian) }

// FieldS14BE read 14 bit signed big-endian integer and add a field
func (d *D) FieldS14BE(name string) int64 { return d.FieldSE(name, 14, BigEndian) }

// FieldS15BE read 15 bit signed big-endian integer and add a field
func (d *D) FieldS15BE(name string) int64 { return d.FieldSE(name, 15, BigEndian) }

// FieldS16BE read 16 bit signed big-endian integer and add a field
func (d *D) FieldS16BE(name string) int64 { return d.FieldSE(name, 16, BigEndian) }

// FieldS17BE read 17 bit signed big-endian integer and add a field
func (d *D) FieldS17BE(name string) int64 { return d.FieldSE(name, 17, BigEndian) }

// FieldS18BE read 18 bit signed big-endian integer and add a field
func (d *D) FieldS18BE(name string) int64 { return d.FieldSE(name, 18, BigEndian) }

// FieldS19BE read 19 bit signed big-endian integer and add a field
func (d *D) FieldS19BE(name string) int64 { return d.FieldSE(name, 19, BigEndian) }

// FieldS20BE read 20 bit signed big-endian integer and add a field
func (d *D) FieldS20BE(name string) int64 { return d.FieldSE(name, 20, BigEndian) }

// FieldS21BE read 21 bit signed big-endian integer and add a field
func (d *D) FieldS21BE(name string) int64 { return d.FieldSE(name, 21, BigEndian) }

// FieldS22BE read 22 bit signed big-endian integer and add a field
func (d *D) FieldS22BE(name string) int64 { return d.FieldSE(name, 22, BigEndian) }

// FieldS23BE read 23 bit signed big-endian integer and add a field
func (d *D) FieldS23BE(name string) int64 { return d.FieldSE(name, 23, BigEndian) }

// FieldS24BE read 24 bit signed big-endian integer and add a field
func (d *D) FieldS24BE(name string) int64 { return d.FieldSE(name, 24, BigEndian) }

// FieldS25BE read 25 bit signed big-endian integer and add a field
func (d *D) FieldS25BE(name string) int64 { return d.FieldSE(name, 25, BigEndian) }

// FieldS26BE read 26 bit signed big-endian integer and add a field
func (d *D) FieldS26BE(name string) int64 { return d.FieldSE(name, 26, BigEndian) }

// FieldS27BE read 27 bit signed big-endian integer and add a field
func (d *D) FieldS27BE(name string) int64 { return d.FieldSE(name, 27, BigEndian) }

// FieldS28BE read 28 bit signed big-endian integer and add a field
func (d *D) FieldS28BE(name string) int64 { return d.FieldSE(name, 28, BigEndian) }

// FieldS29BE read 29 bit signed big-endian integer and add a field
func (d *D) FieldS29BE(name string) int64 { return d.FieldSE(name, 29, BigEndian) }

// FieldS30BE read 30 bit signed big-endian integer and add a field
func (d *D) FieldS30BE(name string) int64 { return d.FieldSE(name, 30, BigEndian) }

// FieldS31BE read 31 bit signed big-endian integer and add a field
func (d *D) FieldS31BE(name string) int64 { return d.FieldSE(name, 31, BigEndian) }

// FieldS32BE read 32 bit signed big-endian integer and add a field
func (d *D) FieldS32BE(name string) int64 { return d.FieldSE(name, 32, BigEndian) }

// FieldS33BE read 33 bit signed big-endian integer and add a field
func (d *D) FieldS33BE(name string) int64 { return d.FieldSE(name, 33, BigEndian) }

// FieldS34BE read 34 bit signed big-endian integer and add a field
func (d *D) FieldS34BE(name string) int64 { return d.FieldSE(name, 34, BigEndian) }

// FieldS35BE read 35 bit signed big-endian integer and add a field
func (d *D) FieldS35BE(name string) int64 { return d.FieldSE(name, 35, BigEndian) }

// FieldS36BE read 36 bit signed big-endian integer and add a field
func (d *D) FieldS36BE(name string) int64 { return d.FieldSE(name, 36, BigEndian) }

// FieldS37BE read 37 bit signed big-endian integer and add a field
func (d *D) FieldS37BE(name string) int64 { return d.FieldSE(name, 37, BigEndian) }

// FieldS38BE read 38 bit signed big-endian integer and add a field
func (d *D) FieldS38BE(name string) int64 { return d.FieldSE(name, 38, BigEndian) }

// FieldS39BE read 39 bit signed big-endian integer and add a field
func (d *D) FieldS39BE(name string) int64 { return d.FieldSE(name, 39, BigEndian) }

// FieldS40BE read 40 bit signed big-endian integer and add a field
func (d *D) FieldS40BE(name string) int64 { return d.FieldSE(name, 40, BigEndian) }

// FieldS41BE read 41 bit signed big-endian integer and add a field
func (d *D) FieldS41BE(name string) int64 { return d.FieldSE(name, 41, BigEndian) }

// FieldS42BE read 42 bit signed big-endian integer and add a field
func (d *D) FieldS42BE(name string) int64 { return d.FieldSE(name, 42, BigEndian) }

// FieldS43BE read 43 bit signed big-endian integer and add a field
func (d *D) FieldS43BE(name string) int64 { return d.FieldSE(name, 43, BigEndian) }

// FieldS44BE read 44 bit signed big-endian integer and add a field
func (d *D) FieldS44BE(name string) int64 { return d.FieldSE(name, 44, BigEndian) }

// FieldS45BE read 45 bit signed big-endian integer and add a field
func (d *D) FieldS45BE(name string) int64 { return d.FieldSE(name, 45, BigEndian) }

// FieldS46BE read 46 bit signed big-endian integer and add a field
func (d *D) FieldS46BE(name string) int64 { return d.FieldSE(name, 46, BigEndian) }

// FieldS47BE read 47 bit signed big-endian integer and add a field
func (d *D) FieldS47BE(name string) int64 { return d.FieldSE(name, 47, BigEndian) }

// FieldS48BE read 48 bit signed big-endian integer and add a field
func (d *D) FieldS48BE(name string) int64 { return d.FieldSE(name, 48, BigEndian) }

// FieldS49BE read 49 bit signed big-endian integer and add a field
func (d *D) FieldS49BE(name string) int64 { return d.FieldSE(name, 49, BigEndian) }

// FieldS50BE read 50 bit signed big-endian integer and add a field
func (d *D) FieldS50BE(name string) int64 { return d.FieldSE(name, 50, BigEndian) }

// FieldS51BE read 51 bit signed big-endian integer and add a field
func (d *D) FieldS51BE(name string) int64 { return d.FieldSE(name, 51, BigEndian) }

// FieldS52BE read 52 bit signed big-endian integer and add a field
func (d *D) FieldS52BE(name string) int64 { return d.FieldSE(name, 52, BigEndian) }

// FieldS53BE read 53 bit signed big-endian integer and add a field
func (d *D) FieldS53BE(name string) int64 { return d.FieldSE(name, 53, BigEndian) }

// FieldS54BE read 54 bit signed big-endian integer and add a field
func (d *D) FieldS54BE(name string) int64 { return d.FieldSE(name, 54, BigEndian) }

// FieldS55BE read 55 bit signed big-endian integer and add a field
func (d *D) FieldS55BE(name string) int64 { return d.FieldSE(name, 55, BigEndian) }

// FieldS56BE read 56 bit signed big-endian integer and add a field
func (d *D) FieldS56BE(name string) int64 { return d.FieldSE(name, 56, BigEndian) }

// FieldS57BE read 57 bit signed big-endian integer and add a field
func (d *D) FieldS57BE(name string) int64 { return d.FieldSE(name, 57, BigEndian) }

// FieldS58BE read 58 bit signed big-endian integer and add a field
func (d *D) FieldS58BE(name string) int64 { return d.FieldSE(name, 58, BigEndian) }

// FieldS59BE read 59 bit signed big-endian integer and add a field
func (d *D) FieldS59BE(name string) int64 { return d.FieldSE(name, 59, BigEndian) }

// FieldS60BE read 60 bit signed big-endian integer and add a field
func (d *D) FieldS60BE(name string) int64 { return d.FieldSE(name, 60, BigEndian) }

// FieldS61BE read 61 bit signed big-endian integer and add a field
func (d *D) FieldS61BE(name string) int64 { return d.FieldSE(name, 61, BigEndian) }

// FieldS62BE read 62 bit signed big-endian integer and add a field
func (d *D) FieldS62BE(name string) int64 { return d.FieldSE(name, 62, BigEndian) }

// FieldS63BE read 63 bit signed big-endian integer and add a field
func (d *D) FieldS63BE(name string) int64 { return d.FieldSE(name, 63, BigEndian) }

// FieldS64BE read 64 bit signed big-endian integer and add a field
func (d *D) FieldS64BE(name string) int64 { return d.FieldSE(name, 64, BigEndian) }

// SLE read a nBits signed little-endian integer
func (d *D) SLE(nBits int) int64 { return d.SE(nBits, LittleEndian) }

// TrySLE try read a nBits signed little-endian integer
func (d *D) TrySLE(nBits int) (int64, error) { return d.TrySE(nBits, LittleEndian) }

// S8LE read 8 bit signed little-endian integer
func (d *D) S8LE() int64 { return d.SE(8, LittleEndian) }

// TryS8LE try read 8 bit signed little-endian integer
func (d *D) TryS8LE() (int64, error) { return d.TrySE(8, LittleEndian) }

// S9LE read 9 bit signed little-endian integer
func (d *D) S9LE() int64 { return d.SE(9, LittleEndian) }

// TryS9LE try read 9 bit signed little-endian integer
func (d *D) TryS9LE() (int64, error) { return d.TrySE(9, LittleEndian) }

// S10LE read 10 bit signed little-endian integer
func (d *D) S10LE() int64 { return d.SE(10, LittleEndian) }

// TryS10LE try read 10 bit signed little-endian integer
func (d *D) TryS10LE() (int64, error) { return d.TrySE(10, LittleEndian) }

// S11LE read 11 bit signed little-endian integer
func (d *D) S11LE() int64 { return d.SE(11, LittleEndian) }

// TryS11LE try read 11 bit signed little-endian integer
func (d *D) TryS11LE() (int64, error) { return d.TrySE(11, LittleEndian) }

// S12LE read 12 bit signed little-endian integer
func (d *D) S12LE() int64 { return d.SE(12, LittleEndian) }

// TryS12LE try read 12 bit signed little-endian integer
func (d *D) TryS12LE() (int64, error) { return d.TrySE(12, LittleEndian) }

// S13LE read 13 bit signed little-endian integer
func (d *D) S13LE() int64 { return d.SE(13, LittleEndian) }

// TryS13LE try read 13 bit signed little-endian integer
func (d *D) TryS13LE() (int64, error) { return d.TrySE(13, LittleEndian) }

// S14LE read 14 bit signed little-endian integer
func (d *D) S14LE() int64 { return d.SE(14, LittleEndian) }

// TryS14LE try read 14 bit signed little-endian integer
func (d *D) TryS14LE() (int64, error) { return d.TrySE(14, LittleEndian) }

// S15LE read 15 bit signed little-endian integer
func (d *D) S15LE() int64 { return d.SE(15, LittleEndian) }

// TryS15LE try read 15 bit signed little-endian integer
func (d *D) TryS15LE() (int64, error) { return d.TrySE(15, LittleEndian) }

// S16LE read 16 bit signed little-endian integer
func (d *D) S16LE() int64 { return d.SE(16, LittleEndian) }

// TryS16LE try read 16 bit signed little-endian integer
func (d *D) TryS16LE() (int64, error) { return d.TrySE(16, LittleEndian) }

// S17LE read 17 bit signed little-endian integer
func (d *D) S17LE() int64 { return d.SE(17, LittleEndian) }

// TryS17LE try read 17 bit signed little-endian integer
func (d *D) TryS17LE() (int64, error) { return d.TrySE(17, LittleEndian) }

// S18LE read 18 bit signed little-endian integer
func (d *D) S18LE() int64 { return d.SE(18, LittleEndian) }

// TryS18LE try read 18 bit signed little-endian integer
func (d *D) TryS18LE() (int64, error) { return d.TrySE(18, LittleEndian) }

// S19LE read 19 bit signed little-endian integer
func (d *D) S19LE() int64 { return d.SE(19, LittleEndian) }

// TryS19LE try read 19 bit signed little-endian integer
func (d *D) TryS19LE() (int64, error) { return d.TrySE(19, LittleEndian) }

// S20LE read 20 bit signed little-endian integer
func (d *D) S20LE() int64 { return d.SE(20, LittleEndian) }

// TryS20LE try read 20 bit signed little-endian integer
func (d *D) TryS20LE() (int64, error) { return d.TrySE(20, LittleEndian) }

// S21LE read 21 bit signed little-endian integer
func (d *D) S21LE() int64 { return d.SE(21, LittleEndian) }

// TryS21LE try read 21 bit signed little-endian integer
func (d *D) TryS21LE() (int64, error) { return d.TrySE(21, LittleEndian) }

// S22LE read 22 bit signed little-endian integer
func (d *D) S22LE() int64 { return d.SE(22, LittleEndian) }

// TryS22LE try read 22 bit signed little-endian integer
func (d *D) TryS22LE() (int64, error) { return d.TrySE(22, LittleEndian) }

// S23LE read 23 bit signed little-endian integer
func (d *D) S23LE() int64 { return d.SE(23, LittleEndian) }

// TryS23LE try read 23 bit signed little-endian integer
func (d *D) TryS23LE() (int64, error) { return d.TrySE(23, LittleEndian) }

// S24LE read 24 bit signed little-endian integer
func (d *D) S24LE() int64 { return d.SE(24, LittleEndian) }

// TryS24LE try read 24 bit signed little-endian integer
func (d *D) TryS24LE() (int64, error) { return d.TrySE(24, LittleEndian) }

// S25LE read 25 bit signed little-endian integer
func (d *D) S25LE() int64 { return d.SE(25, LittleEndian) }

// TryS25LE try read 25 bit signed little-endian integer
func (d *D) TryS25LE() (int64, error) { return d.TrySE(25, LittleEndian) }

// S26LE read 26 bit signed little-endian integer
func (d *D) S26LE() int64 { return d.SE(26, LittleEndian) }

// TryS26LE try read 26 bit signed little-endian integer
func (d *D) TryS26LE() (int64, error) { return d.TrySE(26, LittleEndian) }

// S27LE read 27 bit signed little-endian integer
func (d *D) S27LE() int64 { return d.SE(27, LittleEndian) }

// TryS27LE try read 27 bit signed little-endian integer
func (d *D) TryS27LE() (int64, error) { return d.TrySE(27, LittleEndian) }

// S28LE read 28 bit signed little-endian integer
func (d *D) S28LE() int64 { return d.SE(28, LittleEndian) }

// TryS28LE try read 28 bit signed little-endian integer
func (d *D) TryS28LE() (int64, error) { return d.TrySE(28, LittleEndian) }

// S29LE read 29 bit signed little-endian integer
func (d *D) S29LE() int64 { return d.SE(29, LittleEndian) }

// TryS29LE try read 29 bit signed little-endian integer
func (d *D) TryS29LE() (int64, error) { return d.TrySE(29, LittleEndian) }

// S30LE read 30 bit signed little-endian integer
func (d *D) S30LE() int64 { return d.SE(30, LittleEndian) }

// TryS30LE try read 30 bit signed little-endian integer
func (d *D) TryS30LE() (int64, error) { return d.TrySE(30, LittleEndian) }

// S31LE read 31 bit signed little-endian integer
func (d *D) S31LE() int64 { return d.SE(31, LittleEndian) }

// TryS31LE try read 31 bit signed little-endian integer
func (d *D) TryS31LE() (int64, error) { return d.TrySE(31, LittleEndian) }

// S32LE read 32 bit signed little-endian integer
func (d *D) S32LE() int64 { return d.SE(32, LittleEndian) }

// TryS32LE try read 32 bit signed little-endian integer
func (d *D) TryS32LE() (int64, error) { return d.TrySE(32, LittleEndian) }

// S33LE read 33 bit signed little-endian integer
func (d *D) S33LE() int64 { return d.SE(33, LittleEndian) }

// TryS33LE try read 33 bit signed little-endian integer
func (d *D) TryS33LE() (int64, error) { return d.TrySE(33, LittleEndian) }

// S34LE read 34 bit signed little-endian integer
func (d *D) S34LE() int64 { return d.SE(34, LittleEndian) }

// TryS34LE try read 34 bit signed little-endian integer
func (d *D) TryS34LE() (int64, error) { return d.TrySE(34, LittleEndian) }

// S35LE read 35 bit signed little-endian integer
func (d *D) S35LE() int64 { return d.SE(35, LittleEndian) }

// TryS35LE try read 35 bit signed little-endian integer
func (d *D) TryS35LE() (int64, error) { return d.TrySE(35, LittleEndian) }

// S36LE read 36 bit signed little-endian integer
func (d *D) S36LE() int64 { return d.SE(36, LittleEndian) }

// TryS36LE try read 36 bit signed little-endian integer
func (d *D) TryS36LE() (int64, error) { return d.TrySE(36, LittleEndian) }

// S37LE read 37 bit signed little-endian integer
func (d *D) S37LE() int64 { return d.SE(37, LittleEndian) }

// TryS37LE try read 37 bit signed little-endian integer
func (d *D) TryS37LE() (int64, error) { return d.TrySE(37, LittleEndian) }

// S38LE read 38 bit signed little-endian integer
func (d *D) S38LE() int64 { return d.SE(38, LittleEndian) }

// TryS38LE try read 38 bit signed little-endian integer
func (d *D) TryS38LE() (int64, error) { return d.TrySE(38, LittleEndian) }

// S39LE read 39 bit signed little-endian integer
func (d *D) S39LE() int64 { return d.SE(39, LittleEndian) }

// TryS39LE try read 39 bit signed little-endian integer
func (d *D) TryS39LE() (int64, error) { return d.TrySE(39, LittleEndian) }

// S40LE read 40 bit signed little-endian integer
func (d *D) S40LE() int64 { return d.SE(40, LittleEndian) }

// TryS40LE try read 40 bit signed little-endian integer
func (d *D) TryS40LE() (int64, error) { return d.TrySE(40, LittleEndian) }

// S41LE read 41 bit signed little-endian integer
func (d *D) S41LE() int64 { return d.SE(41, LittleEndian) }

// TryS41LE try read 41 bit signed little-endian integer
func (d *D) TryS41LE() (int64, error) { return d.TrySE(41, LittleEndian) }

// S42LE read 42 bit signed little-endian integer
func (d *D) S42LE() int64 { return d.SE(42, LittleEndian) }

// TryS42LE try read 42 bit signed little-endian integer
func (d *D) TryS42LE() (int64, error) { return d.TrySE(42, LittleEndian) }

// S43LE read 43 bit signed little-endian integer
func (d *D) S43LE() int64 { return d.SE(43, LittleEndian) }

// TryS43LE try read 43 bit signed little-endian integer
func (d *D) TryS43LE() (int64, error) { return d.TrySE(43, LittleEndian) }

// S44LE read 44 bit signed little-endian integer
func (d *D) S44LE() int64 { return d.SE(44, LittleEndian) }

// TryS44LE try read 44 bit signed little-endian integer
func (d *D) TryS44LE() (int64, error) { return d.TrySE(44, LittleEndian) }

// S45LE read 45 bit signed little-endian integer
func (d *D) S45LE() int64 { return d.SE(45, LittleEndian) }

// TryS45LE try read 45 bit signed little-endian integer
func (d *D) TryS45LE() (int64, error) { return d.TrySE(45, LittleEndian) }

// S46LE read 46 bit signed little-endian integer
func (d *D) S46LE() int64 { return d.SE(46, LittleEndian) }

// TryS46LE try read 46 bit signed little-endian integer
func (d *D) TryS46LE() (int64, error) { return d.TrySE(46, LittleEndian) }

// S47LE read 47 bit signed little-endian integer
func (d *D) S47LE() int64 { return d.SE(47, LittleEndian) }

// TryS47LE try read 47 bit signed little-endian integer
func (d *D) TryS47LE() (int64, error) { return d.TrySE(47, LittleEndian) }

// S48LE read 48 bit signed little-endian integer
func (d *D) S48LE() int64 { return d.SE(48, LittleEndian) }

// TryS48LE try read 48 bit signed little-endian integer
func (d *D) TryS48LE() (int64, error) { return d.TrySE(48, LittleEndian) }

// S49LE read 49 bit signed little-endian integer
func (d *D) S49LE() int64 { return d.SE(49, LittleEndian) }

// TryS49LE try read 49 bit signed little-endian integer
func (d *D) TryS49LE() (int64, error) { return d.TrySE(49, LittleEndian) }

// S50LE read 50 bit signed little-endian integer
func (d *D) S50LE() int64 { return d.SE(50, LittleEndian) }

// TryS50LE try read 50 bit signed little-endian integer
func (d *D) TryS50LE() (int64, error) { return d.TrySE(50, LittleEndian) }

// S51LE read 51 bit signed little-endian integer
func (d *D) S51LE() int64 { return d.SE(51, LittleEndian) }

// TryS51LE try read 51 bit signed little-endian integer
func (d *D) TryS51LE() (int64, error) { return d.TrySE(51, LittleEndian) }

// S52LE read 52 bit signed little-endian integer
func (d *D) S52LE() int64 { return d.SE(52, LittleEndian) }

// TryS52LE try read 52 bit signed little-endian integer
func (d *D) TryS52LE() (int64, error) { return d.TrySE(52, LittleEndian) }

// S53LE read 53 bit signed little-endian integer
func (d *D) S53LE() int64 { return d.SE(53, LittleEndian) }

// TryS53LE try read 53 bit signed little-endian integer
func (d *D) TryS53LE() (int64, error) { return d.TrySE(53, LittleEndian) }

// S54LE read 54 bit signed little-endian integer
func (d *D) S54LE() int64 { return d.SE(54, LittleEndian) }

// TryS54LE try read 54 bit signed little-endian integer
func (d *D) TryS54LE() (int64, error) { return d.TrySE(54, LittleEndian) }

// S55LE read 55 bit signed little-endian integer
func (d *D) S55LE() int64 { return d.SE(55, LittleEndian) }

// TryS55LE try read 55 bit signed little-endian integer
func (d *D) TryS55LE() (int64, error) { return d.TrySE(55, LittleEndian) }

// S56LE read 56 bit signed little-endian integer
func (d *D) S56LE() int64 { return d.SE(56, LittleEndian) }

// TryS56LE try read 56 bit signed little-endian integer
func (d *D) TryS56LE() (int64, error) { return d.TrySE(56, LittleEndian) }

// S57LE read 57 bit signed little-endian integer
func (d *D) S57LE() int64 { return d.SE(57, LittleEndian) }

// TryS57LE try read 57 bit signed little-endian integer
func (d *D) TryS57LE() (int64, error) { return d.TrySE(57, LittleEndian) }

// S58LE read 58 bit signed little-endian integer
func (d *D) S58LE() int64 { return d.SE(58, LittleEndian) }

// TryS58LE try read 58 bit signed little-endian integer
func (d *D) TryS58LE() (int64, error) { return d.TrySE(58, LittleEndian) }

// S59LE read 59 bit signed little-endian integer
func (d *D) S59LE() int64 { return d.SE(59, LittleEndian) }

// TryS59LE try read 59 bit signed little-endian integer
func (d *D) TryS59LE() (int64, error) { return d.TrySE(59, LittleEndian) }

// S60LE read 60 bit signed little-endian integer
func (d *D) S60LE() int64 { return d.SE(60, LittleEndian) }

// TryS60LE try read 60 bit signed little-endian integer
func (d *D) TryS60LE() (int64, error) { return d.TrySE(60, LittleEndian) }

// S61LE read 61 bit signed little-endian integer
func (d *D) S61LE() int64 { return d.SE(61, LittleEndian) }

// TryS61LE try read 61 bit signed little-endian integer
func (d *D) TryS61LE() (int64, error) { return d.TrySE(61, LittleEndian) }

// S62LE read 62 bit signed little-endian integer
func (d *D) S62LE() int64 { return d.SE(62, LittleEndian) }

// TryS62LE try read 62 bit signed little-endian integer
func (d *D) TryS62LE() (int64, error) { return d.TrySE(62, LittleEndian) }

// S63LE read 63 bit signed little-endian integer
func (d *D) S63LE() int64 { return d.SE(63, LittleEndian) }

// TryS63LE try read 63 bit signed little-endian integer
func (d *D) TryS63LE() (int64, error) { return d.TrySE(63, LittleEndian) }

// S64LE read 64 bit signed little-endian integer
func (d *D) S64LE() int64 { return d.SE(64, LittleEndian) }

// TryS64LE try read 64 bit signed little-endian integer
func (d *D) TryS64LE() (int64, error) { return d.TrySE(64, LittleEndian) }

// FieldSLE read a nBits signed little-endian integer and add a field
func (d *D) FieldSLE(name string, nBits int) int64 { return d.FieldSE(name, nBits, LittleEndian) }

// FieldS8LE read 8 bit signed little-endian integer and add a field
func (d *D) FieldS8LE(name string) int64 { return d.FieldSE(name, 8, LittleEndian) }

// FieldS9LE read 9 bit signed little-endian integer and add a field
func (d *D) FieldS9LE(name string) int64 { return d.FieldSE(name, 9, LittleEndian) }

// FieldS10LE read 10 bit signed little-endian integer and add a field
func (d *D) FieldS10LE(name string) int64 { return d.FieldSE(name, 10, LittleEndian) }

// FieldS11LE read 11 bit signed little-endian integer and add a field
func (d *D) FieldS11LE(name string) int64 { return d.FieldSE(name, 11, LittleEndian) }

// FieldS12LE read 12 bit signed little-endian integer and add a field
func (d *D) FieldS12LE(name string) int64 { return d.FieldSE(name, 12, LittleEndian) }

// FieldS13LE read 13 bit signed little-endian integer and add a field
func (d *D) FieldS13LE(name string) int64 { return d.FieldSE(name, 13, LittleEndian) }

// FieldS14LE read 14 bit signed little-endian integer and add a field
func (d *D) FieldS14LE(name string) int64 { return d.FieldSE(name, 14, LittleEndian) }

// FieldS15LE read 15 bit signed little-endian integer and add a field
func (d *D) FieldS15LE(name string) int64 { return d.FieldSE(name, 15, LittleEndian) }

// FieldS16LE read 16 bit signed little-endian integer and add a field
func (d *D) FieldS16LE(name string) int64 { return d.FieldSE(name, 16, LittleEndian) }

// FieldS17LE read 17 bit signed little-endian integer and add a field
func (d *D) FieldS17LE(name string) int64 { return d.FieldSE(name, 17, LittleEndian) }

// FieldS18LE read 18 bit signed little-endian integer and add a field
func (d *D) FieldS18LE(name string) int64 { return d.FieldSE(name, 18, LittleEndian) }

// FieldS19LE read 19 bit signed little-endian integer and add a field
func (d *D) FieldS19LE(name string) int64 { return d.FieldSE(name, 19, LittleEndian) }

// FieldS20LE read 20 bit signed little-endian integer and add a field
func (d *D) FieldS20LE(name string) int64 { return d.FieldSE(name, 20, LittleEndian) }

// FieldS21LE read 21 bit signed little-endian integer and add a field
func (d *D) FieldS21LE(name string) int64 { return d.FieldSE(name, 21, LittleEndian) }

// FieldS22LE read 22 bit signed little-endian integer and add a field
func (d *D) FieldS22LE(name string) int64 { return d.FieldSE(name, 22, LittleEndian) }

// FieldS23LE read 23 bit signed little-endian integer and add a field
func (d *D) FieldS23LE(name string) int64 { return d.FieldSE(name, 23, LittleEndian) }

// FieldS24LE read 24 bit signed little-endian integer and add a field
func (d *D) FieldS24LE(name string) int64 { return d.FieldSE(name, 24, LittleEndian) }

// FieldS25LE read 25 bit signed little-endian integer and add a field
func (d *D) FieldS25LE(name string) int64 { return d.FieldSE(name, 25, LittleEndian) }

// FieldS26LE read 26 bit signed little-endian integer and add a field
func (d *D) FieldS26LE(name string) int64 { return d.FieldSE(name, 26, LittleEndian) }

// FieldS27LE read 27 bit signed little-endian integer and add a field
func (d *D) FieldS27LE(name string) int64 { return d.FieldSE(name, 27, LittleEndian) }

// FieldS28LE read 28 bit signed little-endian integer and add a field
func (d *D) FieldS28LE(name string) int64 { return d.FieldSE(name, 28, LittleEndian) }

// FieldS29LE read 29 bit signed little-endian integer and add a field
func (d *D) FieldS29LE(name string) int64 { return d.FieldSE(name, 29, LittleEndian) }

// FieldS30LE read 30 bit signed little-endian integer and add a field
func (d *D) FieldS30LE(name string) int64 { return d.FieldSE(name, 30, LittleEndian) }

// FieldS31LE read 31 bit signed little-endian integer and add a field
func (d *D) FieldS31LE(name string) int64 { return d.FieldSE(name, 31, LittleEndian) }

// FieldS32LE read 32 bit signed little-endian integer and add a field
func (d *D) FieldS32LE(name string) int64 { return d.FieldSE(name, 32, LittleEndian) }

// FieldS33LE read 33 bit signed little-endian integer and add a field
func (d *D) FieldS33LE(name string) int64 { return d.FieldSE(name, 33, LittleEndian) }

// FieldS34LE read 34 bit signed little-endian integer and add a field
func (d *D) FieldS34LE(name string) int64 { return d.FieldSE(name, 34, LittleEndian) }

// FieldS35LE read 35 bit signed little-endian integer and add a field
func (d *D) FieldS35LE(name string) int64 { return d.FieldSE(name, 35, LittleEndian) }

// FieldS36LE read 36 bit signed little-endian integer and add a field
func (d *D) FieldS36LE(name string) int64 { return d.FieldSE(name, 36, LittleEndian) }

// FieldS37LE read 37 bit signed little-endian integer and add a field
func (d *D) FieldS37LE(name string) int64 { return d.FieldSE(name, 37, LittleEndian) }

// FieldS38LE read 38 bit signed little-endian integer and add a field
func (d *D) FieldS38LE(name string) int64 { return d.FieldSE(name, 38, LittleEndian) }

// FieldS39LE read 39 bit signed little-endian integer and add a field
func (d *D) FieldS39LE(name string) int64 { return d.FieldSE(name, 39, LittleEndian) }

// FieldS40LE read 40 bit signed little-endian integer and add a field
func (d *D) FieldS40LE(name string) int64 { return d.FieldSE(name, 40, LittleEndian) }

// FieldS41LE read 41 bit signed little-endian integer and add a field
func (d *D) FieldS41LE(name string) int64 { return d.FieldSE(name, 41, LittleEndian) }

// FieldS42LE read 42 bit signed little-endian integer and add a field
func (d *D) FieldS42LE(name string) int64 { return d.FieldSE(name, 42, LittleEndian) }

// FieldS43LE read 43 bit signed little-endian integer and add a field
func (d *D) FieldS43LE(name string) int64 { return d.FieldSE(name, 43, LittleEndian) }

// FieldS44LE read 44 bit signed little-endian integer and add a field
func (d *D) FieldS44LE(name string) int64 { return d.FieldSE(name, 44, LittleEndian) }

// FieldS45LE read 45 bit signed little-endian integer and add a field
func (d *D) FieldS45LE(name string) int64 { return d.FieldSE(name, 45, LittleEndian) }

// FieldS46LE read 46 bit signed little-endian integer and add a field
func (d *D) FieldS46LE(name string) int64 { return d.FieldSE(name, 46, LittleEndian) }

// FieldS47LE read 47 bit signed little-endian integer and add a field
func (d *D) FieldS47LE(name string) int64 { return d.FieldSE(name, 47, LittleEndian) }

// FieldS48LE read 48 bit signed little-endian integer and add a field
func (d *D) FieldS48LE(name string) int64 { return d.FieldSE(name, 48, LittleEndian) }

// FieldS49LE read 49 bit signed little-endian integer and add a field
func (d *D) FieldS49LE(name string) int64 { return d.FieldSE(name, 49, LittleEndian) }

// FieldS50LE read 50 bit signed little-endian integer and add a field
func (d *D) FieldS50LE(name string) int64 { return d.FieldSE(name, 50, LittleEndian) }

// FieldS51LE read 51 bit signed little-endian integer and add a field
func (d *D) FieldS51LE(name string) int64 { return d.FieldSE(name, 51, LittleEndian) }

// FieldS52LE read 52 bit signed little-endian integer and add a field
func (d *D) FieldS52LE(name string) int64 { return d.FieldSE(name, 52, LittleEndian) }

// FieldS53LE read 53 bit signed little-endian integer and add a field
func (d *D) FieldS53LE(name string) int64 { return d.FieldSE(name, 53, LittleEndian) }

// FieldS54LE read 54 bit signed little-endian integer and add a field
func (d *D) FieldS54LE(name string) int64 { return d.FieldSE(name, 54, LittleEndian) }

// FieldS55LE read 55 bit signed little-endian integer and add a field
func (d *D) FieldS55LE(name string) int64 { return d.FieldSE(name, 55, LittleEndian) }

// FieldS56LE read 56 bit signed little-endian integer and add a field
func (d *D) FieldS56LE(name string) int64 { return d.FieldSE(name, 56, LittleEndian) }

// FieldS57LE read 57 bit signed little-endian integer and add a field
func (d *D) FieldS57LE(name string) int64 { return d.FieldSE(name, 57, LittleEndian) }

// FieldS58LE read 58 bit signed little-endian integer and add a field
func (d *D) FieldS58LE(name string) int64 { return d.FieldSE(name, 58, LittleEndian) }

// FieldS59LE read 59 bit signed little-endian integer and add a field
func (d *D) FieldS59LE(name string) int64 { return d.FieldSE(name, 59, LittleEndian) }

// FieldS60LE read 60 bit signed little-endian integer and add a field
func (d *D) FieldS60LE(name string) int64 { return d.FieldSE(name, 60, LittleEndian) }

// FieldS61LE read 61 bit signed little-endian integer and add a field
func (d *D) FieldS61LE(name string) int64 { return d.FieldSE(name, 61, LittleEndian) }

// FieldS62LE read 62 bit signed little-endian integer and add a field
func (d *D) FieldS62LE(name string) int64 { return d.FieldSE(name, 62, LittleEndian) }

// FieldS63LE read 63 bit signed little-endian integer and add a field
func (d *D) FieldS63LE(name string) int64 { return d.FieldSE(name, 63, LittleEndian) }

// FieldS64LE read 64 bit signed little-endian integer and add a field
func (d *D) FieldS64LE(name string) int64 { return d.FieldSE(name, 64, LittleEndian) }

// U read a nBits unsigned current endian integer
func (d *D) U(nBits int) uint64 { return d.UE(nBits, d.Endian) }

// TryU try read a nBits unsigned current endian integer
func (d *D) TryU(nBits int) (uint64, error) { return d.TryUE(nBits, d.Endian) }

// U1 read 1 bit unsigned current endian integer
func (d *D) U1() uint64 { return d.UE(1, d.Endian) }

// TryU1 try read 1 bit unsigned current endian integer
func (d *D) TryU1() (uint64, error) { return d.TryUE(1, d.Endian) }

// U2 read 2 bit unsigned current endian integer
func (d *D) U2() uint64 { return d.UE(2, d.Endian) }

// TryU2 try read 2 bit unsigned current endian integer
func (d *D) TryU2() (uint64, error) { return d.TryUE(2, d.Endian) }

// U3 read 3 bit unsigned current endian integer
func (d *D) U3() uint64 { return d.UE(3, d.Endian) }

// TryU3 try read 3 bit unsigned current endian integer
func (d *D) TryU3() (uint64, error) { return d.TryUE(3, d.Endian) }

// U4 read 4 bit unsigned current endian integer
func (d *D) U4() uint64 { return d.UE(4, d.Endian) }

// TryU4 try read 4 bit unsigned current endian integer
func (d *D) TryU4() (uint64, error) { return d.TryUE(4, d.Endian) }

// U5 read 5 bit unsigned current endian integer
func (d *D) U5() uint64 { return d.UE(5, d.Endian) }

// TryU5 try read 5 bit unsigned current endian integer
func (d *D) TryU5() (uint64, error) { return d.TryUE(5, d.Endian) }

// U6 read 6 bit unsigned current endian integer
func (d *D) U6() uint64 { return d.UE(6, d.Endian) }

// TryU6 try read 6 bit unsigned current endian integer
func (d *D) TryU6() (uint64, error) { return d.TryUE(6, d.Endian) }

// U7 read 7 bit unsigned current endian integer
func (d *D) U7() uint64 { return d.UE(7, d.Endian) }

// TryU7 try read 7 bit unsigned current endian integer
func (d *D) TryU7() (uint64, error) { return d.TryUE(7, d.Endian) }

// U8 read 8 bit unsigned current endian integer
func (d *D) U8() uint64 { return d.UE(8, d.Endian) }

// TryU8 try read 8 bit unsigned current endian integer
func (d *D) TryU8() (uint64, error) { return d.TryUE(8, d.Endian) }

// U9 read 9 bit unsigned current endian integer
func (d *D) U9() uint64 { return d.UE(9, d.Endian) }

// TryU9 try read 9 bit unsigned current endian integer
func (d *D) TryU9() (uint64, error) { return d.TryUE(9, d.Endian) }

// U10 read 10 bit unsigned current endian integer
func (d *D) U10() uint64 { return d.UE(10, d.Endian) }

// TryU10 try read 10 bit unsigned current endian integer
func (d *D) TryU10() (uint64, error) { return d.TryUE(10, d.Endian) }

// U11 read 11 bit unsigned current endian integer
func (d *D) U11() uint64 { return d.UE(11, d.Endian) }

// TryU11 try read 11 bit unsigned current endian integer
func (d *D) TryU11() (uint64, error) { return d.TryUE(11, d.Endian) }

// U12 read 12 bit unsigned current endian integer
func (d *D) U12() uint64 { return d.UE(12, d.Endian) }

// TryU12 try read 12 bit unsigned current endian integer
func (d *D) TryU12() (uint64, error) { return d.TryUE(12, d.Endian) }

// U13 read 13 bit unsigned current endian integer
func (d *D) U13() uint64 { return d.UE(13, d.Endian) }

// TryU13 try read 13 bit unsigned current endian integer
func (d *D) TryU13() (uint64, error) { return d.TryUE(13, d.Endian) }

// U14 read 14 bit unsigned current endian integer
func (d *D) U14() uint64 { return d.UE(14, d.Endian) }

// TryU14 try read 14 bit unsigned current endian integer
func (d *D) TryU14() (uint64, error) { return d.TryUE(14, d.Endian) }

// U15 read 15 bit unsigned current endian integer
func (d *D) U15() uint64 { return d.UE(15, d.Endian) }

// TryU15 try read 15 bit unsigned current endian integer
func (d *D) TryU15() (uint64, error) { return d.TryUE(15, d.Endian) }

// U16 read 16 bit unsigned current endian integer
func (d *D) U16() uint64 { return d.UE(16, d.Endian) }

// TryU16 try read 16 bit unsigned current endian integer
func (d *D) TryU16() (uint64, error) { return d.TryUE(16, d.Endian) }

// U17 read 17 bit unsigned current endian integer
func (d *D) U17() uint64 { return d.UE(17, d.Endian) }

// TryU17 try read 17 bit unsigned current endian integer
func (d *D) TryU17() (uint64, error) { return d.TryUE(17, d.Endian) }

// U18 read 18 bit unsigned current endian integer
func (d *D) U18() uint64 { return d.UE(18, d.Endian) }

// TryU18 try read 18 bit unsigned current endian integer
func (d *D) TryU18() (uint64, error) { return d.TryUE(18, d.Endian) }

// U19 read 19 bit unsigned current endian integer
func (d *D) U19() uint64 { return d.UE(19, d.Endian) }

// TryU19 try read 19 bit unsigned current endian integer
func (d *D) TryU19() (uint64, error) { return d.TryUE(19, d.Endian) }

// U20 read 20 bit unsigned current endian integer
func (d *D) U20() uint64 { return d.UE(20, d.Endian) }

// TryU20 try read 20 bit unsigned current endian integer
func (d *D) TryU20() (uint64, error) { return d.TryUE(20, d.Endian) }

// U21 read 21 bit unsigned current endian integer
func (d *D) U21() uint64 { return d.UE(21, d.Endian) }

// TryU21 try read 21 bit unsigned current endian integer
func (d *D) TryU21() (uint64, error) { return d.TryUE(21, d.Endian) }

// U22 read 22 bit unsigned current endian integer
func (d *D) U22() uint64 { return d.UE(22, d.Endian) }

// TryU22 try read 22 bit unsigned current endian integer
func (d *D) TryU22() (uint64, error) { return d.TryUE(22, d.Endian) }

// U23 read 23 bit unsigned current endian integer
func (d *D) U23() uint64 { return d.UE(23, d.Endian) }

// TryU23 try read 23 bit unsigned current endian integer
func (d *D) TryU23() (uint64, error) { return d.TryUE(23, d.Endian) }

// U24 read 24 bit unsigned current endian integer
func (d *D) U24() uint64 { return d.UE(24, d.Endian) }

// TryU24 try read 24 bit unsigned current endian integer
func (d *D) TryU24() (uint64, error) { return d.TryUE(24, d.Endian) }

// U25 read 25 bit unsigned current endian integer
func (d *D) U25() uint64 { return d.UE(25, d.Endian) }

// TryU25 try read 25 bit unsigned current endian integer
func (d *D) TryU25() (uint64, error) { return d.TryUE(25, d.Endian) }

// U26 read 26 bit unsigned current endian integer
func (d *D) U26() uint64 { return d.UE(26, d.Endian) }

// TryU26 try read 26 bit unsigned current endian integer
func (d *D) TryU26() (uint64, error) { return d.TryUE(26, d.Endian) }

// U27 read 27 bit unsigned current endian integer
func (d *D) U27() uint64 { return d.UE(27, d.Endian) }

// TryU27 try read 27 bit unsigned current endian integer
func (d *D) TryU27() (uint64, error) { return d.TryUE(27, d.Endian) }

// U28 read 28 bit unsigned current endian integer
func (d *D) U28() uint64 { return d.UE(28, d.Endian) }

// TryU28 try read 28 bit unsigned current endian integer
func (d *D) TryU28() (uint64, error) { return d.TryUE(28, d.Endian) }

// U29 read 29 bit unsigned current endian integer
func (d *D) U29() uint64 { return d.UE(29, d.Endian) }

// TryU29 try read 29 bit unsigned current endian integer
func (d *D) TryU29() (uint64, error) { return d.TryUE(29, d.Endian) }

// U30 read 30 bit unsigned current endian integer
func (d *D) U30() uint64 { return d.UE(30, d.Endian) }

// TryU30 try read 30 bit unsigned current endian integer
func (d *D) TryU30() (uint64, error) { return d.TryUE(30, d.Endian) }

// U31 read 31 bit unsigned current endian integer
func (d *D) U31() uint64 { return d.UE(31, d.Endian) }

// TryU31 try read 31 bit unsigned current endian integer
func (d *D) TryU31() (uint64, error) { return d.TryUE(31, d.Endian) }

// U32 read 32 bit unsigned current endian integer
func (d *D) U32() uint64 { return d.UE(32, d.Endian) }

// TryU32 try read 32 bit unsigned current endian integer
func (d *D) TryU32() (uint64, error) { return d.TryUE(32, d.Endian) }

// U33 read 33 bit unsigned current endian integer
func (d *D) U33() uint64 { return d.UE(33, d.Endian) }

// TryU33 try read 33 bit unsigned current endian integer
func (d *D) TryU33() (uint64, error) { return d.TryUE(33, d.Endian) }

// U34 read 34 bit unsigned current endian integer
func (d *D) U34() uint64 { return d.UE(34, d.Endian) }

// TryU34 try read 34 bit unsigned current endian integer
func (d *D) TryU34() (uint64, error) { return d.TryUE(34, d.Endian) }

// U35 read 35 bit unsigned current endian integer
func (d *D) U35() uint64 { return d.UE(35, d.Endian) }

// TryU35 try read 35 bit unsigned current endian integer
func (d *D) TryU35() (uint64, error) { return d.TryUE(35, d.Endian) }

// U36 read 36 bit unsigned current endian integer
func (d *D) U36() uint64 { return d.UE(36, d.Endian) }

// TryU36 try read 36 bit unsigned current endian integer
func (d *D) TryU36() (uint64, error) { return d.TryUE(36, d.Endian) }

// U37 read 37 bit unsigned current endian integer
func (d *D) U37() uint64 { return d.UE(37, d.Endian) }

// TryU37 try read 37 bit unsigned current endian integer
func (d *D) TryU37() (uint64, error) { return d.TryUE(37, d.Endian) }

// U38 read 38 bit unsigned current endian integer
func (d *D) U38() uint64 { return d.UE(38, d.Endian) }

// TryU38 try read 38 bit unsigned current endian integer
func (d *D) TryU38() (uint64, error) { return d.TryUE(38, d.Endian) }

// U39 read 39 bit unsigned current endian integer
func (d *D) U39() uint64 { return d.UE(39, d.Endian) }

// TryU39 try read 39 bit unsigned current endian integer
func (d *D) TryU39() (uint64, error) { return d.TryUE(39, d.Endian) }

// U40 read 40 bit unsigned current endian integer
func (d *D) U40() uint64 { return d.UE(40, d.Endian) }

// TryU40 try read 40 bit unsigned current endian integer
func (d *D) TryU40() (uint64, error) { return d.TryUE(40, d.Endian) }

// U41 read 41 bit unsigned current endian integer
func (d *D) U41() uint64 { return d.UE(41, d.Endian) }

// TryU41 try read 41 bit unsigned current endian integer
func (d *D) TryU41() (uint64, error) { return d.TryUE(41, d.Endian) }

// U42 read 42 bit unsigned current endian integer
func (d *D) U42() uint64 { return d.UE(42, d.Endian) }

// TryU42 try read 42 bit unsigned current endian integer
func (d *D) TryU42() (uint64, error) { return d.TryUE(42, d.Endian) }

// U43 read 43 bit unsigned current endian integer
func (d *D) U43() uint64 { return d.UE(43, d.Endian) }

// TryU43 try read 43 bit unsigned current endian integer
func (d *D) TryU43() (uint64, error) { return d.TryUE(43, d.Endian) }

// U44 read 44 bit unsigned current endian integer
func (d *D) U44() uint64 { return d.UE(44, d.Endian) }

// TryU44 try read 44 bit unsigned current endian integer
func (d *D) TryU44() (uint64, error) { return d.TryUE(44, d.Endian) }

// U45 read 45 bit unsigned current endian integer
func (d *D) U45() uint64 { return d.UE(45, d.Endian) }

// TryU45 try read 45 bit unsigned current endian integer
func (d *D) TryU45() (uint64, error) { return d.TryUE(45, d.Endian) }

// U46 read 46 bit unsigned current endian integer
func (d *D) U46() uint64 { return d.UE(46, d.Endian) }

// TryU46 try read 46 bit unsigned current endian integer
func (d *D) TryU46() (uint64, error) { return d.TryUE(46, d.Endian) }

// U47 read 47 bit unsigned current endian integer
func (d *D) U47() uint64 { return d.UE(47, d.Endian) }

// TryU47 try read 47 bit unsigned current endian integer
func (d *D) TryU47() (uint64, error) { return d.TryUE(47, d.Endian) }

// U48 read 48 bit unsigned current endian integer
func (d *D) U48() uint64 { return d.UE(48, d.Endian) }

// TryU48 try read 48 bit unsigned current endian integer
func (d *D) TryU48() (uint64, error) { return d.TryUE(48, d.Endian) }

// U49 read 49 bit unsigned current endian integer
func (d *D) U49() uint64 { return d.UE(49, d.Endian) }

// TryU49 try read 49 bit unsigned current endian integer
func (d *D) TryU49() (uint64, error) { return d.TryUE(49, d.Endian) }

// U50 read 50 bit unsigned current endian integer
func (d *D) U50() uint64 { return d.UE(50, d.Endian) }

// TryU50 try read 50 bit unsigned current endian integer
func (d *D) TryU50() (uint64, error) { return d.TryUE(50, d.Endian) }

// U51 read 51 bit unsigned current endian integer
func (d *D) U51() uint64 { return d.UE(51, d.Endian) }

// TryU51 try read 51 bit unsigned current endian integer
func (d *D) TryU51() (uint64, error) { return d.TryUE(51, d.Endian) }

// U52 read 52 bit unsigned current endian integer
func (d *D) U52() uint64 { return d.UE(52, d.Endian) }

// TryU52 try read 52 bit unsigned current endian integer
func (d *D) TryU52() (uint64, error) { return d.TryUE(52, d.Endian) }

// U53 read 53 bit unsigned current endian integer
func (d *D) U53() uint64 { return d.UE(53, d.Endian) }

// TryU53 try read 53 bit unsigned current endian integer
func (d *D) TryU53() (uint64, error) { return d.TryUE(53, d.Endian) }

// U54 read 54 bit unsigned current endian integer
func (d *D) U54() uint64 { return d.UE(54, d.Endian) }

// TryU54 try read 54 bit unsigned current endian integer
func (d *D) TryU54() (uint64, error) { return d.TryUE(54, d.Endian) }

// U55 read 55 bit unsigned current endian integer
func (d *D) U55() uint64 { return d.UE(55, d.Endian) }

// TryU55 try read 55 bit unsigned current endian integer
func (d *D) TryU55() (uint64, error) { return d.TryUE(55, d.Endian) }

// U56 read 56 bit unsigned current endian integer
func (d *D) U56() uint64 { return d.UE(56, d.Endian) }

// TryU56 try read 56 bit unsigned current endian integer
func (d *D) TryU56() (uint64, error) { return d.TryUE(56, d.Endian) }

// U57 read 57 bit unsigned current endian integer
func (d *D) U57() uint64 { return d.UE(57, d.Endian) }

// TryU57 try read 57 bit unsigned current endian integer
func (d *D) TryU57() (uint64, error) { return d.TryUE(57, d.Endian) }

// U58 read 58 bit unsigned current endian integer
func (d *D) U58() uint64 { return d.UE(58, d.Endian) }

// TryU58 try read 58 bit unsigned current endian integer
func (d *D) TryU58() (uint64, error) { return d.TryUE(58, d.Endian) }

// U59 read 59 bit unsigned current endian integer
func (d *D) U59() uint64 { return d.UE(59, d.Endian) }

// TryU59 try read 59 bit unsigned current endian integer
func (d *D) TryU59() (uint64, error) { return d.TryUE(59, d.Endian) }

// U60 read 60 bit unsigned current endian integer
func (d *D) U60() uint64 { return d.UE(60, d.Endian) }

// TryU60 try read 60 bit unsigned current endian integer
func (d *D) TryU60() (uint64, error) { return d.TryUE(60, d.Endian) }

// U61 read 61 bit unsigned current endian integer
func (d *D) U61() uint64 { return d.UE(61, d.Endian) }

// TryU61 try read 61 bit unsigned current endian integer
func (d *D) TryU61() (uint64, error) { return d.TryUE(61, d.Endian) }

// U62 read 62 bit unsigned current endian integer
func (d *D) U62() uint64 { return d.UE(62, d.Endian) }

// TryU62 try read 62 bit unsigned current endian integer
func (d *D) TryU62() (uint64, error) { return d.TryUE(62, d.Endian) }

// U63 read 63 bit unsigned current endian integer
func (d *D) U63() uint64 { return d.UE(63, d.Endian) }

// TryU63 try read 63 bit unsigned current endian integer
func (d *D) TryU63() (uint64, error) { return d.TryUE(63, d.Endian) }

// U64 read 64 bit unsigned current endian integer
func (d *D) U64() uint64 { return d.UE(64, d.Endian) }

// TryU64 try read 64 bit unsigned current endian integer
func (d *D) TryU64() (uint64, error) { return d.TryUE(64, d.Endian) }

// FieldU read a nBits unsigned current endian integer and add a field
func (d *D) FieldU(name string, nBits int) uint64 { return d.FieldUE(name, nBits, d.Endian) }

// FieldU1 read 1 bit unsigned current endian integer and add a field
func (d *D) FieldU1(name string) uint64 { return d.FieldUE(name, 1, d.Endian) }

// FieldU2 read 2 bit unsigned current endian integer and add a field
func (d *D) FieldU2(name string) uint64 { return d.FieldUE(name, 2, d.Endian) }

// FieldU3 read 3 bit unsigned current endian integer and add a field
func (d *D) FieldU3(name string) uint64 { return d.FieldUE(name, 3, d.Endian) }

// FieldU4 read 4 bit unsigned current endian integer and add a field
func (d *D) FieldU4(name string) uint64 { return d.FieldUE(name, 4, d.Endian) }

// FieldU5 read 5 bit unsigned current endian integer and add a field
func (d *D) FieldU5(name string) uint64 { return d.FieldUE(name, 5, d.Endian) }

// FieldU6 read 6 bit unsigned current endian integer and add a field
func (d *D) FieldU6(name string) uint64 { return d.FieldUE(name, 6, d.Endian) }

// FieldU7 read 7 bit unsigned current endian integer and add a field
func (d *D) FieldU7(name string) uint64 { return d.FieldUE(name, 7, d.Endian) }

// FieldU8 read 8 bit unsigned current endian integer and add a field
func (d *D) FieldU8(name string) uint64 { return d.FieldUE(name, 8, d.Endian) }

// FieldU9 read 9 bit unsigned current endian integer and add a field
func (d *D) FieldU9(name string) uint64 { return d.FieldUE(name, 9, d.Endian) }

// FieldU10 read 10 bit unsigned current endian integer and add a field
func (d *D) FieldU10(name string) uint64 { return d.FieldUE(name, 10, d.Endian) }

// FieldU11 read 11 bit unsigned current endian integer and add a field
func (d *D) FieldU11(name string) uint64 { return d.FieldUE(name, 11, d.Endian) }

// FieldU12 read 12 bit unsigned current endian integer and add a field
func (d *D) FieldU12(name string) uint64 { return d.FieldUE(name, 12, d.Endian) }

// FieldU13 read 13 bit unsigned current endian integer and add a field
func (d *D) FieldU13(name string) uint64 { return d.FieldUE(name, 13, d.Endian) }

// FieldU14 read 14 bit unsigned current endian integer and add a field
func (d *D) FieldU14(name string) uint64 { return d.FieldUE(name, 14, d.Endian) }

// FieldU15 read 15 bit unsigned current endian integer and add a field
func (d *D) FieldU15(name string) uint64 { return d.FieldUE(name, 15, d.Endian) }

// FieldU16 read 16 bit unsigned current endian integer and add a field
func (d *D) FieldU16(name string) uint64 { return d.FieldUE(name, 16, d.Endian) }

// FieldU17 read 17 bit unsigned current endian integer and add a field
func (d *D) FieldU17(name string) uint64 { return d.FieldUE(name, 17, d.Endian) }

// FieldU18 read 18 bit unsigned current endian integer and add a field
func (d *D) FieldU18(name string) uint64 { return d.FieldUE(name, 18, d.Endian) }

// FieldU19 read 19 bit unsigned current endian integer and add a field
func (d *D) FieldU19(name string) uint64 { return d.FieldUE(name, 19, d.Endian) }

// FieldU20 read 20 bit unsigned current endian integer and add a field
func (d *D) FieldU20(name string) uint64 { return d.FieldUE(name, 20, d.Endian) }

// FieldU21 read 21 bit unsigned current endian integer and add a field
func (d *D) FieldU21(name string) uint64 { return d.FieldUE(name, 21, d.Endian) }

// FieldU22 read 22 bit unsigned current endian integer and add a field
func (d *D) FieldU22(name string) uint64 { return d.FieldUE(name, 22, d.Endian) }

// FieldU23 read 23 bit unsigned current endian integer and add a field
func (d *D) FieldU23(name string) uint64 { return d.FieldUE(name, 23, d.Endian) }

// FieldU24 read 24 bit unsigned current endian integer and add a field
func (d *D) FieldU24(name string) uint64 { return d.FieldUE(name, 24, d.Endian) }

// FieldU25 read 25 bit unsigned current endian integer and add a field
func (d *D) FieldU25(name string) uint64 { return d.FieldUE(name, 25, d.Endian) }

// FieldU26 read 26 bit unsigned current endian integer and add a field
func (d *D) FieldU26(name string) uint64 { return d.FieldUE(name, 26, d.Endian) }

// FieldU27 read 27 bit unsigned current endian integer and add a field
func (d *D) FieldU27(name string) uint64 { return d.FieldUE(name, 27, d.Endian) }

// FieldU28 read 28 bit unsigned current endian integer and add a field
func (d *D) FieldU28(name string) uint64 { return d.FieldUE(name, 28, d.Endian) }

// FieldU29 read 29 bit unsigned current endian integer and add a field
func (d *D) FieldU29(name string) uint64 { return d.FieldUE(name, 29, d.Endian) }

// FieldU30 read 30 bit unsigned current endian integer and add a field
func (d *D) FieldU30(name string) uint64 { return d.FieldUE(name, 30, d.Endian) }

// FieldU31 read 31 bit unsigned current endian integer and add a field
func (d *D) FieldU31(name string) uint64 { return d.FieldUE(name, 31, d.Endian) }

// FieldU32 read 32 bit unsigned current endian integer and add a field
func (d *D) FieldU32(name string) uint64 { return d.FieldUE(name, 32, d.Endian) }

// FieldU33 read 33 bit unsigned current endian integer and add a field
func (d *D) FieldU33(name string) uint64 { return d.FieldUE(name, 33, d.Endian) }

// FieldU34 read 34 bit unsigned current endian integer and add a field
func (d *D) FieldU34(name string) uint64 { return d.FieldUE(name, 34, d.Endian) }

// FieldU35 read 35 bit unsigned current endian integer and add a field
func (d *D) FieldU35(name string) uint64 { return d.FieldUE(name, 35, d.Endian) }

// FieldU36 read 36 bit unsigned current endian integer and add a field
func (d *D) FieldU36(name string) uint64 { return d.FieldUE(name, 36, d.Endian) }

// FieldU37 read 37 bit unsigned current endian integer and add a field
func (d *D) FieldU37(name string) uint64 { return d.FieldUE(name, 37, d.Endian) }

// FieldU38 read 38 bit unsigned current endian integer and add a field
func (d *D) FieldU38(name string) uint64 { return d.FieldUE(name, 38, d.Endian) }

// FieldU39 read 39 bit unsigned current endian integer and add a field
func (d *D) FieldU39(name string) uint64 { return d.FieldUE(name, 39, d.Endian) }

// FieldU40 read 40 bit unsigned current endian integer and add a field
func (d *D) FieldU40(name string) uint64 { return d.FieldUE(name, 40, d.Endian) }

// FieldU41 read 41 bit unsigned current endian integer and add a field
func (d *D) FieldU41(name string) uint64 { return d.FieldUE(name, 41, d.Endian) }

// FieldU42 read 42 bit unsigned current endian integer and add a field
func (d *D) FieldU42(name string) uint64 { return d.FieldUE(name, 42, d.Endian) }

// FieldU43 read 43 bit unsigned current endian integer and add a field
func (d *D) FieldU43(name string) uint64 { return d.FieldUE(name, 43, d.Endian) }

// FieldU44 read 44 bit unsigned current endian integer and add a field
func (d *D) FieldU44(name string) uint64 { return d.FieldUE(name, 44, d.Endian) }

// FieldU45 read 45 bit unsigned current endian integer and add a field
func (d *D) FieldU45(name string) uint64 { return d.FieldUE(name, 45, d.Endian) }

// FieldU46 read 46 bit unsigned current endian integer and add a field
func (d *D) FieldU46(name string) uint64 { return d.FieldUE(name, 46, d.Endian) }

// FieldU47 read 47 bit unsigned current endian integer and add a field
func (d *D) FieldU47(name string) uint64 { return d.FieldUE(name, 47, d.Endian) }

// FieldU48 read 48 bit unsigned current endian integer and add a field
func (d *D) FieldU48(name string) uint64 { return d.FieldUE(name, 48, d.Endian) }

// FieldU49 read 49 bit unsigned current endian integer and add a field
func (d *D) FieldU49(name string) uint64 { return d.FieldUE(name, 49, d.Endian) }

// FieldU50 read 50 bit unsigned current endian integer and add a field
func (d *D) FieldU50(name string) uint64 { return d.FieldUE(name, 50, d.Endian) }

// FieldU51 read 51 bit unsigned current endian integer and add a field
func (d *D) FieldU51(name string) uint64 { return d.FieldUE(name, 51, d.Endian) }

// FieldU52 read 52 bit unsigned current endian integer and add a field
func (d *D) FieldU52(name string) uint64 { return d.FieldUE(name, 52, d.Endian) }

// FieldU53 read 53 bit unsigned current endian integer and add a field
func (d *D) FieldU53(name string) uint64 { return d.FieldUE(name, 53, d.Endian) }

// FieldU54 read 54 bit unsigned current endian integer and add a field
func (d *D) FieldU54(name string) uint64 { return d.FieldUE(name, 54, d.Endian) }

// FieldU55 read 55 bit unsigned current endian integer and add a field
func (d *D) FieldU55(name string) uint64 { return d.FieldUE(name, 55, d.Endian) }

// FieldU56 read 56 bit unsigned current endian integer and add a field
func (d *D) FieldU56(name string) uint64 { return d.FieldUE(name, 56, d.Endian) }

// FieldU57 read 57 bit unsigned current endian integer and add a field
func (d *D) FieldU57(name string) uint64 { return d.FieldUE(name, 57, d.Endian) }

// FieldU58 read 58 bit unsigned current endian integer and add a field
func (d *D) FieldU58(name string) uint64 { return d.FieldUE(name, 58, d.Endian) }

// FieldU59 read 59 bit unsigned current endian integer and add a field
func (d *D) FieldU59(name string) uint64 { return d.FieldUE(name, 59, d.Endian) }

// FieldU60 read 60 bit unsigned current endian integer and add a field
func (d *D) FieldU60(name string) uint64 { return d.FieldUE(name, 60, d.Endian) }

// FieldU61 read 61 bit unsigned current endian integer and add a field
func (d *D) FieldU61(name string) uint64 { return d.FieldUE(name, 61, d.Endian) }

// FieldU62 read 62 bit unsigned current endian integer and add a field
func (d *D) FieldU62(name string) uint64 { return d.FieldUE(name, 62, d.Endian) }

// FieldU63 read 63 bit unsigned current endian integer and add a field
func (d *D) FieldU63(name string) uint64 { return d.FieldUE(name, 63, d.Endian) }

// FieldU64 read 64 bit unsigned current endian integer and add a field
func (d *D) FieldU64(name string) uint64 { return d.FieldUE(name, 64, d.Endian) }

// UBE read a nBits unsigned big-endian integer
func (d *D) UBE(nBits int) uint64 { return d.UE(nBits, BigEndian) }

// TryUBE try read a nBits unsigned big-endian integer
func (d *D) TryUBE(nBits int) (uint64, error) { return d.TryUE(nBits, BigEndian) }

// U8BE read 8 bit unsigned big-endian integer
func (d *D) U8BE() uint64 { return d.UE(8, BigEndian) }

// TryU8BE try read 8 bit unsigned big-endian integer
func (d *D) TryU8BE() (uint64, error) { return d.TryUE(8, BigEndian) }

// U9BE read 9 bit unsigned big-endian integer
func (d *D) U9BE() uint64 { return d.UE(9, BigEndian) }

// TryU9BE try read 9 bit unsigned big-endian integer
func (d *D) TryU9BE() (uint64, error) { return d.TryUE(9, BigEndian) }

// U10BE read 10 bit unsigned big-endian integer
func (d *D) U10BE() uint64 { return d.UE(10, BigEndian) }

// TryU10BE try read 10 bit unsigned big-endian integer
func (d *D) TryU10BE() (uint64, error) { return d.TryUE(10, BigEndian) }

// U11BE read 11 bit unsigned big-endian integer
func (d *D) U11BE() uint64 { return d.UE(11, BigEndian) }

// TryU11BE try read 11 bit unsigned big-endian integer
func (d *D) TryU11BE() (uint64, error) { return d.TryUE(11, BigEndian) }

// U12BE read 12 bit unsigned big-endian integer
func (d *D) U12BE() uint64 { return d.UE(12, BigEndian) }

// TryU12BE try read 12 bit unsigned big-endian integer
func (d *D) TryU12BE() (uint64, error) { return d.TryUE(12, BigEndian) }

// U13BE read 13 bit unsigned big-endian integer
func (d *D) U13BE() uint64 { return d.UE(13, BigEndian) }

// TryU13BE try read 13 bit unsigned big-endian integer
func (d *D) TryU13BE() (uint64, error) { return d.TryUE(13, BigEndian) }

// U14BE read 14 bit unsigned big-endian integer
func (d *D) U14BE() uint64 { return d.UE(14, BigEndian) }

// TryU14BE try read 14 bit unsigned big-endian integer
func (d *D) TryU14BE() (uint64, error) { return d.TryUE(14, BigEndian) }

// U15BE read 15 bit unsigned big-endian integer
func (d *D) U15BE() uint64 { return d.UE(15, BigEndian) }

// TryU15BE try read 15 bit unsigned big-endian integer
func (d *D) TryU15BE() (uint64, error) { return d.TryUE(15, BigEndian) }

// U16BE read 16 bit unsigned big-endian integer
func (d *D) U16BE() uint64 { return d.UE(16, BigEndian) }

// TryU16BE try read 16 bit unsigned big-endian integer
func (d *D) TryU16BE() (uint64, error) { return d.TryUE(16, BigEndian) }

// U17BE read 17 bit unsigned big-endian integer
func (d *D) U17BE() uint64 { return d.UE(17, BigEndian) }

// TryU17BE try read 17 bit unsigned big-endian integer
func (d *D) TryU17BE() (uint64, error) { return d.TryUE(17, BigEndian) }

// U18BE read 18 bit unsigned big-endian integer
func (d *D) U18BE() uint64 { return d.UE(18, BigEndian) }

// TryU18BE try read 18 bit unsigned big-endian integer
func (d *D) TryU18BE() (uint64, error) { return d.TryUE(18, BigEndian) }

// U19BE read 19 bit unsigned big-endian integer
func (d *D) U19BE() uint64 { return d.UE(19, BigEndian) }

// TryU19BE try read 19 bit unsigned big-endian integer
func (d *D) TryU19BE() (uint64, error) { return d.TryUE(19, BigEndian) }

// U20BE read 20 bit unsigned big-endian integer
func (d *D) U20BE() uint64 { return d.UE(20, BigEndian) }

// TryU20BE try read 20 bit unsigned big-endian integer
func (d *D) TryU20BE() (uint64, error) { return d.TryUE(20, BigEndian) }

// U21BE read 21 bit unsigned big-endian integer
func (d *D) U21BE() uint64 { return d.UE(21, BigEndian) }

// TryU21BE try read 21 bit unsigned big-endian integer
func (d *D) TryU21BE() (uint64, error) { return d.TryUE(21, BigEndian) }

// U22BE read 22 bit unsigned big-endian integer
func (d *D) U22BE() uint64 { return d.UE(22, BigEndian) }

// TryU22BE try read 22 bit unsigned big-endian integer
func (d *D) TryU22BE() (uint64, error) { return d.TryUE(22, BigEndian) }

// U23BE read 23 bit unsigned big-endian integer
func (d *D) U23BE() uint64 { return d.UE(23, BigEndian) }

// TryU23BE try read 23 bit unsigned big-endian integer
func (d *D) TryU23BE() (uint64, error) { return d.TryUE(23, BigEndian) }

// U24BE read 24 bit unsigned big-endian integer
func (d *D) U24BE() uint64 { return d.UE(24, BigEndian) }

// TryU24BE try read 24 bit unsigned big-endian integer
func (d *D) TryU24BE() (uint64, error) { return d.TryUE(24, BigEndian) }

// U25BE read 25 bit unsigned big-endian integer
func (d *D) U25BE() uint64 { return d.UE(25, BigEndian) }

// TryU25BE try read 25 bit unsigned big-endian integer
func (d *D) TryU25BE() (uint64, error) { return d.TryUE(25, BigEndian) }

// U26BE read 26 bit unsigned big-endian integer
func (d *D) U26BE() uint64 { return d.UE(26, BigEndian) }

// TryU26BE try read 26 bit unsigned big-endian integer
func (d *D) TryU26BE() (uint64, error) { return d.TryUE(26, BigEndian) }

// U27BE read 27 bit unsigned big-endian integer
func (d *D) U27BE() uint64 { return d.UE(27, BigEndian) }

// TryU27BE try read 27 bit unsigned big-endian integer
func (d *D) TryU27BE() (uint64, error) { return d.TryUE(27, BigEndian) }

// U28BE read 28 bit unsigned big-endian integer
func (d *D) U28BE() uint64 { return d.UE(28, BigEndian) }

// TryU28BE try read 28 bit unsigned big-endian integer
func (d *D) TryU28BE() (uint64, error) { return d.TryUE(28, BigEndian) }

// U29BE read 29 bit unsigned big-endian integer
func (d *D) U29BE() uint64 { return d.UE(29, BigEndian) }

// TryU29BE try read 29 bit unsigned big-endian integer
func (d *D) TryU29BE() (uint64, error) { return d.TryUE(29, BigEndian) }

// U30BE read 30 bit unsigned big-endian integer
func (d *D) U30BE() uint64 { return d.UE(30, BigEndian) }

// TryU30BE try read 30 bit unsigned big-endian integer
func (d *D) TryU30BE() (uint64, error) { return d.TryUE(30, BigEndian) }

// U31BE read 31 bit unsigned big-endian integer
func (d *D) U31BE() uint64 { return d.UE(31, BigEndian) }

// TryU31BE try read 31 bit unsigned big-endian integer
func (d *D) TryU31BE() (uint64, error) { return d.TryUE(31, BigEndian) }

// U32BE read 32 bit unsigned big-endian integer
func (d *D) U32BE() uint64 { return d.UE(32, BigEndian) }

// TryU32BE try read 32 bit unsigned big-endian integer
func (d *D) TryU32BE() (uint64, error) { return d.TryUE(32, BigEndian) }

// U33BE read 33 bit unsigned big-endian integer
func (d *D) U33BE() uint64 { return d.UE(33, BigEndian) }

// TryU33BE try read 33 bit unsigned big-endian integer
func (d *D) TryU33BE() (uint64, error) { return d.TryUE(33, BigEndian) }

// U34BE read 34 bit unsigned big-endian integer
func (d *D) U34BE() uint64 { return d.UE(34, BigEndian) }

// TryU34BE try read 34 bit unsigned big-endian integer
func (d *D) TryU34BE() (uint64, error) { return d.TryUE(34, BigEndian) }

// U35BE read 35 bit unsigned big-endian integer
func (d *D) U35BE() uint64 { return d.UE(35, BigEndian) }

// TryU35BE try read 35 bit unsigned big-endian integer
func (d *D) TryU35BE() (uint64, error) { return d.TryUE(35, BigEndian) }

// U36BE read 36 bit unsigned big-endian integer
func (d *D) U36BE() uint64 { return d.UE(36, BigEndian) }

// TryU36BE try read 36 bit unsigned big-endian integer
func (d *D) TryU36BE() (uint64, error) { return d.TryUE(36, BigEndian) }

// U37BE read 37 bit unsigned big-endian integer
func (d *D) U37BE() uint64 { return d.UE(37, BigEndian) }

// TryU37BE try read 37 bit unsigned big-endian integer
func (d *D) TryU37BE() (uint64, error) { return d.TryUE(37, BigEndian) }

// U38BE read 38 bit unsigned big-endian integer
func (d *D) U38BE() uint64 { return d.UE(38, BigEndian) }

// TryU38BE try read 38 bit unsigned big-endian integer
func (d *D) TryU38BE() (uint64, error) { return d.TryUE(38, BigEndian) }

// U39BE read 39 bit unsigned big-endian integer
func (d *D) U39BE() uint64 { return d.UE(39, BigEndian) }

// TryU39BE try read 39 bit unsigned big-endian integer
func (d *D) TryU39BE() (uint64, error) { return d.TryUE(39, BigEndian) }

// U40BE read 40 bit unsigned big-endian integer
func (d *D) U40BE() uint64 { return d.UE(40, BigEndian) }

// TryU40BE try read 40 bit unsigned big-endian integer
func (d *D) TryU40BE() (uint64, error) { return d.TryUE(40, BigEndian) }

// U41BE read 41 bit unsigned big-endian integer
func (d *D) U41BE() uint64 { return d.UE(41, BigEndian) }

// TryU41BE try read 41 bit unsigned big-endian integer
func (d *D) TryU41BE() (uint64, error) { return d.TryUE(41, BigEndian) }

// U42BE read 42 bit unsigned big-endian integer
func (d *D) U42BE() uint64 { return d.UE(42, BigEndian) }

// TryU42BE try read 42 bit unsigned big-endian integer
func (d *D) TryU42BE() (uint64, error) { return d.TryUE(42, BigEndian) }

// U43BE read 43 bit unsigned big-endian integer
func (d *D) U43BE() uint64 { return d.UE(43, BigEndian) }

// TryU43BE try read 43 bit unsigned big-endian integer
func (d *D) TryU43BE() (uint64, error) { return d.TryUE(43, BigEndian) }

// U44BE read 44 bit unsigned big-endian integer
func (d *D) U44BE() uint64 { return d.UE(44, BigEndian) }

// TryU44BE try read 44 bit unsigned big-endian integer
func (d *D) TryU44BE() (uint64, error) { return d.TryUE(44, BigEndian) }

// U45BE read 45 bit unsigned big-endian integer
func (d *D) U45BE() uint64 { return d.UE(45, BigEndian) }

// TryU45BE try read 45 bit unsigned big-endian integer
func (d *D) TryU45BE() (uint64, error) { return d.TryUE(45, BigEndian) }

// U46BE read 46 bit unsigned big-endian integer
func (d *D) U46BE() uint64 { return d.UE(46, BigEndian) }

// TryU46BE try read 46 bit unsigned big-endian integer
func (d *D) TryU46BE() (uint64, error) { return d.TryUE(46, BigEndian) }

// U47BE read 47 bit unsigned big-endian integer
func (d *D) U47BE() uint64 { return d.UE(47, BigEndian) }

// TryU47BE try read 47 bit unsigned big-endian integer
func (d *D) TryU47BE() (uint64, error) { return d.TryUE(47, BigEndian) }

// U48BE read 48 bit unsigned big-endian integer
func (d *D) U48BE() uint64 { return d.UE(48, BigEndian) }

// TryU48BE try read 48 bit unsigned big-endian integer
func (d *D) TryU48BE() (uint64, error) { return d.TryUE(48, BigEndian) }

// U49BE read 49 bit unsigned big-endian integer
func (d *D) U49BE() uint64 { return d.UE(49, BigEndian) }

// TryU49BE try read 49 bit unsigned big-endian integer
func (d *D) TryU49BE() (uint64, error) { return d.TryUE(49, BigEndian) }

// U50BE read 50 bit unsigned big-endian integer
func (d *D) U50BE() uint64 { return d.UE(50, BigEndian) }

// TryU50BE try read 50 bit unsigned big-endian integer
func (d *D) TryU50BE() (uint64, error) { return d.TryUE(50, BigEndian) }

// U51BE read 51 bit unsigned big-endian integer
func (d *D) U51BE() uint64 { return d.UE(51, BigEndian) }

// TryU51BE try read 51 bit unsigned big-endian integer
func (d *D) TryU51BE() (uint64, error) { return d.TryUE(51, BigEndian) }

// U52BE read 52 bit unsigned big-endian integer
func (d *D) U52BE() uint64 { return d.UE(52, BigEndian) }

// TryU52BE try read 52 bit unsigned big-endian integer
func (d *D) TryU52BE() (uint64, error) { return d.TryUE(52, BigEndian) }

// U53BE read 53 bit unsigned big-endian integer
func (d *D) U53BE() uint64 { return d.UE(53, BigEndian) }

// TryU53BE try read 53 bit unsigned big-endian integer
func (d *D) TryU53BE() (uint64, error) { return d.TryUE(53, BigEndian) }

// U54BE read 54 bit unsigned big-endian integer
func (d *D) U54BE() uint64 { return d.UE(54, BigEndian) }

// TryU54BE try read 54 bit unsigned big-endian integer
func (d *D) TryU54BE() (uint64, error) { return d.TryUE(54, BigEndian) }

// U55BE read 55 bit unsigned big-endian integer
func (d *D) U55BE() uint64 { return d.UE(55, BigEndian) }

// TryU55BE try read 55 bit unsigned big-endian integer
func (d *D) TryU55BE() (uint64, error) { return d.TryUE(55, BigEndian) }

// U56BE read 56 bit unsigned big-endian integer
func (d *D) U56BE() uint64 { return d.UE(56, BigEndian) }

// TryU56BE try read 56 bit unsigned big-endian integer
func (d *D) TryU56BE() (uint64, error) { return d.TryUE(56, BigEndian) }

// U57BE read 57 bit unsigned big-endian integer
func (d *D) U57BE() uint64 { return d.UE(57, BigEndian) }

// TryU57BE try read 57 bit unsigned big-endian integer
func (d *D) TryU57BE() (uint64, error) { return d.TryUE(57, BigEndian) }

// U58BE read 58 bit unsigned big-endian integer
func (d *D) U58BE() uint64 { return d.UE(58, BigEndian) }

// TryU58BE try read 58 bit unsigned big-endian integer
func (d *D) TryU58BE() (uint64, error) { return d.TryUE(58, BigEndian) }

// U59BE read 59 bit unsigned big-endian integer
func (d *D) U59BE() uint64 { return d.UE(59, BigEndian) }

// TryU59BE try read 59 bit unsigned big-endian integer
func (d *D) TryU59BE() (uint64, error) { return d.TryUE(59, BigEndian) }

// U60BE read 60 bit unsigned big-endian integer
func (d *D) U60BE() uint64 { return d.UE(60, BigEndian) }

// TryU60BE try read 60 bit unsigned big-endian integer
func (d *D) TryU60BE() (uint64, error) { return d.TryUE(60, BigEndian) }

// U61BE read 61 bit unsigned big-endian integer
func (d *D) U61BE() uint64 { return d.UE(61, BigEndian) }

// TryU61BE try read 61 bit unsigned big-endian integer
func (d *D) TryU61BE() (uint64, error) { return d.TryUE(61, BigEndian) }

// U62BE read 62 bit unsigned big-endian integer
func (d *D) U62BE() uint64 { return d.UE(62, BigEndian) }

// TryU62BE try read 62 bit unsigned big-endian integer
func (d *D) TryU62BE() (uint64, error) { return d.TryUE(62, BigEndian) }

// U63BE read 63 bit unsigned big-endian integer
func (d *D) U63BE() uint64 { return d.UE(63, BigEndian) }

// TryU63BE try read 63 bit unsigned big-endian integer
func (d *D) TryU63BE() (uint64, error) { return d.TryUE(63, BigEndian) }

// U64BE read 64 bit unsigned big-endian integer
func (d *D) U64BE() uint64 { return d.UE(64, BigEndian) }

// TryU64BE try read 64 bit unsigned big-endian integer
func (d *D) TryU64BE() (uint64, error) { return d.TryUE(64, BigEndian) }

// FieldUBE read a nBits unsigned big-endian integer and add a field
func (d *D) FieldUBE(name string, nBits int) uint64 { return d.FieldUE(name, nBits, BigEndian) }

// FieldU8BE read 8 bit unsigned big-endian integer and add a field
func (d *D) FieldU8BE(name string) uint64 { return d.FieldUE(name, 8, BigEndian) }

// FieldU9BE read 9 bit unsigned big-endian integer and add a field
func (d *D) FieldU9BE(name string) uint64 { return d.FieldUE(name, 9, BigEndian) }

// FieldU10BE read 10 bit unsigned big-endian integer and add a field
func (d *D) FieldU10BE(name string) uint64 { return d.FieldUE(name, 10, BigEndian) }

// FieldU11BE read 11 bit unsigned big-endian integer and add a field
func (d *D) FieldU11BE(name string) uint64 { return d.FieldUE(name, 11, BigEndian) }

// FieldU12BE read 12 bit unsigned big-endian integer and add a field
func (d *D) FieldU12BE(name string) uint64 { return d.FieldUE(name, 12, BigEndian) }

// FieldU13BE read 13 bit unsigned big-endian integer and add a field
func (d *D) FieldU13BE(name string) uint64 { return d.FieldUE(name, 13, BigEndian) }

// FieldU14BE read 14 bit unsigned big-endian integer and add a field
func (d *D) FieldU14BE(name string) uint64 { return d.FieldUE(name, 14, BigEndian) }

// FieldU15BE read 15 bit unsigned big-endian integer and add a field
func (d *D) FieldU15BE(name string) uint64 { return d.FieldUE(name, 15, BigEndian) }

// FieldU16BE read 16 bit unsigned big-endian integer and add a field
func (d *D) FieldU16BE(name string) uint64 { return d.FieldUE(name, 16, BigEndian) }

// FieldU17BE read 17 bit unsigned big-endian integer and add a field
func (d *D) FieldU17BE(name string) uint64 { return d.FieldUE(name, 17, BigEndian) }

// FieldU18BE read 18 bit unsigned big-endian integer and add a field
func (d *D) FieldU18BE(name string) uint64 { return d.FieldUE(name, 18, BigEndian) }

// FieldU19BE read 19 bit unsigned big-endian integer and add a field
func (d *D) FieldU19BE(name string) uint64 { return d.FieldUE(name, 19, BigEndian) }

// FieldU20BE read 20 bit unsigned big-endian integer and add a field
func (d *D) FieldU20BE(name string) uint64 { return d.FieldUE(name, 20, BigEndian) }

// FieldU21BE read 21 bit unsigned big-endian integer and add a field
func (d *D) FieldU21BE(name string) uint64 { return d.FieldUE(name, 21, BigEndian) }

// FieldU22BE read 22 bit unsigned big-endian integer and add a field
func (d *D) FieldU22BE(name string) uint64 { return d.FieldUE(name, 22, BigEndian) }

// FieldU23BE read 23 bit unsigned big-endian integer and add a field
func (d *D) FieldU23BE(name string) uint64 { return d.FieldUE(name, 23, BigEndian) }

// FieldU24BE read 24 bit unsigned big-endian integer and add a field
func (d *D) FieldU24BE(name string) uint64 { return d.FieldUE(name, 24, BigEndian) }

// FieldU25BE read 25 bit unsigned big-endian integer and add a field
func (d *D) FieldU25BE(name string) uint64 { return d.FieldUE(name, 25, BigEndian) }

// FieldU26BE read 26 bit unsigned big-endian integer and add a field
func (d *D) FieldU26BE(name string) uint64 { return d.FieldUE(name, 26, BigEndian) }

// FieldU27BE read 27 bit unsigned big-endian integer and add a field
func (d *D) FieldU27BE(name string) uint64 { return d.FieldUE(name, 27, BigEndian) }

// FieldU28BE read 28 bit unsigned big-endian integer and add a field
func (d *D) FieldU28BE(name string) uint64 { return d.FieldUE(name, 28, BigEndian) }

// FieldU29BE read 29 bit unsigned big-endian integer and add a field
func (d *D) FieldU29BE(name string) uint64 { return d.FieldUE(name, 29, BigEndian) }

// FieldU30BE read 30 bit unsigned big-endian integer and add a field
func (d *D) FieldU30BE(name string) uint64 { return d.FieldUE(name, 30, BigEndian) }

// FieldU31BE read 31 bit unsigned big-endian integer and add a field
func (d *D) FieldU31BE(name string) uint64 { return d.FieldUE(name, 31, BigEndian) }

// FieldU32BE read 32 bit unsigned big-endian integer and add a field
func (d *D) FieldU32BE(name string) uint64 { return d.FieldUE(name, 32, BigEndian) }

// FieldU33BE read 33 bit unsigned big-endian integer and add a field
func (d *D) FieldU33BE(name string) uint64 { return d.FieldUE(name, 33, BigEndian) }

// FieldU34BE read 34 bit unsigned big-endian integer and add a field
func (d *D) FieldU34BE(name string) uint64 { return d.FieldUE(name, 34, BigEndian) }

// FieldU35BE read 35 bit unsigned big-endian integer and add a field
func (d *D) FieldU35BE(name string) uint64 { return d.FieldUE(name, 35, BigEndian) }

// FieldU36BE read 36 bit unsigned big-endian integer and add a field
func (d *D) FieldU36BE(name string) uint64 { return d.FieldUE(name, 36, BigEndian) }

// FieldU37BE read 37 bit unsigned big-endian integer and add a field
func (d *D) FieldU37BE(name string) uint64 { return d.FieldUE(name, 37, BigEndian) }

// FieldU38BE read 38 bit unsigned big-endian integer and add a field
func (d *D) FieldU38BE(name string) uint64 { return d.FieldUE(name, 38, BigEndian) }

// FieldU39BE read 39 bit unsigned big-endian integer and add a field
func (d *D) FieldU39BE(name string) uint64 { return d.FieldUE(name, 39, BigEndian) }

// FieldU40BE read 40 bit unsigned big-endian integer and add a field
func (d *D) FieldU40BE(name string) uint64 { return d.FieldUE(name, 40, BigEndian) }

// FieldU41BE read 41 bit unsigned big-endian integer and add a field
func (d *D) FieldU41BE(name string) uint64 { return d.FieldUE(name, 41, BigEndian) }

// FieldU42BE read 42 bit unsigned big-endian integer and add a field
func (d *D) FieldU42BE(name string) uint64 { return d.FieldUE(name, 42, BigEndian) }

// FieldU43BE read 43 bit unsigned big-endian integer and add a field
func (d *D) FieldU43BE(name string) uint64 { return d.FieldUE(name, 43, BigEndian) }

// FieldU44BE read 44 bit unsigned big-endian integer and add a field
func (d *D) FieldU44BE(name string) uint64 { return d.FieldUE(name, 44, BigEndian) }

// FieldU45BE read 45 bit unsigned big-endian integer and add a field
func (d *D) FieldU45BE(name string) uint64 { return d.FieldUE(name, 45, BigEndian) }

// FieldU46BE read 46 bit unsigned big-endian integer and add a field
func (d *D) FieldU46BE(name string) uint64 { return d.FieldUE(name, 46, BigEndian) }

// FieldU47BE read 47 bit unsigned big-endian integer and add a field
func (d *D) FieldU47BE(name string) uint64 { return d.FieldUE(name, 47, BigEndian) }

// FieldU48BE read 48 bit unsigned big-endian integer and add a field
func (d *D) FieldU48BE(name string) uint64 { return d.FieldUE(name, 48, BigEndian) }

// FieldU49BE read 49 bit unsigned big-endian integer and add a field
func (d *D) FieldU49BE(name string) uint64 { return d.FieldUE(name, 49, BigEndian) }

// FieldU50BE read 50 bit unsigned big-endian integer and add a field
func (d *D) FieldU50BE(name string) uint64 { return d.FieldUE(name, 50, BigEndian) }

// FieldU51BE read 51 bit unsigned big-endian integer and add a field
func (d *D) FieldU51BE(name string) uint64 { return d.FieldUE(name, 51, BigEndian) }

// FieldU52BE read 52 bit unsigned big-endian integer and add a field
func (d *D) FieldU52BE(name string) uint64 { return d.FieldUE(name, 52, BigEndian) }

// FieldU53BE read 53 bit unsigned big-endian integer and add a field
func (d *D) FieldU53BE(name string) uint64 { return d.FieldUE(name, 53, BigEndian) }

// FieldU54BE read 54 bit unsigned big-endian integer and add a field
func (d *D) FieldU54BE(name string) uint64 { return d.FieldUE(name, 54, BigEndian) }

// FieldU55BE read 55 bit unsigned big-endian integer and add a field
func (d *D) FieldU55BE(name string) uint64 { return d.FieldUE(name, 55, BigEndian) }

// FieldU56BE read 56 bit unsigned big-endian integer and add a field
func (d *D) FieldU56BE(name string) uint64 { return d.FieldUE(name, 56, BigEndian) }

// FieldU57BE read 57 bit unsigned big-endian integer and add a field
func (d *D) FieldU57BE(name string) uint64 { return d.FieldUE(name, 57, BigEndian) }

// FieldU58BE read 58 bit unsigned big-endian integer and add a field
func (d *D) FieldU58BE(name string) uint64 { return d.FieldUE(name, 58, BigEndian) }

// FieldU59BE read 59 bit unsigned big-endian integer and add a field
func (d *D) FieldU59BE(name string) uint64 { return d.FieldUE(name, 59, BigEndian) }

// FieldU60BE read 60 bit unsigned big-endian integer and add a field
func (d *D) FieldU60BE(name string) uint64 { return d.FieldUE(name, 60, BigEndian) }

// FieldU61BE read 61 bit unsigned big-endian integer and add a field
func (d *D) FieldU61BE(name string) uint64 { return d.FieldUE(name, 61, BigEndian) }

// FieldU62BE read 62 bit unsigned big-endian integer and add a field
func (d *D) FieldU62BE(name string) uint64 { return d.FieldUE(name, 62, BigEndian) }

// FieldU63BE read 63 bit unsigned big-endian integer and add a field
func (d *D) FieldU63BE(name string) uint64 { return d.FieldUE(name, 63, BigEndian) }

// FieldU64BE read 64 bit unsigned big-endian integer and add a field
func (d *D) FieldU64BE(name string) uint64 { return d.FieldUE(name, 64, BigEndian) }

// ULE read a nBits unsigned little-endian integer
func (d *D) ULE(nBits int) uint64 { return d.UE(nBits, LittleEndian) }

// TryULE try read a nBits unsigned little-endian integer
func (d *D) TryULE(nBits int) (uint64, error) { return d.TryUE(nBits, LittleEndian) }

// U8LE read 8 bit unsigned little-endian integer
func (d *D) U8LE() uint64 { return d.UE(8, LittleEndian) }

// TryU8LE try read 8 bit unsigned little-endian integer
func (d *D) TryU8LE() (uint64, error) { return d.TryUE(8, LittleEndian) }

// U9LE read 9 bit unsigned little-endian integer
func (d *D) U9LE() uint64 { return d.UE(9, LittleEndian) }

// TryU9LE try read 9 bit unsigned little-endian integer
func (d *D) TryU9LE() (uint64, error) { return d.TryUE(9, LittleEndian) }

// U10LE read 10 bit unsigned little-endian integer
func (d *D) U10LE() uint64 { return d.UE(10, LittleEndian) }

// TryU10LE try read 10 bit unsigned little-endian integer
func (d *D) TryU10LE() (uint64, error) { return d.TryUE(10, LittleEndian) }

// U11LE read 11 bit unsigned little-endian integer
func (d *D) U11LE() uint64 { return d.UE(11, LittleEndian) }

// TryU11LE try read 11 bit unsigned little-endian integer
func (d *D) TryU11LE() (uint64, error) { return d.TryUE(11, LittleEndian) }

// U12LE read 12 bit unsigned little-endian integer
func (d *D) U12LE() uint64 { return d.UE(12, LittleEndian) }

// TryU12LE try read 12 bit unsigned little-endian integer
func (d *D) TryU12LE() (uint64, error) { return d.TryUE(12, LittleEndian) }

// U13LE read 13 bit unsigned little-endian integer
func (d *D) U13LE() uint64 { return d.UE(13, LittleEndian) }

// TryU13LE try read 13 bit unsigned little-endian integer
func (d *D) TryU13LE() (uint64, error) { return d.TryUE(13, LittleEndian) }

// U14LE read 14 bit unsigned little-endian integer
func (d *D) U14LE() uint64 { return d.UE(14, LittleEndian) }

// TryU14LE try read 14 bit unsigned little-endian integer
func (d *D) TryU14LE() (uint64, error) { return d.TryUE(14, LittleEndian) }

// U15LE read 15 bit unsigned little-endian integer
func (d *D) U15LE() uint64 { return d.UE(15, LittleEndian) }

// TryU15LE try read 15 bit unsigned little-endian integer
func (d *D) TryU15LE() (uint64, error) { return d.TryUE(15, LittleEndian) }

// U16LE read 16 bit unsigned little-endian integer
func (d *D) U16LE() uint64 { return d.UE(16, LittleEndian) }

// TryU16LE try read 16 bit unsigned little-endian integer
func (d *D) TryU16LE() (uint64, error) { return d.TryUE(16, LittleEndian) }

// U17LE read 17 bit unsigned little-endian integer
func (d *D) U17LE() uint64 { return d.UE(17, LittleEndian) }

// TryU17LE try read 17 bit unsigned little-endian integer
func (d *D) TryU17LE() (uint64, error) { return d.TryUE(17, LittleEndian) }

// U18LE read 18 bit unsigned little-endian integer
func (d *D) U18LE() uint64 { return d.UE(18, LittleEndian) }

// TryU18LE try read 18 bit unsigned little-endian integer
func (d *D) TryU18LE() (uint64, error) { return d.TryUE(18, LittleEndian) }

// U19LE read 19 bit unsigned little-endian integer
func (d *D) U19LE() uint64 { return d.UE(19, LittleEndian) }

// TryU19LE try read 19 bit unsigned little-endian integer
func (d *D) TryU19LE() (uint64, error) { return d.TryUE(19, LittleEndian) }

// U20LE read 20 bit unsigned little-endian integer
func (d *D) U20LE() uint64 { return d.UE(20, LittleEndian) }

// TryU20LE try read 20 bit unsigned little-endian integer
func (d *D) TryU20LE() (uint64, error) { return d.TryUE(20, LittleEndian) }

// U21LE read 21 bit unsigned little-endian integer
func (d *D) U21LE() uint64 { return d.UE(21, LittleEndian) }

// TryU21LE try read 21 bit unsigned little-endian integer
func (d *D) TryU21LE() (uint64, error) { return d.TryUE(21, LittleEndian) }

// U22LE read 22 bit unsigned little-endian integer
func (d *D) U22LE() uint64 { return d.UE(22, LittleEndian) }

// TryU22LE try read 22 bit unsigned little-endian integer
func (d *D) TryU22LE() (uint64, error) { return d.TryUE(22, LittleEndian) }

// U23LE read 23 bit unsigned little-endian integer
func (d *D) U23LE() uint64 { return d.UE(23, LittleEndian) }

// TryU23LE try read 23 bit unsigned little-endian integer
func (d *D) TryU23LE() (uint64, error) { return d.TryUE(23, LittleEndian) }

// U24LE read 24 bit unsigned little-endian integer
func (d *D) U24LE() uint64 { return d.UE(24, LittleEndian) }

// TryU24LE try read 24 bit unsigned little-endian integer
func (d *D) TryU24LE() (uint64, error) { return d.TryUE(24, LittleEndian) }

// U25LE read 25 bit unsigned little-endian integer
func (d *D) U25LE() uint64 { return d.UE(25, LittleEndian) }

// TryU25LE try read 25 bit unsigned little-endian integer
func (d *D) TryU25LE() (uint64, error) { return d.TryUE(25, LittleEndian) }

// U26LE read 26 bit unsigned little-endian integer
func (d *D) U26LE() uint64 { return d.UE(26, LittleEndian) }

// TryU26LE try read 26 bit unsigned little-endian integer
func (d *D) TryU26LE() (uint64, error) { return d.TryUE(26, LittleEndian) }

// U27LE read 27 bit unsigned little-endian integer
func (d *D) U27LE() uint64 { return d.UE(27, LittleEndian) }

// TryU27LE try read 27 bit unsigned little-endian integer
func (d *D) TryU27LE() (uint64, error) { return d.TryUE(27, LittleEndian) }

// U28LE read 28 bit unsigned little-endian integer
func (d *D) U28LE() uint64 { return d.UE(28, LittleEndian) }

// TryU28LE try read 28 bit unsigned little-endian integer
func (d *D) TryU28LE() (uint64, error) { return d.TryUE(28, LittleEndian) }

// U29LE read 29 bit unsigned little-endian integer
func (d *D) U29LE() uint64 { return d.UE(29, LittleEndian) }

// TryU29LE try read 29 bit unsigned little-endian integer
func (d *D) TryU29LE() (uint64, error) { return d.TryUE(29, LittleEndian) }

// U30LE read 30 bit unsigned little-endian integer
func (d *D) U30LE() uint64 { return d.UE(30, LittleEndian) }

// TryU30LE try read 30 bit unsigned little-endian integer
func (d *D) TryU30LE() (uint64, error) { return d.TryUE(30, LittleEndian) }

// U31LE read 31 bit unsigned little-endian integer
func (d *D) U31LE() uint64 { return d.UE(31, LittleEndian) }

// TryU31LE try read 31 bit unsigned little-endian integer
func (d *D) TryU31LE() (uint64, error) { return d.TryUE(31, LittleEndian) }

// U32LE read 32 bit unsigned little-endian integer
func (d *D) U32LE() uint64 { return d.UE(32, LittleEndian) }

// TryU32LE try read 32 bit unsigned little-endian integer
func (d *D) TryU32LE() (uint64, error) { return d.TryUE(32, LittleEndian) }

// U33LE read 33 bit unsigned little-endian integer
func (d *D) U33LE() uint64 { return d.UE(33, LittleEndian) }

// TryU33LE try read 33 bit unsigned little-endian integer
func (d *D) TryU33LE() (uint64, error) { return d.TryUE(33, LittleEndian) }

// U34LE read 34 bit unsigned little-endian integer
func (d *D) U34LE() uint64 { return d.UE(34, LittleEndian) }

// TryU34LE try read 34 bit unsigned little-endian integer
func (d *D) TryU34LE() (uint64, error) { return d.TryUE(34, LittleEndian) }

// U35LE read 35 bit unsigned little-endian integer
func (d *D) U35LE() uint64 { return d.UE(35, LittleEndian) }

// TryU35LE try read 35 bit unsigned little-endian integer
func (d *D) TryU35LE() (uint64, error) { return d.TryUE(35, LittleEndian) }

// U36LE read 36 bit unsigned little-endian integer
func (d *D) U36LE() uint64 { return d.UE(36, LittleEndian) }

// TryU36LE try read 36 bit unsigned little-endian integer
func (d *D) TryU36LE() (uint64, error) { return d.TryUE(36, LittleEndian) }

// U37LE read 37 bit unsigned little-endian integer
func (d *D) U37LE() uint64 { return d.UE(37, LittleEndian) }

// TryU37LE try read 37 bit unsigned little-endian integer
func (d *D) TryU37LE() (uint64, error) { return d.TryUE(37, LittleEndian) }

// U38LE read 38 bit unsigned little-endian integer
func (d *D) U38LE() uint64 { return d.UE(38, LittleEndian) }

// TryU38LE try read 38 bit unsigned little-endian integer
func (d *D) TryU38LE() (uint64, error) { return d.TryUE(38, LittleEndian) }

// U39LE read 39 bit unsigned little-endian integer
func (d *D) U39LE() uint64 { return d.UE(39, LittleEndian) }

// TryU39LE try read 39 bit unsigned little-endian integer
func (d *D) TryU39LE() (uint64, error) { return d.TryUE(39, LittleEndian) }

// U40LE read 40 bit unsigned little-endian integer
func (d *D) U40LE() uint64 { return d.UE(40, LittleEndian) }

// TryU40LE try read 40 bit unsigned little-endian integer
func (d *D) TryU40LE() (uint64, error) { return d.TryUE(40, LittleEndian) }

// U41LE read 41 bit unsigned little-endian integer
func (d *D) U41LE() uint64 { return d.UE(41, LittleEndian) }

// TryU41LE try read 41 bit unsigned little-endian integer
func (d *D) TryU41LE() (uint64, error) { return d.TryUE(41, LittleEndian) }

// U42LE read 42 bit unsigned little-endian integer
func (d *D) U42LE() uint64 { return d.UE(42, LittleEndian) }

// TryU42LE try read 42 bit unsigned little-endian integer
func (d *D) TryU42LE() (uint64, error) { return d.TryUE(42, LittleEndian) }

// U43LE read 43 bit unsigned little-endian integer
func (d *D) U43LE() uint64 { return d.UE(43, LittleEndian) }

// TryU43LE try read 43 bit unsigned little-endian integer
func (d *D) TryU43LE() (uint64, error) { return d.TryUE(43, LittleEndian) }

// U44LE read 44 bit unsigned little-endian integer
func (d *D) U44LE() uint64 { return d.UE(44, LittleEndian) }

// TryU44LE try read 44 bit unsigned little-endian integer
func (d *D) TryU44LE() (uint64, error) { return d.TryUE(44, LittleEndian) }

// U45LE read 45 bit unsigned little-endian integer
func (d *D) U45LE() uint64 { return d.UE(45, LittleEndian) }

// TryU45LE try read 45 bit unsigned little-endian integer
func (d *D) TryU45LE() (uint64, error) { return d.TryUE(45, LittleEndian) }

// U46LE read 46 bit unsigned little-endian integer
func (d *D) U46LE() uint64 { return d.UE(46, LittleEndian) }

// TryU46LE try read 46 bit unsigned little-endian integer
func (d *D) TryU46LE() (uint64, error) { return d.TryUE(46, LittleEndian) }

// U47LE read 47 bit unsigned little-endian integer
func (d *D) U47LE() uint64 { return d.UE(47, LittleEndian) }

// TryU47LE try read 47 bit unsigned little-endian integer
func (d *D) TryU47LE() (uint64, error) { return d.TryUE(47, LittleEndian) }

// U48LE read 48 bit unsigned little-endian integer
func (d *D) U48LE() uint64 { return d.UE(48, LittleEndian) }

// TryU48LE try read 48 bit unsigned little-endian integer
func (d *D) TryU48LE() (uint64, error) { return d.TryUE(48, LittleEndian) }

// U49LE read 49 bit unsigned little-endian integer
func (d *D) U49LE() uint64 { return d.UE(49, LittleEndian) }

// TryU49LE try read 49 bit unsigned little-endian integer
func (d *D) TryU49LE() (uint64, error) { return d.TryUE(49, LittleEndian) }

// U50LE read 50 bit unsigned little-endian integer
func (d *D) U50LE() uint64 { return d.UE(50, LittleEndian) }

// TryU50LE try read 50 bit unsigned little-endian integer
func (d *D) TryU50LE() (uint64, error) { return d.TryUE(50, LittleEndian) }

// U51LE read 51 bit unsigned little-endian integer
func (d *D) U51LE() uint64 { return d.UE(51, LittleEndian) }

// TryU51LE try read 51 bit unsigned little-endian integer
func (d *D) TryU51LE() (uint64, error) { return d.TryUE(51, LittleEndian) }

// U52LE read 52 bit unsigned little-endian integer
func (d *D) U52LE() uint64 { return d.UE(52, LittleEndian) }

// TryU52LE try read 52 bit unsigned little-endian integer
func (d *D) TryU52LE() (uint64, error) { return d.TryUE(52, LittleEndian) }

// U53LE read 53 bit unsigned little-endian integer
func (d *D) U53LE() uint64 { return d.UE(53, LittleEndian) }

// TryU53LE try read 53 bit unsigned little-endian integer
func (d *D) TryU53LE() (uint64, error) { return d.TryUE(53, LittleEndian) }

// U54LE read 54 bit unsigned little-endian integer
func (d *D) U54LE() uint64 { return d.UE(54, LittleEndian) }

// TryU54LE try read 54 bit unsigned little-endian integer
func (d *D) TryU54LE() (uint64, error) { return d.TryUE(54, LittleEndian) }

// U55LE read 55 bit unsigned little-endian integer
func (d *D) U55LE() uint64 { return d.UE(55, LittleEndian) }

// TryU55LE try read 55 bit unsigned little-endian integer
func (d *D) TryU55LE() (uint64, error) { return d.TryUE(55, LittleEndian) }

// U56LE read 56 bit unsigned little-endian integer
func (d *D) U56LE() uint64 { return d.UE(56, LittleEndian) }

// TryU56LE try read 56 bit unsigned little-endian integer
func (d *D) TryU56LE() (uint64, error) { return d.TryUE(56, LittleEndian) }

// U57LE read 57 bit unsigned little-endian integer
func (d *D) U57LE() uint64 { return d.UE(57, LittleEndian) }

// TryU57LE try read 57 bit unsigned little-endian integer
func (d *D) TryU57LE() (uint64, error) { return d.TryUE(57, LittleEndian) }

// U58LE read 58 bit unsigned little-endian integer
func (d *D) U58LE() uint64 { return d.UE(58, LittleEndian) }

// TryU58LE try read 58 bit unsigned little-endian integer
func (d *D) TryU58LE() (uint64, error) { return d.TryUE(58, LittleEndian) }

// U59LE read 59 bit unsigned little-endian integer
func (d *D) U59LE() uint64 { return d.UE(59, LittleEndian) }

// TryU59LE try read 59 bit unsigned little-endian integer
func (d *D) TryU59LE() (uint64, error) { return d.TryUE(59, LittleEndian) }

// U60LE read 60 bit unsigned little-endian integer
func (d *D) U60LE() uint64 { return d.UE(60, LittleEndian) }

// TryU60LE try read 60 bit unsigned little-endian integer
func (d *D) TryU60LE() (uint64, error) { return d.TryUE(60, LittleEndian) }

// U61LE read 61 bit unsigned little-endian integer
func (d *D) U61LE() uint64 { return d.UE(61, LittleEndian) }

// TryU61LE try read 61 bit unsigned little-endian integer
func (d *D) TryU61LE() (uint64, error) { return d.TryUE(61, LittleEndian) }

// U62LE read 62 bit unsigned little-endian integer
func (d *D) U62LE() uint64 { return d.UE(62, LittleEndian) }

// TryU62LE try read 62 bit unsigned little-endian integer
func (d *D) TryU62LE() (uint64, error) { return d.TryUE(62, LittleEndian) }

// U63LE read 63 bit unsigned little-endian integer
func (d *D) U63LE() uint64 { return d.UE(63, LittleEndian) }

// TryU63LE try read 63 bit unsigned little-endian integer
func (d *D) TryU63LE() (uint64, error) { return d.TryUE(63, LittleEndian) }

// U64LE read 64 bit unsigned little-endian integer
func (d *D) U64LE() uint64 { return d.UE(64, LittleEndian) }

// TryU64LE try read 64 bit unsigned little-endian integer
func (d *D) TryU64LE() (uint64, error) { return d.TryUE(64, LittleEndian) }

// FieldULE read a nBits unsigned little-endian integer and add a field
func (d *D) FieldULE(name string, nBits int) uint64 { return d.FieldUE(name, nBits, LittleEndian) }

// FieldU8LE read 8 bit unsigned little-endian integer and add a field
func (d *D) FieldU8LE(name string) uint64 { return d.FieldUE(name, 8, LittleEndian) }

// FieldU9LE read 9 bit unsigned little-endian integer and add a field
func (d *D) FieldU9LE(name string) uint64 { return d.FieldUE(name, 9, LittleEndian) }

// FieldU10LE read 10 bit unsigned little-endian integer and add a field
func (d *D) FieldU10LE(name string) uint64 { return d.FieldUE(name, 10, LittleEndian) }

// FieldU11LE read 11 bit unsigned little-endian integer and add a field
func (d *D) FieldU11LE(name string) uint64 { return d.FieldUE(name, 11, LittleEndian) }

// FieldU12LE read 12 bit unsigned little-endian integer and add a field
func (d *D) FieldU12LE(name string) uint64 { return d.FieldUE(name, 12, LittleEndian) }

// FieldU13LE read 13 bit unsigned little-endian integer and add a field
func (d *D) FieldU13LE(name string) uint64 { return d.FieldUE(name, 13, LittleEndian) }

// FieldU14LE read 14 bit unsigned little-endian integer and add a field
func (d *D) FieldU14LE(name string) uint64 { return d.FieldUE(name, 14, LittleEndian) }

// FieldU15LE read 15 bit unsigned little-endian integer and add a field
func (d *D) FieldU15LE(name string) uint64 { return d.FieldUE(name, 15, LittleEndian) }

// FieldU16LE read 16 bit unsigned little-endian integer and add a field
func (d *D) FieldU16LE(name string) uint64 { return d.FieldUE(name, 16, LittleEndian) }

// FieldU17LE read 17 bit unsigned little-endian integer and add a field
func (d *D) FieldU17LE(name string) uint64 { return d.FieldUE(name, 17, LittleEndian) }

// FieldU18LE read 18 bit unsigned little-endian integer and add a field
func (d *D) FieldU18LE(name string) uint64 { return d.FieldUE(name, 18, LittleEndian) }

// FieldU19LE read 19 bit unsigned little-endian integer and add a field
func (d *D) FieldU19LE(name string) uint64 { return d.FieldUE(name, 19, LittleEndian) }

// FieldU20LE read 20 bit unsigned little-endian integer and add a field
func (d *D) FieldU20LE(name string) uint64 { return d.FieldUE(name, 20, LittleEndian) }

// FieldU21LE read 21 bit unsigned little-endian integer and add a field
func (d *D) FieldU21LE(name string) uint64 { return d.FieldUE(name, 21, LittleEndian) }

// FieldU22LE read 22 bit unsigned little-endian integer and add a field
func (d *D) FieldU22LE(name string) uint64 { return d.FieldUE(name, 22, LittleEndian) }

// FieldU23LE read 23 bit unsigned little-endian integer and add a field
func (d *D) FieldU23LE(name string) uint64 { return d.FieldUE(name, 23, LittleEndian) }

// FieldU24LE read 24 bit unsigned little-endian integer and add a field
func (d *D) FieldU24LE(name string) uint64 { return d.FieldUE(name, 24, LittleEndian) }

// FieldU25LE read 25 bit unsigned little-endian integer and add a field
func (d *D) FieldU25LE(name string) uint64 { return d.FieldUE(name, 25, LittleEndian) }

// FieldU26LE read 26 bit unsigned little-endian integer and add a field
func (d *D) FieldU26LE(name string) uint64 { return d.FieldUE(name, 26, LittleEndian) }

// FieldU27LE read 27 bit unsigned little-endian integer and add a field
func (d *D) FieldU27LE(name string) uint64 { return d.FieldUE(name, 27, LittleEndian) }

// FieldU28LE read 28 bit unsigned little-endian integer and add a field
func (d *D) FieldU28LE(name string) uint64 { return d.FieldUE(name, 28, LittleEndian) }

// FieldU29LE read 29 bit unsigned little-endian integer and add a field
func (d *D) FieldU29LE(name string) uint64 { return d.FieldUE(name, 29, LittleEndian) }

// FieldU30LE read 30 bit unsigned little-endian integer and add a field
func (d *D) FieldU30LE(name string) uint64 { return d.FieldUE(name, 30, LittleEndian) }

// FieldU31LE read 31 bit unsigned little-endian integer and add a field
func (d *D) FieldU31LE(name string) uint64 { return d.FieldUE(name, 31, LittleEndian) }

// FieldU32LE read 32 bit unsigned little-endian integer and add a field
func (d *D) FieldU32LE(name string) uint64 { return d.FieldUE(name, 32, LittleEndian) }

// FieldU33LE read 33 bit unsigned little-endian integer and add a field
func (d *D) FieldU33LE(name string) uint64 { return d.FieldUE(name, 33, LittleEndian) }

// FieldU34LE read 34 bit unsigned little-endian integer and add a field
func (d *D) FieldU34LE(name string) uint64 { return d.FieldUE(name, 34, LittleEndian) }

// FieldU35LE read 35 bit unsigned little-endian integer and add a field
func (d *D) FieldU35LE(name string) uint64 { return d.FieldUE(name, 35, LittleEndian) }

// FieldU36LE read 36 bit unsigned little-endian integer and add a field
func (d *D) FieldU36LE(name string) uint64 { return d.FieldUE(name, 36, LittleEndian) }

// FieldU37LE read 37 bit unsigned little-endian integer and add a field
func (d *D) FieldU37LE(name string) uint64 { return d.FieldUE(name, 37, LittleEndian) }

// FieldU38LE read 38 bit unsigned little-endian integer and add a field
func (d *D) FieldU38LE(name string) uint64 { return d.FieldUE(name, 38, LittleEndian) }

// FieldU39LE read 39 bit unsigned little-endian integer and add a field
func (d *D) FieldU39LE(name string) uint64 { return d.FieldUE(name, 39, LittleEndian) }

// FieldU40LE read 40 bit unsigned little-endian integer and add a field
func (d *D) FieldU40LE(name string) uint64 { return d.FieldUE(name, 40, LittleEndian) }

// FieldU41LE read 41 bit unsigned little-endian integer and add a field
func (d *D) FieldU41LE(name string) uint64 { return d.FieldUE(name, 41, LittleEndian) }

// FieldU42LE read 42 bit unsigned little-endian integer and add a field
func (d *D) FieldU42LE(name string) uint64 { return d.FieldUE(name, 42, LittleEndian) }

// FieldU43LE read 43 bit unsigned little-endian integer and add a field
func (d *D) FieldU43LE(name string) uint64 { return d.FieldUE(name, 43, LittleEndian) }

// FieldU44LE read 44 bit unsigned little-endian integer and add a field
func (d *D) FieldU44LE(name string) uint64 { return d.FieldUE(name, 44, LittleEndian) }

// FieldU45LE read 45 bit unsigned little-endian integer and add a field
func (d *D) FieldU45LE(name string) uint64 { return d.FieldUE(name, 45, LittleEndian) }

// FieldU46LE read 46 bit unsigned little-endian integer and add a field
func (d *D) FieldU46LE(name string) uint64 { return d.FieldUE(name, 46, LittleEndian) }

// FieldU47LE read 47 bit unsigned little-endian integer and add a field
func (d *D) FieldU47LE(name string) uint64 { return d.FieldUE(name, 47, LittleEndian) }

// FieldU48LE read 48 bit unsigned little-endian integer and add a field
func (d *D) FieldU48LE(name string) uint64 { return d.FieldUE(name, 48, LittleEndian) }

// FieldU49LE read 49 bit unsigned little-endian integer and add a field
func (d *D) FieldU49LE(name string) uint64 { return d.FieldUE(name, 49, LittleEndian) }

// FieldU50LE read 50 bit unsigned little-endian integer and add a field
func (d *D) FieldU50LE(name string) uint64 { return d.FieldUE(name, 50, LittleEndian) }

// FieldU51LE read 51 bit unsigned little-endian integer and add a field
func (d *D) FieldU51LE(name string) uint64 { return d.FieldUE(name, 51, LittleEndian) }

// FieldU52LE read 52 bit unsigned little-endian integer and add a field
func (d *D) FieldU52LE(name string) uint64 { return d.FieldUE(name, 52, LittleEndian) }

// FieldU53LE read 53 bit unsigned little-endian integer and add a field
func (d *D) FieldU53LE(name string) uint64 { return d.FieldUE(name, 53, LittleEndian) }

// FieldU54LE read 54 bit unsigned little-endian integer and add a field
func (d *D) FieldU54LE(name string) uint64 { return d.FieldUE(name, 54, LittleEndian) }

// FieldU55LE read 55 bit unsigned little-endian integer and add a field
func (d *D) FieldU55LE(name string) uint64 { return d.FieldUE(name, 55, LittleEndian) }

// FieldU56LE read 56 bit unsigned little-endian integer and add a field
func (d *D) FieldU56LE(name string) uint64 { return d.FieldUE(name, 56, LittleEndian) }

// FieldU57LE read 57 bit unsigned little-endian integer and add a field
func (d *D) FieldU57LE(name string) uint64 { return d.FieldUE(name, 57, LittleEndian) }

// FieldU58LE read 58 bit unsigned little-endian integer and add a field
func (d *D) FieldU58LE(name string) uint64 { return d.FieldUE(name, 58, LittleEndian) }

// FieldU59LE read 59 bit unsigned little-endian integer and add a field
func (d *D) FieldU59LE(name string) uint64 { return d.FieldUE(name, 59, LittleEndian) }

// FieldU60LE read 60 bit unsigned little-endian integer and add a field
func (d *D) FieldU60LE(name string) uint64 { return d.FieldUE(name, 60, LittleEndian) }

// FieldU61LE read 61 bit unsigned little-endian integer and add a field
func (d *D) FieldU61LE(name string) uint64 { return d.FieldUE(name, 61, LittleEndian) }

// FieldU62LE read 62 bit unsigned little-endian integer and add a field
func (d *D) FieldU62LE(name string) uint64 { return d.FieldUE(name, 62, LittleEndian) }

// FieldU63LE read 63 bit unsigned little-endian integer and add a field
func (d *D) FieldU63LE(name string) uint64 { return d.FieldUE(name, 63, LittleEndian) }

// FieldU64LE read 64 bit unsigned little-endian integer and add a field
func (d *D) FieldU64LE(name string) uint64 { return d.FieldUE(name, 64, LittleEndian) }

// Float readers

// F read a nBits current endian float
func (d *D) F(nBits int) float64 { return d.FE(nBits, d.Endian) }

// TryF try read a nBits current endian float
func (d *D) TryF(nBits int) (float64, error) { return d.TryFE(nBits, d.Endian) }

// F16 read 16 bit current endian float
func (d *D) F16() float64 { return d.FE(16, d.Endian) }

// TryF16 try read 16 bit current endian float
func (d *D) TryF16() (float64, error) { return d.TryFE(16, d.Endian) }

// F32 read 32 bit current endian float
func (d *D) F32() float64 { return d.FE(32, d.Endian) }

// TryF32 try read 32 bit current endian float
func (d *D) TryF32() (float64, error) { return d.TryFE(32, d.Endian) }

// F64 read 64 bit current endian float
func (d *D) F64() float64 { return d.FE(64, d.Endian) }

// TryF64 try read 64 bit current endian float
func (d *D) TryF64() (float64, error) { return d.TryFE(64, d.Endian) }

// FieldF read a nBits current endian float and add a field
func (d *D) FieldF(name string, nBits int) float64 { return d.FieldFE(name, nBits, d.Endian) }

// FieldF16 read 16 bit current endian float and add a field
func (d *D) FieldF16(name string) float64 { return d.FieldFE(name, 16, d.Endian) }

// FieldF32 read 32 bit current endian float and add a field
func (d *D) FieldF32(name string) float64 { return d.FieldFE(name, 32, d.Endian) }

// FieldF64 read 64 bit current endian float and add a field
func (d *D) FieldF64(name string) float64 { return d.FieldFE(name, 64, d.Endian) }

// FBE read a nBits big-endian float
func (d *D) FBE(nBits int) float64 { return d.FE(nBits, BigEndian) }

// TryFBE try read a nBits big-endian float
func (d *D) TryFBE(nBits int) (float64, error) { return d.TryFE(nBits, BigEndian) }

// F16BE read 16 bit big-endian float
func (d *D) F16BE() float64 { return d.FE(16, BigEndian) }

// TryF16BE try read 16 bit big-endian float
func (d *D) TryF16BE() (float64, error) { return d.TryFE(16, BigEndian) }

// F32BE read 32 bit big-endian float
func (d *D) F32BE() float64 { return d.FE(32, BigEndian) }

// TryF32BE try read 32 bit big-endian float
func (d *D) TryF32BE() (float64, error) { return d.TryFE(32, BigEndian) }

// F64BE read 64 bit big-endian float
func (d *D) F64BE() float64 { return d.FE(64, BigEndian) }

// TryF64BE try read 64 bit big-endian float
func (d *D) TryF64BE() (float64, error) { return d.TryFE(64, BigEndian) }

// FieldFBE read a nBits big-endian float and add a field
func (d *D) FieldFBE(name string, nBits int) float64 { return d.FieldFE(name, nBits, BigEndian) }

// FieldF16BE read 16 bit big-endian float and add a field
func (d *D) FieldF16BE(name string) float64 { return d.FieldFE(name, 16, BigEndian) }

// FieldF32BE read 32 bit big-endian float and add a field
func (d *D) FieldF32BE(name string) float64 { return d.FieldFE(name, 32, BigEndian) }

// FieldF64BE read 64 bit big-endian float and add a field
func (d *D) FieldF64BE(name string) float64 { return d.FieldFE(name, 64, BigEndian) }

// FLE read a nBits little-endian float
func (d *D) FLE(nBits int) float64 { return d.FE(nBits, LittleEndian) }

// TryFLE try read a nBits little-endian float
func (d *D) TryFLE(nBits int) (float64, error) { return d.TryFE(nBits, LittleEndian) }

// F16LE read 16 bit little-endian float
func (d *D) F16LE() float64 { return d.FE(16, LittleEndian) }

// TryF16LE try read 16 bit little-endian float
func (d *D) TryF16LE() (float64, error) { return d.TryFE(16, LittleEndian) }

// F32LE read 32 bit little-endian float
func (d *D) F32LE() float64 { return d.FE(32, LittleEndian) }

// TryF32LE try read 32 bit little-endian float
func (d *D) TryF32LE() (float64, error) { return d.TryFE(32, LittleEndian) }

// F64LE read 64 bit little-endian float
func (d *D) F64LE() float64 { return d.FE(64, LittleEndian) }

// TryF64LE try read 64 bit little-endian float
func (d *D) TryF64LE() (float64, error) { return d.TryFE(64, LittleEndian) }

// FieldFLE read a nBits little-endian float and add a field
func (d *D) FieldFLE(name string, nBits int) float64 { return d.FieldFE(name, nBits, LittleEndian) }

// FieldF16LE read 16 bit little-endian float and add a field
func (d *D) FieldF16LE(name string) float64 { return d.FieldFE(name, 16, LittleEndian) }

// FieldF32LE read 32 bit little-endian float and add a field
func (d *D) FieldF32LE(name string) float64 { return d.FieldFE(name, 32, LittleEndian) }

// FieldF64LE read 64 bit little-endian float and add a field
func (d *D) FieldF64LE(name string) float64 { return d.FieldFE(name, 64, LittleEndian) }

// Fixed-point readers

// FP read a nBits current endian fBits fraction bits fixed-point number
func (d *D) FP(nBits int, fBits int64) float64 { return d.FPE(nBits, fBits, d.Endian) }

// TryFP try read a nBits current endian fBits fraction bits fixed-point number
func (d *D) TryFP(nBits int, fBits int64) (float64, error) { return d.TryFPE(nBits, fBits, d.Endian) }

// FP16 read 16 bit current endian fixed-point number
func (d *D) FP16() float64 { return d.FPE(16, 8, d.Endian) }

// TryFP16 try read 16 bit current endian fixed-point number
func (d *D) TryFP16() (float64, error) { return d.TryFPE(16, 8, d.Endian) }

// FP32 read 32 bit current endian fixed-point number
func (d *D) FP32() float64 { return d.FPE(32, 16, d.Endian) }

// TryFP32 try read 32 bit current endian fixed-point number
func (d *D) TryFP32() (float64, error) { return d.TryFPE(32, 16, d.Endian) }

// FP64 read 64 bit current endian fixed-point number
func (d *D) FP64() float64 { return d.FPE(64, 32, d.Endian) }

// TryFP64 try read 64 bit current endian fixed-point number
func (d *D) TryFP64() (float64, error) { return d.TryFPE(64, 32, d.Endian) }

// FieldFP read a nBits current endian fBits fraction fixed-point number and add a field
func (d *D) FieldFP(name string, nBits int, fBits int64) float64 {
	return d.FieldFPE(name, nBits, fBits, d.Endian)
}

// FieldFP16 read 16 bit current endian fixed-point number and add a field
func (d *D) FieldFP16(name string) float64 { return d.FieldFPE(name, 16, 8, d.Endian) }

// FieldFP32 read 32 bit current endian fixed-point number and add a field
func (d *D) FieldFP32(name string) float64 { return d.FieldFPE(name, 32, 16, d.Endian) }

// FieldFP64 read 64 bit current endian fixed-point number and add a field
func (d *D) FieldFP64(name string) float64 { return d.FieldFPE(name, 64, 32, d.Endian) }

// FPBE read a nBits big-endian fBits fraction bits fixed-point number
func (d *D) FPBE(nBits int, fBits int64) float64 { return d.FPE(nBits, fBits, BigEndian) }

// TryFPBE try read a nBits big-endian fBits fraction bits fixed-point number
func (d *D) TryFPBE(nBits int, fBits int64) (float64, error) {
	return d.TryFPE(nBits, fBits, BigEndian)
}

// FP16BE read 16 bit big-endian fixed-point number
func (d *D) FP16BE() float64 { return d.FPE(16, 8, BigEndian) }

// TryFP16BE try read 16 bit big-endian fixed-point number
func (d *D) TryFP16BE() (float64, error) { return d.TryFPE(16, 8, BigEndian) }

// FP32BE read 32 bit big-endian fixed-point number
func (d *D) FP32BE() float64 { return d.FPE(32, 16, BigEndian) }

// TryFP32BE try read 32 bit big-endian fixed-point number
func (d *D) TryFP32BE() (float64, error) { return d.TryFPE(32, 16, BigEndian) }

// FP64BE read 64 bit big-endian fixed-point number
func (d *D) FP64BE() float64 { return d.FPE(64, 32, BigEndian) }

// TryFP64BE try read 64 bit big-endian fixed-point number
func (d *D) TryFP64BE() (float64, error) { return d.TryFPE(64, 32, BigEndian) }

// FieldFPBE read a nBits big-endian fBits fraction fixed-point number and add a field
func (d *D) FieldFPBE(name string, nBits int, fBits int64) float64 {
	return d.FieldFPE(name, nBits, fBits, BigEndian)
}

// FieldFP16BE read 16 bit big-endian fixed-point number and add a field
func (d *D) FieldFP16BE(name string) float64 { return d.FieldFPE(name, 16, 8, BigEndian) }

// FieldFP32BE read 32 bit big-endian fixed-point number and add a field
func (d *D) FieldFP32BE(name string) float64 { return d.FieldFPE(name, 32, 16, BigEndian) }

// FieldFP64BE read 64 bit big-endian fixed-point number and add a field
func (d *D) FieldFP64BE(name string) float64 { return d.FieldFPE(name, 64, 32, BigEndian) }

// FPLE read a nBits little-endian fBits fraction bits fixed-point number
func (d *D) FPLE(nBits int, fBits int64) float64 { return d.FPE(nBits, fBits, LittleEndian) }

// TryFPLE try read a nBits little-endian fBits fraction bits fixed-point number
func (d *D) TryFPLE(nBits int, fBits int64) (float64, error) {
	return d.TryFPE(nBits, fBits, LittleEndian)
}

// FP16LE read 16 bit little-endian fixed-point number
func (d *D) FP16LE() float64 { return d.FPE(16, 8, LittleEndian) }

// TryFP16LE try read 16 bit little-endian fixed-point number
func (d *D) TryFP16LE() (float64, error) { return d.TryFPE(16, 8, LittleEndian) }

// FP32LE read 32 bit little-endian fixed-point number
func (d *D) FP32LE() float64 { return d.FPE(32, 16, LittleEndian) }

// TryFP32LE try read 32 bit little-endian fixed-point number
func (d *D) TryFP32LE() (float64, error) { return d.TryFPE(32, 16, LittleEndian) }

// FP64LE read 64 bit little-endian fixed-point number
func (d *D) FP64LE() float64 { return d.FPE(64, 32, LittleEndian) }

// TryFP64LE try read 64 bit little-endian fixed-point number
func (d *D) TryFP64LE() (float64, error) { return d.TryFPE(64, 32, LittleEndian) }

// FieldFPLE read a nBits little-endian fBits fraction fixed-point number and add a field
func (d *D) FieldFPLE(name string, nBits int, fBits int64) float64 {
	return d.FieldFPE(name, nBits, fBits, LittleEndian)
}

// FieldFP16LE read 16 bit little-endian fixed-point number and add a field
func (d *D) FieldFP16LE(name string) float64 { return d.FieldFPE(name, 16, 8, LittleEndian) }

// FieldFP32LE read 32 bit little-endian fixed-point number and add a field
func (d *D) FieldFP32LE(name string) float64 { return d.FieldFPE(name, 32, 16, LittleEndian) }

// FieldFP64LE read 64 bit little-endian fixed-point number and add a field
func (d *D) FieldFP64LE(name string) float64 { return d.FieldFPE(name, 64, 32, LittleEndian) }