X neo/protogen/decode: Help compiler to elmiminate bounds checks by explicitly specifying :hi

See https://github.com/golang/go/issues/19126#issuecomment-358743715.

Examples:

		before										after

TEXT ·(*GetObject).neoMsgDecode(SB), NOSPLIT, $8-56 // zproto-marshal.go:1914   │TEXT ·(*GetObject).neoMsgDecode(SB), NOSPLIT, $0-56 // zproto-marshal.go:1914
        // SUBQ    $8, SP                                                       │        NO_LOCAL_POINTERS
        // MOVQ    BP, (SP) (BP save)                                           │        // FUNCDATA $0, gclocals·846769608458630ae82546dab39e913e(SB) (args)
        // LEAQ    (SP), BP (BP init)                                           │        // FUNCDATA $1, gclocals·33cdeccccebe80329f1fdbee7f5874cb(SB) (no locals)
        // FUNCDATA $0, gclocals·21e863e2261befa92f8534560680bbb6(SB) (args)    │        MOVQ       data+24(SP), AX
        FUNCDATA   $1, gclocals·69c1753bd5f81501d95132d08af04464(SB) (locals)   │        CMPQ       AX, $24                        // zproto-marshal.go:1915
        MOVQ       data+32(SP), AX                                              │        JGE        pc45
        CMPQ       AX, $24                      // zproto-marshal.go:1915       │        MOVQ       ·ErrDecodeOverflow+8(SB), AX  // zproto-marshal.go:1924
        JLT        pc163                                                        │        MOVQ       ·ErrDecodeOverflow(SB), CX
        MOVQ       data+24(SP), CX                                              │        MOVQ       $0, _r1+40(SP)
        MOVQ       (CX), DX                     // zproto-marshal.go:1918       │        MOVQ       CX, _r2+48(SP)
        BSWAPQ     DX                                                           │        MOVQ       AX, _r2+56(SP)
        MOVQ       p+16(SP), BX                                                 │        RET
        MOVQ       DX, (BX)                                                     │pc45:
        LEAQ       -8(AX), DX                   // zproto-marshal.go:1919       │        MOVQ       data+16(SP), AX
        MOVQ       data+40(SP), SI                                              │        MOVQ       (AX), CX                       // zproto-marshal.go:1918
        LEAQ       -8(SI), DI                                                   │        BSWAPQ     CX
        NEGQ       DI                                                           │        MOVQ       p+8(SP), DX
        SARQ       $63, DI                                                      │        MOVQ       CX, (DX)
        ANDQ       $8, DI                                                       │        MOVQ       8(AX), CX                      // zproto-marshal.go:1919
        CMPQ       DX, $7                                                       │        BSWAPQ     CX
        JLS        pc212                                                        │        MOVQ       CX, 8(DX)
        MOVQ       (CX)(DI*1), DX                                               │        MOVQ       16(AX), AX                     // zproto-marshal.go:1920
        BSWAPQ     DX                                                           │        BSWAPQ     AX
        MOVQ       DX, 8(BX)                                                    │        MOVQ       AX, 16(DX)
        LEAQ       -16(SI), DX                  // zproto-marshal.go:1920       │        MOVQ       $24, _r1+40(SP)                // zproto-marshal.go:1921
        NEGQ       DX                                                           │        MOVQ       $0, _r2+48(SP)
        ADDQ       $-16, AX                                                     │        MOVQ       $0, _r2+56(SP)
        SARQ       $63, DX                                                      │        RET
        ANDQ       $16, DX                                                      │
        CMPQ       AX, $7                                                       │
        JLS        pc205                                                        │
        MOVQ       (CX)(DX*1), AX                                               │
        BSWAPQ     AX                                                           │
        MOVQ       AX, 16(BX)                                                   │
        MOVQ       $24, _r1+48(SP)              // zproto-marshal.go:1921       │
        MOVQ       $0, _r2+56(SP)                                               │
        MOVQ       $0, _r2+64(SP)                                               │
        // MOVQ    (SP), BP (BP restore)                                        │
        // ADDQ    $8, SP (SP restore)                                          │
        RET                                                                     │
pc163:                                                                          │
        MOVQ       ·ErrDecodeOverflow(SB), AX  // zproto-marshal.go:1924        │
        MOVQ       ·ErrDecodeOverflow+8(SB), CX                                 │
        MOVQ       $0, _r1+48(SP)                                               │
        MOVQ       AX, _r2+56(SP)                                               │
        MOVQ       CX, _r2+64(SP)                                               │
        // MOVQ    (SP), BP (BP restore)                                        │
        // ADDQ    $8, SP (SP restore)                                          │
        RET                                                                     │
pc205:                                                                          │
        PCDATA     $0, $1                       // zproto-marshal.go:1920       │
        CALL       runtime.panicindex(SB)                                       │
        UNDEF                                                                   │
pc212:                                                                          │
        PCDATA     $0, $1                       // zproto-marshal.go:1919       │
        CALL       runtime.panicindex(SB)                                       │
        UNDEF                                                                   │

go/neo/protogen.go

@@ -869,7 +869,11 @@ func (e *encoder) genBasic(path string, typ *types.Basic, userType types.Type) {
 
 func (d *decoder) genBasic(assignto string, typ *types.Basic, userType types.Type) {
 	basic := basicTypes[typ.Kind()]
-	dataptr := fmt.Sprintf("data[%v:]", d.n)
+
+	// XXX specifying :hi is not needed - it is only a workaround to help BCE.
+	//     see https://github.com/golang/go/issues/19126#issuecomment-358743715
+	dataptr := fmt.Sprintf("data[%v:%v+%d]", d.n, d.n, basic.wireSize)
+
 	decoded := fmt.Sprintf(basic.decode, dataptr)
 	if userType != typ && userType != nil {
 		// need to cast (like in encode case)