bts, err = msgp.Skip(bts)
			if err != nil {
				err = msgp.WrapError(err)
				return
			}
		}
	}
	o = bts
	return
}

// Msgsize returns an upper bound estimate of the number of bytes occupied by the serialized message
func (z BatchJobKV) Msgsize() (s int) {
	s = 1 + 4 + msgp.StringPrefixSize + len(z.Key) + 6 + msgp.StringPrefixSize + len(z.Value)
	return
}

// DecodeMsg implements msgp.Decodable

			b.Fatal(err)
		}
	}
}

func TestEncodeDecodensScannerOptions(t *testing.T) {
	v := nsScannerOptions{}
	var buf bytes.Buffer
	msgp.Encode(&buf, &v)

	m := v.Msgsize()
	if buf.Len() > m {
		t.Log("WARNING: TestEncodeDecodensScannerOptions Msgsize() is inaccurate")
	}

	vn := nsScannerOptions{}
	err := msgp.Decode(&buf, &vn)
	if err != nil {
		t.Error(err)
	}

	buf.Reset()
	msgp.Encode(&buf, &v)

		*j.val = t
	}
	return bytes, json.Unmarshal(val, j.val)
}

// Msgsize returns the size of an empty JSON object.
func (j *JSON[T]) Msgsize() int {
	return j.p.emptySz
}

// NoPayload is a type that can be used for handlers that do not use a payload.
type NoPayload struct{}

// Msgsize returns 0.
func (p NoPayload) Msgsize() int {
	return 0
}

				err = msgp.WrapError(err)
				return
			}
		}
	}
	o = bts
	return
}

// Msgsize returns an upper bound estimate of the number of bytes occupied by the serialized message
func (z *lastDayTierStats) Msgsize() (s int) {
	s = 1 + 5 + msgp.ArrayHeaderSize
	for za0001 := range z.Bins {
		s += z.Bins[za0001].Msgsize()
	}
	s += 10 + msgp.TimeSize
	return

Joe Tsai <******@****.***> 1446603151 -0800

	}
	o = bts
	return
}

// Msgsize returns an upper bound estimate of the number of bytes occupied by the serialized message
func (z localLockMap) Msgsize() (s int) {
	s = msgp.MapHeaderSize
	if z != nil {
		for zb0006, zb0007 := range z {
			_ = zb0007
			s += msgp.StringPrefixSize + len(zb0006) + msgp.ArrayHeaderSize
			for zb0008 := range zb0007 {
				s += zb0007[zb0008].Msgsize()
			}
		}
	}
	return
}

			}
		}
	}
	o = bts
	return
}

// Msgsize returns an upper bound estimate of the number of bytes occupied by the serialized message
func (z *PoolStatus) Msgsize() (s int) {
	s = 1 + 3 + msgp.IntSize + 3 + msgp.StringPrefixSize + len(z.CmdLine) + 3 + msgp.TimeSize + 4
	if z.Decommission == nil {
		s += msgp.NilSize
	} else {
		s += z.Decommission.Msgsize()
	}
	return
}

		return
	}
	// write "N"
	err = en.Append(0xa1, 0x4e)
	if err != nil {
		return
	}
	err = en.WriteInt64(z.N)
	if err != nil {
		err = msgp.WrapError(err, "N")
		return
	}
	return
}

// MarshalMsg implements msgp.Marshaler
func (z AccElem) MarshalMsg(b []byte) (o []byte, err error) {
	o = msgp.Require(b, z.Msgsize())
	// map header, size 3
	// string "Total"

                //ポジション設定
                this.resize();
                var suggestor = this;
                $(window).resize(function() {
                    suggestor.resize();
                });

                $("body").append($boxElement);
            },

            suggest: function() {
                suggestingSts = true;

                //ポジション設定
                this.resize();

                var suggestor = this;

			bts, err = msgp.Skip(bts)
			if err != nil {
				err = msgp.WrapError(err)
				return
			}
		}
	}
	o = bts
	return
}

// Msgsize returns an upper bound estimate of the number of bytes occupied by the serialized message
func (z testRequest) Msgsize() (s int) {
	s = 1 + 4 + msgp.IntSize + 7 + msgp.StringPrefixSize + len(z.String)
	return
}

// DecodeMsg implements msgp.Decodable